newsletter: jeden Empfänger genau einmal, atomarer Start, Wiederanlauf (Audit Block 2, Deploy B)

F05: chunkById hinter der created_at-Sortierung der Vorschau las ab der
zweiten Seite Empfänger doppelt und ließ die übrigen aus. Auf der Dev-
Kopie erreichte eine Kampagne an 59.705 Nutzer 500 Adressen, davon 480
doppelt. Die Sortierung wird vor dem ID-Chunking verworfen (E4: die
Versandreihenfolge hat keine fachliche Bedeutung), ein Unique-Index auf
(Kampagne, User) fängt jede weitere Doppelung ab; die Migration räumt
vorhandene Doppelungen vorher weg (auf der Dev-Kopie 470 Zeilen).

F14: Der Start übernimmt den Entwurf per bedingtem UPDATE draft→sending;
nur der Gewinner friert Empfänger ein (insertOrIgnore) und plant Jobs
aus dem Protokoll ein. Abbruch beim Einfrieren gibt den Entwurf frei.

F15: Der Versandjob beansprucht die Zeile pending→sending, schreibt
Empfängerstatus, Zähler und Kampagnenabschluss in einer Transaktion und
gibt den Claim bei Versandfehler zurück. Tries und Backoff am Job.
Zusatzbefund: Adressen auf der Sperrliste galten als „gesendet“, weil der
Rückgabewert von Mail::send nicht ausgewertet wurde — jetzt Status
„suppressed“ ohne Zähler.

Neu: php artisan newsletter:resume {kampagne} [--failed]
[--stuck-minutes=30] plant ausstehende Empfänger einer laufenden
Kampagne neu ein; der Circuit-Breaker-Hinweis nennt ihn statt
queue:retry, das Newsletter-Empfänger nicht nachholt.

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

app/Services/Newsletter/CampaignSender.php

@@ -15,6 +15,13 @@ use App\Models\User;
  * dort wird der Opt-out-Stand erneut geprüft, damit eine Abmeldung zwischen
  * Versandstart und Versand sofort greift.
  *
+ * Der Start ist atomar (Audit F14): Nur der Aufruf, der den Entwurf per
+ * bedingtem UPDATE auf „sending“ stellt, legt Empfänger an und plant Jobs
+ * ein. Empfänger werden mit insertOrIgnore gegen den Unique-Index
+ * (Kampagne, User) geschrieben, die Jobs anschließend aus dem Protokoll
+ * heraus eingeplant — ein Wiederanlauf nach Abbruch (`newsletter:resume`)
+ * arbeitet auf demselben Stand.
+ *
  * Große Listen werden gedrosselt: Die Jobs erhalten gestaffelte Delays in
  * Wellen laut config('newsletter.campaign'), damit das SMTP-Limit des
  * Providers nicht reißt und die Domain nicht auf Blocklisten landet.
@@ -28,15 +35,108 @@ class CampaignSender
      */
     public function start(NewsletterCampaign $campaign): int
     {
-        if (! $campaign->isDraft()) {
+        if (! $this->claimDraft($campaign)) {
             return 0;
         }
 
-        $total = 0;
+        try {
+            $this->freezeRecipients($campaign);
+        } catch (\Throwable $exception) {
+            // Abbruch beim Einfrieren: Entwurf bleibt startbar, bereits
+            // angelegte Zeilen werden beim nächsten Start übersprungen.
+            $this->releaseDraft($campaign);
 
+            throw $exception;
+        }
+
+        $total = $campaign->recipients()->count();
+
+        if ($total === 0) {
+            $this->releaseDraft($campaign);
+
+            return 0;
+        }
+
+        $campaign->forceFill(['recipients_total' => $total])->save();
+
+        self::dispatchPending($campaign);
+
+        return $total;
+    }
+
+    /**
+     * Plant für jeden ausstehenden Empfänger einen Versand-Job ein, mit
+     * Drossel-Delay in Wellen. Liest aus dem Protokoll, nicht aus dem
+     * Speicher — so nutzt der Wiederanlauf denselben Weg.
+     *
+     * @return int Anzahl der eingeplanten Jobs.
+     */
+    public static function dispatchPending(NewsletterCampaign $campaign): int
+    {
+        $batchSize = max(1, (int) config('newsletter.campaign.batch_size'));
+        $intervalSeconds = max(1, (int) config('newsletter.campaign.batch_interval_minutes')) * 60;
+        $position = 0;
+
+        $campaign->recipients()
+            ->toBase()
+            ->select('id')
+            ->where('status', NewsletterRecipientStatus::Pending->value)
+            ->chunkById(500, function ($rows) use ($batchSize, $intervalSeconds, &$position): void {
+                foreach ($rows as $row) {
+                    SendNewsletterCampaignMail::dispatch((int) $row->id)
+                        ->delay(intdiv($position, $batchSize) * $intervalSeconds);
+                    $position++;
+                }
+            });
+
+        return $position;
+    }
+
+    /**
+     * Bedingtes UPDATE draft → sending: Genau ein Aufrufer gewinnt, auch bei
+     * zwei parallel geladenen Model-Instanzen desselben Entwurfs.
+     */
+    private function claimDraft(NewsletterCampaign $campaign): bool
+    {
+        $claimed = NewsletterCampaign::query()
+            ->whereKey($campaign->id)
+            ->where('status', NewsletterCampaignStatus::Draft->value)
+            ->update([
+                'status' => NewsletterCampaignStatus::Sending->value,
+                'updated_at' => now(),
+            ]);
+
+        if ($claimed !== 1) {
+            return false;
+        }
+
+        $campaign->forceFill(['status' => NewsletterCampaignStatus::Sending->value])->syncOriginal();
+
+        return true;
+    }
+
+    private function releaseDraft(NewsletterCampaign $campaign): void
+    {
+        NewsletterCampaign::query()
+            ->whereKey($campaign->id)
+            ->where('status', NewsletterCampaignStatus::Sending->value)
+            ->update(['status' => NewsletterCampaignStatus::Draft->value]);
+
+        $campaign->forceFill(['status' => NewsletterCampaignStatus::Draft->value])->syncOriginal();
+    }
+
+    /**
+     * Schreibt die Empfängerliste laut Filter ins Protokoll. Die Filter-
+     * Sortierung ist eine UI-Sortierung der Vorschau (E4) — vor dem
+     * ID-Chunking wird sie verworfen, sonst liest chunkById ab der zweiten
+     * Seite Empfänger doppelt und lässt andere aus (Audit F05).
+     */
+    private function freezeRecipients(NewsletterCampaign $campaign): void
+    {
         $this->recipients->query($campaign->filters ?? [])
             ->select(['id', 'email'])
-            ->chunkById(500, function ($users) use ($campaign, &$total): void {
+            ->reorder('id')
+            ->chunkById(500, function ($users) use ($campaign): void {
                 $rows = $users->map(fn (User $user): array => [
                     'newsletter_campaign_id' => $campaign->id,
                     'user_id' => $user->id,
@@ -46,35 +146,8 @@ class CampaignSender
                     'updated_at' => now(),
                 ])->all();
 
-                $campaign->recipients()->insert($rows);
-                $total += count($rows);
+                $campaign->recipients()->insertOrIgnore($rows);
             });
-
-        if ($total === 0) {
-            return 0;
-        }
-
-        $campaign->update([
-            'status' => NewsletterCampaignStatus::Sending->value,
-            'recipients_total' => $total,
-        ]);
-
-        $batchSize = max(1, (int) config('newsletter.campaign.batch_size'));
-        $intervalSeconds = max(1, (int) config('newsletter.campaign.batch_interval_minutes')) * 60;
-        $position = 0;
-
-        $campaign->recipients()
-            ->toBase()
-            ->select('id')
-            ->chunkById(500, function ($rows) use ($batchSize, $intervalSeconds, &$position): void {
-                foreach ($rows as $row) {
-                    SendNewsletterCampaignMail::dispatch((int) $row->id)
-                        ->delay(intdiv($position, $batchSize) * $intervalSeconds);
-                    $position++;
-                }
-            });
-
-        return $total;
     }
 
     /**