ki/quota: Hash-Bindung atomar bis in den Publish-Lock, roter Re-Check lehnt ab, Kontingent-Altbestand (Block 7, U02–U04)

- Jobs speichern Ergebnis nur per bedingtem UPDATE auf den analysierten Hash;
  publish() prüft bei ki/scheduler unter der Zeilensperre die jüngste gültige
  Klassifikation und plant sonst eine neue Prüfung ein (StaleClassificationException)
- Re-Check ohne Routing: Rot bei einer PM in Review lehnt wie die Erstprüfung ab
- consumePublishSlot() zählt eine NULL-Periode wie den laufenden Monat;
  Backfill-Migration setzt die Periode für Altverbrauch
- ApiPortalResolutionTest: gemeinsame Kategorie wegen der U10-Prüfung

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

app/Console/Commands/PublishScheduledPressReleases.php

@@ -10,6 +10,7 @@ use App\Models\PressRelease;
 use App\Scopes\PortalScope;
 use App\Services\PressRelease\BlacklistViolationException;
 use App\Services\PressRelease\PressReleaseService;
+use App\Services\PressRelease\StaleClassificationException;
 use Illuminate\Console\Command;
 use Illuminate\Support\Str;
 use Throwable;
@@ -30,6 +31,11 @@ use Throwable;
  * zum aktuellen Text (Admin- oder Korrektur-Bearbeitung nach der Prüfung),
  * wird nicht veröffentlicht, sondern eine Prüfung mit Routing eingeplant –
  * Grün geht dann zum fälligen Termin live, Rot lehnt ab und benachrichtigt.
+ * Die Vorprüfung hier ist nur der schnelle Filter; verbindlich prüft
+ * PressReleaseService::publish() unter der Zeilensperre noch einmal
+ * (Audit U02) und meldet eine Abweichung als StaleClassificationException –
+ * die zählt hier ebenfalls als Re-Check, nicht als Fehler; publish() hat die
+ * Prüfung dann schon eingeplant.
  * Technische Fehler ergeben einen Fehler-Exit-Code, damit der Failure-Hook
  * des Schedulers greift (Audit F20); fachliche Ablehnungen nicht.
  */
@@ -115,6 +121,9 @@ class PublishScheduledPressReleases extends Command
             } catch (BlacklistViolationException $e) {
                 $rejected++;
                 $this->warn($line.'  [REJECT: '.$e->word.']');
+            } catch (StaleClassificationException) {
+                $rechecked++;
+                $this->warn($line.'  [RECHECK: Inhalt unter der Sperre abweichend, Prüfung neu eingeplant]');
             } catch (Throwable $e) {
                 $failed++;
                 $this->error($line.'  [FAIL: '.$e->getMessage().']');

app/Jobs/ClassifyPressRelease.php

@@ -2,6 +2,8 @@
 
 namespace App\Jobs;
 
+use App\Enums\PressReleaseClassification;
+use App\Enums\PressReleaseStatus;
 use App\Models\KiAudit;
 use App\Models\PressRelease;
 use App\Scopes\PortalScope;
@@ -10,6 +12,7 @@ use App\Services\PressRelease\Classification\ClassificationManager;
 use App\Services\PressRelease\Classification\ClassificationResult;
 use App\Services\PressRelease\PressReleaseService;
 use App\Services\PressRelease\QuotaExceededException;
+use App\Services\PressRelease\StaleClassificationException;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Queue\Queueable;
 use Illuminate\Support\Facades\Log;
@@ -32,6 +35,24 @@ use Illuminate\Support\Facades\Log;
  * geändert, wird das Ergebnis verworfen (Audit mit `discarded_at`) und ein
  * neuer Lauf für den aktuellen Stand eingeplant – ein altes Urteil darf
  * weder eine neue Version bewerten noch freigeben.
+ *
+ * Atomar (Audit U02): Das Ergebnis wird mit einem bedingten UPDATE
+ * (`WHERE content_hash = <geprüfte Summe>`) geschrieben — Vergleich und
+ * Schreiben sind damit ein Statement, ein Editor kann nicht mehr zwischen
+ * Hash-SELECT und Speichern dazwischenfunken. Der KI-Aufruf läuft bewusst
+ * außerhalb jeder Sperre. Query-Builder-Update ist hier unbedenklich: kein
+ * Observer reagiert auf Klassifikationsfelder (die Suchtabelle spiegelt nur
+ * Titel/Untertitel/Text/Keywords).
+ *
+ * Roter Re-Check (Audit U03): Liefert ein Lauf ohne Routing (`route: false`,
+ * z. B. nach einer Bearbeitung) Rot und die PM wartet noch in `review` —
+ * typisch eine terminierte Grün-PM, die vor dem Termin geändert wurde —,
+ * greift der Rot-Zweig der Erstprüfung (Ablehnung inkl. Autorenmail bzw.
+ * manuelle Prüfung bei erschöpfter Automatik). Sonst bliebe sie als rote
+ * terminierte Meldung still liegen, weil der Scheduler nur Grün/Gelb zieht.
+ * Gelb/Grün ohne Routing und bereits veröffentlichte PMs bleiben unverändert
+ * (Admin-Signal); eine PM, die ausdrücklich auf einen Menschen wartet
+ * (`manual_review_required_at`), wird nicht automatisch abgelehnt.
  */
 class ClassifyPressRelease implements ShouldQueue
 {
@@ -75,11 +96,27 @@ class ClassifyPressRelease implements ShouldQueue
         $analyzedHash = $this->contentHash ?? $pressRelease->content_hash;
         $result = $this->classify($manager, $pressRelease);
 
-        // Inhalt seit der Einplanung geändert? Dann gilt das Urteil für einen
-        // Text, den es nicht mehr gibt: verwerfen und den aktuellen prüfen.
-        $currentHash = PressRelease::withoutGlobalScope(PortalScope::class)->whereKey($pressRelease->id)->value('content_hash');
+        // Bedingtes UPDATE: schreibt nur, wenn der Inhalt noch die geprüfte
+        // Prüfsumme trägt. Altbestand ohne Summe (null) wird unbedingt
+        // geschrieben. 0 Zeilen = Inhalt inzwischen geändert oder PM weg.
+        $classifiedAt = now();
+        $stored = PressRelease::withoutGlobalScope(PortalScope::class)
+            ->whereKey($pressRelease->id)
+            ->when($analyzedHash !== null, fn ($query) => $query->where('content_hash', $analyzedHash))
+            ->update([
+                'classification' => $result->classification->value,
+                'classified_at' => $classifiedAt,
+                'updated_at' => $classifiedAt,
+            ]);
+
+        if ($stored === 0) {
+            $currentHash = PressRelease::withoutGlobalScope(PortalScope::class)->withTrashed()->whereKey($pressRelease->id)->value('content_hash');
+
+            if ($currentHash === null) {
+                // Hart gelöscht: nichts mehr zu binden, kein Audit möglich (FK).
+                return;
+            }
 
-        if ($analyzedHash !== null && $currentHash !== null && $currentHash !== $analyzedHash) {
             KiAudit::query()->create([
                 'press_release_id' => $pressRelease->id,
                 'type' => KiAudit::TYPE_CLASSIFICATION,
@@ -98,10 +135,12 @@ class ClassifyPressRelease implements ShouldQueue
             return;
         }
 
+        // Modell auf den geschriebenen Stand bringen, ohne ein zweites
+        // (unbedingtes) UPDATE auszulösen.
         $pressRelease->forceFill([
             'classification' => $result->classification->value,
-            'classified_at' => now(),
-        ])->save();
+            'classified_at' => $classifiedAt,
+        ])->syncOriginal();
 
         KiAudit::query()->create([
             'press_release_id' => $pressRelease->id,
@@ -115,7 +154,7 @@ class ClassifyPressRelease implements ShouldQueue
             'created_at' => now(),
         ]);
 
-        if (! $this->route) {
+        if (! $this->route && ! $this->redRecheckMustReject($pressRelease, $result)) {
             return;
         }
 
@@ -123,6 +162,12 @@ class ClassifyPressRelease implements ShouldQueue
             $service->routeByClassification($pressRelease, $result->classification, $result->reasonText());
         } catch (BlacklistViolationException) {
             // publish() hat die PM bereits abgelehnt und den Autor benachrichtigt.
+        } catch (StaleClassificationException $exception) {
+            // Inhalt zwischen Audit und Publish-Sperre geändert: publish() hat
+            // bereits eine Prüfung für den aktuellen Stand eingeplant (U02).
+            Log::info('Auto-Veröffentlichung übersprungen: Klassifikation passt nicht mehr zum Inhalt, Prüfung neu eingeplant.', [
+                'press_release_id' => $pressRelease->id,
+            ]);
         } catch (QuotaExceededException $exception) {
             // Kontingent zwischen Einreichung und KI-Freigabe aufgebraucht: PM
             // bleibt in Review, damit Autor/Admin bewusst entscheiden — kein
@@ -133,6 +178,24 @@ class ClassifyPressRelease implements ShouldQueue
         }
     }
 
+    /**
+     * Roter Re-Check ohne Routing einer noch wartenden PM (Audit U03): nur
+     * dann greift der Rot-Zweig der Erstprüfung. Status frisch lesen — der
+     * KI-Aufruf kann gedauert haben, und ein Admin hat womöglich inzwischen
+     * entschieden.
+     */
+    private function redRecheckMustReject(PressRelease $pressRelease, ClassificationResult $result): bool
+    {
+        if ($result->classification !== PressReleaseClassification::Red) {
+            return false;
+        }
+
+        $pressRelease->refresh();
+
+        return $pressRelease->status === PressReleaseStatus::Review
+            && ! $pressRelease->requiresManualReview();
+    }
+
     /**
      * Klassifiziert über den aktiven (oder explizit gewählten) Treiber; bei
      * Fehler greift der deterministische Fallback, damit das Ergebnis

app/Jobs/ScorePressRelease.php

@@ -25,6 +25,9 @@ use Illuminate\Support\Facades\Log;
  *
  * Inhaltsbindung wie bei ClassifyPressRelease (Audit F07): Ergebnis für
  * einen inzwischen geänderten Text wird verworfen und neu eingeplant.
+ * Atomar per bedingtem UPDATE auf die geprüfte Prüfsumme (Audit U02); der
+ * KI-Aufruf läuft außerhalb jeder Sperre. Query-Builder-Update ist hier
+ * unbedenklich: kein Observer reagiert auf Score-Felder.
  */
 class ScorePressRelease implements ShouldQueue
 {
@@ -57,9 +60,28 @@ class ScorePressRelease implements ShouldQueue
         $result = $this->score($manager, $pressRelease);
         $tier = PressReleaseContentTier::fromScore($result->score);
 
-        $currentHash = PressRelease::withoutGlobalScope(PortalScope::class)->whereKey($pressRelease->id)->value('content_hash');
+        // Bedingtes UPDATE: schreibt nur, wenn der Inhalt noch die bewertete
+        // Prüfsumme trägt. Altbestand ohne Summe (null) wird unbedingt
+        // geschrieben. 0 Zeilen = Inhalt inzwischen geändert oder PM weg.
+        $scoredAt = now();
+        $stored = PressRelease::withoutGlobalScope(PortalScope::class)
+            ->whereKey($pressRelease->id)
+            ->when($analyzedHash !== null, fn ($query) => $query->where('content_hash', $analyzedHash))
+            ->update([
+                'content_score' => $result->score,
+                'content_tier' => $tier->value,
+                'scored_at' => $scoredAt,
+                'updated_at' => $scoredAt,
+            ]);
+
+        if ($stored === 0) {
+            $currentHash = PressRelease::withoutGlobalScope(PortalScope::class)->withTrashed()->whereKey($pressRelease->id)->value('content_hash');
+
+            if ($currentHash === null) {
+                // Hart gelöscht: nichts mehr zu binden, kein Audit möglich (FK).
+                return;
+            }
 
-        if ($analyzedHash !== null && $currentHash !== null && $currentHash !== $analyzedHash) {
             KiAudit::query()->create([
                 'press_release_id' => $pressRelease->id,
                 'type' => KiAudit::TYPE_CONTENT_SCORE,
@@ -78,12 +100,6 @@ class ScorePressRelease implements ShouldQueue
             return;
         }
 
-        $pressRelease->forceFill([
-            'content_score' => $result->score,
-            'content_tier' => $tier->value,
-            'scored_at' => now(),
-        ])->save();
-
         KiAudit::query()->create([
             'press_release_id' => $pressRelease->id,
             'type' => KiAudit::TYPE_CONTENT_SCORE,

app/Services/PressRelease/PressReleaseService.php

@@ -14,6 +14,7 @@ use App\Mail\PressReleasePublished;
 use App\Mail\PressReleaseRejected;
 use App\Models\AdminPreset;
 use App\Models\Company;
+use App\Models\KiAudit;
 use App\Models\PressRelease;
 use App\Models\PressReleaseAiDeclaration;
 use App\Models\PressReleaseImage;
@@ -136,7 +137,13 @@ class PressReleaseService
      * Läuft als Re-Check **ohne Routing**: Bewertung + Audit werden
      * aktualisiert, der Status bleibt unverändert. So führt das bloße
      * Bearbeiten nie zu einer überraschenden automatischen Veröffentlichung
-     * oder Ablehnung – die Entscheidung bleibt beim regulären Workflow/Admin.
+     * – die Entscheidung bleibt beim regulären Workflow/Admin.
+     *
+     * Eine Ausnahme (Audit U03): Wird der Re-Check Rot und die PM wartet
+     * noch in `review` (etwa eine terminierte Grün-PM, die vor dem Termin
+     * bearbeitet wurde), lehnt der Job sie wie bei der Erstprüfung ab –
+     * inkl. Autorenmail –, statt sie still als rote terminierte Meldung
+     * liegen zu lassen. Siehe ClassifyPressRelease.
      */
     public function reclassifyIfClassified(PressRelease $pressRelease): void
     {
@@ -272,9 +279,28 @@ class PressReleaseService
         $this->publish($pressRelease, 'ki', $publishedAtOverride);
     }
 
+    /**
+     * Quellen, die ohne menschliche Entscheidung veröffentlichen. Nur sie
+     * prüfen unter der Sperre, ob die freigebende Klassifikation noch zum
+     * Inhalt gehört (Audit U02); `admin` ist die bewusste Übersteuerung.
+     */
+    private const AUTOMATIC_PUBLISH_SOURCES = ['ki', 'scheduler'];
+
+    /**
+     * @throws BlacklistViolationException Unzulässiges Wort — die PM wurde
+     *                                     abgelehnt, der Autor benachrichtigt.
+     * @throws StaleClassificationException Nur bei automatischen Quellen
+     *                                      (`ki`, `scheduler`): Die jüngste
+     *                                      gültige Klassifikation gehört zu
+     *                                      einer anderen Inhaltsversion als
+     *                                      der gesperrten. Nichts geändert;
+     *                                      eine Prüfung mit Routing für den
+     *                                      aktuellen Stand ist eingeplant.
+     */
     public function publish(PressRelease $pressRelease, string $source = 'admin', ?Carbon $publishedAtOverride = null): void
     {
-        $blacklistViolation = DB::transaction(function () use ($pressRelease, $source, $publishedAtOverride): ?array {
+        /** @var array{blacklist?: array{reason: string, word: string}, stale?: array{analyzed: string|null, current: string}}|null $outcome */
+        $outcome = DB::transaction(function () use ($pressRelease, $source, $publishedAtOverride): ?array {
             $locked = PressRelease::query()
                 ->withoutGlobalScope(PortalScope::class)
                 ->whereKey($pressRelease->getKey())
@@ -284,13 +310,24 @@ class PressReleaseService
             $this->assertStatus($locked, [PressReleaseStatus::Review]);
             $previous = $locked->status;
 
+            // Inhaltsbindung unter der Sperre (Audit U02): Der Vergleich im
+            // Job bzw. Scheduler liegt VOR der Sperre – hier zählt, was jetzt
+            // gesperrt ist. Innerhalb der Transaktion nichts ändern.
+            if (in_array($source, self::AUTOMATIC_PUBLISH_SOURCES, true)) {
+                $analyzedHash = $this->latestClassificationHash($locked);
+
+                if ($this->classificationIsStale($locked, $analyzedHash)) {
+                    return ['stale' => ['analyzed' => $analyzedHash, 'current' => (string) $locked->content_hash]];
+                }
+            }
+
             if ($word = $this->blacklist->findInPressRelease($locked)) {
                 $reason = sprintf('Automatische Ablehnung: unzulässiges Wort "%s" gefunden.', $word);
 
                 $locked->update(['status' => PressReleaseStatus::Rejected->value]);
                 $this->logStatusChange($locked, $previous, PressReleaseStatus::Rejected, $reason, 'blacklist');
 
-                return ['reason' => $reason, 'word' => $word];
+                return ['blacklist' => ['reason' => $reason, 'word' => $word]];
             }
 
             $this->consumePublishSlot($locked);
@@ -307,12 +344,18 @@ class PressReleaseService
 
         $pressRelease->refresh();
 
-        if ($blacklistViolation !== null) {
-            $this->notifyAuthor($pressRelease, 'rejected', $blacklistViolation['reason']);
+        if (isset($outcome['stale'])) {
+            ClassifyPressRelease::dispatch($pressRelease->id, route: true, contentHash: $outcome['stale']['current'])->onQueue('classification');
+
+            throw new StaleClassificationException($pressRelease->id, $outcome['stale']['analyzed'], $outcome['stale']['current']);
+        }
+
+        if (isset($outcome['blacklist'])) {
+            $this->notifyAuthor($pressRelease, 'rejected', $outcome['blacklist']['reason']);
 
             throw new BlacklistViolationException(
-                $blacklistViolation['reason'],
-                $blacklistViolation['word'],
+                $outcome['blacklist']['reason'],
+                $outcome['blacklist']['word'],
             );
         }
 
@@ -328,6 +371,32 @@ class PressReleaseService
         $this->notifyAuthor($pressRelease, 'published');
     }
 
+    /**
+     * Prüfsumme der jüngsten gültigen (nicht verworfenen) Klassifikation.
+     * Null, wenn es keine gibt oder sie aus der Zeit vor der Bindung stammt.
+     */
+    private function latestClassificationHash(PressRelease $pressRelease): ?string
+    {
+        return KiAudit::query()
+            ->where('press_release_id', $pressRelease->id)
+            ->where('type', KiAudit::TYPE_CLASSIFICATION)
+            ->whereNull('discarded_at')
+            ->orderByDesc('id')
+            ->value('content_hash');
+    }
+
+    /**
+     * Gleiche Übergangsregel wie im Scheduler: Altbestand ohne Prüfsumme —
+     * auf der PM oder im Audit (auch: noch gar kein Audit) — gilt weiter.
+     * Nur eine vorhandene, abweichende Summe blockiert.
+     */
+    private function classificationIsStale(PressRelease $pressRelease, ?string $analyzedHash): bool
+    {
+        return $analyzedHash !== null
+            && $pressRelease->content_hash !== null
+            && $analyzedHash !== $pressRelease->content_hash;
+    }
+
     /**
      * Zählt beim ersten Übergang zu „published" einen PM-Slot des Eigentümers
      * (Decision-Update §3.2: Slot-Verbrauch bei Veröffentlichung; abgelehnte
@@ -363,11 +432,17 @@ class PressReleaseService
         $plan = $user->currentPlan();
 
         if ($plan && $user->pressReleaseQuotaUsedThisMonth() < $plan->press_release_quota) {
-            // Periodenwechsel atomar unter der Zeilensperre: neuer Monat →
-            // Zähler beginnt bei 1, sonst erhöhen (Audit F18).
+            // Periodenwechsel atomar unter der Zeilensperre: ein explizit
+            // ABWEICHENDER Monat → Zähler beginnt bei 1, sonst erhöhen
+            // (Audit F18). NULL (Altbestand vor der Periodenbindung) zählt
+            // wie der laufende Monat — dieselbe Lesart wie
+            // User::pressReleaseQuotaUsedThisMonth() (Audit U04).
             $period = User::currentQuotaPeriod();
+            $continuesPeriod = $user->press_release_quota_period === null
+                || $user->press_release_quota_period === $period;
+
             $user->forceFill([
-                'press_release_quota_used_this_month' => $user->press_release_quota_period === $period
+                'press_release_quota_used_this_month' => $continuesPeriod
                     ? (int) $user->press_release_quota_used_this_month + 1
                     : 1,
                 'press_release_quota_period' => $period,

app/Services/PressRelease/StaleClassificationException.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Services\PressRelease;
+
+use RuntimeException;
+
+/**
+ * Die freigebende KI-Klassifikation gehört zu einer anderen Inhaltsversion
+ * als der, die unter der Zeilensperre veröffentlicht werden sollte
+ * (Audit U02). Die automatische Veröffentlichung (KI-Job, Scheduler) bricht
+ * ab; eine Prüfung mit Routing für den aktuellen Stand ist bereits
+ * eingeplant. Manuelle Admin-Freigaben prüfen das nicht.
+ */
+class StaleClassificationException extends RuntimeException
+{
+    public function __construct(
+        public readonly int $pressReleaseId,
+        public readonly ?string $analyzedHash,
+        public readonly string $currentHash,
+    ) {
+        parent::__construct(sprintf(
+            'PM #%d: Die KI-Klassifikation gilt für eine ältere Inhaltsversion (%s statt %s) — nicht automatisch veröffentlicht, Prüfung neu eingeplant.',
+            $pressReleaseId,
+            $analyzedHash === null ? 'ohne Prüfsumme' : substr($analyzedHash, 0, 12),
+            substr($currentHash, 0, 12),
+        ));
+    }
+}