web: Entfernung mit 410 Gone als Alternative zur Löschung

Rechtlich oder redaktionell veranlasste Entfernungen brauchten bisher die Löschung — danach antwortet die URL mit 404, als hätte es die Meldung nie gegeben. Newsroom und Pressemitteilung lassen sich jetzt stattdessen mit gone_at markieren: Der Inhalt verschwindet aus allen öffentlichen Listen, die bestehende URL liefert aber einen Tombstone mit Status 410. Die vollständige Löschung bleibt unverändert daneben stehen und erzeugt weiterhin 404. Umkehrbar heißt hier wirklich umkehrbar. markGone() überschreibt zwei Felder — companies.is_active (damit der Newsroom ohne Sonderbehandlung aus Newsroom-Liste und Sitemap fällt, die beide darauf filtern) und press_releases.no_export. Beide Vorzustände werden gesichert und beim Aufheben zurückgestellt, sonst stünde eine schon vorher deaktivierte Firma danach öffentlich in der Übersicht und eine Mitteilung dauerhaft als "kein Export" da, ohne dass das je jemand gewählt hätte. Der Auslieferungs-Cache kennt keine Tags, und die Keys der Listenseiten sind über Portal, Sprache, Seite und Filter verstreut. Eine Entfernung erhöht deshalb eine Generations-Nummer im Cache-Key und verwirft damit alle Seiten-Caches auf einen Schlag — grob, aber Entfernungen sind selten und dürfen nicht bis zu einer Stunde nachhängen. Der Zähler liegt bewusst außerhalb des Namensraums, den er invalidiert, und wird zwischen zwei Queue-Jobs neu gelesen: Ein Worker lebt über beliebig viele Jobs und arbeitete sonst dauerhaft mit dem Stand seines ersten Zugriffs. Beim Newsroom läuft die Tombstone-Prüfung bewusst VOR dem Seiten-Cache — eine Entfernung muss sofort greifen, auch wenn für den Slug noch ein Stale-Eintrag liegt. Kaskadiert man die Entfernung auf die Meldungen einer Firma, wird der Cache einmal am Ende verworfen statt einmal je Meldung; sonst zwänge eine Bestandsfirma mit dreistellig vielen Meldungen die gesamte öffentliche Seite ebenso oft in den Neuaufbau. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-01 11:06:35 +00:00 · 2026-09-01 11:06:35 +00:00 · 0c8e94a6ff
commit 0c8e94a6ff
parent 6a34ab48ee
24 changed files with 1150 additions and 57 deletions
--- a/app/Enums/ActivityType.php
+++ b/app/Enums/ActivityType.php
@ -27,6 +27,7 @@ enum ActivityType: string
    case SyncLock = 'sync_lock';
    case Anonymization = 'anonymization';
    case Correction = 'correction';
+    case ContentRemoval = 'content_removal';

    public function label(): string
    {
@ -49,6 +50,7 @@ enum ActivityType: string
            self::SyncLock => 'Re-Sync-Sperre',
            self::Anonymization => 'Anonymisierung',
            self::Correction => 'Korrektur',
+            self::ContentRemoval => 'Entfernung (410)',
        };
    }

@ -71,6 +73,7 @@ enum ActivityType: string
            self::SyncLock => 'red',
            self::Anonymization => 'red',
            self::Correction => 'blue',
+            self::ContentRemoval => 'red',
        };
    }
 }
--- a/app/Http/Controllers/Web/NewsroomDetailController.php
+++ b/app/Http/Controllers/Web/NewsroomDetailController.php
@ -6,13 +6,22 @@ use App\Http\Controllers\Controller;
 use App\Services\Web\NewsroomDetailPageData;
 use App\Support\WebPortalContext;
 use Illuminate\Contracts\View\View;
+use Illuminate\Http\Response;

 class NewsroomDetailController extends Controller
 {
    // $edition stammt aus dem Gruppen-Prefix {edition} und steht positionsbedingt
    // vor {slug}; es wird hier nicht gebraucht, muss aber in der Signatur stehen.
-    public function __invoke(string $edition, string $slug, NewsroomDetailPageData $pageData): View
+    public function __invoke(string $edition, string $slug, NewsroomDetailPageData $pageData): View|Response
    {
-        return view('web.newsroom', $pageData->build(WebPortalContext::fromRequest(), $slug));
+        $data = $pageData->build(WebPortalContext::fromRequest(), $slug);
+
+        // Bewusst entfernter Newsroom → Tombstone mit 410 Gone (ohne Inhalte).
+        // Vollständig gelöschte Firmen bleiben bei 404.
+        if (isset($data['tombstone'])) {
+            return response()->view('web.newsroom-tombstone', [], 410);
+        }
+
+        return view('web.newsroom', $data);
    }
 }
--- a/app/Http/Controllers/Web/ReleaseDetailController.php
+++ b/app/Http/Controllers/Web/ReleaseDetailController.php
@ -16,9 +16,11 @@ class ReleaseDetailController extends Controller
    {
        $data = $pageData->build(WebPortalContext::fromRequest(), $slug);

-        // T12: depublizierte PM → Tombstone mit 410 Gone (ohne Inhalte).
+        // Bewusst entfernte PM → Tombstone mit 410 Gone (ohne Inhalte).
+        // 'depublished' = Depublikation auf Wunsch des Absenders (T12),
+        // 'removed' = redaktionelle/rechtliche Entfernung.
        if (isset($data['tombstone'])) {
-            return response()->view('web.release-tombstone', [], 410);
+            return response()->view('web.release-tombstone', ['reason' => $data['tombstone']], 410);
        }

        return view('web.release-detail', $data);
--- a/app/Models/Company.php
+++ b/app/Models/Company.php
@ -57,6 +57,8 @@ class Company extends Model
        'logo_variants',
        'boilerplate',
        'is_active',
+        'gone_at',
+        'is_active_before_gone',
        'disable_footer_code',
        'legacy_portal',
        'legacy_id',
@ -69,6 +71,8 @@ class Company extends Model
            'type' => CompanyType::class,
            'logo_variants' => 'array',
            'is_active' => 'boolean',
+            'gone_at' => 'datetime',
+            'is_active_before_gone' => 'boolean',
            'disable_footer_code' => 'boolean',
            'deleted_at' => 'datetime',
        ];
@ -117,6 +121,16 @@ class Company extends Model
        });
    }

+    /**
+     * Mit 410 entfernter Newsroom: die Newsroom-URL bleibt bestehen und liefert
+     * einen Tombstone statt eines 404. Gegenstück zur vollständigen Löschung
+     * (Soft Delete).
+     */
+    public function isGone(): bool
+    {
+        return $this->gone_at !== null;
+    }
+
    public function owner(): BelongsTo
    {
        return $this->belongsTo(User::class, 'owner_user_id');
--- a/app/Models/PressRelease.php
+++ b/app/Models/PressRelease.php
@ -91,6 +91,8 @@ class PressRelease extends Model
        'no_export',
        'published_at',
        'depublished_at',
+        'gone_at',
+        'no_export_before_gone',
        'scheduled_at',
        'embargo_at',
        'withdrawal_waiver_consented_at',
@ -117,6 +119,8 @@ class PressRelease extends Model
            'no_export' => 'boolean',
            'published_at' => 'datetime',
            'depublished_at' => 'datetime',
+            'gone_at' => 'datetime',
+            'no_export_before_gone' => 'boolean',
            'sync_locked_at' => 'datetime',
            'scheduled_at' => 'datetime',
            'embargo_at' => 'datetime',
@ -482,7 +486,17 @@ class PressRelease extends Model
     */
    public function scopeVisibleInArchive(Builder $query): Builder
    {
-        return $query->published()->where('published_at', '<=', now());
+        return $query->published()->where('published_at', '<=', now())->whereNull('gone_at');
+    }
+
+    /**
+     * Mit 410 entfernt: die URL bleibt bestehen und liefert einen Tombstone,
+     * der Inhalt ist aber nicht mehr öffentlich. Gegenstück zur vollständigen
+     * Löschung (Soft Delete), die 404 erzeugt.
+     */
+    public function isGone(): bool
+    {
+        return $this->gone_at !== null;
    }

    /**
@ -494,7 +508,8 @@ class PressRelease extends Model
    {
        return $this->status === PressReleaseStatus::Published
            && $this->published_at !== null
-            && $this->published_at->lessThanOrEqualTo(now());
+            && $this->published_at->lessThanOrEqualTo(now())
+            && $this->gone_at === null;
    }

    /**
--- a/app/Providers/AppServiceProvider.php
+++ b/app/Providers/AppServiceProvider.php
@ -32,6 +32,7 @@ use App\Services\Admin\AdminRequestPerformanceMetrics;
 use App\Services\Newsletter\NullNewsletterSyncClient;
 use App\Services\PressRelease\PressReleaseService;
 use App\Support\OperationalAlert;
+use App\Support\WebPageCache;
 use Illuminate\Auth\Events\Login;
 use Illuminate\Auth\Events\Registered;
 use Illuminate\Auth\Events\Verified;
@ -86,6 +87,12 @@ class AppServiceProvider extends ServiceProvider
    {
        Model::preventLazyLoading(app()->isLocal());

+        // Die Generations-Nummer der Seiten-Caches wird prozessintern gemerkt.
+        // Ein Queue-Worker lebt über beliebig viele Jobs hinweg und würde sonst
+        // dauerhaft mit dem Stand seines ersten Zugriffs arbeiten — Keys einer
+        // längst verworfenen Generation lesen und löschen.
+        Queue::looping(static fn () => WebPageCache::resetMemo());
+
        $scheme = request()->header('X-Forwarded-Proto')
            ?? request()->server('HTTP_X_FORWARDED_PROTO')
            ?? (request()->secure() ? 'https' : 'http');
--- a/app/Services/Company/CompanyRemovalService.php
+++ b/app/Services/Company/CompanyRemovalService.php
@ -0,0 +1,123 @@
+<?php
+
+namespace App\Services\Company;
+
+use App\Enums\ActivityType;
+use App\Models\Company;
+use App\Models\PressRelease;
+use App\Scopes\PortalScope;
+use App\Services\ActivityLog;
+use App\Services\PressRelease\PressReleaseService;
+use App\Support\WebCaches;
+
+/**
+ * Entfernung eines Newsrooms aus der öffentlichen Ansicht.
+ *
+ * Zwei bewusst getrennte Wege:
+ * - Vollständige Löschung (Soft Delete, weiterhin in der Firmen-Verwaltung):
+ *   die Newsroom-URL antwortet danach mit 404.
+ * - Entfernung mit 410 Gone (hier): die URL bleibt bestehen und liefert einen
+ *   Tombstone. Umkehrbar über restoreFromGone().
+ */
+class CompanyRemovalService
+{
+    public function __construct(
+        private readonly PressReleaseService $pressReleases,
+        private readonly ActivityLog $activityLog,
+    ) {}
+
+    /**
+     * Markiert den Newsroom als entfernt (410). Die Firma wird zugleich
+     * deaktiviert — dadurch fällt sie ohne Sonderbehandlung aus
+     * Newsroom-Liste und Sitemap, die beide auf `is_active` filtern.
+     *
+     * Die Pressemitteilungen der Firma bleiben absichtlich unangetastet,
+     * solange $includePressReleases nicht gesetzt ist: eine stille
+     * Massen-Depublikation wäre nicht umkehrbar unterscheidbar von einzeln
+     * entfernten Mitteilungen.
+     *
+     * @return int Anzahl der zusätzlich mit 410 entfernten Pressemitteilungen
+     */
+    public function markGone(Company $company, bool $includePressReleases = false, ?string $reason = null): int
+    {
+        $reason ??= 'Newsroom aus der öffentlichen Ansicht entfernt (410 Gone)';
+
+        if ($company->gone_at === null) {
+            $company->forceFill([
+                'gone_at' => now(),
+                // Vorzustand sichern, sonst ist die Entfernung nicht wirklich
+                // umkehrbar: Eine Firma, die bereits vorher deaktiviert war —
+                // im Bestand der Normalfall bei Karteileichen —, stünde nach
+                // dem Aufheben öffentlich in Newsroom-Übersicht und Sitemap.
+                'is_active_before_gone' => (bool) $company->is_active,
+                'is_active' => false,
+            ])->save();
+
+            $this->activityLog->record(
+                ActivityType::ContentRemoval,
+                sprintf('Newsroom „%s“ mit 410 entfernt: %s', $company->name, $reason),
+                subject: $company,
+            );
+        }
+
+        $affected = 0;
+
+        if ($includePressReleases) {
+            // chunkById statt get(): Eine Bestandsfirma kann dreistellig viele
+            // Mitteilungen haben, die hier sonst allesamt gleichzeitig im
+            // Speicher lägen. Der Filter auf `gone_at` schrumpft mit jedem
+            // Durchgang, deshalb chunkById und nicht chunk — ein Offset würde
+            // Zeilen überspringen.
+            PressRelease::query()
+                ->withoutGlobalScope(PortalScope::class)
+                ->where('company_id', $company->getKey())
+                ->whereNull('gone_at')
+                ->chunkById(200, function ($releases) use ($reason, &$affected): void {
+                    foreach ($releases as $release) {
+                        // Ohne Flush je Mitteilung: der verwirft ALLE
+                        // Seiten-Caches auf einmal und würde die gesamte
+                        // öffentliche Seite pro Zeile in den Neuaufbau zwingen.
+                        // Einmal am Ende genügt.
+                        $this->pressReleases->markGone($release, $reason, flushPublicPages: false);
+                        $affected++;
+                    }
+                });
+        }
+
+        WebCaches::forgetPublicPages();
+
+        return $affected;
+    }
+
+    /**
+     * Hebt die 410-Entfernung des Newsrooms auf. Bereits entfernte
+     * Pressemitteilungen bleiben entfernt — sie werden einzeln freigegeben,
+     * damit eine rechtlich veranlasste Einzel-Entfernung nicht versehentlich
+     * mit zurückkommt.
+     *
+     * `is_active` geht auf den Stand VOR der Entfernung zurück, nicht pauschal
+     * auf „aktiv“. Fehlt der Merker (Entfernung aus der Zeit vor dieser
+     * Spalte), bleibt es beim bisherigen Verhalten — für diese Altfälle ist
+     * „aktiv“ die einzige Annahme, die überhaupt zur Verfügung steht.
+     */
+    public function restoreFromGone(Company $company): void
+    {
+        if ($company->gone_at === null) {
+            return;
+        }
+
+        $company->forceFill([
+            'gone_at' => null,
+            'is_active' => $company->is_active_before_gone ?? true,
+            'is_active_before_gone' => null,
+        ])->save();
+
+        $this->activityLog->record(
+            ActivityType::ContentRemoval,
+            sprintf('410-Entfernung des Newsrooms „%s“ aufgehoben', $company->name),
+            subject: $company,
+        );
+
+        WebCaches::forgetPublicPages();
+    }
+}
--- a/app/Services/PressRelease/BoostService.php
+++ b/app/Services/PressRelease/BoostService.php
@ -13,6 +13,7 @@ use App\Models\User;
 use App\Scopes\PortalScope;
 use App\Services\Billing\CreditPricingService;
 use App\Services\Billing\CreditWalletService;
+use App\Support\WebPageCache;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Cache;
@ -229,12 +230,12 @@ class BoostService

        foreach ($portals as $portal) {
            if ($placement === BoostPlacement::Home) {
-                Cache::forget(sprintf('web.home.%s.%s', $portal, $pressRelease->language));
+                Cache::forget(WebPageCache::key('home', [$portal, $pressRelease->language]));
            }

            foreach ($translations as $translation) {
                if (filled($translation->slug)) {
-                    Cache::forget(sprintf('web.category.%s.%s.%s', $portal, $translation->locale, $translation->slug));
+                    Cache::forget(WebPageCache::key('category', [$portal, $translation->locale, $translation->slug]));
                }
            }
        }
--- a/app/Services/PressRelease/PressReleaseService.php
+++ b/app/Services/PressRelease/PressReleaseService.php
@ -411,7 +411,7 @@ class PressReleaseService
            'depublished_at' => now(),
        ]);
        $pressRelease->lockSync($syncLockReason ?? 'Depublikation auf Wunsch des Absenders');
-        WebCaches::forgetSitemaps();
+        WebCaches::forgetPublicPages();
        $this->logStatusChange($pressRelease, $previous, PressReleaseStatus::Archived, 'Depublikation auf Wunsch des Absenders (kostenpflichtige Serviceleistung)', 'depublication');
    }

@ -464,6 +464,89 @@ class PressReleaseService
        $pressRelease->delete();
    }

+    /**
+     * Entfernung mit 410 Gone: die Mitteilung verschwindet aus allen
+     * öffentlichen Listen, ihre Detail-URL liefert aber weiterhin einen
+     * Tombstone statt eines 404.
+     *
+     * Bewusste Abgrenzung zu deleteFromAdmin(): dort wird der Inhalt durch den
+     * Ersatztext überschrieben bzw. die PM soft-gelöscht. Hier bleibt der
+     * Datensatz unverändert erhalten, damit die Entfernung über
+     * restoreFromGone() umkehrbar und im Audit nachvollziehbar bleibt.
+     *
+     * Die Re-Sync-Sperre ist Pflicht — ohne sie würde der nächste
+     * Importer-Lauf die Entfernung wieder überschreiben.
+     *
+     * $flushPublicPages steuert den Auslieferungs-Cache. Der Flush verwirft
+     * ALLE Seiten-Caches auf einmal (siehe WebPageCache::flush) und ist damit
+     * genau einmal je Vorgang richtig — wer die Methode in einer Schleife
+     * aufruft, schaltet ihn ab und flusht selbst am Ende. Sonst zwingt jede
+     * einzelne Mitteilung die gesamte öffentliche Seite in den Neuaufbau.
+     */
+    public function markGone(PressRelease $pressRelease, ?string $reason = null, bool $flushPublicPages = true): void
+    {
+        if ($pressRelease->gone_at !== null) {
+            return;
+        }
+
+        $previous = $pressRelease->status;
+
+        $pressRelease->update([
+            'status' => PressReleaseStatus::Archived->value,
+            'gone_at' => now(),
+            // Vorzustand sichern: `no_export` kann auch redaktionell oder vom
+            // Kunden gesetzt sein und ist in beiden Detailansichten sichtbar.
+            // Ohne diesen Merker stünde die Mitteilung nach dem Aufheben
+            // dauerhaft als „kein Export“ da, ohne dass das je jemand gewählt
+            // hätte.
+            'no_export_before_gone' => (bool) $pressRelease->no_export,
+            'no_export' => true,
+        ]);
+
+        $pressRelease->lockSync($reason ?? 'Entfernung mit 410 (Tombstone)');
+
+        if ($flushPublicPages) {
+            WebCaches::forgetPublicPages();
+        }
+
+        $this->logStatusChange(
+            $pressRelease,
+            $previous,
+            PressReleaseStatus::Archived,
+            $reason ?? 'Aus der öffentlichen Ansicht entfernt (410 Gone)',
+            'gone',
+        );
+    }
+
+    /**
+     * Hebt eine 410-Entfernung auf. Der Status bleibt bewusst „archived“ —
+     * ob die Mitteilung wieder veröffentlicht wird, entscheidet die Redaktion
+     * anschließend über den regulären Statuswechsel.
+     *
+     * `no_export` geht dagegen auf den Stand VOR der Entfernung zurück: Die
+     * Sperre gehört zur Entfernung, nicht zur Mitteilung. Fehlt der Merker
+     * (Entfernung aus der Zeit vor dieser Spalte), bleibt der aktuelle Wert
+     * stehen — raten wäre schlechter als nichts zu tun.
+     *
+     * Zu $flushPublicPages siehe markGone().
+     */
+    public function restoreFromGone(PressRelease $pressRelease, bool $flushPublicPages = true): void
+    {
+        if ($pressRelease->gone_at === null) {
+            return;
+        }
+
+        $pressRelease->update([
+            'gone_at' => null,
+            'no_export' => $pressRelease->no_export_before_gone ?? $pressRelease->no_export,
+            'no_export_before_gone' => null,
+        ]);
+
+        if ($flushPublicPages) {
+            WebCaches::forgetPublicPages();
+        }
+    }
+
    /**
     * @param  PressReleaseStatus[]  $allowed
     */
--- a/app/Services/Web/NewsroomDetailPageData.php
+++ b/app/Services/Web/NewsroomDetailPageData.php
@ -31,6 +31,14 @@ class NewsroomDetailPageData
        // (Cache-Poisoning über z. B. ?page=2.5).
        $page = Paginator::resolveCurrentPage();

+        // Bewusst VOR dem Seiten-Cache: eine Entfernung (410) muss sofort
+        // greifen, auch wenn für den Slug noch ein bis zu eine Stunde alter
+        // Stale-Eintrag im Cache liegt. Kostet einen indizierten Slug-Lookup
+        // pro Aufruf — vertretbar, weil Entfernungen rechtlich motiviert sind.
+        if ($this->isGone($context, $slug)) {
+            return ['tombstone' => 'removed'];
+        }
+
        $cacheKey = WebPageCache::key('newsroom', [
            implode('-', $context->portalValues),
            $context->language,
@ -45,6 +53,20 @@ class NewsroomDetailPageData
        );
    }

+    /**
+     * Newsroom mit 410 entfernt? Vollständig gelöschte Firmen (Soft Delete)
+     * bleiben bewusst außen vor — deren URL antwortet weiterhin mit 404.
+     */
+    private function isGone(WebPortalContext $context, string $slug): bool
+    {
+        return Company::query()
+            ->withoutGlobalScope(PortalScope::class)
+            ->whereIn('portal', $context->portalValues)
+            ->where('slug', $slug)
+            ->whereNotNull('gone_at')
+            ->exists();
+    }
+
    /**
     * @return array<string, mixed>
     */
--- a/app/Services/Web/ReleaseDetailPageData.php
+++ b/app/Services/Web/ReleaseDetailPageData.php
@ -45,19 +45,23 @@ class ReleaseDetailPageData
            ->first();

        if (! $release) {
-            // T12-Tombstone: depublizierte PMs (kostenpflichtige Entfernung
-            // auf Wunsch des Absenders) melden 410 statt 404 — die URL gab
-            // es, der Inhalt wurde bewusst entfernt.
-            $depublished = PressRelease::query()
+            // Tombstone statt 404: die URL gab es, der Inhalt wurde bewusst
+            // entfernt. Zwei Anlässe mit eigenem Seitentext —
+            // `depublished_at` = kostenpflichtige Depublikation auf Wunsch des
+            // Absenders (T12), `gone_at` = redaktionelle/rechtliche Entfernung
+            // aus dem Admin. Vollständig gelöschte PMs bleiben bei 404.
+            $removed = PressRelease::query()
                ->withoutGlobalScope(PortalScope::class)
                ->forPortalValues($portalValues)
                ->forLanguage($language)
-                ->whereNotNull('depublished_at')
                ->where('slug', $slug)
-                ->exists();
+                ->where(fn (Builder $query) => $query
+                    ->whereNotNull('depublished_at')
+                    ->orWhereNotNull('gone_at'))
+                ->first(['depublished_at', 'gone_at']);

-            if ($depublished) {
-                return ['tombstone' => true];
+            if ($removed) {
+                return ['tombstone' => $removed->depublished_at !== null ? 'depublished' : 'removed'];
            }

            abort(404);
--- a/app/Support/WebCaches.php
+++ b/app/Support/WebCaches.php
@ -10,6 +10,18 @@ use Illuminate\Support\Facades\Cache;
 */
 class WebCaches
 {
+    /**
+     * Kompletter Auslieferungs-Cache nach einer Entfernung: Sitemaps UND alle
+     * Seiten-Caches (Ticker, Startseite, Kategorie-, Newsroom- und Suchlisten).
+     * Ohne den zweiten Teil bliebe eine entfernte Meldung bis zu einer Stunde
+     * in gecachten Listen sichtbar.
+     */
+    public static function forgetPublicPages(): void
+    {
+        self::forgetSitemaps();
+        WebPageCache::flush();
+    }
+
    /**
     * Sitemap-Caches aller Hosts verwerfen (SitemapController cached 1h je
     * Host) — nach einer Mutation darf kein Cache den alten Stand halten.
--- a/app/Support/WebPageCache.php
+++ b/app/Support/WebPageCache.php
@ -33,9 +33,40 @@ class WebPageCache
     */
    public const StaleSeconds = 3600;

+    /**
+     * Cache-Key der Generations-Nummer (siehe generation()).
+     *
+     * Bewusst OHNE `web.`-Präfix: Der Zähler ist der eine Eintrag, der eine
+     * Verwerfung des `web.`-Namensraums überleben muss. Läge er darin, würde
+     * ihn ein pauschales Aufräumen dieses Präfixes mitnehmen — und ein Flush
+     * wäre danach stillschweigend wirkungslos.
+     */
+    private const GenerationKey = 'page-cache.generation';
+
+    /**
+     * Generations-Nummer innerhalb des Requests, damit key() nicht bei jedem
+     * Aufruf erneut den Cache-Store befragt.
+     *
+     * ACHTUNG Lebensdauer: Der Wert gilt für einen Request. In langlebigen
+     * Prozessen (queue:work, künftig Octane) muss er zwischen zwei Vorgängen
+     * verworfen werden — sonst arbeitet der Worker beliebig lange mit einer
+     * veralteten Generation und würde etwa in BoostService::forgetPlacementCaches()
+     * die Keys einer alten Generation löschen, während der aktuelle Eintrag
+     * stehen bliebe. Dafür sorgt resetMemo(), registriert im AppServiceProvider
+     * auf `Queue::looping()`.
+     */
+    private static ?int $generation = null;
+
    /**
     * Baut einen `web.`-Cache-Key aus Segmenten (leere Segmente entfallen).
     *
+     * Der Key enthält eine Generations-Nummer: Der Store kennt keine Tags, und
+     * die Keys der Listenseiten sind über Portal, Sprache, Seite und Filter
+     * verstreut. Um eine Entfernung (410/Depublikation) sofort wirksam zu
+     * machen, wird deshalb die Generation erhöht — dadurch verfallen alle
+     * `web.`-Seiten-Caches auf einen Schlag. Das ist bewusst grob, aber
+     * Entfernungen sind selten und dürfen nicht bis zu einer Stunde nachhängen.
+     *
     * @param  array<int, string|int>  $segments
     */
    public static function key(string $group, array $segments = []): string
@ -45,7 +76,47 @@ class WebPageCache
            static fn (string $segment): bool => $segment !== '',
        );

-        return implode('.', array_merge(['web', $group], $parts));
+        return implode('.', array_merge(['web', 'g'.self::generation(), $group], $parts));
+    }
+
+    /**
+     * Aktuelle Generation der Seiten-Caches.
+     */
+    public static function generation(): int
+    {
+        return self::$generation ??= (int) Cache::get(self::GenerationKey, 0);
+    }
+
+    /**
+     * Verwirft die prozessinterne Merkung der Generation, sodass der nächste
+     * Zugriff wieder den Store fragt. Für langlebige Prozesse (Queue-Worker)
+     * und für Tests, die den Cache-Store zurücksetzen.
+     */
+    public static function resetMemo(): void
+    {
+        self::$generation = null;
+    }
+
+    /**
+     * Verwirft sämtliche `web.`-Seiten-Caches, indem die Generation erhöht
+     * wird. Die alten Einträge laufen über ihre TTL aus und werden nie wieder
+     * gelesen.
+     */
+    public static function flush(): void
+    {
+        $current = self::generation();
+        $next = (int) Cache::increment(self::GenerationKey);
+
+        // Der Zähler MUSS echt weiterlaufen. Wurde er im Store verworfen
+        // (Eviction, `cache:clear`), liefert increment() wieder 1 und die alte
+        // Generation bliebe gültig — dann würde ein Flush stillschweigend
+        // wirkungslos und entfernte Inhalte blieben in den Listen stehen.
+        if ($next <= $current) {
+            $next = $current + 1;
+            Cache::forever(self::GenerationKey, $next);
+        }
+
+        self::$generation = $next;
    }

    /**