Fassung 1.6.0: der Aufgabenplan wird veroeffentlicht

Wiederkehrende Aufgaben ohne Cronjob (ADR 073): Sicherung, Statistik kuerzen, geplante Veroeffentlichung, Updatepruefung und Aufraeumen laufen als Plan in der Tabelle scheduled_task - eine Zeile je Aufgabe mit Faelligkeit, Sperre und letztem Ergebnis. Auf geteiltem Hosting gibt es oft keinen Cronjob; der Plan haengt stattdessen an Anfragen und an einem Takt aus dem geoeffneten Backend. Diese Arbeit entstand in einer parallel laufenden Sitzung und lag bis hierher unveroeffentlicht im Arbeitsverzeichnis: die Releases 1.5.0 bis 1.5.5 wurden bewusst aus dem jeweiligen Tag gebaut und enthielten sie deshalb nicht. Vor der Veroeffentlichung geprueft, nicht bloss eingepackt: - phpunit 452/452, npm test 28/28, npm run test:editor vollstaendig. - Die Migration 20260914000100 legt nur die Tabelle scheduled_task an und nimmt sie beim Zurueckrollen wieder weg. Sie fasst keine bestehenden Daten an. - Seit einer Stunde keine Schreibzugriffe der anderen Sitzung mehr. Dabei zwei Fehler behoben: - config/services.yaml verwendet !tagged_iterator. Das ist gueltiges Symfony, aber "lint:yaml config" kennt eigene Tags nur mit --parse-tags und gab 1 zurueck - der CI-Lauf waere daran gescheitert. Flag ergaenzt. - AdminHeadersSubscriber.php (aus 1.5.3) entsprach nicht dem Stil von php-cs-fixer; composer lint gab 8 zurueck. Behoben. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Fassung 1.5.5: die Verwaltungsnavigation war am Schreibtisch unerreichbar
2026-09-14 08:30:13 +02:00 · 2026-09-14 08:17:56 +02:00 · 2026-09-14 08:08:31 +02:00
40 changed files with 2480 additions and 40 deletions
@@ -24,7 +24,7 @@ jobs:
      - run: php vendor/bin/doctrine-migrations migrate --no-interaction
      - run: php bin/console cms:seed-demo
      - run: php bin/console cms:seed-demo
-      - run: php bin/console lint:twig templates && php bin/console lint:yaml config && php bin/console lint:container
+      - run: php bin/console lint:twig templates && php bin/console lint:yaml config --parse-tags && php bin/console lint:container
      - run: composer build
  browser:
    runs-on: ubuntu-latest
@@ -104,6 +104,25 @@ Die Formate v1/v2/v3 und erlaubten Blöcke stehen in `src/Content/DocumentValida

 Ein JSON-Dokument lässt sich zusätzlich lokal über `php bin/console cms:save-draft PAGE_ID PFAD_ZUR_DATEI ERWARTETE_VERSION` speichern. Der Befehl gibt die neue Revisions-ID aus. Die redaktionelle Bearbeitung und Veröffentlichung erfolgen jetzt über den geschützten Editor.

+## Wiederkehrende Aufgaben
+
+Sicherung, geplante Veröffentlichung, Statistik verdichten, Updateprüfung und Aufräumen laufen über einen eingebauten Plan. Auf geteiltem Hosting gibt es oft keinen Cronjob – deshalb stößt hier **die Anfrage** die Arbeit an, nach der ausgelieferten Antwort (`kernel.terminate`), sodass kein Besucher darauf wartet. Der Bildschirm **Verwaltung → Aufgaben** zeigt Plan, letztes Ergebnis und Protokoll und schaltet jede Aufgabe einzeln.
+
+Vier Auslöser, in aufsteigender Verlässlichkeit:
+
+1. **Besuch** – jeder Seitenaufruf prüft, ob etwas fällig ist. Der Normalfall kostet eine gelesene Datei (`var/scheduler.json`) und keine Datenbankabfrage. Standardmäßig an.
+2. **Geöffnete Verwaltung** – das Backend fragt jede Minute nach, solange der Reiter sichtbar ist. Damit läuft der Plan auch auf einer Website ohne Besucher. Standardmäßig an.
+3. **URL-Cronjob** – wenn der Hoster nur das Aufrufen einer Adresse anbietet: die Adresse steht auf dem Bildschirm „Aufgaben“ (`/cms-cron/<Schlüssel>`, aus `APP_SECRET` abgeleitet), zum Beispiel alle fünf Minuten.
+4. **Konsole** – `php bin/console cms:tasks:run`, für einen echten Cronjob jede Minute:
+
+```
+* * * * *  cd /pfad/zur/installation && php bin/console cms:tasks:run
+```
+
+`cms:tasks` zeigt denselben Plan wie die Verwaltung (`--log` zusätzlich das Protokoll), `cms:tasks:run --task=backup` startet eine bestimmte Aufgabe sofort, `cms:tasks:run --loop=60 --max-time=3600` läuft als Dauerläufer unter einem Prozessverwalter. Die alten Einzelbefehle `cms:backup`, `cms:stats:prune` und `cms:publish-due` gibt es weiterhin; wer sie in einen Cronjob einträgt, schaltet die entsprechende Aufgabe im Plan besser ab, damit nicht beides läuft.
+
+**Die Grenze gehört dazu:** ohne Besuch und ohne geöffnetes Backend passiert nichts. Eine Aufgabe für 03:00 Uhr läuft auf einer stillen Website erst beim nächsten Aufruf, vielleicht um 07:15 Uhr. Wer Minutengenauigkeit braucht, richtet Weg 3 oder 4 ein und schaltet den Besuchs-Auslöser ab.
+
 ## PHP-Webhosting

 Anforderungen vor dem Pilotbetrieb beim Anbieter bestätigen:
@@ -118,4 +137,4 @@ Serverkonfiguration über echte Umgebungsvariablen oder eine nicht öffentliche

 **Composer wird auf dem Hosting nicht vorausgesetzt.** Ein Release wird auf einem Rechner gebaut, der Composer hat: `php scripts/build-release.php` legt `var/releases/kantsites-<Fassung>.zip` samt `.sha256` an. Das Archiv enthält die Anwendung mit fertigem `vendor/` ohne Entwicklungspakete, aber keine Tests, keine Skripte, kein `var/` und kein `.env`; als Vorlage für die eigene Konfiguration liegt `.env.example` bei. Auf dem Hosting wird es entpackt, `.env.local` angelegt, migriert und der Cache gebaut. Node wird dort ebenfalls nicht gebraucht. Keine Installation ins öffentlich erreichbare Projektstammverzeichnis.

-Ein Livegang, Hostzugriff, Restore-Test und Produktionsfreigabe sind nicht erfolgt. Bei bestehenden Installationen vor dem Update Datenbank und Medien sichern und `php vendor/bin/doctrine-migrations migrate --no-interaction` ausführen. Migration `20260912000200` ergänzt Benutzer, `20260912000300` die Medientabelle; beide verändern keine Seitendokumente. Migration `20260912001100` ergänzt drei Datumsspalten an `cms_user` (drei ADD COLUMN, kein Tabellenneubau). Benutzerverwaltung und Passwortänderung gibt es jetzt in der Oberfläche unter „Benutzer“ und „Mein Konto“; `php bin/console cms:user:create` bleibt der Weg, wenn kein Konto mehr funktioniert. Migration `20260912001300` ergänzt zwei Spalten an `page` für Kopf- und Fußbereich je Seite (zwei ADD COLUMN). Migration `20260912001200` legt die Zählertabelle der Statistik an (neue Tabelle, kein Eingriff in Bestehendes); `php bin/console cms:stats:prune` und `php bin/console cms:backup` gehören danach in einen täglichen Cronjob – die Sicherung schreibt nach `var/backups/`, rotiert selbst und enthält Datenbank und Medien, aber weder `.env` noch `vendor/`. Zurückspielen: `php bin/console cms:restore <name>`. Der Code liegt auf `https://git.kant-it.de/kantarci/KantSites.git`; Fassungen sind Tags der Form `v1.0.1`, und die laufende Fassung steht in `VERSION`. Ein Update zieht `php bin/console cms:update` (mit `--check`, `--dry-run`, `--to=v1.2.0`) oder der Bildschirm „System“ in der Verwaltung; `--maintenance=an|aus` schaltet den Wartungszustand von Hand. Ändert ein Update die Abhängigkeiten (`composer.lock`) und ist Composer auf dem Server nicht aufrufbar, bricht der Updater ab und verweist auf das Releasearchiv; Updates ohne Abhängigkeitsänderung laufen auch ohne Composer durch. Ablauf und Grenzen stehen in `docs/UPDATE.md`. Der Abgleich mit der Pilotwebsite bleibt der nächste Schritt.
+Ein Livegang, Hostzugriff, Restore-Test und Produktionsfreigabe sind nicht erfolgt. Bei bestehenden Installationen vor dem Update Datenbank und Medien sichern und `php vendor/bin/doctrine-migrations migrate --no-interaction` ausführen. Migration `20260912000200` ergänzt Benutzer, `20260912000300` die Medientabelle; beide verändern keine Seitendokumente. Migration `20260912001100` ergänzt drei Datumsspalten an `cms_user` (drei ADD COLUMN, kein Tabellenneubau). Benutzerverwaltung und Passwortänderung gibt es jetzt in der Oberfläche unter „Benutzer“ und „Mein Konto“; `php bin/console cms:user:create` bleibt der Weg, wenn kein Konto mehr funktioniert. Migration `20260912001300` ergänzt zwei Spalten an `page` für Kopf- und Fußbereich je Seite (zwei ADD COLUMN). Migration `20260914000100` legt die Tabelle des Aufgabenplans an (neue Tabelle, kein Eingriff in Bestehendes); ohne sie läuft der Plan nicht, meldet das aber, statt eine Seite zu zerstören. Migration `20260912001200` legt die Zählertabelle der Statistik an (neue Tabelle, kein Eingriff in Bestehendes); `php bin/console cms:stats:prune` und `php bin/console cms:backup` erledigt jetzt der eingebaute Aufgabenplan (Abschnitt „Wiederkehrende Aufgaben“); ohne Cronjob genügen Besuche und das geöffnete Backend – die Sicherung schreibt nach `var/backups/`, rotiert selbst und enthält Datenbank und Medien, aber weder `.env` noch `vendor/`. Zurückspielen: `php bin/console cms:restore <name>`. Der Code liegt auf `https://git.kant-it.de/kantarci/KantSites.git`; Fassungen sind Tags der Form `v1.0.1`, und die laufende Fassung steht in `VERSION`. Ein Update zieht `php bin/console cms:update` (mit `--check`, `--dry-run`, `--to=v1.2.0`) oder der Bildschirm „System“ in der Verwaltung; `--maintenance=an|aus` schaltet den Wartungszustand von Hand. Ändert ein Update die Abhängigkeiten (`composer.lock`) und ist Composer auf dem Server nicht aufrufbar, bricht der Updater ab und verweist auf das Releasearchiv; Updates ohne Abhängigkeitsänderung laufen auch ohne Composer durch. Ablauf und Grenzen stehen in `docs/UPDATE.md`. Der Abgleich mit der Pilotwebsite bleibt der nächste Schritt.
@@ -1 +1 @@
-1.5.3
+1.6.0
@@ -15,6 +15,12 @@ services:
    _defaults:
        autowire: true
        autoconfigure: true
+    # Jede Aufgabe traegt sich selbst in den Plan ein: eine Klasse, die App\Ops\Tasks\Task
+    # implementiert, bekommt das Etikett und liegt beim naechsten Abgleich in der Tabelle. Eine
+    # neue Aufgabe ist damit eine Datei und keine Liste, die man an drei Stellen nachfuehrt.
+    _instanceof:
+        App\Ops\Tasks\Task:
+            tags: ['kant.task']
    App\:
        resource: '../src/'
        exclude: '../src/{Kernel.php,Domain/}'
@@ -86,6 +92,25 @@ services:
            $root: '%kernel.project_dir%'
            $databaseUrl: '%env(resolve:DATABASE_URL)%'
            $mediaDirectory: '%env(resolve:MEDIA_DIRECTORY)%'
+    # Der Aufgabenplan. Die Aufgaben kommen ueber ihr Etikett herein, damit diese Stelle nicht
+    # jedes Mal mitwaechst.
+    App\Ops\Scheduler:
+        arguments:
+            $tasks: !tagged_iterator kant.task
+            $projectDir: '%kernel.project_dir%'
+    App\Ops\Tasks\CleanupTask:
+        arguments:
+            $projectDir: '%kernel.project_dir%'
+    App\EventSubscriber\TaskWorkerSubscriber:
+        arguments:
+            $projectDir: '%kernel.project_dir%'
+            $adminPath: '%kant.admin_path%'
+    App\Controller\TaskController:
+        arguments:
+            $secret: '%kernel.secret%'
+    App\Controller\CronController:
+        arguments:
+            $secret: '%kernel.secret%'
    App\Infrastructure\QueryCounter: ~
    App\EventSubscriber\QueryHeaderSubscriber:
        arguments:
@@ -281,7 +281,7 @@ Migration `20260912000900` ergänzt `page.publish_at`, `page.deleted_at` und `re

 `revision.seq` behebt einen echten Fehler, den erst ein Test gezeigt hat: `created_at` hat Sekundengenauigkeit, und mehrere Speichervorgänge fallen in dieselbe Sekunde. Die Reihenfolge im Verlauf war dadurch **nicht eindeutig** – sie richtete sich nach der zufälligen Revisions-ID. Jetzt trägt jede Fassung einen je Seite streng aufsteigenden Zähler; die Migration füllt ihn aus den vorhandenen Zeitstempeln.

-**Geplante Veröffentlichung** setzt `publish_at`. Ein Cron-Aufruf von `cms:publish-due` veröffentlicht, was fällig ist, und löscht den Zeitpunkt. Ohne Cron bleibt die Seite ein Entwurf – die sichere Richtung. Zeitpunkte sind UTC; das steht im Formular, weil ein `datetime-local`-Feld sonst die Zeitzone des Browsers unterstellt. Eine Seite im Papierkorb wird nie durch den Zeitplan veröffentlicht.
+**Geplante Veröffentlichung** setzt `publish_at`. Die Aufgabe `publish-due` veröffentlicht, was fällig ist, und löscht den Zeitpunkt (ADR 073); ohne einen Auslöser – Besuch, geöffnetes Backend, URL-Cron oder Konsole – bleibt die Seite ein Entwurf, die sichere Richtung. Zeitpunkte sind UTC; das steht im Formular, weil ein `datetime-local`-Feld sonst die Zeitzone des Browsers unterstellt. Eine Seite im Papierkorb wird nie durch den Zeitplan veröffentlicht.

 **Eine frei wählbare Startseite ist nicht umgesetzt.** Der Pfad `home` gilt an elf Stellen als Wurzel der Website – öffentliche Routen, Canonical, Sitemap, `llms.txt`, Menüauflösung. Das zu einer Einstellung zu machen ist ein eigener Schritt; bis dahin behält die Startseite ihre Adresse, statt dass die Hälfte des Systems der Änderung folgt und die andere nicht.

@@ -438,7 +438,38 @@ Vom Verweis bleibt nur der Host. Die vollständige Adresse, aus der jemand kam,

 **Der Preis steht auf dem Bildschirm.** Aufrufe statt Besucher, keine Verweildauer, keine Absprungrate, kein Klickweg, kein Land. Das ist keine Lücke, sondern die Folge der Entscheidung: all das braucht Wiedererkennung. Wer es braucht, braucht eine Einwilligung – die Gruppe `statistics` dafür gibt es schon, sie wäre dann ein eigener Baustein.

-**Aufbewahrung:** nach 60 Tagen werden die Stunden eines Tages zu einer Zeile verschmolzen, nach 425 Tagen wird gelöscht. Gut ein Jahr, damit ein Vergleich mit dem Vorjahresmonat möglich bleibt. `cms:stats:prune` macht beides und ist für einen Cronjob gedacht.
+**Aufbewahrung:** nach 60 Tagen werden die Stunden eines Tages zu einer Zeile verschmolzen, nach 425 Tagen wird gelöscht. Gut ein Jahr, damit ein Vergleich mit dem Vorjahresmonat möglich bleibt. `cms:stats:prune` macht beides; im Normalbetrieb erledigt das die Aufgabe `stats-prune` des Plans (ADR 073).
+
+## ADR 073 – Wiederkehrende Aufgaben ohne Cronjob: die Anfrage ist der Auslöser (14.09.2026)
+
+Bis hierher stand in vier Dokumenten derselbe Satz: „gehört in einen Cronjob". Das ist richtig – und auf dem Hosting, für das dieses CMS gebaut ist, oft nicht einlösbar. Kein SSH, kein Supervisor, manchmal nicht einmal ein Cron-Eintrag im Kundenmenü. Die Folge war nicht „läuft seltener", sondern **läuft nie**: keine Sicherung, keine geplante Veröffentlichung, eine Statistiktabelle, die nur wächst.
+
+**Die Entscheidung: Was ein Hosting immer hat, sind Anfragen.** Also arbeitet eine Anfrage die Aufgaben ab – in `kernel.terminate`, nach der ausgelieferten Antwort. Unter PHP-FPM ruft Symfony dort `fastcgi_finish_request()` auf: der Browser ist fertig, während hier noch gearbeitet wird. Das ist derselbe Weg, den WordPress (`wp-cron`) und Shopware gehen, und aus demselben Grund.
+
+Vier Auslöser, eine Mechanik:
+
+| Auslöser | Wer stößt an | Grenzen je Durchlauf |
+| --- | --- | --- |
+| Besuch | jeder Seitenaufruf | 2 Aufgaben, 20 s |
+| Verwaltung | das geöffnete Backend, im Minutentakt | 3 Aufgaben, 45 s |
+| URL-Cron | der Hoster ruft `/cms-cron/<Schlüssel>` | 20 Aufgaben, 240 s |
+| Konsole | `cms:tasks:run`, auch mit `--loop` | frei |
+
+**Was das nicht kann, steht auf dem Bildschirm und nicht im Kleingedruckten:** Ohne Besuch und ohne geöffnetes Backend passiert nichts. Eine Aufgabe für 03:00 Uhr läuft auf einer stillen Website erst um 07:15 Uhr. Für Sitemap, Aufräumen, Updateprüfung und Sicherung ist das brauchbar; für etwas Minutengenaues ist es das nicht, und dann ist einer der beiden unteren Wege die Antwort. Genau dieser Satz steht im Bildschirm „Aufgaben", weil die Alternative ist, dass jemand später an der falschen Stelle sucht.
+
+Drei Eigenschaften entscheiden darüber, ob das im Betrieb trägt:
+
+**1. Der Normalfall kostet keine Datenbankabfrage.** In `var/scheduler.json` steht, wann überhaupt das nächste Mal etwas ansteht, dazu die zwei Schalter. Liegt der Zeitpunkt in der Zukunft, ist der Abonnent nach einem `file_get_contents` fertig. Fehlt die Datei – frische Installation, geleertes `var/`, kein Schreibrecht –, wird die Datenbank gefragt und die Datei neu geschrieben: der teure Weg ist der Ausnahmefall, nicht der Normalfall, und ein schreibgeschütztes `var/` macht das System langsamer, aber nicht falsch.
+
+**2. Zwei Besucher führen eine Aufgabe nicht zweimal aus.** Wer sie ausführen darf, entscheidet ein bedingtes `UPDATE … WHERE next_run_at <= :jetzt AND (locked_until IS NULL OR locked_until <= :jetzt)`. Das ist auf MySQL wie auf SQLite atomar; wer keine Zeile verändert hat, war zu spät und geht weiter. Deshalb ist der Plan eine **Tabelle** und keine Datei: eine Dateisperre ist auf geteiltem Hosting nicht zuverlässig, ein bedingtes UPDATE ist es. Die Sperre verfällt nach 15 Minuten von selbst, denn ein Prozess, den das Hosting mitten im Lauf abschießt, kann sie nicht mehr aufräumen.
+
+**3. Eine Aufgabe darf niemals die Website mitreißen.** Der Abonnent fängt alles. Ein Fehlschlag wird zum sichtbaren Zustand mit wachsendem Abstand bis zum nächsten Versuch (Verdopplung, gedeckelt bei sechs Stunden) – sonst fängt eine Aufgabe, die nicht laufen *kann*, bei jedem Seitenaufruf neu an. Fehlt die Tabelle, weil Dateien hochgeladen und Migrationen noch nicht ausgeführt wurden, passiert schlicht nichts.
+
+**Die Sicherung läuft mit, obwohl sie die schwerste Aufgabe ist.** Sie kopiert Datenbank und Medien, und unter Apache mit mod_php belegt sie dabei einen Prozess, weil es dort kein `fastcgi_finish_request()` gibt – die Seite steht längst im Browser, der Prozess bleibt. Der Handel ist trotzdem eindeutig: eine tägliche Sicherung auf einem Hosting ohne Cron ist mehr wert als gar keine. Wer einen echten Cronjob hat, schaltet den Besuchs-Auslöser ab; der Bildschirm sagt auch das.
+
+**Der Schlüssel des URL-Cronjobs steht in keiner Datenbank.** Er wird aus `APP_SECRET` abgeleitet (`hash_hmac`, 40 Zeichen), ist damit auf jeder Installation ein anderer, überlebt jedes Update und wechselt genau dann, wenn das Geheimnis wechselt. Ein falscher Schlüssel bekommt 404 und nicht 403: wer probiert, soll nicht erfahren, dass es die Stelle gibt.
+
+**Eine neue Aufgabe ist eine Datei.** Wer `App\Ops\Tasks\Task` implementiert, bekommt über `_instanceof` ein Etikett, liegt beim nächsten Abgleich in der Tabelle und steht im Bildschirm – ohne eine Liste, die an drei Stellen nachzuführen wäre. Verschwindet die Klasse, verschwindet die Zeile. Mitgeliefert sind fünf: geplante Veröffentlichung (5 Minuten), Statistik verdichten, Sicherung, Updateprüfung und Aufräumen (je täglich).

 ## ADR 072 – Drei Fehler einer Familie: dieses Hosting ist nicht mein Rechner (13.09.2026)

@@ -23,7 +23,7 @@ Gemessen wurde im Produktionsmodus auf dem PHP-Entwicklungsserver, der dieselben
 2. **HTTPS.** Zertifikat einrichten, dann in `public/.htaccess` die drei Zeilen der HTTPS-Umleitung einschalten. **Erst wenn das eine Weile läuft**, die HSTS-Zeile aktivieren – sie lässt sich in einem Browser ein halbes Jahr lang nicht zurücknehmen.
 3. **www oder nicht.** Das alte kant-it.de ist kanonisch mit `www`. In `.htaccess` steht die Umleitung dafür vorbereitet und auskommentiert; sie muss zur Einstellung `SITE_ORIGIN` passen, die in `.env` steht. Beide zeigen auf dieselbe Schreibweise, sonst zeigt jede Seite auf eine Adresse, die weiterleitet.
 4. **Datenbank.** Geprüft ist ausschließlich SQLite. Für MySQL ist alles vorbereitet, aber nichts erprobt – wer MySQL nimmt, sollte danach Seiten anlegen, veröffentlichen, Bilder hochladen und ein Formular absenden.
-5. **Cronjobs.** Täglich `php bin/console cms:backup` und `php bin/console cms:stats:prune`. Ohne den ersten gibt es keine Sicherung außer der von Hand angelegten.
+5. **Wiederkehrende Aufgaben.** Sicherung, Statistik und geplante Veröffentlichung laufen nach dem Hochladen von selbst – angestoßen von Seitenaufrufen und vom geöffneten Backend (Verwaltung → Aufgaben). **Das genügt, ist aber nicht minutengenau:** ohne Besuch passiert nichts. Bietet der Hoster einen Cronjob, gehört `php bin/console cms:tasks:run` dorthin (jede Minute); bietet er nur einen URL-Cronjob, die Adresse vom Bildschirm „Aufgaben“ (alle fünf Minuten). Danach dort den Auslöser „Besuche der Website“ abschalten. **Nach dem Umzug einmal nachsehen**, ob in der Spalte „Zuletzt“ bei der Sicherung ein `ok` steht – ohne Sicherung gibt es keinen Rückweg.
 6. **Schriften.** Auf dem neuen Server einmal `php bin/console cms:fonts:fetch` ausführen oder im Designbereich den Knopf drücken – die Dateien liegen nicht im Repository. Bis dahin lädt die Seite die Schriften von Google, was sie nicht soll.
 7. **Rechtstexte.** Impressum und Datenschutzerklärung sind vom alten Auftritt übernommen. Der Abschnitt über Google Fonts wurde an die Wirklichkeit angepasst (die Schriften kommen jetzt vom eigenen Server), die Abschnitte über Google Maps und reCAPTCHA entfernt, weil beides nicht eingebunden ist. **Das ersetzt keine anwaltliche Prüfung**, und es ist die Verantwortung des Betreibers, nicht des CMS.
 8. **Texte.** Acht Projektbeschreibungen stammen nicht vom alten Auftritt, sondern sind neu geschrieben. Sie sollten gelesen werden, bevor sie öffentlich sind.
@@ -1,6 +1,6 @@
 # Projektstatus

-Stand: 14.09.2026, Fassung **1.5.3**. Das System heißt **KantSites** (vorher Arbeitstitel „Kant CMS“). **Startseite von 18 auf 8 Datenbankabfragen, gemessenes Ladebudget, alle langen Listen blättern. Sicherung und Wiederherstellung, letztere nachgewiesen. Globale Seitenbreite wirkt jetzt auch nach oben, vier Menüplätze mit drei Menüarten, und jede Seite wählt ihren Kopf- und Fußbereich – auch „keiner“. 93 Gestaltungseigenschaften, neun Einblendungen, sieben Hover-Effekte, Symbol, Fortschritt und ein Slider ohne JavaScript. Update über Git mit Vorprüfung, Sicherung und Rückweg. Statistik ohne Wiedererkennung und damit ohne Einwilligung. Einwilligung mit tatsächlich zurückgehaltenen Einbettungen, Datenschutz und Impressum als Pflichtseiten. Benutzerverwaltung in der Oberfläche, Mediathek als eigene Seite mit Blättern. Die Verwaltung hat einen gemeinsamen Rahmen mit einer Navigation, die zeigt, wo man ist. Eigenes CSS je Element für alle, eigenes Skript nur für Administratoren und nur als eigene Datei. Formatierter Text mit Werkzeugleiste und HTML-Ansicht, serverseitig gegen eine Positivliste gefiltert. Kopf- und Fußbereich sind frei gestaltbare Blockdokumente, dazu verknüpfte wiederverwendbare Sektionen (Arbeitspaket G, Teil 1). Frei wählbare Startseite; `/sitemap.xml` und Geschwister waren lokal nie erreichbar und sind es jetzt. Seiten verschieben mit automatischen Weiterleitungen, Papierkorb, Fassungsverlauf und geplante Veröffentlichung (Arbeitspaket F). Browsertests wiederhergestellt und erweitert; dabei drei echte Fehler gefunden und behoben, darunter die in der Vorschau wirkungslose Gestaltung. Direktbearbeitung in der Vorschau, Kontrastwarnung, Gestaltungsvorlagen und Bildauswahl für Hintergrundbilder. Der Editor gestaltet frei statt über feste Auswahllisten: eigene Farbpalette, Schriften, und jede Eigenschaft je Block, je Gerät und für den Hover-Zustand frei einstellbar (Dokumentschema v10). SEO-Grundlage mit Sitemap, robots.txt, Weiterleitungen und strukturierten Daten (Arbeitspaket E). Formulare mit serverseitiger Validierung, Einwilligung, E-Mail-Versand und Spamschutz (Arbeitspaket D). Tabs als fortschreitende Verbesserung mit JavaScript (Dokumentschema v7). Zehn neue Blöcke für die Abschnitte der Pilotstartseite (Arbeitspaket C). Beiträge mit Datum, Autor, Auszug, Beitragsbild, Kategorien, Schlagwörtern, Archiven, einbettbarer Beitragsliste und RSS (Arbeitspaket B). Menüs mit Seiten-, Anker- und externen Zielen ersetzen die fest verdrahtete Navigation (Arbeitspaket A). Seiten und Beiträge lassen sich im Browser anlegen und löschen, mit Adresshierarchie bis vier Ebenen.** Die vollständige Phase-1-Abnahme bleibt wegen des fehlenden UX-Builder-Referenzabgleichs offen.
+Stand: 14.09.2026, Fassung **1.6.0**. Das System heißt **KantSites** (vorher Arbeitstitel „Kant CMS“). **Startseite von 18 auf 8 Datenbankabfragen, gemessenes Ladebudget, alle langen Listen blättern. Sicherung und Wiederherstellung, letztere nachgewiesen. Globale Seitenbreite wirkt jetzt auch nach oben, vier Menüplätze mit drei Menüarten, und jede Seite wählt ihren Kopf- und Fußbereich – auch „keiner“. 93 Gestaltungseigenschaften, neun Einblendungen, sieben Hover-Effekte, Symbol, Fortschritt und ein Slider ohne JavaScript. Update über Git mit Vorprüfung, Sicherung und Rückweg. Statistik ohne Wiedererkennung und damit ohne Einwilligung. Einwilligung mit tatsächlich zurückgehaltenen Einbettungen, Datenschutz und Impressum als Pflichtseiten. Benutzerverwaltung in der Oberfläche, Mediathek als eigene Seite mit Blättern. Die Verwaltung hat einen gemeinsamen Rahmen mit einer Navigation, die zeigt, wo man ist. Eigenes CSS je Element für alle, eigenes Skript nur für Administratoren und nur als eigene Datei. Formatierter Text mit Werkzeugleiste und HTML-Ansicht, serverseitig gegen eine Positivliste gefiltert. Kopf- und Fußbereich sind frei gestaltbare Blockdokumente, dazu verknüpfte wiederverwendbare Sektionen (Arbeitspaket G, Teil 1). Frei wählbare Startseite; `/sitemap.xml` und Geschwister waren lokal nie erreichbar und sind es jetzt. Seiten verschieben mit automatischen Weiterleitungen, Papierkorb, Fassungsverlauf und geplante Veröffentlichung (Arbeitspaket F). Browsertests wiederhergestellt und erweitert; dabei drei echte Fehler gefunden und behoben, darunter die in der Vorschau wirkungslose Gestaltung. Direktbearbeitung in der Vorschau, Kontrastwarnung, Gestaltungsvorlagen und Bildauswahl für Hintergrundbilder. Der Editor gestaltet frei statt über feste Auswahllisten: eigene Farbpalette, Schriften, und jede Eigenschaft je Block, je Gerät und für den Hover-Zustand frei einstellbar (Dokumentschema v10). SEO-Grundlage mit Sitemap, robots.txt, Weiterleitungen und strukturierten Daten (Arbeitspaket E). Formulare mit serverseitiger Validierung, Einwilligung, E-Mail-Versand und Spamschutz (Arbeitspaket D). Tabs als fortschreitende Verbesserung mit JavaScript (Dokumentschema v7). Zehn neue Blöcke für die Abschnitte der Pilotstartseite (Arbeitspaket C). Beiträge mit Datum, Autor, Auszug, Beitragsbild, Kategorien, Schlagwörtern, Archiven, einbettbarer Beitragsliste und RSS (Arbeitspaket B). Menüs mit Seiten-, Anker- und externen Zielen ersetzen die fest verdrahtete Navigation (Arbeitspaket A). Seiten und Beiträge lassen sich im Browser anlegen und löschen, mit Adresshierarchie bis vier Ebenen.** Die vollständige Phase-1-Abnahme bleibt wegen des fehlenden UX-Builder-Referenzabgleichs offen.

 Erster Commit angelegt (`82b0782`); das Projekt hat damit einen Rückfallpunkt. Noch kein Remote und kein Push.

@@ -14,6 +14,8 @@ Erster Commit angelegt (`82b0782`); das Projekt hat damit einen Rückfallpunkt.

 **Im Nachbau von kant-it.de gefunden und behoben:** vier tote Verweise im Hero-Slider – die Adressen waren im Aufbauskript von Hand geschrieben, die Beiträge bekamen längere. Sie werden jetzt aus derselben Regel abgeleitet, mit der die Beiträge entstehen, und ein zweiter Lauf des Skripts aktualisiert vorhandene Seiten, statt sie zu überspringen. Eine Prüfung aller internen Verweise auf 404 gibt es im CMS noch nicht; gefunden wurden sie mit einem einmaligen Durchlauf im Browser.

+**Wiederkehrende Aufgaben ohne Cronjob (14.09.2026, ADR 073):** Bis hierher stand in vier Dokumenten „gehört in einen Cronjob“ – auf geteiltem Hosting oft nicht einlösbar, und die Folge war nicht „läuft seltener“, sondern **läuft nie**. Jetzt gibt es einen Aufgabenplan mit vier Auslösern: **jeder Seitenaufruf** (nach der ausgelieferten Antwort, in `kernel.terminate`), das **geöffnete Backend** (im Minutentakt, nur solange der Reiter sichtbar ist), ein **URL-Cronjob** unter `/cms-cron/<Schlüssel>` für Hoster, die nur eine Adresse aufrufen können, und die **Konsole** (`cms:tasks:run`, auch als Dauerläufer mit `--loop`). Fünf Aufgaben sind angeschlossen: geplante Veröffentlichung (5 Minuten), Statistik verdichten, Sicherung, Updateprüfung und Aufräumen (je täglich). Der Bildschirm **Aufgaben** zeigt Plan, letztes Ergebnis, Dauer, Auslöser und Protokoll, schaltet jede Aufgabe einzeln und ändert ihren Abstand. **Die Einschränkung steht auf diesem Bildschirm:** ohne Besuch und ohne geöffnetes Backend passiert nichts – eine Aufgabe für 03:00 Uhr läuft auf einer stillen Website erst um 07:15 Uhr.
+
 ## Erledigt

 - `AGENTS.md` und `ENTWICKLUNGSPLAN.md` unverändert aus Downloads im Projektstamm abgelegt; SHA-256 jeweils mit dem Original identisch.
@@ -36,6 +38,7 @@ Erster Commit angelegt (`82b0782`); das Projekt hat damit einen Rückfallpunkt.
 - Seitenerstellung und -löschung im Browser: `POST /admin/pages` (ab `ROLE_EDITOR`) legt Seite oder Beitrag mit gültigem Startdokument als privaten Entwurf an; `POST /admin/pages/{id}/delete` (nur `ROLE_ADMIN`) entfernt eine Seite mit allen Revisionen. Beide mit CSRF-Token, Fehlermeldungen als Flash und ohne JavaScript bedienbar.
 - Adresshierarchie: neue Spalten `path`, `parent_id`, `type`, `created_at` über Migration `20260912000400`; websiteweit eindeutiger Pfad statt eindeutigem Slug, Tiefe bis vier Ebenen, Beiträge ohne Unterseiten, reservierte Adressen und Adressableitung aus dem Titel. Öffentliche Route bedient verschachtelte Pfade wie `/leistungen/webdesign`; ein Lookahead hält `/admin`, `/media` und `/assets` aus dem Auffangmuster.
 - **Ladeverhalten gemessen statt vermutet** (ADR 039, Arbeitspaket M): ein Zähler liefert die Datenbankabfragen je Anfrage im Kopf `X-Kant-Queries` (außerhalb der Produktion). Die erste Messung zeigte 18 Abfragen auf der Startseite, weil Einstellungen und Theme je Aufrufer erneut gelesen wurden; beide merken sich ihren Stand jetzt für die Dauer einer Anfrage – **18 → 8**. Die Browserprüfung misst je Seite HTML, CSS, Anfragen, Skripte und Abfragen gegen Obergrenzen: Startseite 7,4 KB HTML, 22,7 KB CSS, 2 Anfragen, 0 Skripte.
+- **Aufgabenplan ohne Cronjob** (ADR 073, Migration `20260914000100`): eine Zeile je Aufgabe mit Fälligkeit, Sperre und letztem Ergebnis. Wer sie ausführen darf, entscheidet ein bedingtes `UPDATE` – auf MySQL wie auf SQLite atomar, damit zwei gleichzeitige Besucher eine Aufgabe nicht zweimal starten; die Sperre verfällt nach 15 Minuten von selbst. Der Normalfall kostet **keine Datenbankabfrage**: in `var/scheduler.json` steht, wann überhaupt das nächste Mal etwas ansteht. Ein Fehlschlag ist ein sichtbarer Zustand mit wachsendem Abstand bis zum nächsten Versuch (Verdopplung, gedeckelt bei sechs Stunden), und eine scheiternde Aufgabe reißt nie eine Seite mit. Neue Aufgaben sind eine Datei: wer `App\Ops\Tasks\Task` implementiert, steht beim nächsten Abgleich im Plan. Befehle: `cms:tasks`, `cms:tasks:run` (`--task`, `--limit`, `--budget`, `--loop`, `--max-time`).
 - **Das erste Bild einer Seite lädt sofort**, alles darunter weiterhin verzögert. Es ist meistens das größte Ding über der Falz.
 - **Slider mit Punkten ohne Skript** (ADR 044): `::scroll-marker` zeichnet je Folie einen Punkt, der aktive ist erkennbar, die Rollleiste entfällt; ältere Browser behalten das wischbare Schiebefeld. Beitragskarten sind echte Karten (Bild 16:10, 18 px Ecken). Überschriften dürfen ein Wort hervorheben (`<mark>`, in Akzentfarbe). Behoben: die Theme-Schriftskala überschrieb die Größen in Karten und Aufruf-Bändern.
 - **„Weiterlesen" ist jetzt ein Link.** In der wechselseitigen Beitragsliste stand dort eine reine Beschriftung: sie sah aus wie ein Knopf und war keiner. Der Titel steckt für Vorlesesoftware im Linktext, damit nicht zwölf Links gleich heißen.
@@ -141,6 +144,7 @@ Erster Commit angelegt (`82b0782`); das Projekt hat damit einen Rückfallpunkt.
 - 201 PHP-Tests / 716 Assertions unter PHP 8.2.12 und 8.4.22 erfolgreich; zusätzlich 15 JavaScript-Modelltests, der vollständige Playwright-Editortest und die öffentliche Browserprüfung. Abgedeckt sind Migration/Erhaltung, Versionen, ungültige Geräte-/Typ-/Design-/Effektwerte, Vererbung/Reset/Undo, Vorlage-/Galerie-IDs, Uploadvalidierung und Neuencodierung, Metadatenkonflikte, Archivierung sowie sichere Bildquellen.
 - Neu geprüft (15 Tests): privater Entwurf nach dem Anlegen, verschachtelte Pfade mit gleichem Slug unter verschiedenen Eltern, abgewiesene Adressen (Großbuchstaben, Schrägstrich, leer, reserviert, unbekannter Typ, fehlendes Elternteil) ohne Schreibzugriff, doppelte Adresse, Tiefengrenze, Beiträge ohne Unterseiten, Löschen mit allen Revisionen samt Schutz für Elternseiten und veraltete Versionen, sowie dass die CMS-Routen nicht vom öffentlichen Auffangmuster verschluckt werden. Über HTTP zusätzlich: anonyme Schreibversuche, CSRF für Anlegen und Löschen, Adressableitung aus dem Titel, kein Löschangebot und HTTP 403 für die Editorrolle, erfolgreiches Löschen als Administrator.
 - Verwaltung geprüft: axe ohne Verstöße auf Anmeldung, Seitenübersicht und Editor (Desktop und Mobil), 201 PHP-Tests grün. **Nicht geprüft:** kein Screenreader, und die Bildschirme Menüs, Formulare, Bereiche, Design, Einstellungen und Fassungen sind nur von Hand angesehen, nicht automatisiert auf Barrierefreiheit geprüft – die Browserprüfung deckt sie nicht ab.
+- **Aufgabenplan geprüft** (14.09.2026): 12 Tests auf die Mechanik (nur Fälliges läuft; eine gesperrte Aufgabe wird übergangen, eine abgelaufene Sperre übernommen; ein Fehlschlag wird festgehalten und der nächste Versuch rückt weiter weg; eine abgeschaltete Aufgabe läuft nicht, von Hand gestartet doch; eine Anfrage arbeitet nicht alles auf einmal ab; eine fehlende Tabelle ist kein Fehler) und 5 über HTTP (der Bildschirm nennt jede Aufgabe und die Adresse des URL-Cronjobs; anonym führt niemand etwas aus, eine Redakteurin bekommt 403, ohne gültiges Formular passiert nichts; der Takt des Backends antwortet mit JSON; ein falscher Cron-Schlüssel bekommt 404). Von Hand auf der Entwicklungsinstallation **alle vier Auslöser ausgeführt**: alle fünf Aufgaben über die Konsole (Sicherung 36 ms, Updateprüfung 318 ms gegen das echte Repository), ein Seitenaufruf hat eine fällige Aufgabe abgearbeitet (Auslöser `besuch` im Protokoll), das geöffnete Backend hat getaktet (`POST /admin/aufgaben/takt` → 200), und der URL-Cronjob hat mit dem richtigen Schlüssel Text geliefert und mit einem falschen 404. Der Bildschirm wurde im Browser bedient (Abstand und Schalter gespeichert und wieder zurückgesetzt); dabei fiel eine Inline-Stilangabe auf, die die CSP der Verwaltung blockiert hat – sie ist jetzt eine Klasse.
 - Ladeverhalten geprüft: drei Tests – 30 Fassungen ergeben zwei Seiten mit richtiger Reihenfolge und richtigem Rest, eine Seite jenseits des Endes zeigt die letzte statt einer leeren; das erste Bild trägt `loading="eager"` und `fetchpriority="high"`, das zweite `lazy`; und die Startseite bleibt unter zwölf Abfragen. Dazu das Ladebudget in der Browserprüfung.
 - **Wiederherstellung nachgewiesen**, nicht nur gebaut – das war der älteste offene Punkt aus Arbeitspaket I. Acht Tests gegen eine wegwerfbare Installation, darunter der eigentliche: Sicherung anlegen, Seite und Bilddatei löschen, zurückspielen, beides ist wieder da. Dazu von Hand auf der Entwicklungsinstallation: Testseite angelegt (5 Seiten), gesichert, gelöscht (4), zurückgespielt (5, Seite mit ihrer Adresse wieder da), Testseite entfernt (4). Ebenfalls geprüft: eine manipulierte Sicherung wird abgewiesen, eine aus einer neueren Fassung nur mit `--force`, Rotation behält die neuesten, und eine nach der Sicherung hochgeladene Datei überlebt die Wiederherstellung.
 - Seitenbereiche geprüft: Standard, anderer Bereich, „keiner“ (dann steht weder `site-header` noch `site-footer` im HTML, die Seite selbst aber schon), ein Verweis auf einen gelöschten Bereich fällt auf den Standard zurück, eine veraltete Fassungsnummer und eine ungültige Adresse werden abgewiesen. Menüarten: drei angenommen, eine erfundene abgewiesen, Burger als `details` – und die Seite behält `script-src 'none'`. Seitenbreite: die Regel in `site.css` nimmt den Theme-Wert, und ein größerer Wert erscheint als `--k-container` im Seiten-Stylesheet.
@@ -199,6 +203,7 @@ Erster Commit angelegt (`82b0782`); das Projekt hat damit einen Rückfallpunkt.
 - Gestaltung über geprüfte Tokens, keine beliebigen Pixelwerte, eigenen Schriften oder freien Farben. Noch keine Inline-Textbearbeitung, Formulare, dynamischen Menüs, Plugin-/Themeverwaltung oder WordPress-Import. Abschnittsvorlagen sind lokale Blockrezepte, keine globale Templateverwaltung.
 - Mediathek derzeit für statische Bilder: keine Videos/PDFs/SVGs, Lightbox/Slideshow, freie Bildzuschnitte, Ordner, Paginierung oder physische Löschung. Bild-URLs sind öffentlich; Archivieren schützt keine vertraulichen Dateien. Originale werden durch optimierte Varianten ersetzt. Einblendungen starten beim Laden, nicht beim Scrollen.
 - Sektionen bieten die vorhandenen Farb-/Breitentokens geräteübergreifend. Benutzerverwaltung und Passwortänderung sind noch nicht als Browseroberfläche verfügbar.
+- **Der Aufgabenplan ist von Anfragen abhängig.** Ohne Besucher und ohne geöffnetes Backend läuft nichts; minutengenau ist nur ein echter Cronjob oder der URL-Cronjob des Hosters. Unter Apache mit mod_php belegt eine laufende Aufgabe einen PHP-Prozess, nachdem die Seite beim Besucher ist (dort gibt es kein `fastcgi_finish_request()`) – deshalb sind die Grenzen je Seitenaufruf klein (2 Aufgaben, 20 Sekunden) und der Auslöser abschaltbar. Die Sicherung ist die schwerste Aufgabe und läuft trotzdem mit: eine tägliche Sicherung ist mehr wert als keine. **Nicht geprüft:** das Verhalten unter mod_php und unter echter Last – hier lief alles gegen den eingebauten PHP-Server.
 - **Offene redaktionelle Feststellung:** `/grundlagen` trägt einen im Editor gesetzten Textblock in `#d08080` auf hellem Grund – 2,75:1, unter der AA-Schwelle. Die Farbe wurde **nicht** verändert, weil sie eine Nutzerentscheidung ist; die Prüfung nennt sie bei jedem Lauf, und die Kontrastwarnung im Editor meldet sie ebenfalls.
 - **Aus Umuts erweitertem Auftrag noch offen** (Paket G2 im Ausbauplan): die Neugestaltung der Verwaltung.
 - Eigenes CSS kennt keine Gerätevarianten – dafür sind die Vorschaugrößen im Designbereich da. Eigenes Skript hat keine Fassungsverwaltung außer der Seitenhistorie und keine Prüfung auf Syntaxfehler; ein fehlerhaftes Skript schreibt in die Browserkonsole und lässt die Seite sonst unangetastet.
@@ -410,6 +415,93 @@ Werkzeugkasten ist seit 1.5.1 nichts ohne sein Skript. Für einen Editor ist das
 öffentliche Website läuft ohne JavaScript –, aber die Fehleranzeige dafür ist noch die
 Browserkonsole und kein Satz in der Oberfläche.

+## Arbeitspaket H, Teil 3b: der Werkzeugkasten bekommt Bilder und eine Suche
+
+**Erledigt.** Die Elementwahl war eine Liste aus Schriftzeichen – „▣“ für Sektion, „☰“ für Zeile.
+Jetzt trägt jeder der 34 Einträge eine Strichzeichnung, die zeigt, was er baut: die Sektion ein
+gefülltes Band, „Zeile, 3 Spalten“ tatsächlich drei Kästen, das Bild einen Rahmen mit Bergzug.
+
+**Zeichnungen statt Bilddateien.** Flatsome liefert je Element ein PNG mit. Gezeichnet ist hier
+besser: `library-previews.js` ist ein paar hundert Byte statt eines Ordners voller Bitmaps, die
+Formen nehmen die Farbe der Fläche an, auf der sie liegen – gesperrte Einträge werden damit von
+selbst blass – und sie bleiben auf jedem Bildschirm scharf. Die Zeilenvorschau wird gerechnet,
+nicht gezeichnet: zwei, drei oder vier Kästen aus derselben Funktion.
+
+**Suche.** Ein Feld über der Liste filtert über alle Gruppen. Gesucht wird über den Namen, den
+internen Typ **und** den Gruppennamen – wer „slider“ eingibt, muss nicht wissen, dass er unter
+„Gruppen“ einsortiert ist. Gruppen ohne Treffer verschwinden, damit die Liste keine Lücken
+behält, und darunter steht, wie viele von wie vielen übrig sind.
+
+**Dabei bemerkt:** Es gab damit zwei Suchfelder mit dem Namen „Element suchen“ auf einem
+Bildschirm – für eine Sprachausgabe nicht unterscheidbar. Sie heißen jetzt nach dem, was sie
+durchsuchen: „Element zum Einfügen suchen“ im Werkzeugkasten, „Element auf der Seite suchen“ im
+Strukturbaum.
+
+**Geprüft.** Der Browsertest zählt die Vorschaubilder gegen die Einträge (alle 34 haben eines),
+sucht nach „galerie“ (ein Eintrag, eine Gruppe), nach „aufbau“ (fünf Einträge über den
+Gruppennamen), nach etwas Nichtvorhandenem und wieder nach nichts. `npm test` 28 von 28,
+`php vendor/bin/phpunit` 452 von 452, `npm run test:editor` vollständig ohne axe-Verstoß.
+
+**Noch offen aus Teil 3.** Vorlagen je Element mit Vorschaubild. Und das Ziehen der
+Spaltenbreite: das geht heute nicht ohne einen Zwischenschritt, denn eine Zeile ist ein
+CSS-Raster mit **gleich breiten** Spalten (`repeat(n, minmax(0,1fr))`); ein `span` je Spalte
+gibt es nicht. Dafür braucht es erst ein Zwölf-Spalten-Modell im Designtoken-Manifest, und das
+berührt die öffentliche CSS und damit die Messwerte aus AGENTS.md. Das ist ein eigener Schritt,
+kein Nebenbei.
+
+## 1.5.5: die Verwaltungsnavigation war am Schreibtisch unerreichbar
+
+**Der Fehler.** In der ausgelieferten Fassung fehlte in der Verwaltung am Schreibtisch die
+gesamte linke Navigation – Marke oben, Fußzeile unten, dazwischen nichts. Kein Weg zu Seiten,
+Mediathek, Einstellungen außer über die Adresszeile.
+
+Die Navigation steckt in einem `<details>`: auf dem Telefon ein Klappmenü, am Schreibtisch die
+stehende Spalte. Am Schreibtisch wurde der Schalter mit `.shell-menu > summary { display: none }`
+ausgeblendet – aber das Element trug kein `open`, und ein geschlossenes `details` versteckt seinen
+Inhalt selbst. Schalter weg **und** Inhalt weg.
+
+**Die Behebung.** `::details-content` holt den Inhalt am Schreibtisch zurück, während der
+Schalter ausgeblendet bleibt. Kennt ein Browser die Regel nicht, fällt über `@supports` die ganze
+Gruppe weg: dann steht der Schalter da und die Liste ist einen Klick entfernt – statt gar nicht
+da. Auf dem Telefon bleibt es beim Klappmenü.
+
+Der Code dafür lag bereits im Arbeitsverzeichnis: eine parallel laufende Sitzung hatte ihn
+geschrieben, aber nicht committet, und damit war er in keinem Release. Übernommen ist hier nur
+diese Korrektur, nicht die übrige Arbeit jener Sitzung.
+
+**Wie das durchrutschen konnte – und was dagegen getan ist.** Beim vorigen Bericht wurde die
+Navigation für in Ordnung erklärt, nachdem eine **Nachbildung** der Regel in einer leeren Seite
+geprüft worden war. Die Nachbildung enthielt die Korrektur, die ausgelieferte Datei nicht; der
+Befund war damit wertlos. Jetzt prüft der Browsertest die **echte** Verwaltungsseite: am
+Schreibtisch kein Schalter, Navigation sichtbar, der Eintrag „Seiten“ mit messbarer Fläche; auf
+390 px Breite ein Schalter, Liste zunächst zu, ein Klick öffnet sie. Gegenprobe gemacht – gegen
+die ausgelieferte `admin.css` schlägt der Test fehl.
+
+**Geprüft.** `npm run test:editor` vollständig, `npm test` 28 von 28,
+`php vendor/bin/phpunit` 452 von 452.
+
+## 1.6.0: der Aufgabenplan wird veröffentlicht
+
+Diese Fassung bringt den **Aufgabenplan ohne Cronjob** (ADR 073, oben beschrieben) in ein
+Release. Er entstand in einer parallel laufenden Sitzung und lag bis hierher unveröffentlicht im
+Arbeitsverzeichnis – die Releases 1.5.0 bis 1.5.5 wurden bewusst aus dem jeweiligen Tag gebaut
+und enthielten ihn deshalb nicht.
+
+**Vor der Veröffentlichung geprüft, nicht bloß eingepackt:**
+
+- `php vendor/bin/phpunit` 452 von 452, `npm test` 28 von 28, `npm run test:editor` vollständig.
+- Die Migration `20260914000100` legt **nur** die Tabelle `scheduled_task` an und nimmt sie beim
+  Zurückrollen wieder weg. Sie fasst keine bestehenden Daten an – das ist die risikoarme Sorte.
+- Seit einer Stunde keine Schreibzugriffe der anderen Sitzung mehr; der Stand ist ruhig.
+
+**Dabei zwei Fehler behoben:**
+
+- `config/services.yaml` verwendet `!tagged_iterator`. Das ist gültiges Symfony, aber
+  `php bin/console lint:yaml config` kennt eigene Tags nur mit `--parse-tags` und gab 1 zurück –
+  der CI-Lauf in `.github/workflows/ci.yml` wäre daran gescheitert. Das Flag ist ergänzt.
+- `src/EventSubscriber/AdminHeadersSubscriber.php` (aus 1.5.3) entsprach nicht dem Stil von
+  `php-cs-fixer`; `composer lint` gab 8 zurück. Behoben, jetzt 0 von 128 Dateien zu ändern.
+
 ## Nächster konkreter Schritt

 Arbeitspaket H, Teil 3b: Vorschaubilder und Suche im Werkzeugkasten, Vorlagen je Element mit
@@ -0,0 +1,66 @@
+<?php
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20260914000100 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Der Aufgabenplan: eine Zeile je wiederkehrender Aufgabe, mit Faelligkeit, Sperre und letztem Ergebnis.';
+    }
+
+    public function isTransactional(): bool
+    {
+        return false;
+    }
+
+    public function up(Schema $schema): void
+    {
+        // Warum eine Tabelle und keine Datei: die Sperre. Zwei Besucher koennen im selben
+        // Moment dieselbe Aufgabe faellig sehen, und nur einer darf sie ausfuehren. Ein
+        // bedingtes UPDATE ist auf MySQL wie auf SQLite atomar; zwei Prozesse, die eine Datei
+        // sperren, sind es auf geteiltem Hosting nicht zuverlaessig.
+        //
+        // Die Tabelle bleibt klein - eine Zeile je registrierter Aufgabe, heute fuenf. Deshalb
+        // steht hier kein Index: ein voller Durchlauf ueber fuenf Zeilen ist billiger als ein
+        // Index, den jede Aenderung mitpflegen muss.
+        $tasks = $schema->createTable('scheduled_task');
+        // Der technische Name aus dem Code, zum Beispiel `publish-due`. Er ist der Schluessel:
+        // verschwindet eine Aufgabe aus dem Code, verschwindet ihre Zeile beim naechsten Abgleich.
+        $tasks->addColumn('name', 'string', ['length' => 64]);
+        // Der Abstand zwischen zwei Laeufen. Kommt als Vorgabe aus dem Code und ist in der
+        // Verwaltung aenderbar, weil eine taegliche Sicherung auf der einen Installation
+        // richtig und auf der naechsten zu selten ist.
+        $tasks->addColumn('interval_seconds', 'integer', ['default' => 3600]);
+        $tasks->addColumn('enabled', 'boolean', ['default' => true]);
+        // Alle Zeitpunkte in UTC, als Zeichenkette verglichen - wie ueberall sonst im Projekt.
+        $tasks->addColumn('next_run_at', 'datetime_immutable');
+        $tasks->addColumn('last_run_at', 'datetime_immutable', ['notnull' => false]);
+        // Bis wann diese Aufgabe als "laeuft gerade" gilt. Danach darf sie ein anderer
+        // Durchlauf uebernehmen: ein Prozess, den das Hosting nach 30 Sekunden abgeschossen
+        // hat, kann seine Sperre nicht mehr selbst aufraeumen.
+        $tasks->addColumn('locked_until', 'datetime_immutable', ['notnull' => false]);
+        $tasks->addColumn('last_status', 'string', ['length' => 16, 'notnull' => false]);
+        $tasks->addColumn('last_message', 'string', ['length' => 500, 'default' => '']);
+        $tasks->addColumn('last_duration_ms', 'integer', ['default' => 0]);
+        // Wodurch der letzte Lauf ausgeloest wurde: besuch, verwaltung, cron, konsole, hand.
+        // Steht hier, weil die erste Frage bei einer Stoerung immer dieselbe ist: laeuft der
+        // Ausloeser ueberhaupt, den der Betreiber eingerichtet zu haben glaubt?
+        $tasks->addColumn('last_trigger', 'string', ['length' => 16, 'default' => '']);
+        // Aufeinanderfolgende Fehlschlaege. Sie verlaengern den Abstand bis zum naechsten
+        // Versuch, damit eine Aufgabe, die nicht laufen kann, nicht bei jedem Seitenaufruf
+        // wieder anfaengt.
+        $tasks->addColumn('failures', 'integer', ['default' => 0]);
+        $tasks->setPrimaryKey(['name']);
+    }
+
+    public function down(Schema $schema): void
+    {
+        // Faellt die Tabelle, faellt nur der Plan: Zeitpunkte und letzte Meldungen. Kein Inhalt,
+        // kein Konto, keine Datei. Beim naechsten Start legt der Abgleich sie neu an.
+        $schema->dropTable('scheduled_task');
+    }
+}
@@ -446,6 +446,11 @@ details.card > summary:hover { background: #fafbf8 }
 .theme-table td input[type=color] { width: 52px }
 .theme-table .weights-cell { white-space: nowrap }
 .redirect-table td { padding: 8px 12px 8px 0; font-size: 12px }
+/* Der Aufgabenplan: die erste Spalte traegt Text, die schmalen tragen Zahlen und Schalter. */
+.tasks-table td:first-child { min-width: 220px; max-width: 340px }
+.tasks-table td input[type=number] { width: 92px }
+.tasks-table td .field-help { margin-top: 4px }
+.tasks-table .row-actions, .tasks-table td:last-child { white-space: nowrap }
 /* Headings inside a card separate its parts without a second border. */
 .card-body .section-head { margin: 28px 0 12px }
 .card-body .section-head:first-child { margin-top: 14px }
@@ -665,21 +670,33 @@ details.card > summary:hover { background: #fafbf8 }
   also zwei Zeilen, und der letzte Eintrag ausserhalb des Bildes. Auf einem Telefon ist ein
   Klappmenue ehrlicher: eine Zeile im Ruhezustand, aufgeklappt die vollstaendige Liste mit
   Flaechen, die ein Daumen trifft. Das details-Element macht das ohne Skript. */
-.shell-menu > summary { display: none }
+/* Der Schalter traegt seine Gestalt hier, nicht erst im Telefonabschnitt: am Schreibtisch
+   wird er ausgeblendet, aber nur dort, wo der Inhalt sicher sichtbar ist. */
+.shell-menu > summary {
+    display: flex; align-items: center; gap: 10px; list-style: none; cursor: pointer;
+    min-height: 44px; padding: 0 14px; border-radius: 10px;
+    background: #ffffff14; color: #fff; font-weight: 600; font-size: 15px;
+}
+.shell-menu > summary::-webkit-details-marker { display: none }
+.shell-menu > summary:focus-visible { outline: 3px solid var(--mint); outline-offset: 2px }
+.shell-menu[open] > summary { margin-bottom: 8px }
+.shell-menu-icon { font-size: 17px }
+/* Am Schreibtisch steht die Liste dauerhaft da. Ein geschlossenes details-Element versteckt
+   seinen Inhalt aber von sich aus - der Schalter allein auszublenden loescht die Navigation.
+   Erst ::details-content holt sie zurueck. Kennt ein Browser die Regel nicht, faellt die
+   ganze Gruppe weg und der Schalter bleibt stehen: die Liste ist dann einen Klick entfernt
+   statt gar nicht da. */
+@supports selector(::details-content) {
+    .shell-menu > summary { display: none }
+    .shell-menu::details-content { content-visibility: visible; block-size: auto }
+}
@media (max-width: 760px) {
    .shell-nav { flex-wrap: wrap; padding: 10px 14px; gap: 10px; overflow: visible }
    .shell-menu { flex: 1 1 100%; order: 3 }
-    .shell-menu > summary {
-        display: flex; align-items: center; gap: 10px; list-style: none; cursor: pointer;
-        min-height: 44px; padding: 0 14px; border-radius: 10px;
-        background: #ffffff14; color: #fff; font-weight: 600; font-size: 15px;
-    }
-    .shell-menu > summary::-webkit-details-marker { display: none }
-    .shell-menu > summary:focus-visible { outline: 3px solid var(--mint); outline-offset: 2px }
-    .shell-menu-icon { font-size: 17px }
-    .shell-menu[open] > summary { margin-bottom: 8px }
+    .shell-menu > summary { display: flex }
    .shell-menu nav { display: block }
    .shell-menu:not([open]) nav { display: none }
+    .shell-menu:not([open])::details-content { content-visibility: hidden; block-size: 0 }
    .nav-label { display: block; margin: 12px 4px 6px; font-size: 11px; letter-spacing: 1.4px; color: #9db3a8 }
    .nav-list { display: grid; gap: 2px }
    /* Vierundvierzig Pixel: die Flaeche, die ein Daumen zuverlaessig trifft. */
@@ -270,13 +270,14 @@ dialog p{font-size:14px;line-height:1.7;color:var(--muted)}
 .library-group-title{font-size:10px;font-weight:700;letter-spacing:1.1px;text-transform:uppercase;color:var(--muted);margin:0 0 7px}
 .library-group-hint{font-size:10px;line-height:1.5;color:var(--muted);margin:-3px 0 8px}
 .library-buttons{display:grid;grid-template-columns:1fr 1fr;gap:6px}
-.library-buttons button{display:flex;align-items:center;gap:7px;text-align:left;min-height:38px;padding:7px 9px;border:1px solid var(--line);border-radius:7px;background:#f7f9f2;color:var(--ink);font-size:11px;line-height:1.25}
-.library-buttons button>span:first-child{flex:none;width:14px;text-align:center;font-size:13px;color:var(--accent)}
+.library-buttons button{display:flex;align-items:center;gap:8px;text-align:left;min-height:44px;padding:6px 8px;border:1px solid var(--line);border-radius:7px;background:#f7f9f2;color:var(--ink);font-size:11px;line-height:1.25}
+.library-preview{flex:none;display:grid;place-items:center;width:34px;height:23px;color:var(--accent);opacity:.85}
+.library-buttons button:disabled .library-preview{color:var(--muted);opacity:.6}
+.library-name{min-width:0}
 .library-buttons button:hover:not(:disabled){border-color:var(--accent);background:#fff}
 .library-buttons button:disabled{opacity:.4;background:transparent;cursor:not-allowed}
-.library-buttons button:disabled>span:first-child{color:var(--muted)}
-/* A row is offered by column count, so its glyph shows the count - and needs the room for it,
-   instead of the fixed single-glyph width the other entries share. */
-.library-buttons button>span.library-row-glyph{width:auto;letter-spacing:0;font-size:10px;color:var(--accent)}
 .library-buttons button[data-row]{grid-column:span 2}
@media(max-width:1150px){.library-buttons{grid-template-columns:1fr}.library-buttons button[data-row]{grid-column:span 1}}
+
+#library-search{font-size:11px;min-height:36px;padding:9px;margin-bottom:4px}
+#library-found{margin:0 0 10px;min-height:0}
@@ -1,8 +1,9 @@
-import { EditorHistory, labels, icons, blockLabel, blockIcon, isPluginBlock, setStyle, effectiveStyle, locate, clone, isContainer, canContain, insertBlock, insertBlockAt, insertionTarget, moveBlockTo, duplicateBlock, moveBlock, devices, effectiveDesign, setDesign, blockPath, insertPreset, insertRow, insertRowAt, setEffect, insertMedia, upgradeDocument, CATEGORIES, ROW_COLUMNS, whyNot, dropList } from './editor-model.js';
+import { EditorHistory, labels, blockLabel, blockIcon, isPluginBlock, setStyle, effectiveStyle, locate, clone, isContainer, canContain, insertBlock, insertBlockAt, insertionTarget, moveBlockTo, duplicateBlock, moveBlock, devices, effectiveDesign, setDesign, blockPath, insertPreset, insertRow, insertRowAt, setEffect, insertMedia, upgradeDocument, CATEGORIES, ROW_COLUMNS, whyNot, dropList } from './editor-model.js';
 import { openMedia } from './media.js';
 import { createDesignPanel } from './design-panel.js';
 import { createRichText } from './rich-text.js';
 import { createCanvasOverlay } from './canvas-overlay.js';
+import { preview, rowPreview } from './library-previews.js';

 // Mirrors DocumentValidator::ICONS; the server rejects anything outside this list.
 const ICONS = ['app', 'web', 'design', 'network', 'hardware', 'shop', 'support', 'shield', 'clock', 'star', 'phone', 'mail', 'pin', 'check'];
@@ -68,7 +69,7 @@ function controls() {
  updateLibrary();
  $('#presets').querySelectorAll('button').forEach(button => button.disabled = !ready || busy);
  $('#properties').querySelectorAll('input,textarea,select,button').forEach(input => input.disabled = busy);
-  document.querySelectorAll('[data-panel],[data-viewport],#tree-search,#expand-all,#collapse-all').forEach(input => input.disabled = !ready || busy);
+  document.querySelectorAll('[data-panel],[data-viewport],#tree-search,#library-search,#expand-all,#collapse-all').forEach(input => input.disabled = !ready || busy);
  $('[data-panel="design"]').disabled ||= !current;
  $('#select-page').disabled = !ready || busy;
  $('#open-media-library').disabled = !ready || busy;
@@ -756,12 +757,18 @@ function buildLibrary() {
        button.type = 'button'; button.draggable = true;
        button.dataset.add = type;
        if (columns) button.dataset.row = String(columns);
-        const glyph = document.createElement('span'); glyph.setAttribute('aria-hidden', 'true');
-        glyph.textContent = columns ? '▥'.repeat(Math.min(columns, 4)) : icons[type];
-        if (columns) glyph.className = 'library-row-glyph';
+        const name = columns ? `${labels[type]}, ${columns} Spalten` : labels[type];
+        // What is searched for: the name, the internal type and the group it sits in. Someone
+        // looking for "slider" should not have to know it is filed under "Gruppen".
+        button.dataset.search = `${name} ${type} ${category.name}`.toLocaleLowerCase('de');
+        const picture = document.createElement('span');
+        picture.className = 'library-preview';
+        // Drawn, not written: the shapes come from this editor and carry no untrusted text.
+        picture.innerHTML = columns ? rowPreview(columns) : preview(type);
        const text = document.createElement('span');
-        text.textContent = columns ? `${labels[type]}, ${columns} Spalten` : labels[type];
-        button.append(glyph, text);
+        text.className = 'library-name';
+        text.textContent = name;
+        button.append(picture, text);
        list.append(button);
      }
    }
@@ -789,6 +796,24 @@ function updateLibrary() {
  }
 }

+/** Filters the toolbox. A group without a hit disappears, so the list does not keep its gaps. */
+function filterLibrary() {
+  const term = $('#library-search').value.trim().toLocaleLowerCase('de');
+  let hits = 0;
+  for (const group of $('#library').querySelectorAll('.library-group')) {
+    let visible = 0;
+    for (const button of group.querySelectorAll('button')) {
+      const hit = '' === term || (button.dataset.search ?? '').includes(term);
+      button.hidden = !hit;
+      if (hit) visible++;
+    }
+    group.hidden = 0 === visible;
+    hits += visible;
+  }
+  $('#library-found').textContent = '' === term ? '' : (0 === hits ? 'Kein Element mit diesem Namen.' : `${hits} von ${$('#library').querySelectorAll('button').length}`);
+}
+$('#library-search').addEventListener('input', filterLibrary);
+
 $('#library').addEventListener('click', event => {
  const button = event.target.closest('[data-add]');
  if (!button || button.disabled) return;
@@ -0,0 +1,76 @@
+/**
+ * Line art for the toolbox.
+ *
+ * Flatsome ships a PNG per element. Drawings are better here: they are a few hundred bytes
+ * instead of a folder of bitmaps, they take the colour of the surface they sit on, and they stay
+ * sharp on a screen of any density. Every shape lives in the same 24x16 field so the entries
+ * line up in the grid.
+ *
+ * Each value is the inside of an `<svg>`; `stroke` and `fill` come from the wrapper, so a shape
+ * only says what it is, not what colour it has.
+ */
+
+/** A filled bar, the building block most of these are made of. */
+const bar = (x, y, width, height = 2) => `<rect x="${x}" y="${y}" width="${width}" height="${height}" rx="${Math.min(height, 2) / 2}" fill="currentColor" stroke="none"/>`;
+/** Several bars under each other, as a paragraph of text. */
+const lines = (...widths) => widths.map((width, index) => bar(3, 4 + index * 3.4, width, 1.7)).join('');
+
+export const PREVIEWS = {
+  // Aufbau
+  section: '<rect x="1" y="3" width="22" height="10" rx="1.5" fill="currentColor" opacity=".14" stroke="none"/><rect x="1" y="3" width="22" height="10" rx="1.5"/>',
+  row: '<rect x="1" y="3" width="22" height="10" rx="1.5"/><path d="M12 3.6v8.8"/>',
+  column: '<rect x="8" y="1.5" width="8" height="13" rx="1.5"/>',
+
+  // Inhalt
+  heading: `${bar(3, 3.6, 18, 3)}${bar(3, 9, 11, 2)}`,
+  text: lines(18, 16, 11),
+  image: '<rect x="2" y="2.5" width="20" height="11" rx="1.5"/><circle cx="7.5" cy="6.5" r="1.4" fill="currentColor" stroke="none"/><path d="M3.2 12l5-4.4 3.6 3.1 3-2.6 5 3.9"/>',
+  button: '<rect x="4" y="4.5" width="16" height="7" rx="2"/>',
+  icon: '<path d="M12 2.6l2.7 5.6 6 .8-4.4 4.1 1.1 5.8" transform="scale(.86) translate(2 .4)"/><path d="M12 2.6l-2.7 5.6-6 .8 4.4 4.1-1.1 5.8" transform="scale(.86) translate(2 .4)"/>',
+  divider: '<path d="M2 8h20"/>',
+  spacer: '<path d="M3 3h18M3 13h18"/><path d="M12 5.6v4.8M10.4 6.8L12 5.2l1.6 1.6M10.4 9.2L12 10.8l1.6-1.6"/>',
+
+  // Bausteine
+  iconcard: `<rect x="3" y="2.5" width="4.5" height="4.5" rx="1.2"/>${bar(3, 9, 12, 1.9)}${bar(3, 12, 8, 1.5)}`,
+  stat: `${bar(3, 3, 9, 5)}${bar(3, 10.5, 14, 1.7)}`,
+  quote: `<path d="M3.4 7.6c0-2 1.3-3.2 2.9-3.4M8.4 7.6c0-2 1.3-3.2 2.9-3.4"/><path d="M3.4 7.6h2.9v3.2H3.4zM8.4 7.6h2.9v3.2H8.4z"/>${bar(14, 5.6, 7, 1.6)}${bar(14, 9, 5, 1.6)}`,
+  cta: `${bar(2.5, 4, 12, 2.4)}<rect x="2.5" y="8.6" width="9" height="5" rx="1.6"/><rect x="14.5" y="8.6" width="7" height="5" rx="1.6" fill="currentColor" stroke="none"/>`,
+  contact: '<rect x="2.5" y="3.5" width="19" height="9" rx="1.5"/><path d="M2.9 4.4l9.1 5 9.1-5"/>',
+  logos: [2.5, 8, 13.5, 19].map(x => `<rect x="${x}" y="5.5" width="4.5" height="5" rx="1.2"/>`).join(''),
+  progress: '<rect x="2" y="6" width="20" height="4" rx="2"/><rect x="2" y="6" width="12" height="4" rx="2" fill="currentColor" stroke="none"/>',
+
+  // Gruppen
+  gallery: [2.5, 12.5].flatMap(x => [2.5, 8.5].map(y => `<rect x="${x}" y="${y}" width="9" height="5" rx="1.2"/>`)).join(''),
+  accordion: '<rect x="2.5" y="2" width="19" height="4" rx="1.2"/><path d="M18 3.6l1.3 1.3 1.3-1.3"/><rect x="2.5" y="7.5" width="19" height="3" rx="1.2"/><rect x="2.5" y="12" width="19" height="3" rx="1.2"/>',
+  accordionitem: '<rect x="2.5" y="5.5" width="19" height="5" rx="1.2"/><path d="M17.6 7.4l1.3 1.3 1.3-1.3"/>',
+  tabs: '<rect x="2.5" y="2" width="6" height="3.5" rx="1" fill="currentColor" stroke="none"/><rect x="9.5" y="2" width="6" height="3.5" rx="1"/><rect x="2.5" y="6.5" width="19" height="7.5" rx="1.2"/>',
+  tabitem: '<rect x="7" y="2.5" width="10" height="4" rx="1" fill="currentColor" stroke="none"/><rect x="2.5" y="7.5" width="19" height="6" rx="1.2"/>',
+  slider: '<rect x="5.5" y="3" width="13" height="10" rx="1.5"/><path d="M3.4 6.6L1.6 8l1.8 1.4M20.6 6.6L22.4 8l-1.8 1.4"/>',
+
+  // Seite und Daten
+  postlist: '<rect x="2.5" y="2.5" width="7" height="5" rx="1.2"/><rect x="2.5" y="8.5" width="7" height="5" rx="1.2"/>'
+    + `${bar(11.5, 3.2, 10, 1.6)}${bar(11.5, 6, 7, 1.4)}${bar(11.5, 9.2, 10, 1.6)}${bar(11.5, 12, 7, 1.4)}`,
+  postnav: '<path d="M9.4 4.6L6 8l3.4 3.4M14.6 4.6L18 8l-3.4 3.4"/><path d="M6.4 8h3.6M14 8h3.6"/>',
+  breadcrumb: `${bar(2, 7.2, 5, 1.7)}<path d="M8.6 6.3l1.6 1.7-1.6 1.7"/>${bar(11.6, 7.2, 4, 1.7)}<path d="M17.2 6.3l1.6 1.7-1.6 1.7"/>${bar(20.2, 7.2, 2, 1.7)}`,
+  menu: `${bar(2, 7.2, 5, 1.8)}${bar(9, 7.2, 6, 1.8)}${bar(17, 7.2, 5, 1.8)}`,
+  form: '<rect x="2.5" y="2" width="19" height="3.6" rx="1.2"/><rect x="2.5" y="6.8" width="19" height="3.6" rx="1.2"/><rect x="2.5" y="11.6" width="8" height="3.4" rx="1.2" fill="currentColor" stroke="none"/>',
+  legal: `${bar(2, 4, 20, 1.6)}${bar(2, 7.4, 16, 1.6)}${bar(2, 10.8, 11, 1.6)}`,
+  partialref: '<rect x="2.5" y="4.5" width="13" height="9" rx="1.5"/><path d="M6.5 4.5V2h13v9h-2.5"/>',
+  embed: '<rect x="2" y="2.5" width="20" height="11" rx="1.5"/><path d="M10.2 5.6l4.6 2.4-4.6 2.4z" fill="currentColor" stroke="none"/>',
+};
+
+/** The picture for one element type, ready to drop into the markup. */
+export function preview(type) {
+  const shape = PREVIEWS[type];
+  if (!shape) return '';
+  return `<svg viewBox="0 0 24 16" width="34" height="23" fill="none" stroke="currentColor" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" focusable="false">${shape}</svg>`;
+}
+
+/** A row of columns, for the entries that add a row with a column count. */
+export function rowPreview(columns) {
+  const gap = 1.4;
+  const inner = (22 - gap * (columns - 1)) / columns;
+  const cells = Array.from({ length: columns }, (_, index) =>
+    `<rect x="${(1 + index * (inner + gap)).toFixed(2)}" y="3" width="${inner.toFixed(2)}" height="10" rx="1.2"/>`).join('');
+  return `<svg viewBox="0 0 24 16" width="34" height="23" fill="none" stroke="currentColor" stroke-width="1.25" stroke-linejoin="round" aria-hidden="true" focusable="false">${cells}</svg>`;
+}
@@ -0,0 +1,45 @@
+/*
+ * Der Takt des geöffneten Backends.
+ *
+ * Auf einer Website ohne Besucher gibt es keinen Auslöser für wiederkehrende Aufgaben - außer
+ * dem Menschen, der gerade in der Verwaltung arbeitet. Dieses Skript klopft in seinem Namen alle
+ * 60 Sekunden an; der Server entscheidet, ob überhaupt etwas fällig ist.
+ *
+ * Drei Eigenschaften, die es unauffällig machen:
+ *
+ * - Es fragt nur, während der Reiter sichtbar ist. Ein vergessener Hintergrundreiter soll keine
+ *   Sitzung endlos offen halten und keine Anfragen erzeugen, die niemand sehen will.
+ * - Es fragt nie zwei Mal gleichzeitig: eine laufende Anfrage blockiert die nächste.
+ * - Ein Fehlschlag ist kein Ereignis. Kein Hinweis, keine Meldung - beim nächsten Takt wieder.
+ */
+(function () {
+    var endpoint = document.querySelector('meta[name="kant-tick"]');
+    var token = document.querySelector('meta[name="kant-tick-token"]');
+    if (!endpoint || !token || !window.fetch) {
+        return;
+    }
+    var busy = false;
+
+    function tick() {
+        if (busy || document.visibilityState !== 'visible') {
+            return;
+        }
+        busy = true;
+        var body = new FormData();
+        body.append('_csrf_token', token.content);
+        fetch(endpoint.content, { method: 'POST', body: body, credentials: 'same-origin' })
+            .catch(function () {})
+            .then(function () {
+                busy = false;
+            });
+    }
+
+    // Der erste Takt kommt verzögert: beim Seitenaufbau hat der Browser Wichtigeres zu tun.
+    window.setTimeout(tick, 5000);
+    window.setInterval(tick, 60000);
+    document.addEventListener('visibilitychange', function () {
+        if (document.visibilityState === 'visible') {
+            tick();
+        }
+    });
+})();
@@ -64,6 +64,30 @@ try {
  await page.getByRole('button', { name: 'Anmelden', exact: true }).click();
  await page.waitForURL(origin + '/admin');
  console.log('Authenticated in isolated test installation.');
+
+  // --- Die Verwaltungsnavigation ------------------------------------------------------------
+  // Sie steckt in einem details-Element: auf dem Telefon ein Klappmenue, am Schreibtisch die
+  // stehende Spalte. Am Schreibtisch ist der Schalter ausgeblendet - und ein geschlossenes
+  // details versteckt seinen Inhalt von sich aus. Ohne eine Regel, die ihn zurueckholt, ist die
+  // Navigation dort nicht bloss zugeklappt, sondern unerreichbar. Genau so ist 1.5.4 ausgeliefert
+  // worden, und genau das faellt hier auf.
+  const navigation = page.getByRole('navigation', { name: 'Verwaltung' });
+  const schalter = page.locator('.shell-menu > summary');
+  assert.equal(await schalter.isVisible(), false, 'am Schreibtisch gibt es keinen Menueschalter');
+  assert.equal(await navigation.isVisible(), true, 'am Schreibtisch steht die Navigation da');
+  const eintrag = navigation.getByRole('link', { name: 'Seiten', exact: true });
+  const flaeche = await eintrag.boundingBox();
+  assert.ok(flaeche && flaeche.height > 0 && flaeche.width > 0, 'ihre Eintraege sind anklickbar');
+
+  // Auf dem Telefon dagegen: ein Schalter, zunaechst zu, ein Klick oeffnet.
+  await page.setViewportSize({ width: 390, height: 844 });
+  assert.equal(await schalter.isVisible(), true, 'auf dem Telefon gibt es den Schalter');
+  assert.equal(await navigation.isVisible(), false, 'und die Liste ist zunaechst zu');
+  await schalter.click();
+  assert.equal(await navigation.isVisible(), true, 'ein Klick oeffnet sie');
+  await page.setViewportSize({ width: 1600, height: 1100 });
+  checks.push({ name: 'the administration navigation is reachable on both sizes', passed: true });
+  console.log('Administration navigation passed.');
  await axe('page list');
  await page.screenshot({ path: 'reports/editor/pages.png', fullPage: true });
  await page.locator('a[href="/admin/pages/test-home"]').first().click();
@@ -170,6 +194,24 @@ try {
  // Differenz.
  assert.equal(await page.locator('#structure .tree-item').filter({ hasText: 'Spalte' }).count(), columnsBefore + 3);
  await page.getByRole('button', { name: 'Rückgängig', exact: true }).click();
+  // Jeder Eintrag traegt eine Zeichnung statt eines Schriftzeichens.
+  const mitBild = await page.locator('#library button .library-preview svg').count();
+  const knoepfe = await page.locator('#library button').count();
+  assert.equal(mitBild, knoepfe, `alle ${knoepfe} Eintraege haben ein Vorschaubild`);
+
+  // Die Suche greift ueber alle Gruppen und blendet leere Gruppen aus.
+  await page.locator('#library-search').fill('galerie');
+  await page.locator('#library-found').filter({ hasText: 'von' }).waitFor();
+  assert.equal(await page.locator('#library button:visible').count(), 1, 'genau die Galerie bleibt');
+  assert.equal(await page.locator('#library .library-group:visible').count(), 1, 'nur ihre Gruppe bleibt');
+  // Auch der Gruppenname findet: "Aufbau" gehoert zu Sektion, Zeile und Spalte.
+  await page.locator('#library-search').fill('aufbau');
+  assert.equal(await page.locator('#library button:visible').count(), 5, 'Sektion, drei Zeilen, Spalte');
+  await page.locator('#library-search').fill('gibtesnicht');
+  await page.locator('#library-found').filter({ hasText: 'Kein Element' }).waitFor();
+  await page.locator('#library-search').fill('');
+  assert.equal(await page.locator('#library button:visible').count(), knoepfe, 'leere Suche zeigt wieder alles');
+
  checks.push({ name: 'the toolbox follows the structure', passed: true });
  await page.screenshot({ path: 'reports/editor/toolbox.png' });
  console.log('Context aware toolbox passed.');
@@ -219,11 +261,11 @@ try {

  await page.getByRole('button', { name: 'Einklappen', exact: true }).click();
  assert.equal(await page.locator('#structure .tree-item').count(), 3);
-  await page.getByLabel('Element suchen', { exact: true }).fill('Meine bearbeitete');
+  await page.getByLabel('Element auf der Seite suchen', { exact: true }).fill('Meine bearbeitete');
  assert.equal(await page.locator('#structure .tree-item').count(), 2);
  await page.locator('#structure [data-block-id="headline"]').focus();
  await page.keyboard.press('Enter');
-  await page.getByLabel('Element suchen', { exact: true }).fill('');
+  await page.getByLabel('Element auf der Seite suchen', { exact: true }).fill('');
  assert.equal(await page.locator('#structure [data-block-id="headline"]').isVisible(), true);
  await page.getByRole('button', { name: 'Alle öffnen', exact: true }).click();
  await page.getByRole('button', { name: 'Design', exact: true }).click();
@@ -0,0 +1,98 @@
+<?php
+
+namespace App\Command;
+
+use App\Ops\Scheduler;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+/**
+ * Der dritte Weg: ein echter Cronjob oder ein Dauerläufer.
+ *
+ * Für Installationen, die eine Konsole haben. Er tut dasselbe wie der Besuchs-Auslöser, nur ohne
+ * dessen enge Grenzen – und er läuft auch nachts um drei, wenn die Website leer ist.
+ *
+ *     * * * * *  cd /pfad && php bin/console cms:tasks:run       (jede Minute, Standardweg)
+ *     php bin/console cms:tasks:run --loop=60 --max-time=3600    (Dauerläufer, z. B. unter Supervisor)
+ *     php bin/console cms:tasks:run --task=backup                (eine bestimmte, sofort)
+ */
+#[AsCommand(name: 'cms:tasks:run', description: 'Führt fällige Aufgaben aus. Für einen echten Cronjob oder als Dauerläufer.')]
+final class RunTasksCommand extends Command
+{
+    public function __construct(private Scheduler $scheduler)
+    {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this->addOption('task', null, InputOption::VALUE_REQUIRED, 'Nur diese Aufgabe, unabhängig vom Zeitplan.')
+            ->addOption('limit', null, InputOption::VALUE_REQUIRED, 'Höchstens so viele Aufgaben je Durchlauf.', '10')
+            ->addOption('budget', null, InputOption::VALUE_REQUIRED, 'Höchstens so viele Sekunden je Durchlauf.', '300')
+            ->addOption('loop', null, InputOption::VALUE_REQUIRED, 'Als Dauerläufer: Sekunden zwischen zwei Durchläufen.')
+            ->addOption('max-time', null, InputOption::VALUE_REQUIRED, 'Der Dauerläufer endet nach so vielen Sekunden.', '3600');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+        if (null !== ($name = $input->getOption('task'))) {
+            $result = $this->scheduler->runNow((string) $name, 'konsole');
+            if (null === $result) {
+                $io->error('Diese Aufgabe gibt es nicht oder sie läuft gerade schon. `cms:tasks` zeigt, welche es gibt.');
+
+                return Command::FAILURE;
+            }
+            $this->report($io, [$result]);
+
+            return 'ok' === $result['status'] ? Command::SUCCESS : Command::FAILURE;
+        }
+        $limit = max(1, (int) $input->getOption('limit'));
+        $budget = max(1, (int) $input->getOption('budget'));
+        $loop = null !== $input->getOption('loop') ? max(5, (int) $input->getOption('loop')) : null;
+        $deadline = microtime(true) + max(0, (int) $input->getOption('max-time'));
+
+        $failed = false;
+        while (true) {
+            $results = $this->scheduler->runDue('konsole', $limit, $budget);
+            $failed = $failed || [] !== array_filter($results, static fn (array $r): bool => 'ok' !== $r['status']);
+            $this->report($io, $results);
+            if (null === $loop) {
+                break;
+            }
+            // Ein Dauerläufer, der nie endet, sammelt Speicher und hält eine Datenbankverbindung
+            // über Tage. Er endet nach `--max-time`; der Prozessverwalter startet ihn neu.
+            if (microtime(true) + $loop > $deadline) {
+                $io->writeln(sprintf('<comment>Ende nach %d Sekunden – neu starten lassen.</comment>', (int) $input->getOption('max-time')));
+                break;
+            }
+            sleep($loop);
+        }
+
+        return $failed ? Command::FAILURE : Command::SUCCESS;
+    }
+
+    /** @param list<array{name: string, label: string, status: string, message: string, ms: int}> $results */
+    private function report(SymfonyStyle $io, array $results): void
+    {
+        if ([] === $results) {
+            $io->writeln(sprintf('<info>%s</info> nichts fällig.', gmdate('H:i:s')));
+
+            return;
+        }
+        foreach ($results as $result) {
+            $io->writeln(sprintf(
+                '<info>%s</info> %s %s (%d ms): %s',
+                gmdate('H:i:s'),
+                'ok' === $result['status'] ? '<info>ok</info>    ' : '<error>fehler</error>',
+                $result['name'],
+                $result['ms'],
+                $result['message'],
+            ));
+        }
+    }
+}
@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Command;
+
+use App\Ops\Scheduler;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+/**
+ * Was der Plan vorhat und was zuletzt passiert ist.
+ *
+ * Dieselbe Auskunft wie der Bildschirm „Aufgaben“, nur für den, der ohnehin auf der Konsole
+ * steht – und für den Fall, dass die Verwaltung gerade nicht erreichbar ist.
+ */
+#[AsCommand(name: 'cms:tasks', description: 'Zeigt den Aufgabenplan: Abstand, Fälligkeit und das letzte Ergebnis.')]
+final class TasksCommand extends Command
+{
+    public function __construct(private Scheduler $scheduler)
+    {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this->addOption('log', null, InputOption::VALUE_NONE, 'Zusätzlich die letzten Protokollzeilen.');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+        // Erst der Abgleich (er legt fehlende Zeilen an und schreibt die Zustandsdatei neu), dann
+        // die Auskunft daraus - sonst zeigt der erste Aufruf nach einem Update einen Zeitpunkt,
+        // der eine Sekunde spaeter schon nicht mehr stimmt.
+        $tasks = $this->scheduler->overview();
+        $state = $this->scheduler->fastState();
+        $io->writeln(sprintf(
+            'Auslöser: Besuch <info>%s</info>, Verwaltung <info>%s</info>. Konsole und URL-Cron laufen immer.',
+            $state['traffic'] ? 'an' : 'aus',
+            $state['admin'] ? 'an' : 'aus',
+        ));
+        $io->writeln(sprintf(
+            'Jetzt ist %s UTC; das nächste Mal steht %s an.',
+            gmdate('Y-m-d H:i:s'),
+            null === $state['next'] ? 'unbekannt' : gmdate('Y-m-d H:i:s', $state['next']),
+        ));
+
+        $rows = [];
+        foreach ($tasks as $task) {
+            $rows[] = [
+                $task['name'],
+                $task['enabled'] ? ($task['due'] ? 'fällig' : 'an') : 'aus',
+                $this->minutes($task['interval']),
+                $task['next'],
+                $task['running'] ? 'läuft' : ($task['status'] ?? '–'),
+                mb_substr($task['message'], 0, 60),
+            ];
+        }
+        if ([] === $rows) {
+            $io->warning('Keine Aufgaben. Fehlt die Migration? `php vendor/bin/doctrine-migrations migrate`');
+        } else {
+            $io->table(['Name', 'Zustand', 'Abstand', 'Nächster Lauf (UTC)', 'Zuletzt', 'Meldung'], $rows);
+        }
+
+        if ($input->getOption('log')) {
+            $io->section('Protokoll');
+            $lines = $this->scheduler->protocol(30);
+            $io->writeln([] === $lines ? 'Noch nichts protokolliert.' : $lines);
+        }
+
+        return Command::SUCCESS;
+    }
+
+    private function minutes(int $seconds): string
+    {
+        return $seconds >= 86400 && 0 === $seconds % 86400
+            ? sprintf('%d Tag(e)', intdiv($seconds, 86400))
+            : sprintf('%d Min.', max(1, intdiv($seconds, 60)));
+    }
+}
@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Controller;
+
+use App\EventSubscriber\TaskWorkerSubscriber;
+use App\Ops\Scheduler;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+/**
+ * Der Cronjob für Hostings, die nur eine URL aufrufen können.
+ *
+ * Viele Tarife bieten keinen Shell-Cron, aber einen „URL-Cronjob": der Hoster ruft alle paar
+ * Minuten eine Adresse auf. Das genügt – und ist gegenüber dem Besuchs-Auslöser der bessere Weg,
+ * weil er auch dann läuft, wenn niemand auf der Website ist.
+ *
+ * Drei Entscheidungen:
+ *
+ * 1. **Der Schlüssel steht in der Adresse**, weil ein URL-Cronjob nichts anderes mitschicken
+ *    kann als eine Adresse. Er ist aus dem Anwendungsgeheimnis abgeleitet, 40 Zeichen lang und
+ *    auf jeder Installation ein anderer.
+ * 2. **Ein falscher Schlüssel bekommt 404**, nicht 403. Wer probiert, soll nicht erfahren, dass
+ *    es hier überhaupt etwas gibt.
+ * 3. **Die Antwort ist Text**, nicht HTML: sie landet im Protokoll des Hosters, und dort ist
+ *    eine Zeile je Aufgabe das Nützlichste, was ankommen kann.
+ */
+final class CronController extends AbstractController
+{
+    public function __construct(private Scheduler $scheduler, private string $secret)
+    {
+    }
+
+    #[Route('/cms-cron/{token}', name: 'cms_cron', requirements: ['token' => '[a-f0-9]{40}'], methods: ['GET', 'POST'])]
+    public function run(Request $request, string $token): Response
+    {
+        if (!hash_equals(Scheduler::cronToken($this->secret), $token)) {
+            throw $this->createNotFoundException();
+        }
+        $request->attributes->set(TaskWorkerSubscriber::HANDLED, true);
+        // Hier wartet kein Mensch: ein Aufruf darf alles abarbeiten, was ansteht.
+        @ignore_user_abort(true);
+        @set_time_limit(0);
+        $began = microtime(true);
+        $results = $this->scheduler->runDue('cron', 20, 240);
+
+        $lines = [sprintf('%s UTC', gmdate('Y-m-d H:i:s'))];
+        foreach ($results as $result) {
+            $lines[] = sprintf('%-14s %-7s %6d ms  %s', $result['name'], $result['status'], $result['ms'], $result['message']);
+        }
+        $lines[] = sprintf('%d Aufgabe(n) in %.1f s.', count($results), microtime(true) - $began);
+
+        return new Response(implode("\n", $lines)."\n", Response::HTTP_OK, [
+            'Content-Type' => 'text/plain; charset=UTF-8',
+            'Cache-Control' => 'no-store',
+            'X-Robots-Tag' => 'noindex, nofollow',
+        ]);
+    }
+}
@@ -222,7 +222,7 @@ final class EditorController extends AbstractController

        return $this->back('' === trim($request->request->getString('publishAt'))
            ? 'Die geplante Veröffentlichung wurde entfernt.'
-            : 'Die Veröffentlichung ist geplant. Sie erfolgt, sobald cms:publish-due läuft.', 'success');
+            : 'Die Veröffentlichung ist geplant. Sie erfolgt beim ersten Aufruf der Website nach diesem Zeitpunkt – siehe „Aufgaben“.', 'success');
    }

    #[Route('/pages/{id}/restore', name: 'admin_restore_page', methods: ['POST'])]
@@ -0,0 +1,147 @@
+<?php
+
+namespace App\Controller;
+
+use App\EventSubscriber\TaskWorkerSubscriber;
+use App\Ops\Scheduler;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+
+/**
+ * Der Bildschirm „Aufgaben“ und der Takt des geöffneten Backends.
+ *
+ * Zwei verschiedene Dinge in einer Datei, weil sie dasselbe Thema haben: hier sieht der Betreiber,
+ * was der Plan vorhat und was zuletzt passiert ist – und hier klopft die geöffnete Verwaltung im
+ * Minutentakt an, damit auf einer Website ohne Besucher trotzdem etwas läuft.
+ */
+final class TaskController extends AbstractController
+{
+    public function __construct(private Scheduler $scheduler, private string $secret)
+    {
+    }
+
+    #[Route('/%kant.admin_path%/aufgaben', name: 'admin_tasks', methods: ['GET'])]
+    public function index(): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        $state = $this->scheduler->fastState();
+
+        return $this->render('admin/tasks.html.twig', [
+            'tasks' => $this->scheduler->overview(),
+            'traffic' => $state['traffic'],
+            'admin' => $state['admin'],
+            'next' => $state['next'],
+            'now' => gmdate('Y-m-d H:i:s'),
+            'protocol' => $this->scheduler->protocol(30),
+            // Der Schlüssel für einen URL-Cronjob. Er steht in keiner Datenbank: er wird aus dem
+            // Anwendungsgeheimnis abgeleitet, ist damit auf jedem Server ein anderer und ändert
+            // sich, wenn das Geheimnis gewechselt wird.
+            'cronUrl' => $this->generateUrl('cms_cron', ['token' => Scheduler::cronToken($this->secret)], UrlGeneratorInterface::ABSOLUTE_URL),
+        ]);
+    }
+
+    #[Route('/%kant.admin_path%/aufgaben/ausfuehren', name: 'admin_tasks_run', methods: ['POST'])]
+    public function run(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        if (!$this->isCsrfTokenValid('tasks', $request->request->getString('_csrf_token'))) {
+            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+        }
+        @set_time_limit(0);
+        $result = $this->scheduler->runNow($request->request->getString('name'));
+        if (null === $result) {
+            return $this->back('Diese Aufgabe gibt es nicht oder sie läuft gerade schon.');
+        }
+        $this->addFlash('ok' === $result['status'] ? 'success' : 'error', sprintf(
+            '%s: %s (%d ms)',
+            $result['label'],
+            $result['message'],
+            $result['ms'],
+        ));
+
+        return $this->redirectToRoute('admin_tasks');
+    }
+
+    /**
+     * Abstand, Ein/Aus je Aufgabe und die beiden Auslöser, die in Anfragen stecken.
+     *
+     * Ein Formular für alles, weil es eine Entscheidung ist: wie dieser Server seine Aufgaben
+     * abarbeitet. Zwei getrennte Formulare hätten zwei Speicherknöpfe und dieselbe Wirkung.
+     */
+    #[Route('/%kant.admin_path%/aufgaben/einstellen', name: 'admin_tasks_configure', methods: ['POST'])]
+    public function configure(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        if (!$this->isCsrfTokenValid('tasks', $request->request->getString('_csrf_token'))) {
+            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+        }
+        $this->scheduler->setWorkers(
+            $request->request->getBoolean('traffic'),
+            $request->request->getBoolean('admin'),
+        );
+        $enabled = $request->request->all('enabled');
+        foreach ($request->request->all('interval') as $name => $minutes) {
+            $name = (string) $name;
+            $this->scheduler->setInterval($name, max(1, (int) $minutes) * 60);
+            $this->scheduler->enable($name, isset($enabled[$name]));
+        }
+        $this->addFlash('success', 'Der Plan ist gespeichert.');
+
+        return $this->redirectToRoute('admin_tasks');
+    }
+
+    /** Eine Sperre, die stehen geblieben ist, weil das Hosting den Prozess mitten im Lauf beendet hat. */
+    #[Route('/%kant.admin_path%/aufgaben/freigeben', name: 'admin_tasks_release', methods: ['POST'])]
+    public function release(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        if (!$this->isCsrfTokenValid('tasks', $request->request->getString('_csrf_token'))) {
+            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+        }
+        $this->scheduler->release($request->request->getString('name'));
+        $this->addFlash('success', 'Die Sperre ist aufgehoben. Die Aufgabe darf wieder starten.');
+
+        return $this->redirectToRoute('admin_tasks');
+    }
+
+    /**
+     * Der Takt der geöffneten Verwaltung.
+     *
+     * Damit läuft der Plan auch auf einer Website, die gerade niemand besucht – solange jemand im
+     * Backend arbeitet. Das Skript fragt nur, während der Reiter sichtbar ist; ein im Hintergrund
+     * vergessener Reiter soll keine Sitzung endlos offen halten.
+     *
+     * Die Grenzen sind hier großzügiger als beim Besuch: hier wartet niemand auf eine Seite.
+     */
+    #[Route('/%kant.admin_path%/aufgaben/takt', name: 'admin_tasks_tick', methods: ['POST'])]
+    public function tick(Request $request): JsonResponse
+    {
+        $this->denyAccessUnlessGranted('ROLE_EDITOR');
+        if (!$this->isCsrfTokenValid('tasks-tick', $request->request->getString('_csrf_token'))) {
+            return new JsonResponse(['error' => 'token'], Response::HTTP_FORBIDDEN);
+        }
+        $request->attributes->set(TaskWorkerSubscriber::HANDLED, true);
+        $state = $this->scheduler->fastState();
+        if (!$state['admin']) {
+            return new JsonResponse(['off' => true, 'ran' => []]);
+        }
+        @set_time_limit(120);
+        $ran = $this->scheduler->runDue('verwaltung', 3, 45);
+
+        return new JsonResponse([
+            'ran' => $ran,
+            'next' => $this->scheduler->fastState()['next'],
+        ]);
+    }
+
+    private function back(string $error): Response
+    {
+        $this->addFlash('error', $error);
+
+        return $this->redirectToRoute('admin_tasks');
+    }
+}
@@ -0,0 +1,84 @@
+<?php
+
+namespace App\EventSubscriber;
+
+use App\Ops\Scheduler;
+use App\Ops\Updater;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpKernel\Event\TerminateEvent;
+use Symfony\Component\HttpKernel\KernelEvents;
+
+/**
+ * Der Auslöser, den ein Hosting ohne Cronjob hat: die Anfrage selbst.
+ *
+ * Nach `kernel.terminate`, also nachdem die Antwort das Haus verlassen hat. Unter PHP-FPM ruft
+ * Symfony dafür `fastcgi_finish_request()` auf - der Browser ist fertig, während hier noch
+ * gearbeitet wird. Unter Apache mit mod_php gibt es das nicht: die Seite steht dann zwar schon
+ * im Browser, der Prozess bleibt aber belegt, bis die Aufgabe fertig ist. Deshalb sind die
+ * Grenzen klein - zwei Aufgaben, zwanzig Sekunden -, und deshalb lässt sich dieser Auslöser
+ * abschalten, wenn ein echter Cronjob die Arbeit übernimmt.
+ *
+ * Der Normalfall kostet nichts: eine Datei lesen, Zeitpunkt vergleichen, fertig. Erst wenn
+ * wirklich etwas ansteht, wird die Datenbank gefragt.
+ */
+final class TaskWorkerSubscriber implements EventSubscriberInterface
+{
+    /** Anfragen, hinter denen kein Mensch und keine Seite steht. */
+    private const IGNORED = '#^/(assets/|media/|favicon)#';
+
+    /** Ein Aufruf, der die Aufgaben schon selbst abgearbeitet hat, setzt dieses Attribut. */
+    public const HANDLED = 'kant_tasks_handled';
+
+    public function __construct(
+        private Scheduler $scheduler,
+        private string $projectDir,
+        private string $adminPath,
+        private int $limit = 2,
+        private int $budget = 20,
+    ) {
+    }
+
+    public static function getSubscribedEvents(): array
+    {
+        // Nach dem Zähler der Statistik (Standardpriorität 0): der schreibt eine Zeile, das hier
+        // kann Sekunden dauern.
+        return [KernelEvents::TERMINATE => ['onTerminate', -64]];
+    }
+
+    public function onTerminate(TerminateEvent $event): void
+    {
+        $request = $event->getRequest();
+        if ($request->attributes->getBoolean(self::HANDLED)) {
+            return;
+        }
+        $path = $request->getPathInfo();
+        if (1 === preg_match(self::IGNORED, $path)) {
+            return;
+        }
+        // Während eines Updates läuft nichts: die Dateien sind vielleicht schon die neuen und
+        // die Datenbank noch die alte. Und vor der Installation gibt es keine Tabelle.
+        if (is_file($this->projectDir.'/'.Updater::MAINTENANCE_FILE) || !is_file($this->projectDir.'/'.InstallSubscriber::MARKER)) {
+            return;
+        }
+        $admin = str_starts_with($path, '/'.$this->adminPath);
+        $state = $this->scheduler->fastState();
+        if (!($admin ? $state['admin'] : $state['traffic'])) {
+            return;
+        }
+        if (null !== $state['next'] && $state['next'] > time()) {
+            return;
+        }
+
+        try {
+            // Die Antwort ist raus; ein abgebrochener Aufruf soll die Arbeit trotzdem zu Ende
+            // bringen, sonst bliebe eine Aufgabe auf halbem Weg mit gesetzter Sperre liegen.
+            @ignore_user_abort(true);
+            @set_time_limit($this->budget + 60);
+            $this->scheduler->runDue($admin ? 'verwaltung' : 'besuch', $this->limit, $this->budget);
+        } catch (\Throwable) {
+            // Eine Aufgabe darf niemals eine Website kaputtmachen. Was schiefging, steht in der
+            // Zeile der Aufgabe und in var/tasks.log - hier ist niemand mehr, dem man es sagen
+            // könnte: die Antwort ist längst verschickt.
+        }
+    }
+}
@@ -36,7 +36,7 @@ final class ArchiveUpdate
     * ersetzt" und „Migrationen" aus - Zeitüberschreitung, anderer Browser, anderer Rechner -,
     * bliebe die Website sonst im Wartungszustand und der Knopf, der sie herausholt, wäre weg.
     */
-    private const MARKE = 'var/update/offen.json';
+    public const MARKE = 'var/update/offen.json';

    /** Das Protokoll - dieselbe Datei, in die auch der Updater über Git schreibt. */
    private const PROTOKOLL = 'var/updates.log';
@@ -0,0 +1,498 @@
+<?php
+
+namespace App\Ops;
+
+use App\Ops\Tasks\Task;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Exception\TableNotFoundException;
+
+/**
+ * Wiederkehrende Aufgaben auf einem Hosting, das keinen Cronjob hat.
+ *
+ * Das Problem ist nicht, *was* zu tun ist, sondern *wer es anstoesst*. Auf geteiltem Webhosting
+ * gibt es oft weder SSH noch Cron; es gibt nur Anfragen. Also uebernehmen die Anfragen die
+ * Arbeit - nach der Antwort, in `kernel.terminate`, damit kein Besucher darauf wartet. Vier
+ * Ausloeser, dieselbe Mechanik:
+ *
+ * - **Besuch:** jeder Seitenaufruf schaut nach, ob etwas faellig ist (`TaskWorkerSubscriber`).
+ * - **Verwaltung:** das geoeffnete Backend fragt im Takt nach, auch ohne Besucher.
+ * - **URL-Cron:** ein Aufruf von `/cms-cron/<Schluessel>`, wenn der Hoster das anbietet.
+ * - **Konsole:** `cms:tasks:run`, auch als Dauerlaeufer mit `--loop`.
+ *
+ * Was das *nicht* kann, und das gehoert an diese Stelle und nicht ins Kleingedruckte: **ohne
+ * Anfrage passiert nichts.** Eine Aufgabe fuer 03:00 Uhr laeuft beim ersten Aufruf danach, auf
+ * einer stillen Website also vielleicht um 07:15 Uhr. Fuer Sitemap, Aufraeumen, Updatepruefung
+ * und Sicherung ist das brauchbar; fuer etwas, das minutengenau sein muss, ist es das nicht.
+ *
+ * Zwei Eigenschaften machen das im Betrieb tragfaehig:
+ *
+ * 1. **Der Normalfall kostet keine Datenbankabfrage.** In `var/scheduler.json` steht, wann das
+ *    naechste Mal ueberhaupt etwas ansteht. Solange dieser Zeitpunkt in der Zukunft liegt, ist
+ *    ein Seitenaufruf mit einem `file_get_contents` fertig.
+ * 2. **Zwei Besucher fuehren eine Aufgabe nicht zweimal aus.** Wer sie ausfuehren darf, wird mit
+ *    einem bedingten UPDATE entschieden - das ist auf MySQL wie auf SQLite atomar. Wer keine
+ *    Zeile veraendert hat, war zu spaet und geht weiter.
+ */
+final class Scheduler
+{
+    public const STATE_FILE = 'var/scheduler.json';
+    public const LOG_FILE = 'var/tasks.log';
+
+    /**
+     * Wie lange eine begonnene Aufgabe als laufend gilt.
+     *
+     * Es gibt keinen Weg, das Ende eines Prozesses zu erfahren, den das Hosting mitten im Lauf
+     * abgeschossen hat. Also verfaellt die Sperre von selbst. Fuenfzehn Minuten sind lang genug
+     * fuer eine Sicherung und kurz genug, dass eine haengengebliebene Aufgabe denselben Tag
+     * wieder mitmacht.
+     */
+    public const LOCK_SECONDS = 900;
+
+    /** Obergrenze fuer den wachsenden Abstand nach Fehlschlaegen: sechs Stunden. */
+    private const MAX_BACKOFF = 21600;
+
+    /** So viele Zeilen behaelt das Protokoll beim Kuerzen. */
+    private const LOG_LINES = 200;
+
+    /** @var array<string, Task>|null */
+    private ?array $registry = null;
+
+    /** @param iterable<Task> $tasks */
+    public function __construct(
+        private Connection $db,
+        private iterable $tasks,
+        private string $projectDir,
+    ) {
+    }
+
+    // ---------------------------------------------------------------- Ausfuehren
+
+    /**
+     * Fuehrt aus, was faellig ist - hoechstens `$limit` Aufgaben und hoechstens `$budget` Sekunden.
+     *
+     * Beide Grenzen sind da, weil dieser Aufruf in einer Webanfrage stecken kann. Sie werden
+     * *zwischen* zwei Aufgaben geprueft, nicht innerhalb einer: eine laufende Sicherung
+     * abzubrechen waere schlimmer, als sie zu Ende laufen zu lassen.
+     *
+     * @return list<array{name: string, label: string, status: string, message: string, ms: int}>
+     */
+    public function runDue(string $trigger, int $limit = 3, int $budget = 20, ?\DateTimeImmutable $now = null): array
+    {
+        $now ??= self::now();
+        $registry = $this->registry();
+        $rows = $this->rows();
+        // Nach einem Update kennt der Code eine Aufgabe mehr oder eine weniger als die Datenbank.
+        // Das faellt hier auf, und zwar ohne eine zusaetzliche Abfrage.
+        if (array_keys($rows) !== array_keys($registry)) {
+            if (!$this->sync($now)) {
+                return [];
+            }
+            $rows = $this->rows();
+        }
+        $started = microtime(true);
+        $results = [];
+        foreach ($this->due($rows, $now) as $row) {
+            if (count($results) >= $limit || microtime(true) - $started > $budget) {
+                break;
+            }
+            if (!$this->claim((string) $row['name'], $now)) {
+                // Ein anderer Prozess war schneller. Das ist kein Fehler, das ist der Zweck.
+                continue;
+            }
+            $results[] = $this->execute($registry[(string) $row['name']], $row, $trigger, self::now());
+        }
+        $this->refreshState();
+
+        return $results;
+    }
+
+    /**
+     * Fuehrt eine Aufgabe sofort aus, unabhaengig von ihrem Zeitplan.
+     *
+     * Der Knopf "Jetzt ausfuehren" in der Verwaltung. Abgeschaltete Aufgaben laufen so trotzdem -
+     * wer sie von Hand startet, meint sie auch. Die Sperre gilt aber weiter: zweimal derselbe
+     * Klick soll nicht zwei Sicherungen anlegen.
+     *
+     * Gibt null zurueck, wenn es die Aufgabe nicht gibt oder sie gerade schon laeuft.
+     *
+     * @return array{name: string, label: string, status: string, message: string, ms: int}|null
+     */
+    public function runNow(string $name, string $trigger = 'hand'): ?array
+    {
+        $now = self::now();
+        $registry = $this->registry();
+        if (!isset($registry[$name])) {
+            return null;
+        }
+        $this->sync($now);
+        $rows = $this->rows();
+        if (!isset($rows[$name]) || !$this->claim($name, $now, false)) {
+            return null;
+        }
+        $result = $this->execute($registry[$name], $rows[$name], $trigger, self::now());
+        $this->refreshState();
+
+        return $result;
+    }
+
+    /**
+     * Sichert sich eine Aufgabe.
+     *
+     * Der ganze Schutz gegen doppelte Ausfuehrung steckt in dieser einen Anweisung: die
+     * Bedingungen stehen im WHERE, nicht in PHP. Zwischen einem `SELECT ... WHERE faellig` und
+     * einem `UPDATE` liegt ein Moment, in dem ein zweiter Prozess dasselbe liest - hier nicht.
+     * Wer 1 zurueckbekommt, hat sie; wer 0 zurueckbekommt, war zu spaet.
+     */
+    private function claim(string $name, \DateTimeImmutable $now, bool $onlyWhenDue = true): bool
+    {
+        $stamp = $now->format('Y-m-d H:i:s');
+        $until = $now->modify('+'.self::LOCK_SECONDS.' seconds')->format('Y-m-d H:i:s');
+        $sql = 'UPDATE scheduled_task SET locked_until = ?, last_run_at = ? WHERE name = ? AND (locked_until IS NULL OR locked_until <= ?)';
+        $parameters = [$until, $stamp, $name, $stamp];
+        if ($onlyWhenDue) {
+            $sql .= ' AND next_run_at <= ?';
+            $parameters[] = $stamp;
+        }
+
+        try {
+            return 1 === $this->db->executeStatement($sql, $parameters);
+        } catch (\Throwable) {
+            return false;
+        }
+    }
+
+    /**
+     * @param array<string, mixed> $row
+     *
+     * @return array{name: string, label: string, status: string, message: string, ms: int}
+     */
+    private function execute(Task $task, array $row, string $trigger, \DateTimeImmutable $now): array
+    {
+        $begin = microtime(true);
+        try {
+            $message = trim($task->run());
+            $status = 'ok';
+            $failures = 0;
+        } catch (\Throwable $error) {
+            // Auch ein Fehler ist ein Ergebnis. Er steht in der Zeile, im Protokoll und auf dem
+            // Bildschirm "Aufgaben" - und er verlaengert den Abstand bis zum naechsten Versuch,
+            // damit eine Aufgabe, die nicht laufen *kann*, nicht bei jedem Aufruf neu anfaengt.
+            $status = 'fehler';
+            $message = sprintf('%s (%s:%d)', $error->getMessage(), basename($error->getFile()), $error->getLine());
+            $failures = (int) $row['failures'] + 1;
+        }
+        $ms = (int) round((microtime(true) - $begin) * 1000);
+        $interval = max(60, (int) $row['interval_seconds']);
+        $delay = 'ok' === $status
+            ? $interval
+            : (int) min(self::MAX_BACKOFF, $interval * 2 ** min($failures, 6));
+        $message = '' === $message ? 'Erledigt.' : mb_substr($message, 0, 480);
+
+        try {
+            $this->db->executeStatement(
+                'UPDATE scheduled_task SET next_run_at = ?, last_status = ?, last_message = ?, last_duration_ms = ?, last_trigger = ?, failures = ?, locked_until = NULL WHERE name = ?',
+                [
+                    $now->modify('+'.$delay.' seconds')->format('Y-m-d H:i:s'),
+                    $status, $message, $ms, $trigger, $failures, $task->name(),
+                ],
+            );
+        } catch (\Throwable) {
+            // Die Aufgabe ist gelaufen; nur das Nachtragen ging schief. Die Sperre verfaellt von
+            // selbst, und das Protokoll unten haelt fest, was passiert ist.
+        }
+        $this->append(sprintf(
+            '[%s] %-14s %-7s %6d ms  %-11s %s',
+            $now->format('Y-m-d H:i:s'),
+            $task->name(),
+            $status,
+            $ms,
+            $trigger,
+            str_replace(["\r", "\n"], ' ', $message),
+        ));
+
+        return ['name' => $task->name(), 'label' => $task->label(), 'status' => $status, 'message' => $message, 'ms' => $ms];
+    }
+
+    // ---------------------------------------------------------------- Zustand und Verwaltung
+
+    /**
+     * Der schnelle Blick, ohne Datenbank: darf der Besuchs- beziehungsweise Backend-Ausloeser
+     * arbeiten, und wann steht ueberhaupt das naechste Mal etwas an?
+     *
+     * Fehlt die Datei - frische Installation, geleertes `var/`, kein Schreibrecht -, ist die
+     * Antwort "ja, und der Zeitpunkt ist unbekannt". Dann fragt der naechste Aufruf die
+     * Datenbank und schreibt sie neu. Der teure Weg ist der Ausnahmefall, nicht der Normalfall.
+     *
+     * @return array{traffic: bool, admin: bool, next: ?int}
+     */
+    public function fastState(): array
+    {
+        $raw = @file_get_contents($this->projectDir.'/'.self::STATE_FILE);
+        $data = is_string($raw) ? json_decode($raw, true) : null;
+        if (!is_array($data)) {
+            return ['traffic' => true, 'admin' => true, 'next' => null];
+        }
+
+        return [
+            'traffic' => (bool) ($data['traffic'] ?? true),
+            'admin' => (bool) ($data['admin'] ?? true),
+            'next' => isset($data['next']) ? (int) $data['next'] : null,
+        ];
+    }
+
+    /**
+     * Der Schluessel fuer den URL-Cronjob, abgeleitet aus dem Anwendungsgeheimnis.
+     *
+     * Nicht in der Datenbank, weil er dann eine Migration, eine Oberflaeche zum Wechseln und
+     * einen Weg braeuchte, ihn nach einem Restore wiederzufinden. So ist er auf jeder
+     * Installation ein anderer, ueberlebt jedes Update und wechselt genau dann, wenn das
+     * Geheimnis wechselt - also dann, wenn man ihn wechseln will.
+     */
+    public static function cronToken(string $secret): string
+    {
+        return substr(hash_hmac('sha256', 'cms-cron', $secret), 0, 40);
+    }
+
+    /** Schaltet die beiden Ausloeser, die in Anfragen stecken. Konsole und URL-Cron laufen unabhaengig davon weiter. */
+    public function setWorkers(bool $traffic, bool $admin): void
+    {
+        $this->writeState(['traffic' => $traffic, 'admin' => $admin, 'next' => $this->fastState()['next']]);
+    }
+
+    /**
+     * Legt fehlende Zeilen an und entfernt Zeilen ohne Aufgabe im Code.
+     *
+     * Neue Aufgaben starten mit einem Abstand von zwei Minuten und nicht sofort: sonst faellt
+     * direkt nach einem Update alles gleichzeitig an, und zwar im ersten Seitenaufruf danach.
+     *
+     * @return bool false, wenn die Tabelle (noch) nicht da ist - vor der Installation und
+     *              zwischen hochgeladenem Code und ausgefuehrter Migration
+     */
+    public function sync(?\DateTimeImmutable $now = null): bool
+    {
+        $now ??= self::now();
+        $registry = $this->registry();
+
+        try {
+            $existing = $this->rows();
+            foreach ($registry as $name => $task) {
+                if (isset($existing[$name])) {
+                    continue;
+                }
+                $this->db->insert('scheduled_task', [
+                    'name' => $name,
+                    'interval_seconds' => $task->interval(),
+                    'enabled' => true,
+                    'next_run_at' => $now->modify('+120 seconds')->format('Y-m-d H:i:s'),
+                    'last_message' => '',
+                    'last_duration_ms' => 0,
+                    'last_trigger' => '',
+                    'failures' => 0,
+                ]);
+            }
+            foreach (array_keys($existing) as $name) {
+                if (!isset($registry[$name])) {
+                    $this->db->executeStatement('DELETE FROM scheduled_task WHERE name = ?', [$name]);
+                }
+            }
+        } catch (TableNotFoundException) {
+            // Vor der Installation und zwischen hochgeladenem Code und ausgefuehrter Migration.
+            return false;
+        } catch (\Throwable) {
+            return false;
+        }
+        $this->refreshState();
+
+        return true;
+    }
+
+    /**
+     * Alles, was der Bildschirm "Aufgaben" zeigt.
+     *
+     * @return list<array{name: string, label: string, explanation: string, interval: int,
+     *     enabled: bool, next: string, last: ?string, status: ?string, message: string,
+     *     ms: int, trigger: string, failures: int, running: bool, due: bool}>
+     */
+    public function overview(?\DateTimeImmutable $now = null): array
+    {
+        $now ??= self::now();
+        $this->sync($now);
+        $stamp = $now->format('Y-m-d H:i:s');
+        $overview = [];
+        foreach ($this->rows() as $name => $row) {
+            $task = $this->registry()[$name] ?? null;
+            if (null === $task) {
+                continue;
+            }
+            $locked = (string) ($row['locked_until'] ?? '');
+            $overview[] = [
+                'name' => $name,
+                'label' => $task->label(),
+                'explanation' => $task->explanation(),
+                'interval' => (int) $row['interval_seconds'],
+                'enabled' => (bool) $row['enabled'],
+                'next' => (string) $row['next_run_at'],
+                'last' => null !== $row['last_run_at'] ? (string) $row['last_run_at'] : null,
+                'status' => null !== $row['last_status'] ? (string) $row['last_status'] : null,
+                'message' => (string) $row['last_message'],
+                'ms' => (int) $row['last_duration_ms'],
+                'trigger' => (string) $row['last_trigger'],
+                'failures' => (int) $row['failures'],
+                'running' => '' !== $locked && $locked > $stamp,
+                'due' => (bool) $row['enabled'] && (string) $row['next_run_at'] <= $stamp,
+            ];
+        }
+
+        return $overview;
+    }
+
+    public function enable(string $name, bool $on): void
+    {
+        $this->db->executeStatement('UPDATE scheduled_task SET enabled = ? WHERE name = ?', [$on, $name]);
+        $this->refreshState();
+    }
+
+    /** Der Abstand, in Sekunden. Unter einer Minute ergibt er keinen Sinn, ueber einem Monat auch nicht. */
+    public function setInterval(string $name, int $seconds): void
+    {
+        $this->db->executeStatement(
+            'UPDATE scheduled_task SET interval_seconds = ? WHERE name = ?',
+            [max(60, min(2592000, $seconds)), $name],
+        );
+        $this->refreshState();
+    }
+
+    /** Gibt eine haengende Sperre frei - fuer den Fall, dass ein Prozess mitten im Lauf abgebrochen wurde. */
+    public function release(string $name): void
+    {
+        $this->db->executeStatement('UPDATE scheduled_task SET locked_until = NULL WHERE name = ?', [$name]);
+        $this->refreshState();
+    }
+
+    /**
+     * Die letzten Zeilen des Protokolls, neueste zuerst.
+     *
+     * @return list<string>
+     */
+    public function protocol(int $lines = 40): array
+    {
+        $raw = @file_get_contents($this->projectDir.'/'.self::LOG_FILE);
+        if (!is_string($raw) || '' === trim($raw)) {
+            return [];
+        }
+
+        return array_slice(array_reverse(array_values(array_filter(explode("\n", trim($raw))))), 0, $lines);
+    }
+
+    // ---------------------------------------------------------------- Innenleben
+
+    /** @return array<string, Task> */
+    private function registry(): array
+    {
+        if (null !== $this->registry) {
+            return $this->registry;
+        }
+        $registry = [];
+        foreach ($this->tasks as $task) {
+            $registry[$task->name()] = $task;
+        }
+        ksort($registry);
+
+        return $this->registry = $registry;
+    }
+
+    /** @return array<string, array<string, mixed>> */
+    private function rows(): array
+    {
+        try {
+            $rows = $this->db->fetchAllAssociative('SELECT * FROM scheduled_task');
+        } catch (\Throwable) {
+            return [];
+        }
+        $indexed = [];
+        foreach ($rows as $row) {
+            $indexed[(string) $row['name']] = $row;
+        }
+        ksort($indexed);
+
+        return $indexed;
+    }
+
+    /**
+     * @param array<string, array<string, mixed>> $rows
+     *
+     * @return list<array<string, mixed>>
+     */
+    private function due(array $rows, \DateTimeImmutable $now): array
+    {
+        $stamp = $now->format('Y-m-d H:i:s');
+        $due = [];
+        foreach ($rows as $row) {
+            $locked = (string) ($row['locked_until'] ?? '');
+            if ((bool) $row['enabled'] && (string) $row['next_run_at'] <= $stamp && ('' === $locked || $locked <= $stamp)) {
+                $due[] = $row;
+            }
+        }
+        // Die am laengsten ueberfaellige zuerst - sonst kommt eine Aufgabe mit kurzem Abstand
+        // immer wieder dran und eine mit langem nie.
+        usort($due, static fn (array $a, array $b): int => strcmp((string) $a['next_run_at'], (string) $b['next_run_at']));
+
+        return $due;
+    }
+
+    /**
+     * Schreibt in die Zustandsdatei, wann das naechste Mal etwas ansteht.
+     *
+     * Eine laufende Aufgabe zaehlt dabei erst ab dem Ende ihrer Sperre. Ohne das waere waehrend
+     * einer langen Sicherung jeder Seitenaufruf wieder bei der Datenbank: faellig ist sie ja,
+     * sie ist nur schon vergeben. Mit dem Ende der Sperre steht in der Datei ein Zeitpunkt in
+     * der Zukunft, und die uebrigen Anfragen sind nach einem Dateizugriff fertig.
+     */
+    private function refreshState(): void
+    {
+        $next = null;
+        foreach ($this->rows() as $row) {
+            if (!(bool) $row['enabled']) {
+                continue;
+            }
+            $when = max((string) $row['next_run_at'], (string) ($row['locked_until'] ?? ''));
+            $stamp = strtotime($when.' UTC');
+            if (false !== $stamp && (null === $next || $stamp < $next)) {
+                $next = $stamp;
+            }
+        }
+        $state = $this->fastState();
+        $this->writeState(['traffic' => $state['traffic'], 'admin' => $state['admin'], 'next' => $next]);
+    }
+
+    /** @param array{traffic: bool, admin: bool, next: ?int} $state */
+    private function writeState(array $state): void
+    {
+        $file = $this->projectDir.'/'.self::STATE_FILE;
+        if (!is_dir(dirname($file))) {
+            @mkdir(dirname($file), 0o775, true);
+        }
+        // Schlaegt das fehl - schreibgeschuetztes var/ -, fragt jeder Aufruf wieder die
+        // Datenbank. Langsamer, aber richtig; ein Fehler ist es nicht.
+        @file_put_contents($file, json_encode($state, JSON_PRETTY_PRINT), LOCK_EX);
+    }
+
+    private function append(string $line): void
+    {
+        $file = $this->projectDir.'/'.self::LOG_FILE;
+        if (!is_dir(dirname($file))) {
+            @mkdir(dirname($file), 0o775, true);
+        }
+        @file_put_contents($file, $line."\n", FILE_APPEND | LOCK_EX);
+        // Selbst begrenzend, damit das Protokoll auch ohne die Aufraeumaufgabe nie gross wird.
+        if ((int) @filesize($file) > 100000) {
+            $lines = array_values(array_filter(explode("\n", (string) @file_get_contents($file))));
+            @file_put_contents($file, implode("\n", array_slice($lines, -self::LOG_LINES))."\n", LOCK_EX);
+        }
+    }
+
+    private static function now(): \DateTimeImmutable
+    {
+        return new \DateTimeImmutable('now', new \DateTimeZone('UTC'));
+    }
+}
@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Ops\Tasks;
+
+use App\Ops\Backup;
+
+/**
+ * Die tägliche Sicherung von Datenbank und Medien.
+ *
+ * Die schwerste Aufgabe im Plan, und die einzige, bei der das Ausführen in einer Webanfrage
+ * wirklich etwas kostet: sie kopiert die Datenbank und den Medienordner. Der Besucher wartet
+ * trotzdem nicht darauf – sie läuft nach der ausgelieferten Antwort. Was sie belegt, ist ein
+ * PHP-Prozess des Hostings, einmal am Tag, für die Dauer einer Kopie.
+ *
+ * Wer einen echten Cronjob hat, sollte sie dort laufen lassen und hier abschalten. Wer keinen
+ * hat, hat mit dieser Aufgabe eine tägliche Sicherung statt gar keiner – und das ist der Grund,
+ * warum sie trotz ihres Gewichts im Plan steht.
+ */
+final class BackupTask implements Task
+{
+    public function __construct(private Backup $backup)
+    {
+    }
+
+    public function name(): string
+    {
+        return 'backup';
+    }
+
+    public function label(): string
+    {
+        return 'Sicherung anlegen';
+    }
+
+    public function explanation(): string
+    {
+        return 'Ohne sie gibt es keinen Rückweg außer der von Hand angelegten Sicherung. Sie rotiert selbst und enthält Datenbank und Medien, aber weder .env noch vendor/.';
+    }
+
+    public function interval(): int
+    {
+        return 86400;
+    }
+
+    public function run(): string
+    {
+        $result = $this->backup->create('automatisch');
+        $removed = $this->backup->rotate();
+
+        return sprintf(
+            '%s angelegt: %d Seite(n), %d Mediendatei(en).%s',
+            $result['name'],
+            $result['manifest']['inhalt']['seiten'],
+            $result['manifest']['medien']['dateien'],
+            [] === $removed ? '' : sprintf(' %d alte entfernt.', count($removed)),
+        );
+    }
+}
@@ -0,0 +1,142 @@
+<?php
+
+namespace App\Ops\Tasks;
+
+use App\Ops\ArchiveUpdate;
+use App\Ops\Scheduler;
+use App\Ops\Updater;
+
+/**
+ * Räumt in `var/` auf, was mit der Zeit liegen bleibt.
+ *
+ * Drei Dinge, und ausdrücklich nur diese drei: abgelaufene Sitzungsdateien, alte Arbeitsordner
+ * eines Updates und zu lang gewordene Protokolle. Nichts davon ist Inhalt, nichts davon lässt
+ * sich vermissen.
+ *
+ * Was diese Aufgabe **nicht** anfasst: Sicherungen (die rotiert `cms:backup` selbst und nach
+ * einer anderen Regel), den Cache (den baut Symfony auf, wenn er fehlt, aber ihn mitten im
+ * Betrieb zu löschen macht die nächste Anfrage langsam ohne Grund) und den Ordner eines Updates,
+ * das noch auf seinen zweiten Schritt wartet.
+ */
+final class CleanupTask implements Task
+{
+    /** Sitzungen und Update-Arbeitsordner, die älter sind, werden entfernt. */
+    private const KEEP_DAYS = 30;
+
+    /** So viele Zeilen bleiben in den Protokollen stehen. */
+    private const KEEP_LINES = 200;
+
+    public function __construct(private string $projectDir)
+    {
+    }
+
+    public function name(): string
+    {
+        return 'cleanup';
+    }
+
+    public function label(): string
+    {
+        return 'Aufräumen';
+    }
+
+    public function explanation(): string
+    {
+        return sprintf(
+            'Entfernt Sitzungsdateien und Update-Arbeitsordner, die älter als %d Tage sind, und kürzt die Protokolle. Sicherungen und Inhalte bleiben unberührt.',
+            self::KEEP_DAYS,
+        );
+    }
+
+    public function interval(): int
+    {
+        return 86400;
+    }
+
+    public function run(): string
+    {
+        $limit = time() - self::KEEP_DAYS * 86400;
+
+        return sprintf(
+            '%d Sitzungsdatei(en), %d Update-Ordner entfernt, %d Protokoll(e) gekürzt.',
+            $this->sessions($limit),
+            $this->updateFolders($limit),
+            $this->logs(),
+        );
+    }
+
+    /** Sitzungsdateien. Der Garbage Collector von PHP ist auf vielen Hostings abgeschaltet. */
+    private function sessions(int $limit): int
+    {
+        $removed = 0;
+        foreach (glob($this->projectDir.'/var/sessions/*/sess_*') ?: [] as $file) {
+            if (is_file($file) && (int) @filemtime($file) < $limit && @unlink($file)) {
+                ++$removed;
+            }
+        }
+
+        return $removed;
+    }
+
+    /**
+     * Die Arbeitsordner des Archiv-Updates.
+     *
+     * Der jüngste ist der Rückweg aus dem letzten Update, und den lässt diese Aufgabe einen
+     * Monat lang stehen. Wartet ein Update noch auf seinen zweiten Schritt, wird gar nichts
+     * angefasst: dann ist einer dieser Ordner der Stand, auf den zurückgegangen wird.
+     */
+    private function updateFolders(int $limit): int
+    {
+        if (is_file($this->projectDir.'/'.ArchiveUpdate::MARKE)) {
+            return 0;
+        }
+        $removed = 0;
+        foreach (glob($this->projectDir.'/var/update/*', GLOB_ONLYDIR) ?: [] as $folder) {
+            if ((int) @filemtime($folder) < $limit && $this->removeDirectory($folder)) {
+                ++$removed;
+            }
+        }
+
+        return $removed;
+    }
+
+    private function logs(): int
+    {
+        $shortened = 0;
+        foreach ([Updater::LOG_FILE, Scheduler::LOG_FILE] as $relative) {
+            $file = $this->projectDir.'/'.$relative;
+            $raw = @file_get_contents($file);
+            if (!is_string($raw)) {
+                continue;
+            }
+            $lines = array_values(array_filter(explode("\n", $raw)));
+            if (count($lines) <= self::KEEP_LINES) {
+                continue;
+            }
+            if (false !== @file_put_contents($file, implode("\n", array_slice($lines, -self::KEEP_LINES))."\n", LOCK_EX)) {
+                ++$shortened;
+            }
+        }
+
+        return $shortened;
+    }
+
+    /** Rekursiv löschen, aber nur unterhalb von `var/` – geprüft, nicht angenommen. */
+    private function removeDirectory(string $path): bool
+    {
+        $real = realpath($path);
+        $var = realpath($this->projectDir.'/var');
+        if (false === $real || false === $var || !str_starts_with($real, $var.DIRECTORY_SEPARATOR)) {
+            return false;
+        }
+        $items = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($real, \FilesystemIterator::SKIP_DOTS),
+            \RecursiveIteratorIterator::CHILD_FIRST,
+        );
+        foreach ($items as $item) {
+            $item->isDir() ? @rmdir($item->getPathname()) : @unlink($item->getPathname());
+        }
+
+        return @rmdir($real);
+    }
+}
@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Ops\Tasks;
+
+use App\Content\Statistics;
+
+/**
+ * Verdichtet und löscht die Zähler der Statistik.
+ *
+ * Einmal täglich reicht: die Tabelle wächst mit Seiten und Stunden, nicht mit Besuchen, und ein
+ * Tag Verzug ändert an ihrer Größe nichts.
+ */
+final class PruneStatisticsTask implements Task
+{
+    public function __construct(private Statistics $statistics)
+    {
+    }
+
+    public function name(): string
+    {
+        return 'stats-prune';
+    }
+
+    public function label(): string
+    {
+        return 'Statistik verdichten';
+    }
+
+    public function explanation(): string
+    {
+        return sprintf(
+            'Ohne sie behält die Statistik jede Stunde einzeln, für immer. Verdichtet wird nach %d Tagen, gelöscht nach %d.',
+            Statistics::COMPACT_AFTER_DAYS,
+            Statistics::KEEP_DAYS,
+        );
+    }
+
+    public function interval(): int
+    {
+        return 86400;
+    }
+
+    public function run(): string
+    {
+        $result = $this->statistics->prune();
+
+        return sprintf(
+            '%d Tag(e) zusammengefasst, %d Zeile(n) jenseits von %d Tagen entfernt.',
+            $result['compacted'],
+            $result['removed'],
+            Statistics::KEEP_DAYS,
+        );
+    }
+}
@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Ops\Tasks;
+
+use App\Content\PageRepository;
+
+/**
+ * Veröffentlicht Seiten, deren geplanter Zeitpunkt vergangen ist.
+ *
+ * Die Aufgabe mit dem kürzesten Abstand, weil sie die einzige ist, die jemand *bemerkt*: wer eine
+ * Seite für Montag 9 Uhr plant, schaut Montag um 9 Uhr nach. Fünf Minuten sind der Kompromiss
+ * zwischen „wirkt sofort" und „fällt bei jedem zweiten Seitenaufruf an".
+ */
+final class PublishDueTask implements Task
+{
+    public function __construct(private PageRepository $pages)
+    {
+    }
+
+    public function name(): string
+    {
+        return 'publish-due';
+    }
+
+    public function label(): string
+    {
+        return 'Geplante Veröffentlichungen';
+    }
+
+    public function explanation(): string
+    {
+        return 'Ohne sie bleibt eine geplante Seite ein Entwurf – die sichere Richtung, aber nicht die gewollte.';
+    }
+
+    public function interval(): int
+    {
+        return 300;
+    }
+
+    public function run(): string
+    {
+        $published = $this->pages->publishDue();
+
+        return [] === $published
+            ? 'Nichts fällig.'
+            : sprintf('%d Seite(n) veröffentlicht: /%s', count($published), implode(', /', $published));
+    }
+}
@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Ops\Tasks;
+
+/**
+ * Eine wiederkehrende Aufgabe.
+ *
+ * Der Vertrag ist absichtlich winzig, weil der Ausloeser nicht feststeht: dieselbe Aufgabe laeuft
+ * je nach Hosting im Seitenaufruf eines Besuchers, im geoeffneten Backend, ueber einen
+ * URL-Cronjob oder auf der Konsole. Was sie tut, darf davon nicht abhaengen.
+ *
+ * Drei Regeln, die aus dem Ausfuehrungsort folgen:
+ *
+ * 1. **Kurz sein oder unterbrechbar.** Ein Lauf haengt an einem PHP-Prozess, den das Hosting
+ *    nach seiner eigenen Zeit abbricht. Wer viel zu tun hat, arbeitet portionsweise und
+ *    berichtet, was offen blieb - der naechste Lauf macht weiter.
+ * 2. **Fehler werfen, nicht schlucken.** Eine geworfene Ausnahme wird zum sichtbaren Fehler mit
+ *    wachsendem Abstand bis zum naechsten Versuch. Ein stilles `return` sieht aus wie Erfolg.
+ * 3. **Nichts ausgeben.** Es gibt keine Konsole; die Rueckgabe ist der ganze Bericht.
+ */
+interface Task
+{
+    /** Technischer, gleichbleibender Name, zum Beispiel `publish-due`. Er ist der Schluessel in der Datenbank. */
+    public function name(): string;
+
+    /** Die Bezeichnung in der Verwaltung. */
+    public function label(): string;
+
+    /** Ein Satz darueber, was ausbleibt, wenn diese Aufgabe nicht laeuft. */
+    public function explanation(): string;
+
+    /** Vorgabe fuer den Abstand zwischen zwei Laeufen, in Sekunden. In der Verwaltung aenderbar. */
+    public function interval(): int;
+
+    /**
+     * Fuehrt die Aufgabe aus.
+     *
+     * @return string eine kurze Meldung fuer den Betreiber, die auch dann etwas sagt, wenn nichts
+     *                zu tun war ("Nichts faellig." ist eine Antwort, "" ist keine)
+     *
+     * @throws \Throwable wenn die Aufgabe ihr Ziel nicht erreicht hat
+     */
+    public function run(): string;
+}
@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Ops\Tasks;
+
+use App\Ops\ArchiveUpdate;
+use App\Ops\Updater;
+
+/**
+ * Fragt einmal täglich, ob es eine neuere Fassung gibt.
+ *
+ * Sie prüft nur und installiert nichts. Ein Update tauscht Dateien und führt Migrationen aus;
+ * das gehört an einen Knopf, den ein Mensch drückt, und nicht in den Seitenaufruf eines
+ * Besuchers.
+ *
+ * Ist die Fassungsliste nicht erreichbar, ist das ein Fehler und keine Entwarnung: „keine
+ * Antwort" und „kein Update" sehen sonst gleich aus, und das eine ist eine Nachricht, das andere
+ * eine ausgefallene Prüfung.
+ */
+final class UpdateCheckTask implements Task
+{
+    public function __construct(private ArchiveUpdate $archive, private Updater $updater)
+    {
+    }
+
+    public function name(): string
+    {
+        return 'update-check';
+    }
+
+    public function label(): string
+    {
+        return 'Nach Updates sehen';
+    }
+
+    public function explanation(): string
+    {
+        return 'Fragt beim Repository nach der neuesten Fassung. Sie installiert nichts – das Ergebnis steht hier und auf dem Bildschirm „System".';
+    }
+
+    public function interval(): int
+    {
+        return 86400;
+    }
+
+    public function run(): string
+    {
+        $latest = $this->archive->latest();
+        if (null === $latest) {
+            throw new \RuntimeException('Die Fassungsliste war nicht erreichbar. Erlaubt dieses Hosting ausgehende Verbindungen?');
+        }
+        $installed = $this->updater->version();
+
+        return version_compare($latest['version'], $installed, '>')
+            ? sprintf('Fassung %s ist verfügbar; installiert ist %s.', $latest['version'], $installed)
+            : sprintf('Aktuell: Fassung %s.', $installed);
+    }
+}
@@ -17,13 +17,16 @@
       Importzeile sie kennen muss. Sie steht vor jedem Modul-Skript; spaeter geladen wirkt sie
       nicht mehr. #}
    <script type="importmap" nonce="{{ csp_nonce() }}">{"imports":{
-{%- for modul in ['editor-model', 'media', 'design-panel', 'rich-text', 'canvas-overlay'] %}
+{%- for modul in ['editor-model', 'media', 'design-panel', 'rich-text', 'canvas-overlay', 'library-previews'] %}
        "/assets/{{ modul }}.js": "/assets/{{ modul }}.js?v={{ kant_version() }}"{{ loop.last ? '' : ',' }}
 {%- endfor %}
    }}</script>
    <script src="/assets/color-field.js?v={{ kant_version() }}" defer></script>
 {% block styles %}{% endblock %}
    {% block scripts %}{% endblock %}
+    {# Eigener Block, nicht Teil von `scripts`: Bildschirme wie die Mediathek ersetzen `scripts`
+       vollstaendig, und der Takt der Verwaltung darf davon nicht abhaengen. #}
+    {% block worker %}{% endblock %}
 </head>
 <body class="{% block body_class %}{% endblock %}">
    <a class="skip-link" href="#admin-main">Zum Inhalt springen</a>
@@ -21,12 +21,15 @@
        <aside class="left-panel" aria-label="Elemente und Seitenstruktur">
            <section class="panel-section"><div class="panel-title"><h2>Werkzeugkasten</h2><button id="toggle-library" class="text-button" aria-expanded="true" aria-controls="toolbox">− <span class="visually-hidden">Werkzeugkasten einklappen</span></button></div><div id="toolbox"><p id="insert-hint" class="insert-hint" role="status" hidden>Einfügepunkt gesetzt — das nächste Element landet dort. <button id="cancel-insert" class="text-button" type="button">Abbrechen</button></p><h3 class="preset-heading">Element hinzufügen</h3>
                <p class="panel-hint">Ziehen und in der Vorschau ablegen, oder klicken. Der Werkzeugkasten zeigt an, was an der gewählten Stelle hineinpasst — was dort nicht hingehört, sagt beim Überfahren warum.</p>
+                <label class="search-label" for="library-search">Element zum Einfügen suchen</label>
+                <input id="library-search" type="search" placeholder="z. B. Galerie, Zeile, Formular …" autocomplete="off">
+                <p id="library-found" class="field-help" role="status"></p>
                <div id="library" class="library"></div>
                <button id="open-media-library" class="secondary full-width media-launch" disabled>Medienverwaltung öffnen</button>
                <h3 class="preset-heading">Fertige Abschnitte</h3><p class="panel-hint">Wird nach dem aktuellen Seitenabschnitt eingefügt.</p>
                <div id="presets" class="preset-library"><button data-preset="hero" disabled><span aria-hidden="true">▮</span> Vollbild-Hero</button><button data-preset="intro" disabled><span aria-hidden="true">▤</span> Intro mit Button</button><button data-preset="columns" disabled><span aria-hidden="true">▥</span> Zwei Leistungen</button><button data-preset="cta" disabled><span aria-hidden="true">↗</span> Kontaktaufruf</button></div>
            </div></section>
-            <section class="panel-section structure-section"><div class="panel-title"><h2>Struktur</h2><button id="select-page" class="text-button">Seite</button></div><label class="search-label" for="tree-search">Element suchen</label><input id="tree-search" type="search" placeholder="Text oder Elementtyp …"><div class="tree-tools"><button id="expand-all" class="text-button">Alle öffnen</button><button id="collapse-all" class="text-button">Einklappen</button></div><p class="panel-hint">Ziehen oder mit den Schaltflächen verschieben.</p><nav id="structure" aria-label="Blöcke auswählen"></nav>
+            <section class="panel-section structure-section"><div class="panel-title"><h2>Struktur</h2><button id="select-page" class="text-button">Seite</button></div><label class="search-label" for="tree-search">Element auf der Seite suchen</label><input id="tree-search" type="search" placeholder="Text oder Elementtyp …"><div class="tree-tools"><button id="expand-all" class="text-button">Alle öffnen</button><button id="collapse-all" class="text-button">Einklappen</button></div><p class="panel-hint">Ziehen oder mit den Schaltflächen verschieben.</p><nav id="structure" aria-label="Blöcke auswählen"></nav>
                <div class="block-actions"><button id="move-up" title="Nach oben verschieben" aria-label="Nach oben verschieben">↑</button><button id="move-down" title="Nach unten verschieben" aria-label="Nach unten verschieben">↓</button><button id="nest" title="In vorherigen Container verschachteln" aria-label="In vorherigen Container verschachteln">⇥</button><button id="outdent" title="Eine Ebene herausheben" aria-label="Eine Ebene herausheben">⇤</button><button id="duplicate">Duplizieren</button><button id="delete" class="danger-text">Löschen</button></div>
            </section>
        </aside>
@@ -14,6 +14,7 @@
    theme: 'M12 3a9 9 0 1 0 0 18Zm0 0a9 9 0 0 1 0 18',
    settings: 'M12 15a3 3 0 1 0 0-6 3 3 0 0 0 0 6Zm8-3a8 8 0 0 0-.2-1.7l2-1.5-2-3.5-2.3 1a8 8 0 0 0-3-1.7L14 2h-4l-.5 2.6a8 8 0 0 0-3 1.7l-2.3-1-2 3.5 2 1.5a8 8 0 0 0 0 3.4l-2 1.5 2 3.5 2.3-1a8 8 0 0 0 3 1.7L10 22h4l.5-2.6a8 8 0 0 0 3-1.7l2.3 1 2-3.5-2-1.5c.1-.6.2-1.1.2-1.7Z',
    system: 'M8 8h8v8H8Zm-4 2h4m-4 4h4m8-4h4m-4 4h4M10 4v4m4-4v4m-4 8v4m4-4v4',
+    tasks: 'M12 21a9 9 0 1 0 0-18 9 9 0 0 0 0 18Zm0-13.5V12l3.5 2.2',
    users: 'M12 12a4 4 0 1 0 0-8 4 4 0 0 0 0 8Zm-8 8c0-3.3 3.6-5 8-5s8 1.7 8 5',
    external: 'M14 4h6v6m0-6-8 8M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5'
 } %}
@@ -201,7 +201,7 @@
                        <div class="field">
                            <label for="publish-{{ page.id }}">Veröffentlichen am</label>
                            <input id="publish-{{ page.id }}" name="publishAt" type="datetime-local" value="{{ page.publish_at ? page.publish_at|date('Y-m-d\\TH:i') : '' }}">
-                            <p class="field-help">Zeiten in UTC. Leer lassen, um die Planung zu entfernen. Die Veröffentlichung erfolgt, sobald <code>cms:publish-due</code> läuft.</p>
+                            <p class="field-help">Zeiten in UTC. Leer lassen, um die Planung zu entfernen. Veröffentlicht wird beim ersten Aufruf der Website nach diesem Zeitpunkt; wie oft nachgesehen wird, steht unter <a href="{{ path('admin_tasks') }}">Aufgaben</a>.</p>
                        </div>
                        <button class="secondary" type="submit">Zeitpunkt speichern</button>
                    </form>
@@ -2,6 +2,13 @@
   click away and the current one is visible. Screens fill in heading, lead, actions and content. #}
 {% extends 'admin/base.html.twig' %}
 {% block body_class %}admin-shell{% endblock %}
+{# Solange jemand hier arbeitet, laeuft der Aufgabenplan - auch auf einer Website ohne Besucher.
+   Das Skript fragt im Minutentakt an; was faellig ist, entscheidet der Server. #}
+{% block worker %}
+    <meta name="kant-tick" content="{{ path('admin_tasks_tick') }}">
+    <meta name="kant-tick-token" content="{{ csrf_token('tasks-tick') }}">
+    <script src="/assets/task-worker.js?v={{ kant_version() }}" defer></script>
+{% endblock %}
 {% block body %}
 <header class="shell-nav">
    <a class="brand" href="{{ path('admin_pages') }}"><span class="brand-icon" aria-hidden="true">k.</span>kant<span>sites</span></a>
@@ -15,7 +22,7 @@
            <span class="shell-menu-label">{{ {
                'pages': 'Seiten', 'partials': 'Bereiche', 'menus': 'Menüs', 'media': 'Mediathek',
                'forms': 'Formulare', 'statistics': 'Statistik', 'theme': 'Design',
-                'settings': 'Einstellungen', 'system': 'System', 'users': 'Benutzer',
+                'settings': 'Einstellungen', 'system': 'System', 'tasks': 'Aufgaben', 'users': 'Benutzer',
                'account': 'Mein Konto'
            }[nav|default('')]|default('Verwaltung') }}</span>
        </summary>
@@ -39,6 +46,7 @@
            <li><a class="nav-item" href="{{ path('admin_theme') }}"{{ nav|default('') == 'theme' ? ' aria-current="page"' : '' }}>{% include 'admin/icon.html.twig' with {name: 'theme'} only %}Design</a></li>
            <li><a class="nav-item" href="{{ path('admin_settings') }}"{{ nav|default('') == 'settings' ? ' aria-current="page"' : '' }}>{% include 'admin/icon.html.twig' with {name: 'settings'} only %}Einstellungen</a></li>
            {% if is_granted('ROLE_ADMIN') %}<li><a class="nav-item" href="{{ path('admin_system') }}"{{ nav|default('') == 'system' ? ' aria-current="page"' : '' }}>{% include 'admin/icon.html.twig' with {name: 'system'} only %}System</a></li>{% endif %}
+            {% if is_granted('ROLE_ADMIN') %}<li><a class="nav-item" href="{{ path('admin_tasks') }}"{{ nav|default('') == 'tasks' ? ' aria-current="page"' : '' }}>{% include 'admin/icon.html.twig' with {name: 'tasks'} only %}Aufgaben</a></li>{% endif %}
            {% if is_granted('ROLE_ADMIN') %}<li><a class="nav-item" href="{{ path('admin_users') }}"{{ nav|default('') == 'users' ? ' aria-current="page"' : '' }}>{% include 'admin/icon.html.twig' with {name: 'users'} only %}Benutzer</a></li>{% endif %}
            <li><a class="nav-item nav-out" href="/">{% include 'admin/icon.html.twig' with {name: 'external'} only %}Website ansehen</a></li>
            <li><a class="nav-item nav-out" href="/beitraege">{% include 'admin/icon.html.twig' with {name: 'external'} only %}Beitragsübersicht</a></li>
@@ -186,7 +186,7 @@
    <div class="card-head"><h2>Sicherungen</h2><span class="muted">{{ backups|length }} vorhanden · var/backups</span></div>
    <div class="card-body">
        <p class="muted">Eine Sicherung enthält die Datenbank als vollständige Kopie – nicht als Dateikopie während des Schreibens, die unbrauchbar sein kann – und den Medienordner. <strong>Nicht enthalten sind <code>.env</code>, <code>vendor/</code> und der Quellcode</strong>: die kommen aus dem Repository, und <code>.env</code> enthält das Geheimnis dieser Installation.</p>
-        <p class="field-help">Zurückspielen geht bewusst nur auf der Konsole: <code>php bin/console cms:restore &lt;name&gt;</code>. Ein Knopf, der die ganze Datenbank ersetzt, gehört nicht neben einen, der eine Seite speichert. Für den täglichen Cronjob: <code>php bin/console cms:backup</code>.</p>
+        <p class="field-help">Zurückspielen geht bewusst nur auf der Konsole: <code>php bin/console cms:restore &lt;name&gt;</code>. Ein Knopf, der die ganze Datenbank ersetzt, gehört nicht neben einen, der eine Seite speichert. Die tägliche Sicherung erledigt der <a href="{{ path('admin_tasks') }}">Aufgabenplan</a> – auch ohne Cronjob.</p>
        <form action="{{ path('admin_system_backup') }}" method="post">
            <input type="hidden" name="_csrf_token" value="{{ csrf_token('system') }}">
            <button class="primary" type="submit">Sicherung jetzt anlegen</button>
@@ -0,0 +1,131 @@
+{% extends 'admin/shell.html.twig' %}
+{% set nav = 'tasks' %}
+{% block title %}Aufgaben{% endblock %}
+{% block heading %}Wiederkehrende Aufgaben{% endblock %}
+{% block lead %}Was regelmäßig laufen soll, wer es anstößt und was zuletzt dabei herauskam. Alle Zeiten in UTC.{% endblock %}
+{% block content %}
+
+{# Der wichtigste Satz zuerst, und zwar als Einschränkung und nicht als Werbung: ohne Anfrage
+   passiert nichts. Wer das nicht weiß, sucht später den Fehler an der falschen Stelle. #}
+<div class="card">
+    <div class="card-head">
+        <h2>Wer die Arbeit anstößt</h2>
+        <span class="muted">{{ next is null ? 'Zeitpunkt noch unbekannt' : 'Nächster Lauf: ' ~ next|date('Y-m-d H:i:s', 'UTC') ~ ' UTC' }}</span>
+    </div>
+    <div class="card-body">
+        <p class="muted">Ein Webhosting ohne Cronjob hat nur eines: Anfragen. Deshalb erledigt eine Anfrage die Arbeit – nach der ausgelieferten Antwort, sodass niemand darauf wartet. <strong>Ohne Besuch und ohne geöffnete Verwaltung passiert nichts.</strong> Eine Aufgabe für 03:00 Uhr läuft dann beim ersten Aufruf danach, auf einer stillen Website vielleicht um 07:15 Uhr. Wer es genauer braucht, richtet einen der beiden unteren Wege ein.</p>
+
+        <form action="{{ path('admin_tasks_configure') }}" method="post">
+            <input type="hidden" name="_csrf_token" value="{{ csrf_token('tasks') }}">
+
+            <fieldset class="field-set">
+                <legend>Auslöser in Anfragen</legend>
+                <label class="check-label"><input type="checkbox" name="traffic" value="1"{{ traffic ? ' checked' : '' }}> Besuche der Website</label>
+                <p class="field-help">Jeder Seitenaufruf schaut nach, ob etwas fällig ist. Der Normalfall kostet eine gelesene Datei und keine Datenbankabfrage. Ausschalten, wenn ein echter Cronjob die Arbeit übernimmt.</p>
+                <label class="check-label"><input type="checkbox" name="admin" value="1"{{ admin ? ' checked' : '' }}> Geöffnete Verwaltung</label>
+                <p class="field-help">Solange dieser Bildschirm offen und sichtbar ist, fragt er jede Minute nach. So läuft der Plan auch auf einer Website, die gerade niemand besucht.</p>
+            </fieldset>
+
+            <div class="section-head"><h2>Der Plan</h2><span class="muted">Abstand in Minuten</span></div>
+            <table class="table tasks-table">
+                <thead>
+                    <tr><th scope="col">Aufgabe</th><th scope="col" class="check-cell">An</th><th scope="col">Abstand</th><th scope="col">Nächster Lauf</th><th scope="col">Zuletzt</th><th scope="col"></th></tr>
+                </thead>
+                <tbody>
+                {% for task in tasks %}
+                    <tr>
+                        <td>
+                            <strong>{{ task.label }}</strong>
+                            <p class="field-help">{{ task.explanation }}</p>
+                            <p class="field-help"><code>{{ task.name }}</code></p>
+                        </td>
+                        <td class="check-cell">
+                            <input type="checkbox" name="enabled[{{ task.name }}]" value="1"{{ task.enabled ? ' checked' : '' }} aria-label="{{ task.label }} ausführen">
+                        </td>
+                        <td><input type="number" name="interval[{{ task.name }}]" value="{{ (task.interval / 60)|round }}" min="1" max="43200" step="1" aria-label="Abstand für {{ task.label }} in Minuten"></td>
+                        <td>
+                            {% if not task.enabled %}<span class="pill pill-off">aus</span>
+                            {% elseif task.running %}<span class="pill pill-draft">läuft</span>
+                            {% elseif task.due %}<span class="pill pill-draft">fällig</span>
+                            {% else %}<span class="muted">{{ task.next }}</span>{% endif %}
+                        </td>
+                        <td>
+                            {% if task.status is null %}
+                                <span class="muted">noch nie</span>
+                            {% else %}
+                                <span class="pill {{ task.status == 'ok' ? 'pill-live' : 'pill-off' }}">{{ task.status }}</span>
+                                <p class="field-help">{{ task.last }} · {{ task.ms }} ms{% if task.trigger %} · durch {{ task.trigger }}{% endif %}</p>
+                                <p class="field-help{{ task.status == 'ok' ? '' : ' danger-text' }}">{{ task.message }}</p>
+                                {% if task.failures > 1 %}<p class="field-help danger-text">{{ task.failures }} Fehlschläge nacheinander – der Abstand bis zum nächsten Versuch wächst.</p>{% endif %}
+                            {% endif %}
+                        </td>
+                        <td>
+                            <button class="secondary" type="submit" form="run-{{ task.name }}">Jetzt ausführen</button>
+                            {% if task.running %}<button class="text-button" type="submit" form="release-{{ task.name }}">Sperre aufheben</button>{% endif %}
+                        </td>
+                    </tr>
+                {% else %}
+                    <tr><td colspan="6">Keine Aufgaben. Fehlt die Migration? Der Bildschirm <a href="{{ path('admin_system') }}">System</a> führt sie aus.</td></tr>
+                {% endfor %}
+                </tbody>
+            </table>
+            <button class="primary" type="submit">Plan speichern</button>
+        </form>
+
+        {# Die Formulare der Knöpfe stehen außerhalb der Tabelle: ein Formular im Formular gibt es
+           in HTML nicht, und `form="..."` verbindet Knopf und Formular über die Tabelle hinweg. #}
+        {% for task in tasks %}
+        <form id="run-{{ task.name }}" action="{{ path('admin_tasks_run') }}" method="post" hidden>
+            <input type="hidden" name="_csrf_token" value="{{ csrf_token('tasks') }}">
+            <input type="hidden" name="name" value="{{ task.name }}">
+        </form>
+        {% if task.running %}
+        <form id="release-{{ task.name }}" action="{{ path('admin_tasks_release') }}" method="post" hidden>
+            <input type="hidden" name="_csrf_token" value="{{ csrf_token('tasks') }}">
+            <input type="hidden" name="name" value="{{ task.name }}">
+        </form>
+        {% endif %}
+        {% endfor %}
+    </div>
+</div>
+
+<div class="card">
+    <div class="card-head"><h2>Der zuverlässige Weg</h2><span class="muted">falls dieses Hosting ihn anbietet</span></div>
+    <div class="card-body">
+        <p class="muted">Beide Wege sind unabhängig von den Schaltern oben – sie laufen auch dann, wenn Besuch und Verwaltung ausgeschaltet sind. Wer einen davon einrichtet, sollte den Besuchs-Auslöser abschalten: die Arbeit ist dann schon getan, und die Website antwortet ein wenig schneller.</p>
+        <dl class="facts">
+            <dt>URL-Cronjob</dt>
+            <dd>
+                <code>{{ cronUrl }}</code>
+                <p class="field-help">Diese Adresse beim Hoster als Cronjob eintragen, zum Beispiel alle fünf Minuten. Der Schlüssel ist aus dem Anwendungsgeheimnis abgeleitet, steht in keiner Datenbank und ändert sich, wenn das Geheimnis gewechselt wird. Er gehört nicht in eine E-Mail und nicht in ein Ticket.</p>
+            </dd>
+            <dt>Konsole</dt>
+            <dd>
+                <code>php bin/console cms:tasks:run</code>
+                <p class="field-help">Für einen echten Cronjob, jede Minute. <code>cms:tasks</code> zeigt denselben Plan wie dieser Bildschirm, <code>cms:tasks:run --loop=60</code> läuft dauerhaft.</p>
+            </dd>
+        </dl>
+    </div>
+</div>
+
+<div class="card">
+    <div class="card-head"><h2>Protokoll</h2><span class="muted">die letzten Läufe, neueste zuerst</span></div>
+    <div class="card-body">
+        {% if protocol is empty %}
+        <p class="muted">Noch nichts gelaufen. Steht in der Spalte „Nächster Lauf“ ein Zeitpunkt, ist alles in Ordnung – der Plan wartet.</p>
+        {% else %}
+        <div class="table-wrap">
+            <table class="table">
+                <tbody>
+                {% for line in protocol %}
+                    <tr><td><code>{{ line }}</code></td></tr>
+                {% endfor %}
+                </tbody>
+            </table>
+        </div>
+        <p class="field-help">Aus <code>var/tasks.log</code>. Die Datei kürzt sich selbst; die Aufgabe „Aufräumen“ tut es ebenfalls.</p>
+        {% endif %}
+    </div>
+</div>
+
+{% endblock %}
@@ -13,7 +13,7 @@
 <ul class="check-list">
    <li class="check-warn"><span class="check-mark" aria-hidden="true">·</span><span><strong>Impressum und Datenschutzerklärung ausfüllen.</strong> Beide Seiten sind angelegt und veröffentlicht; die Pflichtangaben stehen als <code>NOCH AUSZUFÜLLEN</code> darin. Solange sie so dastehen, sind sie eine Baustelle mit Ansage – aber keine Erklärung.</span></li>
    <li class="check-warn"><span class="check-mark" aria-hidden="true">·</span><span><strong>Die Datei <code>install.php</code> löschen</strong>, falls du über sie installiert hast. Sie löscht sich selbst, aber nachsehen kostet nichts.</span></li>
-    <li class="check-warn"><span class="check-mark" aria-hidden="true">·</span><span><strong>Einen täglichen Cronjob einrichten:</strong> <code>php bin/console cms:backup</code> für die Sicherung und <code>php bin/console cms:stats:prune</code> für die Statistik. Ohne Sicherung gibt es keinen Rückweg.</span></li>
+    <li class="check-ok"><span class="check-mark" aria-hidden="true">✓</span><span><strong>Sicherung und Aufräumen laufen bereits.</strong> Der Aufgabenplan unter „Aufgaben“ wird von Seitenaufrufen und vom geöffneten Backend angestoßen – ohne Cronjob. Genau, aber nicht minutengenau: ohne Besuch passiert nichts. Wenn dein Hosting einen Cronjob anbietet, trage dort <code>php bin/console cms:tasks:run</code> ein (jede Minute) oder die Adresse des URL-Cronjobs vom Bildschirm „Aufgaben“.</span></li>
    <li class="check-warn"><span class="check-mark" aria-hidden="true">·</span><span><strong>HTTPS prüfen.</strong> Eine Anmeldung über <code>http://</code> überträgt das Passwort im Klartext.</span></li>
    <li class="check-warn"><span class="check-mark" aria-hidden="true">·</span><span><strong>Inhalt und Gestaltung:</strong> Startseite bearbeiten, unter „Design“ Farben und Schriften setzen, unter „Einstellungen“ die Angaben zum Unternehmen ergänzen.</span></li>
 </ul>
@@ -0,0 +1,259 @@
+<?php
+
+namespace App\Tests;
+
+use App\Infrastructure\ConnectionFactory;
+use App\Ops\Scheduler;
+use Doctrine\DBAL\Connection;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Der Aufgabenplan - und zwar die Eigenschaften, an denen er auf einem echten Hosting scheitern
+ * würde: läuft eine Aufgabe zweimal, wenn zwei Besucher gleichzeitig kommen? Reißt eine kaputte
+ * Aufgabe die Website mit? Fängt eine, die nicht laufen kann, bei jedem Seitenaufruf neu an?
+ */
+final class SchedulerTest extends TestCase
+{
+    private Connection $db;
+    private string $databaseFile;
+    private string $projectDir;
+
+    protected function setUp(): void
+    {
+        $this->databaseFile = tempnam(sys_get_temp_dir(), 'kant-tasks-');
+        $this->db = ConnectionFactory::create('sqlite:///'.str_replace('\\', '/', $this->databaseFile));
+        TestSchema::build($this->db);
+        $this->projectDir = sys_get_temp_dir().'/kant-tasks-'.bin2hex(random_bytes(6));
+        mkdir($this->projectDir.'/var', 0o775, true);
+    }
+
+    protected function tearDown(): void
+    {
+        $this->db->close();
+        gc_collect_cycles();
+        @unlink($this->databaseFile);
+        foreach (glob($this->projectDir.'/var/*') ?: [] as $file) {
+            @unlink($file);
+        }
+        @rmdir($this->projectDir.'/var');
+        @rmdir($this->projectDir);
+    }
+
+    /** @param list<SpyTask> $tasks */
+    private function scheduler(array $tasks): Scheduler
+    {
+        return new Scheduler($this->db, $tasks, $this->projectDir);
+    }
+
+    private function makeDue(string $name): void
+    {
+        $this->db->executeStatement('UPDATE scheduled_task SET next_run_at = ? WHERE name = ?', ['2020-01-01 00:00:00', $name]);
+    }
+
+    public function testTheCodeDecidesWhichTasksExist(): void
+    {
+        $this->scheduler([new SpyTask('a'), new SpyTask('b')])->sync();
+        self::assertSame(['a', 'b'], $this->db->fetchFirstColumn('SELECT name FROM scheduled_task ORDER BY name'));
+
+        // Nach einem Update kennt der Code eine Aufgabe weniger: ihre Zeile geht mit.
+        $this->scheduler([new SpyTask('a')])->sync();
+        self::assertSame(['a'], $this->db->fetchFirstColumn('SELECT name FROM scheduled_task'));
+    }
+
+    public function testANewTaskDoesNotRunInTheVeryNextRequest(): void
+    {
+        // Sonst faellt direkt nach einem Update alles gleichzeitig an - im ersten Aufruf danach.
+        $task = new SpyTask('a');
+        self::assertSame([], $this->scheduler([$task])->runDue('besuch'));
+        self::assertSame(0, $task->runs);
+    }
+
+    public function testWhatIsDueRunsAndIsThenRescheduled(): void
+    {
+        $task = new SpyTask('a', 600);
+        $scheduler = $this->scheduler([$task]);
+        $scheduler->sync();
+        $this->makeDue('a');
+
+        $results = $scheduler->runDue('besuch');
+        self::assertCount(1, $results);
+        self::assertSame('ok', $results[0]['status']);
+        self::assertSame('Lauf 1', $results[0]['message']);
+        self::assertSame(1, $task->runs);
+
+        // Danach ist sie nicht mehr faellig, und ein zweiter Aufruf laesst sie in Ruhe.
+        self::assertSame([], $scheduler->runDue('besuch'));
+        self::assertSame(1, $task->runs);
+        $row = $this->db->fetchAssociative('SELECT * FROM scheduled_task WHERE name = ?', ['a']);
+        self::assertSame('besuch', $row['last_trigger']);
+        self::assertGreaterThan(gmdate('Y-m-d H:i:s'), (string) $row['next_run_at']);
+        self::assertNull($row['locked_until']);
+    }
+
+    /**
+     * Der eigentliche Zweck der Sperre: zwei Besucher im selben Moment.
+     *
+     * Nachgestellt wird der Zustand, den der erste hinterlaesst, waehrend er noch arbeitet -
+     * faellig, aber gesperrt. Der zweite muss daran vorbeigehen.
+     */
+    public function testALockedTaskIsLeftAloneByTheNextRequest(): void
+    {
+        $task = new SpyTask('a');
+        $scheduler = $this->scheduler([$task]);
+        $scheduler->sync();
+        $this->db->executeStatement(
+            'UPDATE scheduled_task SET next_run_at = ?, locked_until = ? WHERE name = ?',
+            ['2020-01-01 00:00:00', gmdate('Y-m-d H:i:s', time() + 300), 'a'],
+        );
+
+        self::assertSame([], $scheduler->runDue('besuch'));
+        self::assertSame(0, $task->runs);
+    }
+
+    /** Eine Sperre, deren Prozess das Hosting abgeschossen hat, blockiert nicht fuer immer. */
+    public function testAnExpiredLockIsTakenOver(): void
+    {
+        $task = new SpyTask('a');
+        $scheduler = $this->scheduler([$task]);
+        $scheduler->sync();
+        $this->db->executeStatement(
+            'UPDATE scheduled_task SET next_run_at = ?, locked_until = ? WHERE name = ?',
+            ['2020-01-01 00:00:00', '2020-01-01 00:15:00', 'a'],
+        );
+
+        self::assertCount(1, $scheduler->runDue('besuch'));
+        self::assertSame(1, $task->runs);
+    }
+
+    public function testAFailingTaskIsRecordedAndWaitsLongerEachTime(): void
+    {
+        $task = new SpyTask('a', 300, new \RuntimeException('Kein Netz.'));
+        $scheduler = $this->scheduler([$task]);
+        $scheduler->sync();
+        $this->makeDue('a');
+
+        $results = $scheduler->runDue('besuch');
+        self::assertSame('fehler', $results[0]['status']);
+        self::assertStringContainsString('Kein Netz.', $results[0]['message']);
+        $first = $this->db->fetchAssociative('SELECT * FROM scheduled_task WHERE name = ?', ['a']);
+        self::assertSame(1, (int) $first['failures']);
+        // 300 Sekunden Abstand, ein Fehlschlag: der naechste Versuch liegt weiter weg als der
+        // gewoehnliche Abstand, aber die Sperre ist weg - die Aufgabe haengt nicht fest.
+        self::assertNull($first['locked_until']);
+        self::assertGreaterThan(gmdate('Y-m-d H:i:s', time() + 400), (string) $first['next_run_at']);
+
+        $this->makeDue('a');
+        $scheduler->runDue('besuch');
+        $second = $this->db->fetchAssociative('SELECT * FROM scheduled_task WHERE name = ?', ['a']);
+        self::assertSame(2, (int) $second['failures']);
+        self::assertGreaterThan((string) $first['next_run_at'], (string) $second['next_run_at']);
+    }
+
+    public function testASwitchedOffTaskNeverRuns(): void
+    {
+        $task = new SpyTask('a');
+        $scheduler = $this->scheduler([$task]);
+        $scheduler->sync();
+        $scheduler->enable('a', false);
+        $this->makeDue('a');
+
+        self::assertSame([], $scheduler->runDue('besuch'));
+        self::assertSame(0, $task->runs);
+
+        // Von Hand gestartet laeuft sie trotzdem: wer den Knopf drueckt, meint sie auch.
+        $result = $scheduler->runNow('a');
+        self::assertNotNull($result);
+        self::assertSame(1, $task->runs);
+    }
+
+    public function testOneRequestDoesNotRunEverythingAtOnce(): void
+    {
+        $tasks = [new SpyTask('a'), new SpyTask('b'), new SpyTask('c')];
+        $scheduler = $this->scheduler($tasks);
+        $scheduler->sync();
+        foreach (['a', 'b', 'c'] as $name) {
+            $this->makeDue($name);
+        }
+
+        self::assertCount(2, $scheduler->runDue('besuch', 2));
+        self::assertSame(2, array_sum(array_map(static fn (SpyTask $t): int => $t->runs, $tasks)));
+    }
+
+    /**
+     * Der schnelle Weg: eine Datei sagt, wann sich das Fragen der Datenbank ueberhaupt lohnt.
+     *
+     * Ohne diese Eigenschaft kostet der Aufgabenplan jeden Seitenaufruf eine Abfrage - genau das,
+     * was auf geteiltem Hosting am meisten weh tut.
+     */
+    public function testTheStateFileHoldsTheNextMomentAnythingIsDue(): void
+    {
+        $scheduler = $this->scheduler([new SpyTask('a', 600)]);
+        $scheduler->sync();
+
+        $state = $scheduler->fastState();
+        self::assertTrue($state['traffic']);
+        self::assertNotNull($state['next']);
+        self::assertGreaterThan(time(), $state['next']);
+        self::assertFileExists($this->projectDir.'/'.Scheduler::STATE_FILE);
+
+        // Die Schalter ueberleben das Nachtragen des naechsten Zeitpunkts.
+        $scheduler->setWorkers(false, true);
+        $this->makeDue('a');
+        $scheduler->runDue('besuch');
+        self::assertFalse($scheduler->fastState()['traffic']);
+        self::assertTrue($scheduler->fastState()['admin']);
+    }
+
+    /**
+     * Waehrend eine Aufgabe laeuft, schickt die Zustandsdatei die uebrigen Anfragen weg.
+     *
+     * Sonst waere jeder Seitenaufruf waehrend einer langen Sicherung wieder bei der Datenbank:
+     * faellig ist sie ja, sie ist nur schon vergeben.
+     */
+    public function testARunningTaskKeepsTheOtherRequestsOutOfTheDatabase(): void
+    {
+        $scheduler = $this->scheduler([new SpyTask('a')]);
+        $scheduler->sync();
+        $lockEnds = gmdate('Y-m-d H:i:s', time() + 600);
+        $this->db->executeStatement(
+            'UPDATE scheduled_task SET next_run_at = ?, locked_until = ? WHERE name = ?',
+            ['2020-01-01 00:00:00', $lockEnds, 'a'],
+        );
+
+        $scheduler->runDue('besuch');
+        self::assertSame(strtotime($lockEnds.' UTC'), $scheduler->fastState()['next']);
+    }
+
+    /** Zwischen hochgeladenem Code und ausgefuehrter Migration darf nichts explodieren. */
+    public function testAMissingTableIsNotAnError(): void
+    {
+        $this->db->executeStatement('DROP TABLE scheduled_task');
+        $task = new SpyTask('a');
+
+        self::assertSame([], $this->scheduler([$task])->runDue('besuch'));
+        self::assertSame([], $this->scheduler([$task])->overview());
+        self::assertSame(0, $task->runs);
+    }
+
+    public function testTheProtocolKeepsWhatHappened(): void
+    {
+        $scheduler = $this->scheduler([new SpyTask('a')]);
+        $scheduler->sync();
+        $scheduler->runNow('a');
+
+        $lines = $scheduler->protocol();
+        self::assertCount(1, $lines);
+        self::assertStringContainsString('a', $lines[0]);
+        self::assertStringContainsString('ok', $lines[0]);
+        self::assertStringContainsString('hand', $lines[0]);
+    }
+
+    public function testTheCronKeyDependsOnTheApplicationSecret(): void
+    {
+        $one = Scheduler::cronToken('geheimnis-eins');
+        $two = Scheduler::cronToken('geheimnis-zwei');
+        self::assertSame(40, strlen($one));
+        self::assertNotSame($one, $two);
+        self::assertSame($one, Scheduler::cronToken('geheimnis-eins'));
+    }
+}
@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Tests;
+
+use App\Ops\Tasks\Task;
+
+/**
+ * Eine Aufgabe, die nichts tut außer mitzählen - oder auf Wunsch zu scheitern.
+ *
+ * Der Plan lässt sich nur dann ehrlich prüfen, wenn die Aufgabe selbst nichts kann: was hier
+ * gemessen wird, ist die Mechanik ringsum - Fälligkeit, Sperre, Abstand nach einem Fehlschlag.
+ */
+final class SpyTask implements Task
+{
+    public int $runs = 0;
+
+    public function __construct(
+        private string $name,
+        private int $interval = 300,
+        private ?\Throwable $error = null,
+    ) {
+    }
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public function label(): string
+    {
+        return 'Testaufgabe '.$this->name;
+    }
+
+    public function explanation(): string
+    {
+        return 'Nur für Tests.';
+    }
+
+    public function interval(): int
+    {
+        return $this->interval;
+    }
+
+    public function run(): string
+    {
+        ++$this->runs;
+        if (null !== $this->error) {
+            throw $this->error;
+        }
+
+        return 'Lauf '.$this->runs;
+    }
+}
@@ -0,0 +1,168 @@
+<?php
+
+namespace App\Tests;
+
+use App\Infrastructure\ConnectionFactory;
+use App\Kernel;
+use App\Ops\Scheduler;
+use Doctrine\DBAL\Connection;
+use Symfony\Bundle\FrameworkBundle\KernelBrowser;
+use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+
+/**
+ * Die drei Auslöser, wie sie über HTTP erreichbar sind.
+ *
+ * Geprüft wird nicht das Aussehen, sondern wer was darf: Der Bildschirm gehört Administratoren,
+ * der Takt der Verwaltung braucht eine Anmeldung und ein gültiges Formular, und der URL-Cronjob
+ * hängt an einem Schlüssel, der sich nicht erraten lässt. Jede dieser Stellen startet Arbeit auf
+ * dem Server – eine offene wäre eine Einladung.
+ */
+final class TaskScreenTest extends WebTestCase
+{
+    private const FIXTURE_PASSWORD = 'Fixture-only-password';
+    private const SECRET = 'isolated-test-secret';
+
+    private Connection $db;
+    private string $path;
+    private array $previous;
+
+    protected static function getKernelClass(): string
+    {
+        return Kernel::class;
+    }
+
+    protected function setUp(): void
+    {
+        $this->path = tempnam(sys_get_temp_dir(), 'kant-tasks-web-');
+        $url = 'sqlite:///'.str_replace('\\', '/', $this->path);
+        $this->previous = [$_SERVER, $_ENV];
+        foreach (['APP_SECRET' => self::SECRET, 'DATABASE_URL' => $url, 'SITE_ORIGIN' => 'https://cms.test', 'MEDIA_DIRECTORY' => $this->path.'-media'] as $key => $value) {
+            $_SERVER[$key] = $_ENV[$key] = $value;
+        }
+        $this->db = ConnectionFactory::create($url);
+        TestSchema::build($this->db);
+        $this->db->insert('website', ['id' => 'default', 'name' => 'Test', 'default_locale' => 'de', 'theme' => '{}']);
+        foreach (['admin' => 'ROLE_ADMIN', 'editor' => 'ROLE_EDITOR'] as $username => $role) {
+            $this->db->insert('cms_user', [
+                'id' => bin2hex(random_bytes(8)),
+                'username' => $username,
+                'password_hash' => password_hash(self::FIXTURE_PASSWORD, PASSWORD_BCRYPT, ['cost' => 4]),
+                'roles' => json_encode([$role], JSON_THROW_ON_ERROR),
+                'created_at' => gmdate('Y-m-d H:i:s'),
+                'password_changed_at' => gmdate('Y-m-d H:i:s'),
+            ]);
+        }
+    }
+
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+        $this->db->close();
+        gc_collect_cycles();
+        @unlink($this->path);
+        [$_SERVER, $_ENV] = $this->previous;
+    }
+
+    public function testTheScreenNamesEveryTaskAndTheWayWithoutVisitors(): void
+    {
+        $client = $this->login();
+        $client->request('GET', '/admin/aufgaben');
+        self::assertSame(200, $client->getResponse()->getStatusCode());
+        $html = (string) $client->getResponse()->getContent();
+
+        foreach (['publish-due', 'stats-prune', 'backup', 'update-check', 'cleanup'] as $task) {
+            self::assertStringContainsString($task, $html);
+        }
+        // Die Einschränkung gehört auf den Bildschirm und nicht in die Dokumentation: wer sie
+        // nicht kennt, sucht den Fehler später an der falschen Stelle.
+        self::assertStringContainsString('Ohne Besuch und ohne geöffnete Verwaltung passiert nichts.', $html);
+        self::assertStringContainsString('/cms-cron/'.Scheduler::cronToken(self::SECRET), $html);
+        // Und der Plan steht danach in der Datenbank - eine Zeile je Aufgabe, nicht mehr.
+        self::assertSame(5, (int) $this->db->fetchOne('SELECT COUNT(*) FROM scheduled_task'));
+    }
+
+    public function testStartingWorkNeedsAnAdministratorAndAValidForm(): void
+    {
+        self::ensureKernelShutdown();
+        $anonymous = self::createClient();
+        $anonymous->followRedirects(false);
+        $anonymous->request('POST', '/admin/aufgaben/ausfuehren');
+        self::assertSame('http://localhost/admin/login', $anonymous->getResponse()->headers->get('Location'));
+
+        $editor = $this->login('editor');
+        $editor->request('GET', '/admin/aufgaben');
+        self::assertSame(403, $editor->getResponse()->getStatusCode(), 'Eine Redakteurin verwaltet den Plan nicht.');
+
+        $admin = $this->login();
+        $admin->request('POST', '/admin/aufgaben/ausfuehren', ['_csrf_token' => 'erfunden', 'name' => 'publish-due']);
+        $admin->followRedirect();
+        self::assertStringContainsString('Sitzung ist abgelaufen', (string) $admin->getResponse()->getContent());
+        self::assertNull($this->db->fetchOne('SELECT last_status FROM scheduled_task WHERE name = ?', ['publish-due']));
+    }
+
+    public function testAnAdministratorCanRunATaskFromTheScreen(): void
+    {
+        $client = $this->login();
+        $crawler = $client->request('GET', '/admin/aufgaben');
+        $client->submit($crawler->filter('#run-publish-due')->form());
+        $client->followRedirect();
+
+        self::assertStringContainsString('Geplante Veröffentlichungen', (string) $client->getResponse()->getContent());
+        $row = $this->db->fetchAssociative('SELECT * FROM scheduled_task WHERE name = ?', ['publish-due']);
+        self::assertSame('ok', $row['last_status']);
+        self::assertSame('hand', $row['last_trigger']);
+        self::assertNull($row['locked_until'], 'Nach dem Lauf ist die Sperre weg - sonst blockiert ein Klick die Aufgabe für eine Viertelstunde.');
+    }
+
+    /** Der zweite Auslöser: das geöffnete Backend. Er gehört jedem angemeldeten Konto, nicht nur der Verwaltung. */
+    public function testTheOpenBackendDrivesThePlan(): void
+    {
+        $editor = $this->login('editor');
+        $editor->request('GET', '/admin');
+        $token = $this->tokenFrom((string) $editor->getResponse()->getContent());
+        self::assertNotSame('', $token, 'Jeder Bildschirm der Verwaltung bringt den Takt mit.');
+
+        $editor->request('POST', '/admin/aufgaben/takt', ['_csrf_token' => $token]);
+        self::assertSame(200, $editor->getResponse()->getStatusCode());
+        $answer = json_decode((string) $editor->getResponse()->getContent(), true);
+        self::assertIsArray($answer);
+        self::assertArrayHasKey('ran', $answer);
+
+        // Ohne gültiges Formular passiert nichts, auch für ein angemeldetes Konto nicht.
+        $editor->request('POST', '/admin/aufgaben/takt', ['_csrf_token' => 'erfunden']);
+        self::assertSame(403, $editor->getResponse()->getStatusCode());
+    }
+
+    /** Der dritte Auslöser: ein Aufruf von außen, der nur mit dem richtigen Schlüssel etwas tut. */
+    public function testTheUrlCronAnswersOnlyToItsKey(): void
+    {
+        self::ensureKernelShutdown();
+        $client = self::createClient();
+
+        $client->request('GET', '/cms-cron/'.str_repeat('a', 40));
+        self::assertSame(404, $client->getResponse()->getStatusCode(), 'Ein falscher Schlüssel erfährt nicht einmal, dass es die Stelle gibt.');
+
+        $client->request('GET', '/cms-cron/'.Scheduler::cronToken(self::SECRET));
+        self::assertSame(200, $client->getResponse()->getStatusCode());
+        self::assertStringContainsString('text/plain', (string) $client->getResponse()->headers->get('Content-Type'));
+        self::assertStringContainsString('noindex', (string) $client->getResponse()->headers->get('X-Robots-Tag'));
+        self::assertStringContainsString('Aufgabe(n)', (string) $client->getResponse()->getContent());
+    }
+
+    private function tokenFrom(string $html): string
+    {
+        return 1 === preg_match('#<meta name="kant-tick-token" content="([^"]+)"#', $html, $match) ? $match[1] : '';
+    }
+
+    private function login(string $username = 'admin'): KernelBrowser
+    {
+        self::ensureKernelShutdown();
+        $client = self::createClient();
+        $client->followRedirects(false);
+        $crawler = $client->request('GET', '/admin/login');
+        $client->submit($crawler->selectButton('Anmelden')->form(['_username' => $username, '_password' => self::FIXTURE_PASSWORD]));
+        $client->followRedirect();
+
+        return $client;
+    }
+}
@@ -18,6 +18,7 @@ use DoctrineMigrations\Version20260912001100;
 use DoctrineMigrations\Version20260912001200;
 use DoctrineMigrations\Version20260912001300;
 use DoctrineMigrations\Version20260913000100;
+use DoctrineMigrations\Version20260914000100;
 use Psr\Log\NullLogger;

 /**
@@ -47,6 +48,7 @@ final class TestSchema
            Version20260912001200::class,
            Version20260912001300::class,
            Version20260913000100::class,
+            Version20260914000100::class,
        ] as $migration) {
            (new $migration($db, new NullLogger()))->up($schema);
        }
@@ -1 +1 @@
 .5.3
 .6.0