diff --git a/admin/src/app/dashboard/PlacementPage.tsx b/admin/src/app/dashboard/PlacementPage.tsx
new file mode 100644
index 00000000..3be05859
--- /dev/null
+++ b/admin/src/app/dashboard/PlacementPage.tsx
@@ -0,0 +1,549 @@
+// /placement — seed inbox-placement testing.
+//
+// Send a tokenized copy of a real template through a real sender to the panel
+// of Warmbly-controlled SEED mailboxes, then watch where each landed (Inbox /
+// Spam / Promotions / other), rolled up per provider. A backend poller fills in
+// results as the probes sync into each seed's inbox, so a test starts "pending"
+// and resolves over the next few minutes.
+
+import { useMemo, useState } from "react";
+import {
+    keepPreviousData,
+    useMutation,
+    useQuery,
+    useQueryClient,
+} from "@tanstack/react-query";
+import { toast } from "sonner";
+import { Inbox, Send, Sparkles, Tag, TriangleAlert } from "lucide-react";
+import { PageHeader } from "@/components/layout/PageHeader";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { Skeleton } from "@/components/ui/skeleton";
+import { ErrorState } from "@/components/ErrorState";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogHeader,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import { DataTable, type Column } from "@/components/data/DataTable";
+import { useCursorPager } from "@/lib/useCursorPager";
+import {
+    createPlacementTest,
+    getPlacementTest,
+    listPlacementTests,
+    listSeedCandidates,
+    listSeedMailboxes,
+    setSeedMailbox,
+    type PlacementFolder,
+    type PlacementTestRow,
+    type SeedAccount,
+} from "@/lib/api/client/admin/placement";
+import { fmtDate } from "./warmup-content/shared";
+
+const STATUS_TONE: Record<string, string> = {
+    pending: "border-amber-300 bg-amber-50 text-amber-700",
+    completed: "border-emerald-300 bg-emerald-50 text-emerald-700",
+};
+
+const FOLDER_TONE: Record<PlacementFolder, string> = {
+    inbox: "border-emerald-300 bg-emerald-50 text-emerald-700",
+    promotions: "border-sky-300 bg-sky-50 text-sky-700",
+    spam: "border-red-300 bg-red-50 text-red-700",
+    other: "border-zinc-300 bg-zinc-50 text-zinc-600",
+    pending: "border-amber-300 bg-amber-50 text-amber-700",
+};
+
+const PROVIDER_LABEL: Record<string, string> = {
+    gmail: "Gmail / Workspace",
+    outlook: "Outlook / M365",
+    smtp_imap: "SMTP / IMAP",
+    unknown: "Unknown",
+};
+
+function providerLabel(p: string): string {
+    return PROVIDER_LABEL[p] ?? p;
+}
+
+export default function PlacementPage() {
+    return (
+        <div>
+            <PageHeader
+                title="Inbox placement"
+                description="Send a tokenized copy of a template through a real sender to the seed panel, then classify where it landed per provider. Results fill in as the probes sync into each seed's inbox."
+            />
+
+            <OperationalNotice />
+
+            <section className="mt-6">
+                <h2 className="text-sm font-semibold mb-2">Run a placement test</h2>
+                <CreateTestForm />
+            </section>
+
+            <section className="mt-8">
+                <h2 className="text-sm font-semibold mb-2">Tests</h2>
+                <TestsTable />
+            </section>
+
+            <section className="mt-8">
+                <h2 className="text-sm font-semibold mb-2">Seed mailboxes</h2>
+                <SeedsSection />
+            </section>
+        </div>
+    );
+}
+
+function OperationalNotice() {
+    return (
+        <div className="mt-4 flex gap-2 rounded-md border border-amber-300 bg-amber-50 px-3 py-2.5 text-[12.5px] text-amber-800">
+            <TriangleAlert className="size-4 shrink-0 mt-0.5" />
+            <div>
+                Placement classification only works for mailboxes Warmbly owns and
+                syncs. Connect real seed mailboxes across providers (Gmail/Workspace,
+                Outlook/M365, Yahoo, AOL, iCloud, corporate) and flag them below.
+                Gmail Promotions-tab detection additionally needs category-label sync
+                (a worker follow-up); until then a Gmail tab reads as Inbox.
+            </div>
+        </div>
+    );
+}
+
+// --- Create -------------------------------------------------------------
+
+function CreateTestForm() {
+    const qc = useQueryClient();
+    const [senderId, setSenderId] = useState("");
+    const [subject, setSubject] = useState("");
+    const [bodyPlain, setBodyPlain] = useState("");
+
+    const create = useMutation({
+        mutationFn: () =>
+            createPlacementTest({
+                sender_account_id: senderId.trim(),
+                subject: subject.trim(),
+                body_plain: bodyPlain,
+                body_html: "",
+            }),
+        onSuccess: () => {
+            toast.success("Placement test sent to the seed panel");
+            setSubject("");
+            setBodyPlain("");
+            qc.invalidateQueries({ queryKey: ["admin", "placement", "tests"] });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to send test"),
+    });
+
+    const canSubmit =
+        senderId.trim() !== "" && subject.trim() !== "" && bodyPlain.trim() !== "";
+
+    return (
+        <div className="rounded-md border border-zinc-200 bg-white p-4 space-y-3">
+            <div className="grid gap-3 md:grid-cols-2">
+                <div className="space-y-1.5">
+                    <Label htmlFor="pl-sender">Sender account ID</Label>
+                    <Input
+                        id="pl-sender"
+                        placeholder="email_account UUID to send from"
+                        value={senderId}
+                        onChange={(e) => setSenderId(e.target.value)}
+                    />
+                    <p className="text-[11px] text-muted-foreground">
+                        The real mailbox whose deliverability you are testing. Copy its
+                        ID from the Mailboxes explorer.
+                    </p>
+                </div>
+                <div className="space-y-1.5">
+                    <Label htmlFor="pl-subject">Subject</Label>
+                    <Input
+                        id="pl-subject"
+                        placeholder="Template subject line"
+                        value={subject}
+                        onChange={(e) => setSubject(e.target.value)}
+                    />
+                    <p className="text-[11px] text-muted-foreground">
+                        A hidden placement token is appended so we can find the copy in
+                        each seed inbox.
+                    </p>
+                </div>
+            </div>
+            <div className="space-y-1.5">
+                <Label htmlFor="pl-body">Body (plain text)</Label>
+                <Textarea
+                    id="pl-body"
+                    rows={6}
+                    placeholder="The template body to test."
+                    value={bodyPlain}
+                    onChange={(e) => setBodyPlain(e.target.value)}
+                />
+            </div>
+            <div className="flex justify-end">
+                <Button
+                    onClick={() => create.mutate()}
+                    disabled={!canSubmit || create.isPending}
+                >
+                    <Send className="size-4" />
+                    {create.isPending ? "Sending…" : "Send placement test"}
+                </Button>
+            </div>
+        </div>
+    );
+}
+
+// --- Tests --------------------------------------------------------------
+
+function TestsTable() {
+    const pager = useCursorPager();
+    const [openId, setOpenId] = useState<string | null>(null);
+
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "placement", "tests", pager.cursor],
+        queryFn: () => listPlacementTests({ cursor: pager.cursor, limit: 25 }),
+        staleTime: 15_000,
+        refetchInterval: 30_000,
+        placeholderData: keepPreviousData,
+    });
+
+    const rows = data?.data ?? [];
+
+    const columns: Column<PlacementTestRow>[] = useMemo(
+        () => [
+            {
+                id: "subject",
+                header: "Subject",
+                cell: (r) => (
+                    <span className="font-medium text-zinc-800">{r.subject}</span>
+                ),
+            },
+            {
+                id: "status",
+                header: "Status",
+                cell: (r) => (
+                    <Badge
+                        variant="outline"
+                        className={STATUS_TONE[r.status] ?? FOLDER_TONE.other}
+                    >
+                        {r.status}
+                    </Badge>
+                ),
+            },
+            {
+                id: "created_at",
+                header: "Created",
+                cell: (r) => (
+                    <span className="text-zinc-500">{fmtDate(r.created_at)}</span>
+                ),
+            },
+            {
+                id: "finished_at",
+                header: "Finished",
+                cell: (r) => (
+                    <span className="text-zinc-500">
+                        {r.finished_at ? fmtDate(r.finished_at) : "—"}
+                    </span>
+                ),
+            },
+        ],
+        [],
+    );
+
+    return (
+        <>
+            <DataTable<PlacementTestRow>
+                columns={columns}
+                rows={rows}
+                getRowId={(r) => r.id}
+                loading={isLoading}
+                error={error}
+                onRetry={() => refetch()}
+                onRowClick={(r) => setOpenId(r.id)}
+                emptyTitle="No placement tests yet"
+                emptyHint="Send one above to see where it lands."
+                noun="tests"
+                pager={{
+                    canPrev: pager.canPrev,
+                    canNext: !!data?.pagination.has_more,
+                    onPrev: pager.prev,
+                    onNext: () => pager.next(data?.pagination.next_cursor ?? null),
+                    page: pager.page,
+                    shown: rows.length,
+                    total: data?.pagination.total,
+                }}
+            />
+            <TestDetailDialog
+                id={openId}
+                onClose={() => setOpenId(null)}
+            />
+        </>
+    );
+}
+
+function TestDetailDialog({
+    id,
+    onClose,
+}: {
+    id: string | null;
+    onClose: () => void;
+}) {
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "placement", "test", id],
+        queryFn: () => getPlacementTest(id as string),
+        enabled: !!id,
+        refetchInterval: 15_000,
+    });
+
+    const detail = data?.data;
+
+    return (
+        <Dialog open={!!id} onOpenChange={(o) => !o && onClose()}>
+            <DialogContent className="max-w-2xl">
+                <DialogHeader>
+                    <DialogTitle>Placement result</DialogTitle>
+                    <DialogDescription>
+                        {detail?.test.subject ?? "Per-provider folder rollup."}
+                    </DialogDescription>
+                </DialogHeader>
+
+                {isLoading && <Skeleton className="h-40" />}
+                {error && (
+                    <ErrorState
+                        error={error}
+                        title="Failed to load test"
+                        onRetry={() => refetch()}
+                    />
+                )}
+
+                {detail && (
+                    <div className="space-y-5">
+                        <div className="space-y-2">
+                            <div className="text-[10px] uppercase tracking-wider text-muted-foreground">
+                                Per-provider rollup
+                            </div>
+                            {detail.rollup.length === 0 ? (
+                                <p className="text-[12.5px] text-zinc-500">
+                                    No seeds resolved yet.
+                                </p>
+                            ) : (
+                                <div className="space-y-2">
+                                    {detail.rollup.map((r) => (
+                                        <div
+                                            key={r.provider}
+                                            className="rounded-md border border-zinc-200 p-3"
+                                        >
+                                            <div className="mb-2 flex items-center gap-1.5 text-[12.5px] font-medium text-zinc-800">
+                                                <Sparkles className="size-3.5 text-zinc-400" />
+                                                {providerLabel(r.provider)}
+                                                <span className="text-zinc-400 font-normal">
+                                                    · {r.total} seed{r.total === 1 ? "" : "s"}
+                                                </span>
+                                            </div>
+                                            <div className="flex flex-wrap gap-1.5">
+                                                <Count tone={FOLDER_TONE.inbox} icon={<Inbox className="size-3" />} label="Inbox" n={r.inbox} />
+                                                <Count tone={FOLDER_TONE.promotions} icon={<Tag className="size-3" />} label="Promotions" n={r.promotions} />
+                                                <Count tone={FOLDER_TONE.spam} icon={<TriangleAlert className="size-3" />} label="Spam" n={r.spam} />
+                                                <Count tone={FOLDER_TONE.other} label="Other" n={r.other} />
+                                                <Count tone={FOLDER_TONE.pending} label="Pending" n={r.pending} />
+                                            </div>
+                                        </div>
+                                    ))}
+                                </div>
+                            )}
+                        </div>
+
+                        <div className="space-y-2">
+                            <div className="text-[10px] uppercase tracking-wider text-muted-foreground">
+                                Per-seed detail
+                            </div>
+                            <div className="overflow-hidden rounded-md border border-zinc-200">
+                                <table className="w-full text-[12.5px]">
+                                    <thead className="bg-zinc-50 text-left text-zinc-500">
+                                        <tr>
+                                            <th className="px-3 py-1.5 font-medium">Seed</th>
+                                            <th className="px-3 py-1.5 font-medium">Provider</th>
+                                            <th className="px-3 py-1.5 font-medium">Folder</th>
+                                            <th className="px-3 py-1.5 font-medium">Detected</th>
+                                        </tr>
+                                    </thead>
+                                    <tbody>
+                                        {detail.results.map((res) => (
+                                            <tr
+                                                key={res.seed_account_id}
+                                                className="border-t border-zinc-100"
+                                            >
+                                                <td className="px-3 py-1.5 font-mono text-[11px] text-zinc-600">
+                                                    {res.seed_account_id.slice(0, 8)}
+                                                </td>
+                                                <td className="px-3 py-1.5 text-zinc-600">
+                                                    {providerLabel(res.provider || "unknown")}
+                                                </td>
+                                                <td className="px-3 py-1.5">
+                                                    <Badge
+                                                        variant="outline"
+                                                        className={FOLDER_TONE[res.folder]}
+                                                    >
+                                                        {res.folder}
+                                                    </Badge>
+                                                </td>
+                                                <td className="px-3 py-1.5 text-zinc-500">
+                                                    {res.detected_at
+                                                        ? fmtDate(res.detected_at)
+                                                        : "—"}
+                                                </td>
+                                            </tr>
+                                        ))}
+                                    </tbody>
+                                </table>
+                            </div>
+                        </div>
+                    </div>
+                )}
+            </DialogContent>
+        </Dialog>
+    );
+}
+
+function Count({
+    tone,
+    icon,
+    label,
+    n,
+}: {
+    tone: string;
+    icon?: React.ReactNode;
+    label: string;
+    n: number;
+}) {
+    return (
+        <Badge variant="outline" className={tone}>
+            {icon}
+            <span className="ml-0.5">
+                {label} {n}
+            </span>
+        </Badge>
+    );
+}
+
+// --- Seeds --------------------------------------------------------------
+
+function SeedsSection() {
+    const qc = useQueryClient();
+    const [search, setSearch] = useState("");
+
+    const seeds = useQuery({
+        queryKey: ["admin", "placement", "seeds"],
+        queryFn: () => listSeedMailboxes(),
+        staleTime: 15_000,
+    });
+
+    const candidates = useQuery({
+        queryKey: ["admin", "placement", "seed-candidates", search],
+        queryFn: () => listSeedCandidates(search || undefined),
+        enabled: search.trim().length >= 2,
+        placeholderData: keepPreviousData,
+    });
+
+    const toggle = useMutation({
+        mutationFn: ({ id, isSeed }: { id: string; isSeed: boolean }) =>
+            setSeedMailbox(id, isSeed),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: ["admin", "placement", "seeds"] });
+            qc.invalidateQueries({
+                queryKey: ["admin", "placement", "seed-candidates"],
+            });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to update seed"),
+    });
+
+    return (
+        <div className="grid gap-4 lg:grid-cols-2">
+            <div className="rounded-md border border-zinc-200 bg-white p-4">
+                <div className="mb-2 text-[12.5px] font-medium text-zinc-800">
+                    Active seed panel
+                </div>
+                {seeds.isLoading && <Skeleton className="h-24" />}
+                {seeds.error && (
+                    <ErrorState
+                        error={seeds.error}
+                        title="Failed to load seeds"
+                        onRetry={() => seeds.refetch()}
+                    />
+                )}
+                {seeds.data && seeds.data.data.length === 0 && (
+                    <p className="text-[12.5px] text-zinc-500">
+                        No seed mailboxes yet. Search on the right to flag one.
+                    </p>
+                )}
+                <div className="space-y-1.5">
+                    {seeds.data?.data.map((s) => (
+                        <SeedRow
+                            key={s.id}
+                            seed={s}
+                            disabled={toggle.isPending}
+                            onToggle={(isSeed) => toggle.mutate({ id: s.id, isSeed })}
+                        />
+                    ))}
+                </div>
+            </div>
+
+            <div className="rounded-md border border-zinc-200 bg-white p-4">
+                <div className="mb-2 text-[12.5px] font-medium text-zinc-800">
+                    Add a seed
+                </div>
+                <Input
+                    placeholder="Search connected mailboxes by email…"
+                    value={search}
+                    onChange={(e) => setSearch(e.target.value)}
+                />
+                <p className="mt-1 mb-2 text-[11px] text-muted-foreground">
+                    Type at least 2 characters. Flagging a mailbox as a seed makes it a
+                    placement recipient — it should be a mailbox Warmbly owns and syncs.
+                </p>
+                {candidates.isLoading && search.trim().length >= 2 && (
+                    <Skeleton className="h-20" />
+                )}
+                <div className="space-y-1.5">
+                    {candidates.data?.data.map((s) => (
+                        <SeedRow
+                            key={s.id}
+                            seed={s}
+                            disabled={toggle.isPending}
+                            onToggle={(isSeed) => toggle.mutate({ id: s.id, isSeed })}
+                        />
+                    ))}
+                </div>
+            </div>
+        </div>
+    );
+}
+
+function SeedRow({
+    seed,
+    disabled,
+    onToggle,
+}: {
+    seed: SeedAccount;
+    disabled: boolean;
+    onToggle: (isSeed: boolean) => void;
+}) {
+    return (
+        <div className="flex items-center justify-between gap-2 rounded-md border border-zinc-100 px-2.5 py-1.5">
+            <div className="min-w-0">
+                <div className="truncate text-[12.5px] text-zinc-800">{seed.email}</div>
+                <div className="flex items-center gap-1.5 text-[11px] text-zinc-500">
+                    <span>{providerLabel(seed.provider)}</span>
+                    <span>·</span>
+                    <span>{seed.status}</span>
+                </div>
+            </div>
+            <Switch
+                checked={seed.is_seed}
+                disabled={disabled}
+                onCheckedChange={(v) => onToggle(v)}
+            />
+        </div>
+    );
+}
diff --git a/admin/src/app/dashboard/WarmupAppealsPage.tsx b/admin/src/app/dashboard/WarmupAppealsPage.tsx
new file mode 100644
index 00000000..d3489f92
--- /dev/null
+++ b/admin/src/app/dashboard/WarmupAppealsPage.tsx
@@ -0,0 +1,581 @@
+// Warmup appeals review surface. Where the Warmup page is the at-a-glance
+// pool monitor, this page is the focused enforcement queue: admins triage
+// warmup-ban appeals (approve = unblock the mailbox, reject = stays blocked)
+// and can unblock blocked mailboxes directly.
+//
+//   - Appeals tab: filterable by status (pending/approved/rejected), with
+//     approve/reject actions on pending rows that capture optional review
+//     notes. The pending view polls so the queue stays current.
+//   - Blocked mailboxes tab: every mailbox currently blocked from the pool,
+//     with whether it has an open appeal and a direct (confirmed) unblock.
+//
+// Mirrors LimitRequestsPage's review pattern so the two enforcement queues
+// read the same way.
+
+import { useEffect, useState } from "react";
+import {
+    keepPreviousData,
+    useMutation,
+    useQuery,
+    useQueryClient,
+} from "@tanstack/react-query";
+import { toast } from "sonner";
+import { CheckCircle2, ShieldCheck, XCircle } from "lucide-react";
+import { PageHeader } from "@/components/layout/PageHeader";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { Textarea } from "@/components/ui/textarea";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import {
+    Explorer,
+    FilterGroup,
+    SelectFilter,
+} from "@/components/data/Explorer";
+import { DataTable, type Column } from "@/components/data/DataTable";
+import { useCursorPager } from "@/lib/useCursorPager";
+import {
+    approveAppeal,
+    listBlockedWarmupAccounts,
+    listWarmupAppeals,
+    rejectAppeal,
+    unblockWarmupAccount,
+} from "@/lib/api/client/admin/warmup";
+import type {
+    AdminBlockedAccount,
+    WarmupAppeal,
+    WarmupAppealStatus,
+} from "@/lib/api/models/admin";
+
+const STATUS_TONE: Record<WarmupAppealStatus, string> = {
+    pending: "border-amber-300 text-amber-700 bg-amber-50",
+    approved: "border-emerald-300 text-emerald-700 bg-emerald-50",
+    rejected: "border-red-300 text-red-700 bg-red-50",
+};
+
+type AppealStatusFilter = WarmupAppealStatus | "all";
+
+const STATUS_OPTIONS: { value: AppealStatusFilter; label: string }[] = [
+    { value: "pending", label: "Pending" },
+    { value: "approved", label: "Approved" },
+    { value: "rejected", label: "Rejected" },
+    { value: "all", label: "All statuses" },
+];
+
+export default function WarmupAppealsPage() {
+    const [tab, setTab] = useState("appeals");
+
+    return (
+        <div>
+            <PageHeader
+                title="Warmup appeals"
+                description="Review warmup-ban appeals and unblock mailboxes. Approving an appeal unblocks the mailbox and re-admits it to the pool; rejecting keeps it blocked. Shared paid-pool reputation matters more than any single mailbox."
+            />
+
+            <Tabs value={tab} onValueChange={setTab}>
+                <TabsList variant="line">
+                    <TabsTrigger value="appeals">Appeals</TabsTrigger>
+                    <TabsTrigger value="blocked">Blocked mailboxes</TabsTrigger>
+                </TabsList>
+
+                <TabsContent value="appeals" className="mt-5">
+                    <AppealsTab />
+                </TabsContent>
+                <TabsContent value="blocked" className="mt-5">
+                    <BlockedTab />
+                </TabsContent>
+            </Tabs>
+        </div>
+    );
+}
+
+function AppealsTab() {
+    const [status, setStatus] = useState<AppealStatusFilter>("pending");
+    const pager = useCursorPager();
+    const { reset } = pager;
+
+    const [reviewing, setReviewing] = useState<{
+        appeal: WarmupAppeal;
+        mode: "approve" | "reject";
+    } | null>(null);
+
+    useEffect(() => {
+        reset();
+    }, [status, reset]);
+
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup", "appeals", status, pager.cursor],
+        queryFn: () => listWarmupAppeals(status, pager.cursor),
+        // Keep the pending queue current without a manual refresh.
+        refetchInterval: status === "pending" ? 15_000 : false,
+        placeholderData: keepPreviousData,
+        staleTime: 10_000,
+    });
+
+    const rows = data?.data ?? [];
+    const activeCount = status !== "pending" ? 1 : 0;
+
+    const columns: Column<WarmupAppeal>[] = [
+        {
+            id: "mailbox",
+            header: "Mailbox",
+            cell: (a) => (
+                <span className="font-mono text-xs">
+                    {a.email_account?.email ?? a.email_account_id}
+                </span>
+            ),
+            csv: (a) => a.email_account?.email ?? a.email_account_id,
+        },
+        {
+            id: "user",
+            header: "User",
+            cell: (a) => (
+                <span className="text-xs">{a.user?.email ?? a.user_id}</span>
+            ),
+            csv: (a) => a.user?.email ?? a.user_id,
+        },
+        {
+            id: "reason",
+            header: "Reason",
+            cell: (a) => (
+                <span className="block max-w-md truncate text-xs" title={a.reason}>
+                    {a.reason}
+                </span>
+            ),
+            csv: (a) => a.reason,
+        },
+        {
+            id: "status",
+            header: "Status",
+            cell: (a) => (
+                <div>
+                    <Badge
+                        variant="outline"
+                        className={`text-[10px] ${STATUS_TONE[a.status]}`}
+                    >
+                        {a.status}
+                    </Badge>
+                    {a.review_notes && a.status !== "pending" && (
+                        <div
+                            className="mt-1 max-w-xs truncate text-[10px] text-muted-foreground"
+                            title={a.review_notes}
+                        >
+                            "{a.review_notes}"
+                        </div>
+                    )}
+                </div>
+            ),
+            csv: (a) => a.status,
+        },
+        {
+            id: "created",
+            header: "Submitted",
+            cell: (a) => (
+                <span className="text-xs text-muted-foreground">
+                    {new Date(a.created_at).toLocaleDateString()}
+                </span>
+            ),
+            csv: (a) => a.created_at,
+        },
+        {
+            id: "reviewed",
+            header: "Reviewed",
+            defaultHidden: true,
+            cell: (a) => (
+                <span className="text-xs text-muted-foreground">
+                    {a.reviewed_at
+                        ? new Date(a.reviewed_at).toLocaleDateString()
+                        : "—"}
+                </span>
+            ),
+            csv: (a) => a.reviewed_at ?? "",
+        },
+        {
+            id: "actions",
+            header: "",
+            align: "right",
+            cell: (a) => {
+                const canReview = a.status === "pending";
+                return (
+                    <div className="space-x-1.5 whitespace-nowrap">
+                        <Button
+                            size="sm"
+                            disabled={!canReview}
+                            onClick={() => setReviewing({ appeal: a, mode: "approve" })}
+                            className="bg-emerald-600 hover:bg-emerald-700 text-white text-xs disabled:bg-zinc-200"
+                        >
+                            <CheckCircle2 className="size-3" /> Approve
+                        </Button>
+                        <Button
+                            size="sm"
+                            disabled={!canReview}
+                            onClick={() => setReviewing({ appeal: a, mode: "reject" })}
+                            className="bg-red-600 hover:bg-red-700 text-white text-xs disabled:bg-zinc-200"
+                        >
+                            <XCircle className="size-3" /> Reject
+                        </Button>
+                    </div>
+                );
+            },
+        },
+    ];
+
+    return (
+        <>
+            <Explorer
+                activeCount={activeCount}
+                onReset={() => setStatus("pending")}
+                filters={
+                    <FilterGroup label="Status">
+                        <SelectFilter
+                            value={status}
+                            onChange={(v) => setStatus(v as AppealStatusFilter)}
+                            options={STATUS_OPTIONS}
+                            placeholder="Pending"
+                        />
+                    </FilterGroup>
+                }
+            >
+                <DataTable
+                    columns={columns}
+                    rows={rows}
+                    getRowId={(a) => a.id}
+                    loading={isLoading}
+                    error={error}
+                    onRetry={() => refetch()}
+                    errorTitle="Failed to load appeals"
+                    storageKey="admin.warmup-appeals"
+                    csvName="warmbly-warmup-appeals"
+                    noun="appeals"
+                    emptyTitle="No appeals"
+                    emptyHint={
+                        status === "pending"
+                            ? "No pending appeals to review."
+                            : "No appeals match this status."
+                    }
+                    pager={{
+                        canPrev: pager.canPrev,
+                        canNext: !!data?.pagination?.has_more,
+                        onPrev: pager.prev,
+                        onNext: () => pager.next(data?.pagination?.next_cursor),
+                        page: pager.page,
+                        shown: rows.length,
+                        total: data?.pagination?.total ?? null,
+                    }}
+                />
+            </Explorer>
+
+            {reviewing && (
+                <ReviewAppealDialog
+                    appeal={reviewing.appeal}
+                    mode={reviewing.mode}
+                    open
+                    onOpenChange={(v) => !v && setReviewing(null)}
+                    onDone={() => setReviewing(null)}
+                />
+            )}
+        </>
+    );
+}
+
+function ReviewAppealDialog({
+    appeal,
+    mode,
+    open,
+    onOpenChange,
+    onDone,
+}: {
+    appeal: WarmupAppeal;
+    mode: "approve" | "reject";
+    open: boolean;
+    onOpenChange: (v: boolean) => void;
+    onDone: () => void;
+}) {
+    const qc = useQueryClient();
+    const [notes, setNotes] = useState("");
+    const mailbox = appeal.email_account?.email ?? appeal.email_account_id;
+
+    const mutation = useMutation({
+        mutationFn: () =>
+            mode === "approve"
+                ? approveAppeal(appeal.id, { approved: true, notes })
+                : rejectAppeal(appeal.id, { approved: false, notes }),
+        onSuccess: () => {
+            toast.success(
+                `Appeal ${mode === "approve" ? "approved" : "rejected"}`,
+            );
+            // Approving unblocks the mailbox, so refresh both queues.
+            qc.invalidateQueries({ queryKey: ["admin", "warmup"] });
+            onDone();
+        },
+        onError: (err: Error) => toast.error(err.message || "Action failed"),
+    });
+
+    return (
+        <Dialog open={open} onOpenChange={onOpenChange}>
+            <DialogContent>
+                <DialogHeader>
+                    <DialogTitle>
+                        {mode === "approve" ? "Approve appeal" : "Reject appeal"}
+                    </DialogTitle>
+                    <DialogDescription>
+                        {mode === "approve" ? (
+                            <>
+                                Approving unblocks{" "}
+                                <span className="font-mono">{mailbox}</span> and
+                                re-admits it to the warmup pool. Notes are recorded
+                                for audit.
+                            </>
+                        ) : (
+                            <>
+                                Rejecting keeps{" "}
+                                <span className="font-mono">{mailbox}</span>{" "}
+                                blocked. Notes are recorded for audit and may be
+                                shown to the user.
+                            </>
+                        )}
+                    </DialogDescription>
+                </DialogHeader>
+                <div className="rounded-md border border-border bg-muted/40 p-2.5 text-xs text-muted-foreground">
+                    <span className="font-medium text-foreground">
+                        Appeal reason:
+                    </span>{" "}
+                    {appeal.reason}
+                </div>
+                <div>
+                    <Label htmlFor="notes" className="text-xs font-medium">
+                        Review notes (optional)
+                    </Label>
+                    <Textarea
+                        id="notes"
+                        placeholder={
+                            mode === "approve"
+                                ? "Optional: why the mailbox is being re-admitted"
+                                : "Optional: why the appeal is being rejected"
+                        }
+                        value={notes}
+                        onChange={(e) => setNotes(e.target.value)}
+                        className="mt-1"
+                        autoFocus
+                    />
+                </div>
+                <DialogFooter>
+                    <Button variant="outline" onClick={() => onOpenChange(false)}>
+                        Cancel
+                    </Button>
+                    <Button
+                        onClick={() => mutation.mutate()}
+                        disabled={mutation.isPending}
+                        className={
+                            mode === "approve"
+                                ? "bg-emerald-600 hover:bg-emerald-700 text-white"
+                                : "bg-red-600 hover:bg-red-700 text-white"
+                        }
+                    >
+                        {mutation.isPending
+                            ? "Working…"
+                            : mode === "approve"
+                              ? "Approve & unblock"
+                              : "Reject"}
+                    </Button>
+                </DialogFooter>
+            </DialogContent>
+        </Dialog>
+    );
+}
+
+function BlockedTab() {
+    const pager = useCursorPager();
+    const [unblocking, setUnblocking] = useState<AdminBlockedAccount | null>(
+        null,
+    );
+
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup", "blocked", pager.cursor],
+        queryFn: () => listBlockedWarmupAccounts(pager.cursor),
+        refetchInterval: 30_000,
+        placeholderData: keepPreviousData,
+        staleTime: 10_000,
+    });
+
+    const rows = data?.data ?? [];
+
+    const columns: Column<AdminBlockedAccount>[] = [
+        {
+            id: "mailbox",
+            header: "Mailbox",
+            cell: (a) => <span className="font-mono text-xs">{a.email}</span>,
+            csv: (a) => a.email,
+        },
+        {
+            id: "owner",
+            header: "Owner",
+            cell: (a) => (
+                <span className="text-xs">{a.user?.email ?? a.user_id}</span>
+            ),
+            csv: (a) => a.user?.email ?? a.user_id,
+        },
+        {
+            id: "reason",
+            header: "Reason",
+            cell: (a) => (
+                <span
+                    className="block max-w-md truncate text-xs"
+                    title={a.block_reason}
+                >
+                    {a.block_reason}
+                </span>
+            ),
+            csv: (a) => a.block_reason,
+        },
+        {
+            id: "blocked",
+            header: "Blocked",
+            cell: (a) => (
+                <span className="text-xs text-muted-foreground">
+                    {new Date(a.blocked_at).toLocaleDateString()}
+                </span>
+            ),
+            csv: (a) => a.blocked_at,
+        },
+        {
+            id: "appeal",
+            header: "Appeal",
+            cell: (a) =>
+                a.has_appeal ? (
+                    <Badge
+                        variant="outline"
+                        className={`text-[10px] ${
+                            STATUS_TONE[a.appeal_status ?? "pending"]
+                        }`}
+                    >
+                        {a.appeal_status ?? "pending"}
+                    </Badge>
+                ) : (
+                    <span className="text-muted-foreground">—</span>
+                ),
+            csv: (a) => (a.has_appeal ? (a.appeal_status ?? "pending") : ""),
+        },
+        {
+            id: "actions",
+            header: "",
+            align: "right",
+            cell: (a) => (
+                <Button
+                    size="sm"
+                    variant="outline"
+                    onClick={() => setUnblocking(a)}
+                    className="text-xs"
+                >
+                    <ShieldCheck className="size-3" /> Unblock
+                </Button>
+            ),
+        },
+    ];
+
+    return (
+        <>
+            <DataTable
+                columns={columns}
+                rows={rows}
+                getRowId={(a) => a.id}
+                loading={isLoading}
+                error={error}
+                onRetry={() => refetch()}
+                errorTitle="Failed to load blocked mailboxes"
+                storageKey="admin.warmup-blocked"
+                csvName="warmbly-warmup-blocked"
+                noun="mailboxes"
+                emptyTitle="No blocked mailboxes"
+                emptyHint="No mailboxes are currently blocked from warmup."
+                pager={{
+                    canPrev: pager.canPrev,
+                    canNext: !!data?.pagination?.has_more,
+                    onPrev: pager.prev,
+                    onNext: () => pager.next(data?.pagination?.next_cursor),
+                    page: pager.page,
+                    shown: rows.length,
+                    total: data?.pagination?.total ?? null,
+                }}
+            />
+
+            {unblocking && (
+                <UnblockDialog
+                    account={unblocking}
+                    open
+                    onOpenChange={(v) => !v && setUnblocking(null)}
+                    onDone={() => setUnblocking(null)}
+                />
+            )}
+        </>
+    );
+}
+
+function UnblockDialog({
+    account,
+    open,
+    onOpenChange,
+    onDone,
+}: {
+    account: AdminBlockedAccount;
+    open: boolean;
+    onOpenChange: (v: boolean) => void;
+    onDone: () => void;
+}) {
+    const qc = useQueryClient();
+    const mutation = useMutation({
+        mutationFn: () => unblockWarmupAccount(account.id),
+        onSuccess: () => {
+            toast.success("Mailbox unblocked");
+            qc.invalidateQueries({ queryKey: ["admin", "warmup"] });
+            onDone();
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to unblock"),
+    });
+
+    return (
+        <Dialog open={open} onOpenChange={onOpenChange}>
+            <DialogContent>
+                <DialogHeader>
+                    <DialogTitle>Unblock mailbox</DialogTitle>
+                    <DialogDescription>
+                        Unblock <span className="font-mono">{account.email}</span>{" "}
+                        and re-admit it to the warmup pool? This bypasses any open
+                        appeal and is recorded for audit.
+                    </DialogDescription>
+                </DialogHeader>
+                {account.has_appeal && (
+                    <div className="rounded-md border border-amber-300 bg-amber-50 p-2.5 text-xs text-amber-800">
+                        This mailbox has an open appeal
+                        {account.appeal_status
+                            ? ` (${account.appeal_status})`
+                            : ""}
+                        . Unblocking here does not record an appeal decision —
+                        prefer approving the appeal if you want it tracked as a
+                        review outcome.
+                    </div>
+                )}
+                <DialogFooter>
+                    <Button variant="outline" onClick={() => onOpenChange(false)}>
+                        Cancel
+                    </Button>
+                    <Button
+                        onClick={() => mutation.mutate()}
+                        disabled={mutation.isPending}
+                        className="bg-emerald-600 hover:bg-emerald-700 text-white"
+                    >
+                        {mutation.isPending ? "Working…" : "Unblock"}
+                    </Button>
+                </DialogFooter>
+            </DialogContent>
+        </Dialog>
+    );
+}
diff --git a/admin/src/app/dashboard/WarmupPage.tsx b/admin/src/app/dashboard/WarmupPage.tsx
index a2891b39..806f779a 100644
--- a/admin/src/app/dashboard/WarmupPage.tsx
+++ b/admin/src/app/dashboard/WarmupPage.tsx
@@ -108,15 +108,26 @@ function HealthSummary() {
 
     // Guard every field: a partial response must degrade gracefully, never
     // throw and blank the whole tab.
+    //
+    // `avg_spam_placement_rate` is ALREADY a percent (the backend computes
+    // placements/sent*100), so we render it directly — no second *100.
     const placement = data.avg_spam_placement_rate ?? 0;
-    const spamPct = (placement * 100).toFixed(1);
+    const spamPct = placement.toFixed(1);
     const placementTone =
-        placement >= 0.2 ? "text-red-700" : placement >= 0.1 ? "text-amber-700" : "text-emerald-600";
+        placement >= 20 ? "text-red-700" : placement >= 10 ? "text-amber-700" : "text-emerald-600";
     const atRisk = data.at_risk_count ?? 0;
     const blocked = data.blocked_count ?? 0;
 
+    // `spam_placement_by_provider` is a Record of RAW COUNTS (backend does
+    // COUNT(*)), not rates. Sort worst-first by count so the riskiest
+    // mailbox-provider surface is the first thing an investigator sees.
+    const byProvider = Object.entries(data.spam_placement_by_provider ?? {}).sort(
+        (a, b) => b[1] - a[1],
+    );
+
     return (
-        <div className="grid gap-3 md:grid-cols-4 mb-6">
+        <div className="mb-6">
+        <div className="grid gap-3 md:grid-cols-4">
             <HealthCard
                 icon={<Activity className="size-4" />}
                 title="Total participants"
@@ -147,6 +158,31 @@ function HealthSummary() {
                 tone={blocked > 0 ? "text-red-700" : undefined}
             />
         </div>
+
+        {byProvider.length > 0 && (
+            <div className="mt-3 border border-border rounded-lg p-3 bg-card">
+                <div className="flex items-center gap-1.5 text-xs text-muted-foreground mb-2">
+                    <Flame className="size-4" />
+                    <span>Spam placements by provider (count)</span>
+                </div>
+                <div className="grid gap-2 sm:grid-cols-2 lg:grid-cols-3">
+                    {byProvider.map(([provider, count]) => (
+                        <div
+                            key={provider}
+                            className="flex items-center justify-between text-xs"
+                        >
+                            <span className="capitalize truncate text-foreground">
+                                {provider}
+                            </span>
+                            <span className="tabular-nums font-medium text-foreground">
+                                {(count ?? 0).toLocaleString()}
+                            </span>
+                        </div>
+                    ))}
+                </div>
+            </div>
+        )}
+        </div>
     );
 }
 
diff --git a/admin/src/app/dashboard/warmup-content/GeneratePage.tsx b/admin/src/app/dashboard/warmup-content/GeneratePage.tsx
new file mode 100644
index 00000000..c19bc179
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/GeneratePage.tsx
@@ -0,0 +1,690 @@
+// /warmup-content/generate — enqueue warmup-content generation. Two modes in
+// one full-width page:
+//
+//   Sync   — the existing immediate-enqueue path (one background job).
+//   Batch  — OpenAI Batch API: cheaper, async, high volume. Exposes every
+//            knob (pool, segment, model, count up to 2000, max messages,
+//            completion window) plus a theme multi-input that fans out one
+//            batch job per theme. Returned job ids are surfaced in a live
+//            "Recent batch jobs" view that polls while anything is in flight,
+//            with an inline Cancel per job.
+//
+// Neither mode runs inline: submitting returns job id(s); progress is watched
+// here and on the Jobs tab.
+
+import { useMemo, useState, type KeyboardEvent } from "react";
+import {
+    keepPreviousData,
+    useMutation,
+    useQuery,
+    useQueryClient,
+} from "@tanstack/react-query";
+import { useNavigate } from "react-router-dom";
+import { toast } from "sonner";
+import { AlertTriangle, Ban, Layers, Sparkles, X, Zap } from "lucide-react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Textarea } from "@/components/ui/textarea";
+import { ErrorState } from "@/components/ErrorState";
+import {
+    Select,
+    SelectContent,
+    SelectItem,
+    SelectTrigger,
+    SelectValue,
+} from "@/components/ui/select";
+import { APIError } from "@/lib/api/client";
+import {
+    cancelWarmupBatch,
+    generateWarmupContent,
+    isJobActive,
+    isJobCancellable,
+    listWarmupGenerationJobs,
+    submitWarmupBatch,
+    type GenerateBatchRequest,
+    type WarmupGenerationJob,
+} from "@/lib/api/client/admin/warmupContent";
+import { cn } from "@/lib/utils";
+import { PoolBadge } from "./components";
+import { batchTone, fmtDate, jobTone } from "./shared";
+
+const COMPLETION_WINDOWS = ["24h"];
+
+// A 400 whose code marks generation as un-runnable. We disable submit and show
+// a clear banner instead of letting the user fire a doomed request.
+const NOT_CONFIGURED_CODES = new Set([
+    "not_configured",
+    "daily_cap_reached",
+]);
+
+function notConfiguredMessage(err: unknown): string | null {
+    if (err instanceof APIError && err.status === 400) {
+        if (!err.code || NOT_CONFIGURED_CODES.has(err.code)) {
+            return err.message || "Generation is not configured right now.";
+        }
+    }
+    return null;
+}
+
+type Mode = "sync" | "batch";
+
+export default function GeneratePage() {
+    const navigate = useNavigate();
+    const [mode, setMode] = useState<Mode>("sync");
+
+    return (
+        <div className="w-full space-y-6">
+            <div className="inline-flex rounded-lg border border-border bg-muted/40 p-1">
+                <button
+                    type="button"
+                    onClick={() => setMode("sync")}
+                    className={cn(
+                        "inline-flex items-center gap-1.5 rounded-md px-3 py-1.5 text-sm font-medium transition-colors",
+                        mode === "sync"
+                            ? "bg-background text-foreground shadow-sm"
+                            : "text-foreground/60 hover:text-foreground",
+                    )}
+                >
+                    <Zap className="size-4" /> Instant
+                </button>
+                <button
+                    type="button"
+                    onClick={() => setMode("batch")}
+                    className={cn(
+                        "inline-flex items-center gap-1.5 rounded-md px-3 py-1.5 text-sm font-medium transition-colors",
+                        mode === "batch"
+                            ? "bg-background text-foreground shadow-sm"
+                            : "text-foreground/60 hover:text-foreground",
+                    )}
+                >
+                    <Layers className="size-4" /> Batch
+                </button>
+            </div>
+            <p className="max-w-3xl text-[12.5px] text-muted-foreground">
+                Same result either way — both produce warmup threads and add the passing ones
+                to the library. They only differ in <em>how</em> the AI runs them:{" "}
+                <strong className="font-medium text-foreground">Instant</strong> generates
+                immediately (best for a handful while you watch).{" "}
+                <strong className="font-medium text-foreground">Batch</strong> hands the work
+                to OpenAI's Batch API — about 50% cheaper and processed in the background (up
+                to ~24h) — best for generating a lot at once.
+            </p>
+
+            {mode === "sync" ? (
+                <SyncGenerate onQueued={() => navigate("/warmup-content/jobs")} />
+            ) : (
+                <BatchGenerate />
+            )}
+        </div>
+    );
+}
+
+// ====================================================================
+// Sync mode — the existing immediate-enqueue path.
+// ====================================================================
+
+function SyncGenerate({ onQueued }: { onQueued: () => void }) {
+    const qc = useQueryClient();
+    const [count, setCount] = useState(10);
+    const [segment, setSegment] = useState("");
+    const [theme, setTheme] = useState("");
+    const [model, setModel] = useState("");
+
+    const generate = useMutation({
+        mutationFn: () =>
+            generateWarmupContent({
+                count,
+                segment: segment.trim() || undefined,
+                theme: theme.trim() || undefined,
+                model: model.trim() || undefined,
+            }),
+        onSuccess: (res) => {
+            toast.success("Generation job queued", {
+                description: `Job ${res.job_id} is running offline. Watch the Jobs tab for progress.`,
+            });
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content", "jobs"] });
+            onQueued();
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to queue job"),
+    });
+
+    const blocked = notConfiguredMessage(generate.error);
+
+    return (
+        <div className="space-y-5">
+            <div className="rounded-lg border border-[var(--admin-accent)]/30 bg-[var(--admin-accent-soft)]/40 p-3 text-[12.5px] text-muted-foreground">
+                <div className="flex items-center gap-2 font-medium text-foreground">
+                    <Sparkles className="size-4 text-[var(--admin-accent-strong)]" />
+                    Runs offline
+                </div>
+                <p className="mt-1">
+                    Generation does not run inline. Submitting enqueues a background job
+                    that produces threads, lint-checks them, and adds the passing ones to
+                    the library. Track progress on the Jobs tab.
+                </p>
+            </div>
+
+            {blocked && <NotConfiguredBanner message={blocked} />}
+
+            <div className="grid gap-4 rounded-lg border border-border bg-card p-4 sm:grid-cols-2 lg:grid-cols-3">
+                <div>
+                    <Label htmlFor="gen-count" className="mb-1 text-xs">
+                        Count
+                    </Label>
+                    <Input
+                        id="gen-count"
+                        type="number"
+                        min={1}
+                        max={500}
+                        value={count}
+                        onChange={(e) =>
+                            setCount(Math.max(1, Math.min(500, Number(e.target.value) || 0)))
+                        }
+                    />
+                    <p className="mt-1 text-[11px] text-muted-foreground">
+                        Number of conversation threads to generate.
+                    </p>
+                </div>
+
+                <div>
+                    <Label htmlFor="gen-segment" className="mb-1 text-xs">
+                        Segment <span className="text-muted-foreground">(optional)</span>
+                    </Label>
+                    <Input
+                        id="gen-segment"
+                        placeholder="e.g. saas, agency, ecommerce"
+                        value={segment}
+                        onChange={(e) => setSegment(e.target.value)}
+                    />
+                </div>
+
+                <div className="sm:col-span-2 lg:col-span-3">
+                    <Label htmlFor="gen-theme" className="mb-1 text-xs">
+                        Theme <span className="text-muted-foreground">(optional)</span>
+                    </Label>
+                    <Textarea
+                        id="gen-theme"
+                        placeholder="Steer the topic, e.g. 'casual product follow-ups between colleagues'"
+                        value={theme}
+                        onChange={(e) => setTheme(e.target.value)}
+                    />
+                </div>
+
+                <div>
+                    <Label htmlFor="gen-model" className="mb-1 text-xs">
+                        Model override{" "}
+                        <span className="text-muted-foreground">(optional)</span>
+                    </Label>
+                    <Input
+                        id="gen-model"
+                        placeholder="Defaults to the configured model"
+                        value={model}
+                        onChange={(e) => setModel(e.target.value)}
+                    />
+                </div>
+
+                <div className="flex justify-end sm:col-span-2 lg:col-span-3">
+                    <Button
+                        onClick={() => generate.mutate()}
+                        disabled={generate.isPending || count < 1 || !!blocked}
+                    >
+                        <Sparkles className="size-4" />
+                        {generate.isPending ? "Queuing…" : "Queue generation job"}
+                    </Button>
+                </div>
+            </div>
+        </div>
+    );
+}
+
+// ====================================================================
+// Batch mode — OpenAI Batch API, every knob exposed + live monitor.
+// ====================================================================
+
+function BatchGenerate() {
+    const qc = useQueryClient();
+
+    const [segment, setSegment] = useState("");
+    const [model, setModel] = useState("");
+    const [count, setCount] = useState(100);
+    const [maxMessages, setMaxMessages] = useState(6);
+    const [completionWindow, setCompletionWindow] = useState("24h");
+    const [themes, setThemes] = useState<string[]>([]);
+    const [themeDraft, setThemeDraft] = useState("");
+    const [lastJobIds, setLastJobIds] = useState<string[]>([]);
+
+    function commitTheme() {
+        const t = themeDraft.trim();
+        if (!t) return;
+        setThemes((prev) => (prev.includes(t) ? prev : [...prev, t]));
+        setThemeDraft("");
+    }
+    function onThemeKeyDown(e: KeyboardEvent<HTMLInputElement>) {
+        if (e.key === "Enter" || e.key === ",") {
+            e.preventDefault();
+            commitTheme();
+        } else if (e.key === "Backspace" && !themeDraft && themes.length) {
+            setThemes((prev) => prev.slice(0, -1));
+        }
+    }
+    function removeTheme(t: string) {
+        setThemes((prev) => prev.filter((x) => x !== t));
+    }
+
+    const submit = useMutation({
+        mutationFn: () => {
+            const body: GenerateBatchRequest = {
+                segment: segment.trim() || undefined,
+                model: model.trim() || undefined,
+                count,
+                max_messages: maxMessages,
+                completion_window: completionWindow,
+                themes: themes.length ? themes : undefined,
+            };
+            return submitWarmupBatch(body);
+        },
+        onSuccess: (res) => {
+            const ids = res.job_ids ?? [];
+            setLastJobIds(ids);
+            toast.success(
+                ids.length === 1
+                    ? "Batch job submitted"
+                    : `${ids.length} batch jobs submitted`,
+                {
+                    description: "Watch progress below or on the Jobs tab.",
+                },
+            );
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content", "jobs"] });
+        },
+        onError: (err: Error) => {
+            if (!notConfiguredMessage(err)) {
+                toast.error(err.message || "Failed to submit batch");
+            }
+        },
+    });
+
+    const blocked = notConfiguredMessage(submit.error);
+    const jobCount = themes.length ? themes.length : 1;
+
+    return (
+        <div className="grid gap-6 lg:grid-cols-[minmax(0,28rem)_minmax(0,1fr)]">
+            <div className="space-y-5">
+                <div className="rounded-lg border border-sky-300/40 bg-sky-50/50 p-3 text-[12.5px] text-muted-foreground">
+                    <div className="flex items-center gap-2 font-medium text-foreground">
+                        <Layers className="size-4 text-sky-600" />
+                        OpenAI Batch — async &amp; cheaper
+                    </div>
+                    <p className="mt-1">
+                        Batch generation runs through the OpenAI Batch API: lower cost, much
+                        higher volume, and completion within the chosen window (typically up
+                        to {completionWindow}). Add multiple themes to fan out one batch job
+                        per theme; leave themes empty to rotate the configured defaults.
+                    </p>
+                </div>
+
+                {blocked && <NotConfiguredBanner message={blocked} />}
+
+                <div className="space-y-4 rounded-lg border border-border bg-card p-4">
+                    <div className="grid gap-4 sm:grid-cols-2">
+                        <div>
+                            <Label className="mb-1 text-xs">Completion window</Label>
+                            <Select
+                                value={completionWindow}
+                                onValueChange={setCompletionWindow}
+                            >
+                                <SelectTrigger>
+                                    <SelectValue />
+                                </SelectTrigger>
+                                <SelectContent>
+                                    {COMPLETION_WINDOWS.map((w) => (
+                                        <SelectItem key={w} value={w}>
+                                            {w}
+                                        </SelectItem>
+                                    ))}
+                                </SelectContent>
+                            </Select>
+                        </div>
+
+                        <div>
+                            <Label htmlFor="batch-count" className="mb-1 text-xs">
+                                Count{" "}
+                                <span className="text-muted-foreground">
+                                    {themes.length ? "(per theme)" : "(threads)"}
+                                </span>
+                            </Label>
+                            <Input
+                                id="batch-count"
+                                type="number"
+                                min={1}
+                                max={2000}
+                                value={count}
+                                onChange={(e) =>
+                                    setCount(
+                                        Math.max(1, Math.min(2000, Number(e.target.value) || 0)),
+                                    )
+                                }
+                            />
+                            <p className="mt-1 text-[11px] text-muted-foreground">
+                                Up to 2000; the server also clamps to the daily cap.
+                            </p>
+                        </div>
+                        <div>
+                            <Label htmlFor="batch-max-msgs" className="mb-1 text-xs">
+                                Max messages / thread
+                            </Label>
+                            <Input
+                                id="batch-max-msgs"
+                                type="number"
+                                min={1}
+                                max={50}
+                                value={maxMessages}
+                                onChange={(e) =>
+                                    setMaxMessages(
+                                        Math.max(1, Math.min(50, Number(e.target.value) || 0)),
+                                    )
+                                }
+                            />
+                        </div>
+                    </div>
+
+                    <div>
+                        <Label htmlFor="batch-segment" className="mb-1 text-xs">
+                            Segment <span className="text-muted-foreground">(optional)</span>
+                        </Label>
+                        <Input
+                            id="batch-segment"
+                            placeholder="e.g. saas, agency, ecommerce"
+                            value={segment}
+                            onChange={(e) => setSegment(e.target.value)}
+                        />
+                    </div>
+
+                    <div>
+                        <Label htmlFor="batch-model" className="mb-1 text-xs">
+                            Model override{" "}
+                            <span className="text-muted-foreground">(optional)</span>
+                        </Label>
+                        <Input
+                            id="batch-model"
+                            placeholder="Defaults to the configured model"
+                            value={model}
+                            onChange={(e) => setModel(e.target.value)}
+                        />
+                    </div>
+
+                    <div>
+                        <Label htmlFor="batch-theme" className="mb-1 text-xs">
+                            Themes{" "}
+                            <span className="text-muted-foreground">
+                                (optional — one job per theme)
+                            </span>
+                        </Label>
+                        <div className="flex flex-wrap items-center gap-1.5 rounded-md border border-input bg-transparent p-1.5 focus-within:border-ring focus-within:ring-[3px] focus-within:ring-ring/30">
+                            {themes.map((t) => (
+                                <span
+                                    key={t}
+                                    className="inline-flex items-center gap-1 rounded bg-sky-50 px-2 py-0.5 text-xs text-sky-700 ring-1 ring-inset ring-sky-200"
+                                >
+                                    {t}
+                                    <button
+                                        type="button"
+                                        className="rounded-full p-0.5 hover:bg-sky-100"
+                                        onClick={() => removeTheme(t)}
+                                        aria-label={`Remove ${t}`}
+                                    >
+                                        <X className="size-3" />
+                                    </button>
+                                </span>
+                            ))}
+                            <input
+                                id="batch-theme"
+                                value={themeDraft}
+                                onChange={(e) => setThemeDraft(e.target.value)}
+                                onKeyDown={onThemeKeyDown}
+                                onBlur={commitTheme}
+                                placeholder={
+                                    themes.length
+                                        ? "Add another…"
+                                        : "Type a theme and press Enter"
+                                }
+                                className="min-w-[8rem] flex-1 bg-transparent px-1 py-0.5 text-sm outline-none placeholder:text-muted-foreground"
+                            />
+                        </div>
+                        <p className="mt-1 text-[11px] text-muted-foreground">
+                            Press Enter or comma to add. With themes set, the count above is
+                            per theme.
+                        </p>
+                    </div>
+
+                    <div className="flex items-center justify-between gap-3 border-t border-border pt-3">
+                        <p className="text-[11px] text-muted-foreground">
+                            Will submit{" "}
+                            <span className="font-medium text-foreground">{jobCount}</span>{" "}
+                            batch job{jobCount === 1 ? "" : "s"} ·{" "}
+                            <span className="font-medium text-foreground">{count}</span>{" "}
+                            thread{count === 1 ? "" : "s"} each
+                        </p>
+                        <Button
+                            onClick={() => submit.mutate()}
+                            disabled={submit.isPending || count < 1 || !!blocked}
+                        >
+                            <Layers className="size-4" />
+                            {submit.isPending ? "Submitting…" : "Submit batch"}
+                        </Button>
+                    </div>
+                </div>
+
+                {lastJobIds.length > 0 && (
+                    <div className="rounded-lg border border-emerald-300/50 bg-emerald-50/50 p-3 text-[12.5px]">
+                        <div className="font-medium text-emerald-800">
+                            Submitted {lastJobIds.length} job
+                            {lastJobIds.length === 1 ? "" : "s"}
+                        </div>
+                        <div className="mt-1 flex flex-wrap gap-1.5">
+                            {lastJobIds.map((id) => (
+                                <Badge
+                                    key={id}
+                                    variant="outline"
+                                    className="font-mono text-[10px]"
+                                >
+                                    {id}
+                                </Badge>
+                            ))}
+                        </div>
+                    </div>
+                )}
+            </div>
+
+            <BatchMonitor highlightIds={lastJobIds} />
+        </div>
+    );
+}
+
+// ====================================================================
+// Live batch monitor — polls jobs while any is in flight, cancel inline.
+// ====================================================================
+
+function BatchMonitor({ highlightIds }: { highlightIds: string[] }) {
+    const qc = useQueryClient();
+    const highlight = useMemo(() => new Set(highlightIds), [highlightIds]);
+
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup-content", "jobs", "batch-monitor"],
+        queryFn: () => listWarmupGenerationJobs({ limit: 25 }),
+        placeholderData: keepPreviousData,
+        refetchInterval: (query) => {
+            const rows = query.state.data?.data ?? [];
+            return rows.some(isJobActive) ? 10_000 : false;
+        },
+    });
+
+    const cancel = useMutation({
+        mutationFn: (id: string) => cancelWarmupBatch(id),
+        onSuccess: () => {
+            toast.success("Batch cancellation requested");
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content", "jobs"] });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to cancel job"),
+    });
+
+    const batchJobs = (data?.data ?? []).filter((j) => j.mode === "batch");
+
+    return (
+        <div className="space-y-3">
+            <div className="flex items-center justify-between">
+                <h2 className="text-sm font-semibold">Recent batch jobs</h2>
+                <span className="text-[11px] text-muted-foreground">
+                    auto-refreshes while running
+                </span>
+            </div>
+
+            {error ? (
+                <ErrorState
+                    error={error}
+                    title="Failed to load batch jobs"
+                    onRetry={() => refetch()}
+                />
+            ) : isLoading ? (
+                <div className="space-y-2">
+                    <Skeleton className="h-20" />
+                    <Skeleton className="h-20" />
+                </div>
+            ) : batchJobs.length === 0 ? (
+                <div className="rounded-lg border border-dashed border-border p-8 text-center text-sm text-muted-foreground">
+                    No batch jobs yet. Submit one to watch it here.
+                </div>
+            ) : (
+                <div className="space-y-2">
+                    {batchJobs.map((j) => (
+                        <BatchJobCard
+                            key={j.id}
+                            job={j}
+                            highlighted={highlight.has(j.id)}
+                            onCancel={() => cancel.mutate(j.id)}
+                            cancelling={cancel.isPending}
+                        />
+                    ))}
+                </div>
+            )}
+        </div>
+    );
+}
+
+function BatchJobCard({
+    job,
+    highlighted,
+    onCancel,
+    cancelling,
+}: {
+    job: WarmupGenerationJob;
+    highlighted: boolean;
+    onCancel: () => void;
+    cancelling: boolean;
+}) {
+    const requested = job.requested_count || 0;
+    const generated = job.generated_count || 0;
+    const pct =
+        requested > 0 ? Math.min(100, Math.round((generated / requested) * 100)) : 0;
+
+    return (
+        <div
+            className={cn(
+                "rounded-lg border bg-card p-3",
+                highlighted ? "border-sky-400 ring-1 ring-sky-200" : "border-border",
+            )}
+        >
+            <div className="flex items-start justify-between gap-3">
+                <div className="min-w-0 space-y-1">
+                    <div className="flex flex-wrap items-center gap-1.5">
+                        <PoolBadge pool={job.pool_type} />
+                        <Badge
+                            variant="outline"
+                            className={`text-[10px] ${jobTone(job.status)}`}
+                        >
+                            {job.status}
+                        </Badge>
+                        {job.batch_status && (
+                            <Badge
+                                variant="outline"
+                                className={`text-[10px] ${batchTone(job.batch_status)}`}
+                            >
+                                {job.batch_status}
+                            </Badge>
+                        )}
+                        {job.completion_window && (
+                            <span className="text-[10px] text-muted-foreground">
+                                {job.completion_window}
+                            </span>
+                        )}
+                    </div>
+                    <div className="truncate font-mono text-[11px] text-muted-foreground">
+                        {job.id}
+                    </div>
+                    {job.theme && (
+                        <div className="truncate text-[11px] text-muted-foreground">
+                            theme: {job.theme}
+                        </div>
+                    )}
+                </div>
+                {isJobCancellable(job) && (
+                    <Button
+                        size="xs"
+                        variant="outline"
+                        className="shrink-0 text-red-700 hover:bg-red-50"
+                        onClick={onCancel}
+                        disabled={cancelling}
+                    >
+                        <Ban className="size-3" /> Cancel
+                    </Button>
+                )}
+            </div>
+
+            <div className="mt-2.5">
+                <div className="mb-1 flex items-center justify-between text-[11px] text-muted-foreground">
+                    <span>
+                        {generated.toLocaleString()} / {requested.toLocaleString()} generated
+                    </span>
+                    <span className="tabular-nums">{pct}%</span>
+                </div>
+                <div className="h-1.5 w-full overflow-hidden rounded-full bg-muted">
+                    <div
+                        className="h-full rounded-full bg-sky-500 transition-all"
+                        style={{ width: `${pct}%` }}
+                    />
+                </div>
+            </div>
+
+            <div className="mt-2 grid grid-cols-2 gap-x-4 gap-y-0.5 text-[11px] text-muted-foreground">
+                <span>Lint rejected: {job.lint_rejected_count}</span>
+                <span>Failed: {job.failed_count}</span>
+                <span>Started: {fmtDate(job.started_at)}</span>
+                <span>Finished: {fmtDate(job.finished_at)}</span>
+            </div>
+
+            {job.error && (
+                <div className="mt-2 rounded border border-red-200 bg-red-50 px-2 py-1 text-[11px] text-red-700">
+                    {job.error}
+                </div>
+            )}
+        </div>
+    );
+}
+
+// ====================================================================
+// Shared "not configured" banner.
+// ====================================================================
+
+function NotConfiguredBanner({ message }: { message: string }) {
+    return (
+        <div className="flex items-start gap-2 rounded-lg border border-amber-300 bg-amber-50 p-3 text-[12.5px] text-amber-800">
+            <AlertTriangle className="mt-0.5 size-4 shrink-0" />
+            <div>
+                <div className="font-medium">Generation unavailable</div>
+                <p className="mt-0.5">{message}</p>
+            </div>
+        </div>
+    );
+}
diff --git a/admin/src/app/dashboard/warmup-content/JobsPage.tsx b/admin/src/app/dashboard/warmup-content/JobsPage.tsx
new file mode 100644
index 00000000..7ee8e363
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/JobsPage.tsx
@@ -0,0 +1,494 @@
+// /warmup-content/jobs — paged table of generation jobs (sync + batch),
+// polled live so running jobs update without a manual refresh. Batch jobs
+// surface their OpenAI batch status and an inline Cancel action.
+
+import { useMemo, useState } from "react";
+import {
+    keepPreviousData,
+    useMutation,
+    useQuery,
+    useQueryClient,
+} from "@tanstack/react-query";
+import { toast } from "sonner";
+import { Ban } from "lucide-react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Skeleton } from "@/components/ui/skeleton";
+import { ErrorState } from "@/components/ErrorState";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import { DataTable, type Column } from "@/components/data/DataTable";
+import { useCursorPager } from "@/lib/useCursorPager";
+import {
+    cancelWarmupBatch,
+    getWarmupGenerationJob,
+    isJobActive,
+    isJobCancellable,
+    listWarmupGenerationJobs,
+    type WarmupGenerationJob,
+} from "@/lib/api/client/admin/warmupContent";
+import { PoolBadge } from "./components";
+import { batchTone, fmtDate, jobTone } from "./shared";
+
+export default function JobsPage() {
+    const qc = useQueryClient();
+    const pager = useCursorPager();
+    const [openId, setOpenId] = useState<string | null>(null);
+
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup-content", "jobs", pager.cursor],
+        queryFn: () => listWarmupGenerationJobs({ cursor: pager.cursor, limit: 50 }),
+        placeholderData: keepPreviousData,
+        // Poll only while at least one job is still in flight; idle pages stop
+        // hammering the endpoint.
+        refetchInterval: (query) => {
+            const rows = query.state.data?.data ?? [];
+            return rows.some(isJobActive) ? 10_000 : false;
+        },
+    });
+
+    const cancel = useMutation({
+        mutationFn: (id: string) => cancelWarmupBatch(id),
+        onSuccess: () => {
+            toast.success("Batch cancellation requested");
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content", "jobs"] });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to cancel job"),
+    });
+
+    const columns: Column<WarmupGenerationJob>[] = useMemo(
+        () => [
+            {
+                id: "status",
+                header: "Status",
+                cell: (j) => (
+                    <Badge variant="outline" className={`text-[10px] ${jobTone(j.status)}`}>
+                        {j.status}
+                    </Badge>
+                ),
+                csv: (j) => j.status,
+            },
+            {
+                id: "mode",
+                header: "Mode",
+                cell: (j) => (
+                    <Badge
+                        variant="outline"
+                        className={`text-[10px] ${
+                            j.mode === "batch"
+                                ? "border-sky-300 bg-sky-50 text-sky-700"
+                                : "border-zinc-300 text-zinc-600"
+                        }`}
+                    >
+                        {j.mode ?? "sync"}
+                    </Badge>
+                ),
+                csv: (j) => j.mode ?? "sync",
+            },
+            {
+                id: "batch_status",
+                header: "Batch",
+                cell: (j) =>
+                    j.mode === "batch" && j.batch_status ? (
+                        <Badge
+                            variant="outline"
+                            className={`text-[10px] ${batchTone(j.batch_status)}`}
+                        >
+                            {j.batch_status}
+                        </Badge>
+                    ) : (
+                        <span className="text-xs text-muted-foreground">—</span>
+                    ),
+                csv: (j) => j.batch_status ?? "",
+            },
+            {
+                id: "pool",
+                header: "Pool",
+                cell: (j) => <PoolBadge pool={j.pool_type} />,
+                csv: (j) => j.pool_type,
+            },
+            {
+                id: "segment",
+                header: "Segment",
+                cell: (j) => <span className="text-xs">{j.segment || "—"}</span>,
+                csv: (j) => j.segment,
+            },
+            {
+                id: "trigger",
+                header: "Trigger",
+                cell: (j) => (
+                    <span className="text-xs text-muted-foreground">
+                        {j.trigger || "—"}
+                    </span>
+                ),
+                csv: (j) => j.trigger,
+            },
+            {
+                id: "model",
+                header: "Model",
+                cell: (j) => <span className="text-xs">{j.model || "—"}</span>,
+                csv: (j) => j.model,
+            },
+            {
+                id: "counts",
+                header: "Generated / Requested",
+                align: "right",
+                cell: (j) => (
+                    <span className="tabular-nums">
+                        {j.generated_count} / {j.requested_count}
+                    </span>
+                ),
+                csv: (j) => `${j.generated_count}/${j.requested_count}`,
+            },
+            {
+                id: "rejected",
+                header: "Lint rej.",
+                align: "right",
+                cell: (j) => (
+                    <span
+                        className={`tabular-nums ${
+                            j.lint_rejected_count > 0
+                                ? "text-amber-700"
+                                : "text-muted-foreground"
+                        }`}
+                    >
+                        {j.lint_rejected_count}
+                    </span>
+                ),
+                csv: (j) => j.lint_rejected_count,
+            },
+            {
+                id: "failed",
+                header: "Failed",
+                align: "right",
+                cell: (j) => (
+                    <span
+                        className={`tabular-nums ${
+                            j.failed_count > 0 ? "text-red-700" : "text-muted-foreground"
+                        }`}
+                    >
+                        {j.failed_count}
+                    </span>
+                ),
+                csv: (j) => j.failed_count,
+            },
+            {
+                id: "window",
+                header: "Window",
+                cell: (j) => (
+                    <span className="text-xs text-muted-foreground">
+                        {j.completion_window || "—"}
+                    </span>
+                ),
+                csv: (j) => j.completion_window ?? "",
+                defaultHidden: true,
+            },
+            {
+                id: "batch_id",
+                header: "Batch ID",
+                cell: (j) => (
+                    <span className="font-mono text-[11px] text-muted-foreground">
+                        {j.batch_id || "—"}
+                    </span>
+                ),
+                csv: (j) => j.batch_id ?? "",
+                defaultHidden: true,
+            },
+            {
+                id: "started",
+                header: "Started",
+                cell: (j) => (
+                    <span className="text-xs text-muted-foreground">
+                        {fmtDate(j.started_at)}
+                    </span>
+                ),
+                csv: (j) => j.started_at ?? "",
+            },
+            {
+                id: "finished",
+                header: "Finished",
+                cell: (j) => (
+                    <span className="text-xs text-muted-foreground">
+                        {fmtDate(j.finished_at)}
+                    </span>
+                ),
+                csv: (j) => j.finished_at ?? "",
+            },
+            {
+                id: "error",
+                header: "Error",
+                cell: (j) =>
+                    j.error ? (
+                        <span className="text-xs text-red-700" title={j.error}>
+                            {j.error.length > 60 ? `${j.error.slice(0, 60)}…` : j.error}
+                        </span>
+                    ) : (
+                        <span className="text-xs text-muted-foreground">—</span>
+                    ),
+                csv: (j) => j.error,
+                defaultHidden: true,
+            },
+            {
+                id: "created",
+                header: "Created",
+                cell: (j) => (
+                    <span className="text-xs text-muted-foreground">
+                        {new Date(j.created_at).toLocaleString()}
+                    </span>
+                ),
+                csv: (j) => j.created_at,
+                defaultHidden: true,
+            },
+            {
+                id: "actions",
+                header: "Actions",
+                align: "right",
+                cell: (j) =>
+                    isJobCancellable(j) ? (
+                        <div
+                            className="flex justify-end"
+                            onClick={(e) => e.stopPropagation()}
+                        >
+                            <Button
+                                size="xs"
+                                variant="outline"
+                                className="text-red-700 hover:bg-red-50"
+                                onClick={() => cancel.mutate(j.id)}
+                                disabled={cancel.isPending}
+                            >
+                                <Ban className="size-3" /> Cancel
+                            </Button>
+                        </div>
+                    ) : (
+                        <span className="block text-right text-xs text-muted-foreground">
+                            —
+                        </span>
+                    ),
+            },
+        ],
+        [cancel],
+    );
+
+    const rows = data?.data ?? [];
+
+    return (
+        <>
+            <DataTable
+                columns={columns}
+                rows={rows}
+                getRowId={(j) => j.id}
+                loading={isLoading}
+                error={error}
+                onRetry={() => refetch()}
+                onRowClick={(j) => setOpenId(j.id)}
+                errorTitle="Failed to load jobs"
+                storageKey="admin.warmup-content.jobs"
+                csvName="warmbly-warmup-content-jobs"
+                noun="jobs"
+                emptyTitle="No generation jobs"
+                emptyHint="Queue a job from the Generate tab to see it here."
+                pager={{
+                    canPrev: pager.canPrev,
+                    canNext: !!data?.pagination.has_more,
+                    onPrev: pager.prev,
+                    onNext: () => pager.next(data?.pagination.next_cursor),
+                    page: pager.page,
+                    shown: rows.length,
+                    total: data?.pagination.total ?? null,
+                }}
+            />
+
+            {openId && (
+                <JobDetailDialog
+                    id={openId}
+                    open
+                    onOpenChange={(v) => !v && setOpenId(null)}
+                />
+            )}
+        </>
+    );
+}
+
+function JobDetailField({
+    label,
+    value,
+    mono,
+}: {
+    label: string;
+    value: React.ReactNode;
+    mono?: boolean;
+}) {
+    return (
+        <div>
+            <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">
+                {label}
+            </div>
+            <div className={`text-[13px] text-foreground ${mono ? "font-mono break-all" : ""}`}>
+                {value}
+            </div>
+        </div>
+    );
+}
+
+function JobDetailDialog({
+    id,
+    open,
+    onOpenChange,
+}: {
+    id: string;
+    open: boolean;
+    onOpenChange: (v: boolean) => void;
+}) {
+    // Poll while the job is still running so the drawer mirrors the live table.
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup-content", "job", id],
+        queryFn: () => getWarmupGenerationJob(id),
+        refetchInterval: (query) => {
+            const j = query.state.data?.data;
+            return j && isJobActive(j) ? 10_000 : false;
+        },
+    });
+    const j = data?.data;
+    const isBatch = j?.mode === "batch";
+
+    return (
+        <Dialog open={open} onOpenChange={onOpenChange}>
+            <DialogContent className="sm:max-w-2xl">
+                <DialogHeader>
+                    <DialogTitle className="flex items-center gap-2">
+                        Generation job
+                        {j ? (
+                            <Badge
+                                variant="outline"
+                                className={`text-[10px] ${jobTone(j.status)}`}
+                            >
+                                {j.status}
+                            </Badge>
+                        ) : null}
+                    </DialogTitle>
+                    <DialogDescription>
+                        {j ? (
+                            <span className="font-mono text-[11px]">{j.id}</span>
+                        ) : (
+                            "Full job detail."
+                        )}
+                    </DialogDescription>
+                </DialogHeader>
+
+                {error ? (
+                    <ErrorState
+                        error={error}
+                        title="Failed to load job"
+                        onRetry={() => refetch()}
+                    />
+                ) : isLoading || !j ? (
+                    <div className="space-y-2">
+                        <Skeleton className="h-5 w-1/2" />
+                        <Skeleton className="h-16" />
+                        <Skeleton className="h-16" />
+                    </div>
+                ) : (
+                    <div className="space-y-4">
+                        <div className="grid grid-cols-2 gap-3 sm:grid-cols-3">
+                            <JobDetailField
+                                label="Mode"
+                                value={
+                                    <Badge
+                                        variant="outline"
+                                        className={`text-[10px] ${
+                                            isBatch
+                                                ? "border-sky-300 bg-sky-50 text-sky-700"
+                                                : "border-zinc-300 text-zinc-600"
+                                        }`}
+                                    >
+                                        {j.mode ?? "sync"}
+                                    </Badge>
+                                }
+                            />
+                            <JobDetailField label="Pool" value={<PoolBadge pool={j.pool_type} />} />
+                            <JobDetailField label="Segment" value={j.segment || "—"} />
+                            <JobDetailField label="Trigger" value={j.trigger || "—"} />
+                            <JobDetailField label="Model" value={j.model || "—"} />
+                            <JobDetailField label="Theme" value={j.theme || "—"} />
+                        </div>
+
+                        <div className="grid grid-cols-2 gap-3 sm:grid-cols-4">
+                            <JobDetailField
+                                label="Requested"
+                                value={j.requested_count.toLocaleString()}
+                            />
+                            <JobDetailField
+                                label="Generated"
+                                value={j.generated_count.toLocaleString()}
+                            />
+                            <JobDetailField
+                                label="Lint rejected"
+                                value={j.lint_rejected_count.toLocaleString()}
+                            />
+                            <JobDetailField
+                                label="Failed"
+                                value={j.failed_count.toLocaleString()}
+                            />
+                        </div>
+
+                        {isBatch && (
+                            <div className="grid grid-cols-2 gap-3 rounded-lg border border-border bg-muted/30 p-3 sm:grid-cols-3">
+                                <JobDetailField
+                                    label="Batch status"
+                                    value={
+                                        j.batch_status ? (
+                                            <Badge
+                                                variant="outline"
+                                                className={`text-[10px] ${batchTone(
+                                                    j.batch_status,
+                                                )}`}
+                                            >
+                                                {j.batch_status}
+                                            </Badge>
+                                        ) : (
+                                            "—"
+                                        )
+                                    }
+                                />
+                                <JobDetailField
+                                    label="Completion window"
+                                    value={j.completion_window || "—"}
+                                />
+                                <JobDetailField
+                                    label="Batch ID"
+                                    value={j.batch_id || "—"}
+                                    mono
+                                />
+                            </div>
+                        )}
+
+                        {j.error && (
+                            <div className="rounded-lg border border-red-200 bg-red-50 p-3">
+                                <div className="text-[10px] font-semibold uppercase tracking-wider text-red-700">
+                                    Error
+                                </div>
+                                <div className="mt-1 text-[13px] whitespace-pre-wrap text-red-700">
+                                    {j.error}
+                                </div>
+                            </div>
+                        )}
+
+                        <div className="grid grid-cols-2 gap-3 text-[11px] text-muted-foreground sm:grid-cols-3">
+                            <div>Started: {fmtDate(j.started_at)}</div>
+                            <div>Finished: {fmtDate(j.finished_at)}</div>
+                            <div>Created: {fmtDate(j.created_at)}</div>
+                        </div>
+                    </div>
+                )}
+
+                <DialogFooter showCloseButton />
+            </DialogContent>
+        </Dialog>
+    );
+}
diff --git a/admin/src/app/dashboard/warmup-content/LibraryPage.tsx b/admin/src/app/dashboard/warmup-content/LibraryPage.tsx
new file mode 100644
index 00000000..1c90c470
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/LibraryPage.tsx
@@ -0,0 +1,455 @@
+// /warmup-content/library — filterable, paged table of generated conversation
+// threads, with a detail dialog + archive/unarchive/delete actions.
+
+import { useEffect, useMemo, useState } from "react";
+import {
+    keepPreviousData,
+    useMutation,
+    useQuery,
+    useQueryClient,
+} from "@tanstack/react-query";
+import { toast } from "sonner";
+import { Archive, ArchiveRestore, Trash2 } from "lucide-react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { Skeleton } from "@/components/ui/skeleton";
+import { ErrorState } from "@/components/ErrorState";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import {
+    Select,
+    SelectContent,
+    SelectItem,
+    SelectTrigger,
+    SelectValue,
+} from "@/components/ui/select";
+import { DataTable, type Column } from "@/components/data/DataTable";
+import { useCursorPager } from "@/lib/useCursorPager";
+import {
+    archiveWarmupConversation,
+    deleteWarmupConversation,
+    getWarmupConversation,
+    listWarmupConversations,
+    unarchiveWarmupConversation,
+    type WarmupConversationRow,
+} from "@/lib/api/client/admin/warmupContent";
+import { CONTENT_STATUS_TONE, fmtDate } from "./shared";
+
+export default function LibraryPage() {
+    const qc = useQueryClient();
+    const [source, setSource] = useState("");
+    const [status, setStatus] = useState("");
+    const [openId, setOpenId] = useState<string | null>(null);
+    const [confirmDelete, setConfirmDelete] = useState<WarmupConversationRow | null>(
+        null,
+    );
+    const pager = useCursorPager();
+    const { reset } = pager;
+
+    const filterKey = JSON.stringify({ source, status });
+    useEffect(() => {
+        reset();
+    }, [filterKey, reset]);
+
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup-content", "conversations", filterKey, pager.cursor],
+        queryFn: () =>
+            listWarmupConversations({
+                source: source || undefined,
+                status: status || undefined,
+                cursor: pager.cursor,
+                limit: 50,
+            }),
+        staleTime: 30_000,
+        placeholderData: keepPreviousData,
+    });
+
+    const archive = useMutation({
+        mutationFn: (id: string) => archiveWarmupConversation(id),
+        onSuccess: () => {
+            toast.success("Conversation archived");
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content"] });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to archive"),
+    });
+    const unarchive = useMutation({
+        mutationFn: (id: string) => unarchiveWarmupConversation(id),
+        onSuccess: () => {
+            toast.success("Conversation restored");
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content"] });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to restore"),
+    });
+    const remove = useMutation({
+        mutationFn: (id: string) => deleteWarmupConversation(id),
+        onSuccess: () => {
+            toast.success("Conversation deleted");
+            setConfirmDelete(null);
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content"] });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to delete"),
+    });
+
+    const columns: Column<WarmupConversationRow>[] = useMemo(
+        () => [
+            {
+                id: "subject",
+                header: "Thread",
+                cell: (c) => (
+                    <div className="min-w-0">
+                        <div className="truncate font-medium">
+                            {c.subject || "(no subject)"}
+                        </div>
+                        <div className="truncate text-[11px] text-muted-foreground">
+                            {c.theme || c.description || "—"}
+                        </div>
+                    </div>
+                ),
+                csv: (c) => c.subject,
+            },
+            {
+                id: "segment",
+                header: "Segment",
+                cell: (c) => <span className="text-xs">{c.segment || "—"}</span>,
+                csv: (c) => c.segment,
+            },
+            {
+                id: "source",
+                header: "Source",
+                cell: (c) => (
+                    <span className="text-xs text-muted-foreground">
+                        {c.source || "—"}
+                    </span>
+                ),
+                csv: (c) => c.source,
+            },
+            {
+                id: "messages",
+                header: "Msgs",
+                align: "right",
+                cell: (c) => <span className="tabular-nums">{c.message_count}</span>,
+                csv: (c) => c.message_count,
+            },
+            {
+                id: "usage",
+                header: "Used",
+                align: "right",
+                cell: (c) => <span className="tabular-nums">{c.usage_count}</span>,
+                csv: (c) => c.usage_count,
+            },
+            {
+                id: "lint",
+                header: "Lint",
+                cell: (c) =>
+                    c.lint_passed ? (
+                        <Badge
+                            variant="outline"
+                            className="text-[10px] border-emerald-300 bg-emerald-50 text-emerald-700"
+                        >
+                            pass
+                        </Badge>
+                    ) : (
+                        <Badge
+                            variant="outline"
+                            className="text-[10px] border-red-300 bg-red-50 text-red-700"
+                        >
+                            fail
+                        </Badge>
+                    ),
+                csv: (c) => (c.lint_passed ? "pass" : "fail"),
+            },
+            {
+                id: "status",
+                header: "Status",
+                cell: (c) => (
+                    <Badge
+                        variant="outline"
+                        className={`text-[10px] ${
+                            CONTENT_STATUS_TONE[c.status] ?? "border-zinc-300 text-zinc-600"
+                        }`}
+                    >
+                        {c.status}
+                    </Badge>
+                ),
+                csv: (c) => c.status,
+            },
+            {
+                id: "created",
+                header: "Created",
+                cell: (c) => (
+                    <span className="text-xs text-muted-foreground">
+                        {new Date(c.created_at).toLocaleDateString()}
+                    </span>
+                ),
+                csv: (c) => c.created_at,
+                defaultHidden: true,
+            },
+            {
+                id: "actions",
+                header: "Actions",
+                align: "right",
+                cell: (c) => (
+                    <div
+                        className="flex items-center justify-end gap-1.5"
+                        onClick={(e) => e.stopPropagation()}
+                    >
+                        {c.status === "archived" ? (
+                            <Button
+                                size="xs"
+                                variant="outline"
+                                onClick={() => unarchive.mutate(c.id)}
+                                disabled={unarchive.isPending}
+                            >
+                                <ArchiveRestore className="size-3" /> Restore
+                            </Button>
+                        ) : (
+                            <Button
+                                size="xs"
+                                variant="outline"
+                                onClick={() => archive.mutate(c.id)}
+                                disabled={archive.isPending}
+                            >
+                                <Archive className="size-3" /> Archive
+                            </Button>
+                        )}
+                        <Button
+                            size="xs"
+                            variant="outline"
+                            className="text-red-700 hover:bg-red-50"
+                            onClick={() => setConfirmDelete(c)}
+                        >
+                            <Trash2 className="size-3" /> Delete
+                        </Button>
+                    </div>
+                ),
+            },
+        ],
+        [archive, unarchive],
+    );
+
+    const rows = data?.data ?? [];
+
+    return (
+        <div className="space-y-4">
+            <div className="flex flex-wrap items-end gap-3">
+                <div className="w-44">
+                    <Label className="mb-1 text-xs text-muted-foreground">Source</Label>
+                    <Select
+                        value={source || "any"}
+                        onValueChange={(v) => setSource(v === "any" ? "" : v)}
+                    >
+                        <SelectTrigger size="sm">
+                            <SelectValue placeholder="Any source" />
+                        </SelectTrigger>
+                        <SelectContent>
+                            <SelectItem value="any">Any source</SelectItem>
+                            <SelectItem value="ai">AI generated</SelectItem>
+                            <SelectItem value="curated">Curated</SelectItem>
+                            <SelectItem value="imported">Imported</SelectItem>
+                        </SelectContent>
+                    </Select>
+                </div>
+                <div className="w-40">
+                    <Label className="mb-1 text-xs text-muted-foreground">Status</Label>
+                    <Select
+                        value={status || "any"}
+                        onValueChange={(v) => setStatus(v === "any" ? "" : v)}
+                    >
+                        <SelectTrigger size="sm">
+                            <SelectValue placeholder="Any status" />
+                        </SelectTrigger>
+                        <SelectContent>
+                            <SelectItem value="any">Any status</SelectItem>
+                            <SelectItem value="active">Active</SelectItem>
+                            <SelectItem value="archived">Archived</SelectItem>
+                            <SelectItem value="draft">Draft</SelectItem>
+                        </SelectContent>
+                    </Select>
+                </div>
+            </div>
+
+            <DataTable
+                columns={columns}
+                rows={rows}
+                getRowId={(c) => c.id}
+                loading={isLoading}
+                error={error}
+                onRetry={() => refetch()}
+                onRowClick={(c) => setOpenId(c.id)}
+                errorTitle="Failed to load conversations"
+                storageKey="admin.warmup-content.library"
+                csvName="warmbly-warmup-content"
+                noun="conversations"
+                emptyTitle="No conversations"
+                emptyHint="No warmup content matches these filters."
+                pager={{
+                    canPrev: pager.canPrev,
+                    canNext: !!data?.pagination.has_more,
+                    onPrev: pager.prev,
+                    onNext: () => pager.next(data?.pagination.next_cursor),
+                    page: pager.page,
+                    shown: rows.length,
+                    total: data?.pagination.total ?? null,
+                }}
+            />
+
+            {openId && (
+                <ConversationDialog
+                    id={openId}
+                    open
+                    onOpenChange={(v) => !v && setOpenId(null)}
+                />
+            )}
+
+            <Dialog
+                open={!!confirmDelete}
+                onOpenChange={(v) => !v && setConfirmDelete(null)}
+            >
+                <DialogContent>
+                    <DialogHeader>
+                        <DialogTitle>Delete conversation</DialogTitle>
+                        <DialogDescription>
+                            This permanently removes the thread{" "}
+                            <span className="font-medium">
+                                “{confirmDelete?.subject || "(no subject)"}”
+                            </span>{" "}
+                            from the library. This cannot be undone — archive instead if you
+                            only want it out of rotation.
+                        </DialogDescription>
+                    </DialogHeader>
+                    <DialogFooter>
+                        <Button variant="outline" onClick={() => setConfirmDelete(null)}>
+                            Cancel
+                        </Button>
+                        <Button
+                            variant="destructive"
+                            disabled={remove.isPending}
+                            onClick={() => confirmDelete && remove.mutate(confirmDelete.id)}
+                        >
+                            {remove.isPending ? "Deleting…" : "Delete"}
+                        </Button>
+                    </DialogFooter>
+                </DialogContent>
+            </Dialog>
+        </div>
+    );
+}
+
+function ConversationDialog({
+    id,
+    open,
+    onOpenChange,
+}: {
+    id: string;
+    open: boolean;
+    onOpenChange: (v: boolean) => void;
+}) {
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup-content", "conversation", id],
+        queryFn: () => getWarmupConversation(id),
+    });
+    const c = data?.data;
+
+    return (
+        <Dialog open={open} onOpenChange={onOpenChange}>
+            <DialogContent className="sm:max-w-2xl">
+                <DialogHeader>
+                    <DialogTitle className="truncate pr-6">
+                        {c?.subject || (isLoading ? "Loading…" : "Conversation")}
+                    </DialogTitle>
+                    <DialogDescription>
+                        {c?.description || "Full generated warmup thread."}
+                    </DialogDescription>
+                </DialogHeader>
+
+                {error ? (
+                    <ErrorState
+                        error={error}
+                        title="Failed to load conversation"
+                        onRetry={() => refetch()}
+                    />
+                ) : isLoading || !c ? (
+                    <div className="space-y-2">
+                        <Skeleton className="h-5 w-1/2" />
+                        <Skeleton className="h-16" />
+                        <Skeleton className="h-16" />
+                    </div>
+                ) : (
+                    <div className="space-y-4">
+                        <div className="flex flex-wrap items-center gap-2 text-xs">
+                            {c.segment && (
+                                <Badge variant="outline" className="text-[10px]">
+                                    segment: {c.segment}
+                                </Badge>
+                            )}
+                            <Badge variant="outline" className="text-[10px]">
+                                source: {c.source || "—"}
+                            </Badge>
+                            <Badge
+                                variant="outline"
+                                className={`text-[10px] ${
+                                    CONTENT_STATUS_TONE[c.status] ??
+                                    "border-zinc-300 text-zinc-600"
+                                }`}
+                            >
+                                {c.status}
+                            </Badge>
+                            <Badge
+                                variant="outline"
+                                className={`text-[10px] ${
+                                    c.lint_passed
+                                        ? "border-emerald-300 bg-emerald-50 text-emerald-700"
+                                        : "border-red-300 bg-red-50 text-red-700"
+                                }`}
+                            >
+                                lint {c.lint_passed ? "pass" : "fail"}
+                            </Badge>
+                            <span className="text-muted-foreground">
+                                used {c.usage_count}×
+                            </span>
+                        </div>
+
+                        <div className="max-h-[50vh] space-y-2 overflow-y-auto rounded-lg border border-border bg-muted/30 p-3">
+                            {(c.messages ?? []).map((m, i) => (
+                                <div
+                                    key={i}
+                                    className="rounded-md border border-border bg-card p-2.5 text-[13px] leading-relaxed whitespace-pre-wrap"
+                                >
+                                    <div className="mb-1 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">
+                                        Message {i + 1}
+                                    </div>
+                                    {m}
+                                </div>
+                            ))}
+                            {(c.messages ?? []).length === 0 && (
+                                <div className="py-4 text-center text-sm text-muted-foreground">
+                                    No messages in this thread.
+                                </div>
+                            )}
+                        </div>
+
+                        <div className="grid grid-cols-2 gap-2 text-[11px] text-muted-foreground">
+                            <div>
+                                Generated by job:{" "}
+                                <span className="font-mono">
+                                    {c.generated_by_job_id ?? "—"}
+                                </span>
+                            </div>
+                            <div>Created: {fmtDate(c.created_at)}</div>
+                            <div>Updated: {fmtDate(c.updated_at)}</div>
+                        </div>
+                    </div>
+                )}
+
+                <DialogFooter showCloseButton />
+            </DialogContent>
+        </Dialog>
+    );
+}
diff --git a/admin/src/app/dashboard/warmup-content/OverviewPage.tsx b/admin/src/app/dashboard/warmup-content/OverviewPage.tsx
new file mode 100644
index 00000000..d2dd58c1
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/OverviewPage.tsx
@@ -0,0 +1,250 @@
+// /warmup-content/overview — headline counts, AI/schedule status, per-pool
+// library breakdown, and content-source vs spam-placement A/B comparison.
+
+import { useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { Archive, CalendarClock, Inbox, Play, Sparkles } from "lucide-react";
+import { Skeleton } from "@/components/ui/skeleton";
+import { ErrorState } from "@/components/ErrorState";
+import {
+    getWarmupContentAb,
+    getWarmupContentOverview,
+} from "@/lib/api/client/admin/warmupContent";
+import { StatCard } from "./components";
+import { fmtDate } from "./shared";
+
+export default function OverviewPage() {
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup-content", "overview"],
+        queryFn: getWarmupContentOverview,
+        refetchInterval: 30_000,
+    });
+
+    const ab = useQuery({
+        queryKey: ["admin", "warmup-content", "ab", 14],
+        queryFn: () => getWarmupContentAb(14),
+        staleTime: 60_000,
+    });
+
+    // Content is one shared library now — pools only isolate mailbox
+    // reputation, not content. Aggregate the per-pool breakdown by
+    // segment+source so the table reflects the actual library shape rather
+    // than misleading per-pool rows (e.g. "free has no content").
+    const bySegmentSource = useMemo(() => {
+        const acc = new Map<
+            string,
+            { segment: string; source: string; active: number; archived: number }
+        >();
+        for (const p of data?.by_pool ?? []) {
+            const key = `${p.segment}::${p.source}`;
+            const cur = acc.get(key);
+            if (cur) {
+                cur.active += p.active;
+                cur.archived += p.archived;
+            } else {
+                acc.set(key, {
+                    segment: p.segment,
+                    source: p.source,
+                    active: p.active,
+                    archived: p.archived,
+                });
+            }
+        }
+        return Array.from(acc.values());
+    }, [data?.by_pool]);
+
+    if (isLoading) {
+        return (
+            <div className="grid gap-3 md:grid-cols-5">
+                {Array.from({ length: 5 }).map((_, i) => (
+                    <Skeleton key={i} className="h-24" />
+                ))}
+            </div>
+        );
+    }
+    if (error) {
+        return (
+            <ErrorState
+                error={error}
+                title="Failed to load overview"
+                onRetry={() => refetch()}
+            />
+        );
+    }
+    if (!data) return null;
+
+    return (
+        <div className="space-y-6">
+            <div className="grid gap-3 md:grid-cols-5">
+                <StatCard
+                    icon={<Inbox className="size-4" />}
+                    title="Active threads"
+                    value={(data.total_active ?? 0).toLocaleString()}
+                    hint="available to warmup sends"
+                />
+                <StatCard
+                    icon={<Archive className="size-4" />}
+                    title="Archived"
+                    value={(data.total_archived ?? 0).toLocaleString()}
+                    hint="retired from rotation"
+                />
+                <StatCard
+                    icon={<Sparkles className="size-4" />}
+                    title="AI generation"
+                    value={data.ai_enabled ? "Enabled" : "Disabled"}
+                    tone={data.ai_enabled ? "text-emerald-600" : "text-muted-foreground"}
+                    hint="master generation toggle"
+                />
+                <StatCard
+                    icon={<CalendarClock className="size-4" />}
+                    title="Schedule"
+                    value={data.schedule_enabled ? "On" : "Off"}
+                    tone={
+                        data.schedule_enabled ? "text-emerald-600" : "text-muted-foreground"
+                    }
+                    hint="automatic top-up jobs"
+                />
+                <StatCard
+                    icon={<Play className="size-4" />}
+                    title="Last generated"
+                    value={
+                        data.last_generated_at
+                            ? new Date(data.last_generated_at).toLocaleDateString()
+                            : "Never"
+                    }
+                    hint={
+                        data.last_generated_at
+                            ? fmtDate(data.last_generated_at)
+                            : "no jobs yet"
+                    }
+                />
+            </div>
+
+            <section>
+                <h2 className="mb-2 text-sm font-semibold">Library by segment & source</h2>
+                <div className="overflow-hidden rounded-lg border border-border bg-card">
+                    <table className="w-full text-sm">
+                        <thead className="bg-muted/50 text-xs uppercase text-muted-foreground">
+                            <tr>
+                                <th className="px-3 py-2 text-left font-medium">Segment</th>
+                                <th className="px-3 py-2 text-left font-medium">Source</th>
+                                <th className="px-3 py-2 text-right font-medium">Active</th>
+                                <th className="px-3 py-2 text-right font-medium">Archived</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {bySegmentSource.map((p, i) => (
+                                <tr
+                                    key={`${p.segment}-${p.source}-${i}`}
+                                    className="border-t border-border"
+                                >
+                                    <td className="px-3 py-2 text-xs">{p.segment || "—"}</td>
+                                    <td className="px-3 py-2 text-xs text-muted-foreground">
+                                        {p.source || "—"}
+                                    </td>
+                                    <td className="px-3 py-2 text-right tabular-nums text-emerald-600">
+                                        {p.active.toLocaleString()}
+                                    </td>
+                                    <td className="px-3 py-2 text-right tabular-nums text-muted-foreground">
+                                        {p.archived.toLocaleString()}
+                                    </td>
+                                </tr>
+                            ))}
+                            {bySegmentSource.length === 0 && (
+                                <tr>
+                                    <td
+                                        colSpan={4}
+                                        className="py-6 text-center text-sm text-muted-foreground"
+                                    >
+                                        No content generated yet.
+                                    </td>
+                                </tr>
+                            )}
+                        </tbody>
+                    </table>
+                </div>
+            </section>
+
+            <section>
+                <h2 className="mb-2 text-sm font-semibold">
+                    Content source vs spam placement
+                    {ab.data ? (
+                        <span className="ml-2 text-xs font-normal text-muted-foreground">
+                            last {ab.data.window_days} days
+                        </span>
+                    ) : null}
+                </h2>
+                {ab.error ? (
+                    <ErrorState
+                        error={ab.error}
+                        title="Failed to load A/B comparison"
+                        onRetry={() => ab.refetch()}
+                    />
+                ) : ab.isLoading ? (
+                    <Skeleton className="h-24" />
+                ) : (
+                    <div className="overflow-hidden rounded-lg border border-border bg-card">
+                        <table className="w-full text-sm">
+                            <thead className="bg-muted/50 text-xs uppercase text-muted-foreground">
+                                <tr>
+                                    <th className="px-3 py-2 text-left font-medium">Source</th>
+                                    <th className="px-3 py-2 text-right font-medium">Sent</th>
+                                    <th className="px-3 py-2 text-right font-medium">
+                                        Spam placements
+                                    </th>
+                                    <th className="px-3 py-2 text-right font-medium">
+                                        Placement rate
+                                    </th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {(ab.data?.data ?? []).map((r) => {
+                                    // Backend already returns a percent (it
+                                    // multiplies by 100), so use it directly.
+                                    const pct = r.spam_placement_rate ?? 0;
+                                    const tone =
+                                        pct >= 20
+                                            ? "text-red-700"
+                                            : pct >= 10
+                                              ? "text-amber-700"
+                                              : "text-emerald-600";
+                                    return (
+                                        <tr
+                                            key={r.content_source}
+                                            className="border-t border-border"
+                                        >
+                                            <td className="px-3 py-2 text-xs">
+                                                {r.content_source}
+                                            </td>
+                                            <td className="px-3 py-2 text-right tabular-nums">
+                                                {r.sent.toLocaleString()}
+                                            </td>
+                                            <td className="px-3 py-2 text-right tabular-nums">
+                                                {r.spam_placements.toLocaleString()}
+                                            </td>
+                                            <td
+                                                className={`px-3 py-2 text-right tabular-nums ${tone}`}
+                                            >
+                                                {pct.toFixed(2)}%
+                                            </td>
+                                        </tr>
+                                    );
+                                })}
+                                {(ab.data?.data ?? []).length === 0 && (
+                                    <tr>
+                                        <td
+                                            colSpan={4}
+                                            className="py-6 text-center text-sm text-muted-foreground"
+                                        >
+                                            Not enough delivery data yet.
+                                        </td>
+                                    </tr>
+                                )}
+                            </tbody>
+                        </table>
+                    </div>
+                )}
+            </section>
+        </div>
+    );
+}
diff --git a/admin/src/app/dashboard/warmup-content/SettingsPage.tsx b/admin/src/app/dashboard/warmup-content/SettingsPage.tsx
new file mode 100644
index 00000000..3c9e9a43
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/SettingsPage.tsx
@@ -0,0 +1,367 @@
+// /warmup-content/settings — full editor for WarmupGenerationSettings:
+// master toggles, generation cadence/model/caps, per-pool targets, and the
+// engagement-simulation knobs.
+
+import { useEffect, useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import { FlaskConical } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Switch } from "@/components/ui/switch";
+import { Skeleton } from "@/components/ui/skeleton";
+import { ErrorState } from "@/components/ErrorState";
+import {
+    getWarmupGenerationSettings,
+    updateWarmupGenerationSettings,
+    type WarmupGenerationPoolConfig,
+    type WarmupGenerationSettings,
+} from "@/lib/api/client/admin/warmupContent";
+
+function NumberField({
+    id,
+    label,
+    hint,
+    value,
+    onChange,
+    min,
+    max,
+    step,
+}: {
+    id: string;
+    label: string;
+    hint?: string;
+    value: number;
+    onChange: (v: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+}) {
+    return (
+        <div>
+            <Label htmlFor={id} className="mb-1 text-xs">
+                {label}
+            </Label>
+            <Input
+                id={id}
+                type="number"
+                min={min}
+                max={max}
+                step={step}
+                value={value}
+                onChange={(e) => onChange(Number(e.target.value))}
+            />
+            {hint && <p className="mt-1 text-[11px] text-muted-foreground">{hint}</p>}
+        </div>
+    );
+}
+
+function ToggleRow({
+    label,
+    hint,
+    checked,
+    onChange,
+}: {
+    label: string;
+    hint?: string;
+    checked: boolean;
+    onChange: (v: boolean) => void;
+}) {
+    return (
+        <label className="flex items-start justify-between gap-3 rounded-md border border-border bg-card px-3 py-2.5">
+            <div className="min-w-0">
+                <div className="text-sm font-medium">{label}</div>
+                {hint && (
+                    <div className="mt-0.5 text-[11px] text-muted-foreground">{hint}</div>
+                )}
+            </div>
+            <Switch checked={checked} onCheckedChange={onChange} />
+        </label>
+    );
+}
+
+export default function SettingsPage() {
+    const qc = useQueryClient();
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["admin", "warmup-content", "settings"],
+        queryFn: getWarmupGenerationSettings,
+    });
+
+    const [form, setForm] = useState<WarmupGenerationSettings | null>(null);
+
+    useEffect(() => {
+        if (data?.data) setForm(data.data);
+    }, [data]);
+
+    const save = useMutation({
+        mutationFn: (body: WarmupGenerationSettings) =>
+            updateWarmupGenerationSettings(body),
+        onSuccess: () => {
+            toast.success("Settings saved");
+            qc.invalidateQueries({ queryKey: ["admin", "warmup-content"] });
+        },
+        onError: (err: Error) => toast.error(err.message || "Failed to save settings"),
+    });
+
+    if (isLoading || !form) {
+        if (error) {
+            return (
+                <ErrorState
+                    error={error}
+                    title="Failed to load settings"
+                    onRetry={() => refetch()}
+                />
+            );
+        }
+        return (
+            <div className="space-y-3">
+                <Skeleton className="h-16" />
+                <Skeleton className="h-40" />
+                <Skeleton className="h-40" />
+            </div>
+        );
+    }
+
+    function patch(p: Partial<WarmupGenerationSettings>) {
+        setForm((f) => (f ? { ...f, ...p } : f));
+    }
+    function patchEngagement(p: Partial<WarmupGenerationSettings["engagement"]>) {
+        setForm((f) => (f ? { ...f, engagement: { ...f.engagement, ...p } } : f));
+    }
+    // Warmup content is a single shared library — free/premium pools only
+    // isolate mailbox reputation, not content. We persist that library as a
+    // single `pools` entry (pool_type "premium") so the scheduler still tops
+    // up the shared library. `library` reads that entry (with sane defaults);
+    // `patchLibrary` writes it back, collapsing any legacy multi-pool array.
+    const library: WarmupGenerationPoolConfig = form.pools[0] ?? {
+        pool_type: "premium",
+        enabled: true,
+        target_active_threads: 0,
+        segments: [],
+    };
+    function patchLibrary(p: Partial<WarmupGenerationPoolConfig>) {
+        setForm((f) => {
+            if (!f) return f;
+            const next: WarmupGenerationPoolConfig = {
+                ...(f.pools[0] ?? {
+                    pool_type: "premium",
+                    enabled: true,
+                    target_active_threads: 0,
+                    segments: [],
+                }),
+                ...p,
+                pool_type: "premium",
+            };
+            return { ...f, pools: [next] };
+        });
+    }
+
+    return (
+        <div className="space-y-6">
+            <section className="space-y-2">
+                <h2 className="text-sm font-semibold">Master controls</h2>
+                <div className="grid gap-2 sm:grid-cols-2">
+                    <ToggleRow
+                        label="AI generation enabled"
+                        hint="Master switch for the offline generator. When off, no new content is produced."
+                        checked={form.enabled}
+                        onChange={(v) => patch({ enabled: v })}
+                    />
+                    <ToggleRow
+                        label="Scheduled generation"
+                        hint="Automatically enqueue top-up jobs on a cadence to keep the library stocked."
+                        checked={form.schedule_enabled}
+                        onChange={(v) => patch({ schedule_enabled: v })}
+                    />
+                </div>
+            </section>
+
+            <section className="space-y-3">
+                <h2 className="text-sm font-semibold">Generation</h2>
+                <div className="grid gap-4 rounded-lg border border-border bg-card p-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
+                    <NumberField
+                        id="set-cadence"
+                        label="Cadence (hours)"
+                        hint="Interval between scheduled top-up jobs."
+                        value={form.cadence_hours}
+                        min={1}
+                        onChange={(v) => patch({ cadence_hours: v })}
+                    />
+                    <div>
+                        <Label htmlFor="set-model" className="mb-1 text-xs">
+                            Model
+                        </Label>
+                        <Input
+                            id="set-model"
+                            value={form.model}
+                            onChange={(e) => patch({ model: e.target.value })}
+                        />
+                        <p className="mt-1 text-[11px] text-muted-foreground">
+                            Default model used for generation.
+                        </p>
+                    </div>
+                    <NumberField
+                        id="set-max-msgs"
+                        label="Max messages / thread"
+                        hint="Upper bound on messages in a generated conversation."
+                        value={form.max_messages_per_thread}
+                        min={1}
+                        onChange={(v) => patch({ max_messages_per_thread: v })}
+                    />
+                    <NumberField
+                        id="set-daily-cap"
+                        label="Daily generation cap"
+                        hint="Max threads generated across all jobs per day."
+                        value={form.daily_generation_cap}
+                        min={0}
+                        onChange={(v) => patch({ daily_generation_cap: v })}
+                    />
+                    <NumberField
+                        id="set-ai-share"
+                        label="AI selection share (%)"
+                        hint="Share of warmup sends that draw from AI-generated content (0–100)."
+                        value={form.ai_selection_share}
+                        min={0}
+                        max={100}
+                        onChange={(v) =>
+                            patch({ ai_selection_share: Math.max(0, Math.min(100, v)) })
+                        }
+                    />
+                </div>
+            </section>
+
+            <section className="space-y-3">
+                <h2 className="text-sm font-semibold">Content library</h2>
+                <p className="text-[11px] text-muted-foreground">
+                    Free and premium pools only isolate mailbox reputation — warmup
+                    content is shared across both, so there's one library.
+                </p>
+                <div className="space-y-3 rounded-lg border border-border bg-card p-4">
+                    <div className="flex items-center justify-between">
+                        <span className="text-sm font-medium">Shared library</span>
+                        <div className="flex items-center gap-2 text-xs text-muted-foreground">
+                            <span>{library.enabled ? "Enabled" : "Disabled"}</span>
+                            <Switch
+                                checked={library.enabled}
+                                onCheckedChange={(v) => patchLibrary({ enabled: v })}
+                            />
+                        </div>
+                    </div>
+                    <div className="grid gap-4 sm:grid-cols-2">
+                        <NumberField
+                            id="library-target"
+                            label="Target active threads"
+                            hint="Library top-up target the scheduler aims to keep stocked."
+                            value={library.target_active_threads}
+                            min={0}
+                            onChange={(v) => patchLibrary({ target_active_threads: v })}
+                        />
+                        <div>
+                            <Label htmlFor="library-segments" className="mb-1 text-xs">
+                                Segments
+                            </Label>
+                            <Input
+                                id="library-segments"
+                                placeholder="comma,separated,segments"
+                                value={library.segments.join(", ")}
+                                onChange={(e) =>
+                                    patchLibrary({
+                                        segments: e.target.value
+                                            .split(",")
+                                            .map((s) => s.trim())
+                                            .filter(Boolean),
+                                    })
+                                }
+                            />
+                            <p className="mt-1 text-[11px] text-muted-foreground">
+                                Comma-separated segments to generate content for.
+                            </p>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <section className="space-y-3">
+                <h2 className="text-sm font-semibold">Engagement simulation</h2>
+                <p className="text-[12.5px] text-muted-foreground">
+                    How recipient mailboxes behave toward warmup mail — rescuing from spam,
+                    marking important/read, and dwell time before actions.
+                </p>
+                <div className="grid gap-4 rounded-lg border border-border bg-card p-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-6">
+                    <NumberField
+                        id="eng-rescue"
+                        label="Spam rescue rate"
+                        hint="Fraction of spam-foldered warmup mail that gets rescued (0–1)."
+                        value={form.engagement.spam_rescue_rate}
+                        min={0}
+                        max={1}
+                        step={0.01}
+                        onChange={(v) => patchEngagement({ spam_rescue_rate: v })}
+                    />
+                    <NumberField
+                        id="eng-important"
+                        label="Mark important rate"
+                        hint="Fraction marked as important (0–1)."
+                        value={form.engagement.mark_important_rate}
+                        min={0}
+                        max={1}
+                        step={0.01}
+                        onChange={(v) => patchEngagement({ mark_important_rate: v })}
+                    />
+                    <NumberField
+                        id="eng-read"
+                        label="Mark read rate"
+                        hint="Fraction opened / marked read (0–1)."
+                        value={form.engagement.mark_read_rate}
+                        min={0}
+                        max={1}
+                        step={0.01}
+                        onChange={(v) => patchEngagement({ mark_read_rate: v })}
+                    />
+                    <NumberField
+                        id="eng-star"
+                        label="Star rate (%)"
+                        hint="Share of warmup mail starred / flagged (0–100)."
+                        value={form.engagement.star_rate}
+                        min={0}
+                        max={100}
+                        onChange={(v) =>
+                            patchEngagement({ star_rate: Math.max(0, Math.min(100, v)) })
+                        }
+                    />
+                    <NumberField
+                        id="eng-min-dwell"
+                        label="Min dwell (seconds)"
+                        hint="Shortest simulated read time before an action."
+                        value={form.engagement.min_dwell_seconds}
+                        min={0}
+                        onChange={(v) => patchEngagement({ min_dwell_seconds: v })}
+                    />
+                    <NumberField
+                        id="eng-max-dwell"
+                        label="Max dwell (seconds)"
+                        hint="Longest simulated read time before an action."
+                        value={form.engagement.max_dwell_seconds}
+                        min={0}
+                        onChange={(v) => patchEngagement({ max_dwell_seconds: v })}
+                    />
+                </div>
+            </section>
+
+            <div className="sticky bottom-0 flex justify-end gap-2 border-t border-border bg-background/95 py-3 backdrop-blur">
+                <Button
+                    variant="outline"
+                    onClick={() => data?.data && setForm(data.data)}
+                    disabled={save.isPending}
+                >
+                    Reset
+                </Button>
+                <Button onClick={() => form && save.mutate(form)} disabled={save.isPending}>
+                    <FlaskConical className="size-4" />
+                    {save.isPending ? "Saving…" : "Save settings"}
+                </Button>
+            </div>
+        </div>
+    );
+}
diff --git a/admin/src/app/dashboard/warmup-content/WarmupContentLayout.tsx b/admin/src/app/dashboard/warmup-content/WarmupContentLayout.tsx
new file mode 100644
index 00000000..00af28f8
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/WarmupContentLayout.tsx
@@ -0,0 +1,71 @@
+// Warmup Content section shell. Each tab is now its own route — this layout
+// renders the shared page header plus a sub-nav tab bar (NavLink, so the
+// active route highlights) and an <Outlet/> for the active tab's full-width
+// page body.
+//
+//   /warmup-content/overview   — headline counts, AI/schedule status, A/B
+//   /warmup-content/library    — generated-thread library + actions
+//   /warmup-content/generate   — sync + OpenAI Batch generation
+//   /warmup-content/jobs       — generation jobs, polled live
+//   /warmup-content/settings   — generation + engagement settings
+
+import { NavLink, Outlet } from "react-router-dom";
+import {
+    CalendarClock,
+    Inbox,
+    Layers,
+    Play,
+    Sparkles,
+    type LucideIcon,
+} from "lucide-react";
+import { PageHeader } from "@/components/layout/PageHeader";
+import { cn } from "@/lib/utils";
+
+interface SubTab {
+    to: string;
+    label: string;
+    icon: LucideIcon;
+}
+
+const TABS: SubTab[] = [
+    { to: "/warmup-content/overview", label: "Overview", icon: Layers },
+    { to: "/warmup-content/library", label: "Library", icon: Inbox },
+    { to: "/warmup-content/generate", label: "Generate", icon: Sparkles },
+    { to: "/warmup-content/jobs", label: "Jobs", icon: Play },
+    { to: "/warmup-content/settings", label: "Settings", icon: CalendarClock },
+];
+
+export default function WarmupContentLayout() {
+    return (
+        <div className="w-full">
+            <PageHeader
+                title="Warmup Content"
+                description="Control and observe the offline AI warmup-content generator: review the generated thread library, enqueue background generation (sync or OpenAI Batch), watch jobs, and tune generation + engagement settings."
+            />
+
+            <div className="mb-6 border-b border-border">
+                <nav className="-mb-px flex flex-wrap items-center gap-1">
+                    {TABS.map(({ to, label, icon: Icon }) => (
+                        <NavLink
+                            key={to}
+                            to={to}
+                            className={({ isActive }) =>
+                                cn(
+                                    "relative inline-flex items-center gap-1.5 rounded-t-md border-b-2 px-3 py-2 text-sm font-medium transition-colors",
+                                    isActive
+                                        ? "border-[var(--admin-accent)] text-[var(--admin-accent-strong)]"
+                                        : "border-transparent text-foreground/60 hover:text-foreground",
+                                )
+                            }
+                        >
+                            <Icon className="size-4" />
+                            {label}
+                        </NavLink>
+                    ))}
+                </nav>
+            </div>
+
+            <Outlet />
+        </div>
+    );
+}
diff --git a/admin/src/app/dashboard/warmup-content/components.tsx b/admin/src/app/dashboard/warmup-content/components.tsx
new file mode 100644
index 00000000..35b97a23
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/components.tsx
@@ -0,0 +1,53 @@
+// Small shared presentational components for the warmup-content section:
+// the pool badge and the overview stat card. Kept JSX-only (no constant/fn
+// exports) so React Fast Refresh stays happy — pure helpers live in
+// `shared.ts`.
+
+import type { ReactNode } from "react";
+import { Badge } from "@/components/ui/badge";
+
+export function PoolBadge({ pool }: { pool: string }) {
+    return (
+        <Badge
+            variant="outline"
+            className={`text-[10px] ${
+                pool === "premium"
+                    ? "border-purple-300 bg-purple-50 text-purple-700"
+                    : "border-zinc-300 text-zinc-700"
+            }`}
+        >
+            {pool}
+        </Badge>
+    );
+}
+
+export function StatCard({
+    icon,
+    title,
+    value,
+    hint,
+    tone,
+}: {
+    icon: ReactNode;
+    title: string;
+    value: string;
+    hint?: string;
+    tone?: string;
+}) {
+    return (
+        <div className="rounded-lg border border-border bg-card p-3">
+            <div className="flex items-center gap-1.5 text-xs text-muted-foreground">
+                {icon}
+                <span>{title}</span>
+            </div>
+            <div className={`mt-1 text-2xl font-semibold tabular-nums ${tone ?? ""}`}>
+                {value}
+            </div>
+            {hint && (
+                <div className="mt-0.5 truncate text-[10px] text-muted-foreground">
+                    {hint}
+                </div>
+            )}
+        </div>
+    );
+}
diff --git a/admin/src/app/dashboard/warmup-content/shared.ts b/admin/src/app/dashboard/warmup-content/shared.ts
new file mode 100644
index 00000000..635be4b1
--- /dev/null
+++ b/admin/src/app/dashboard/warmup-content/shared.ts
@@ -0,0 +1,50 @@
+// Shared constants + pure helpers for the warmup-content section. These were
+// previously module-private to the single page; now that each tab is its own
+// route they live here so every page renders the same tones + date formatting.
+//
+// Keep this file JSX-free — the badge/stat-card *components* live in
+// `components.tsx` so React Fast Refresh stays happy.
+
+const JOB_STATUS_TONE: Record<string, string> = {
+    pending: "border-amber-300 bg-amber-50 text-amber-700",
+    queued: "border-amber-300 bg-amber-50 text-amber-700",
+    running: "border-amber-300 bg-amber-50 text-amber-700",
+    completed: "border-emerald-300 bg-emerald-50 text-emerald-700",
+    succeeded: "border-emerald-300 bg-emerald-50 text-emerald-700",
+    failed: "border-red-300 bg-red-50 text-red-700",
+    error: "border-red-300 bg-red-50 text-red-700",
+    cancelled: "border-zinc-300 bg-zinc-50 text-zinc-600",
+    canceled: "border-zinc-300 bg-zinc-50 text-zinc-600",
+};
+
+export function jobTone(status: string): string {
+    return JOB_STATUS_TONE[status] ?? "border-zinc-300 bg-zinc-50 text-zinc-600";
+}
+
+// OpenAI Batch lifecycle tones. In-flight states read amber/sky, terminal-good
+// reads emerald, terminal-bad reads red, and cancelled reads neutral.
+const BATCH_STATUS_TONE: Record<string, string> = {
+    validating: "border-amber-300 bg-amber-50 text-amber-700",
+    in_progress: "border-sky-300 bg-sky-50 text-sky-700",
+    finalizing: "border-sky-300 bg-sky-50 text-sky-700",
+    cancelling: "border-amber-300 bg-amber-50 text-amber-700",
+    completed: "border-emerald-300 bg-emerald-50 text-emerald-700",
+    failed: "border-red-300 bg-red-50 text-red-700",
+    expired: "border-red-300 bg-red-50 text-red-700",
+    cancelled: "border-zinc-300 bg-zinc-50 text-zinc-600",
+};
+
+export function batchTone(status: string): string {
+    return BATCH_STATUS_TONE[status] ?? "border-zinc-300 bg-zinc-50 text-zinc-600";
+}
+
+export const CONTENT_STATUS_TONE: Record<string, string> = {
+    active: "border-emerald-300 bg-emerald-50 text-emerald-700",
+    archived: "border-zinc-300 bg-zinc-50 text-zinc-600",
+    draft: "border-amber-300 bg-amber-50 text-amber-700",
+};
+
+export function fmtDate(s: string | null | undefined): string {
+    if (!s) return "—";
+    return new Date(s).toLocaleString();
+}
diff --git a/admin/src/components/layout/Sidebar.tsx b/admin/src/components/layout/Sidebar.tsx
index c8db0908..ee195070 100644
--- a/admin/src/components/layout/Sidebar.tsx
+++ b/admin/src/components/layout/Sidebar.tsx
@@ -24,6 +24,8 @@ import {
     Send,
     Server,
     ServerCog,
+    ShieldCheck,
+    Sparkles,
     Ticket,
     Users,
 } from "lucide-react";
@@ -55,7 +57,10 @@ const GROUPS: NavGroup[] = [
                 icon: Rocket,
             },
             { to: "/mailboxes", label: "Mailboxes", icon: Mailbox },
-            { to: "/warmup", label: "Warmup", icon: Flame },
+            { to: "/warmup", label: "Warmup", icon: Flame, end: true },
+            { to: "/warmup/appeals", label: "Warmup Appeals", icon: ShieldCheck },
+            { to: "/warmup-content", label: "Warmup Content", icon: Sparkles },
+            { to: "/placement", label: "Inbox Placement", icon: Inbox },
             { to: "/campaigns", label: "Campaigns", icon: Megaphone },
         ],
     },
diff --git a/admin/src/lib/api/client/admin/placement.ts b/admin/src/lib/api/client/admin/placement.ts
new file mode 100644
index 00000000..6ffbae78
--- /dev/null
+++ b/admin/src/lib/api/client/admin/placement.ts
@@ -0,0 +1,162 @@
+// /admin/placement/* — seed inbox-placement testing.
+//
+// A placement test sends a tokenized copy of a template through a real sender
+// to a panel of Warmbly-controlled SEED mailboxes; a backend poller then looks
+// the token up in each seed's synced inbox (the unibox) and classifies where it
+// landed (Inbox / Spam / Promotions / other), per provider. This module shapes
+// the requests and returns the backend's `{ data }` / `{ pagination }`
+// envelopes. Types are co-located here since this surface is self-contained.
+
+import { Request } from "@/lib/api/client";
+import { buildSearchQuery } from "@/lib/api/client/admin/query";
+
+// --------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------
+
+export type PlacementFolder =
+    | "inbox"
+    | "promotions"
+    | "spam"
+    | "other"
+    | "pending";
+
+export type PlacementStatus = "pending" | "completed";
+
+export interface PlacementTestRow {
+    id: string;
+    organization_id: string | null;
+    sender_account_id: string;
+    subject: string;
+    status: PlacementStatus;
+    created_at: string;
+    finished_at: string | null;
+}
+
+export interface PlacementResultRow {
+    seed_account_id: string;
+    provider: string;
+    folder: PlacementFolder;
+    detected_at: string | null;
+    raw_flags: string;
+}
+
+export interface PlacementProviderRollup {
+    provider: string;
+    inbox: number;
+    promotions: number;
+    spam: number;
+    other: number;
+    pending: number;
+    total: number;
+}
+
+export interface PlacementTestDetail {
+    test: PlacementTestRow;
+    rollup: PlacementProviderRollup[];
+    results: PlacementResultRow[];
+}
+
+export interface SeedAccount {
+    id: string;
+    email: string;
+    name: string;
+    provider: string;
+    status: string;
+    worker_id: string | null;
+    is_seed: boolean;
+}
+
+export interface Pagination {
+    total: number;
+    has_more: boolean;
+    next_cursor: string | null;
+}
+
+export interface PlacementTestsResult {
+    data: PlacementTestRow[];
+    pagination: Pagination;
+}
+
+export interface CreatePlacementTestRequest {
+    sender_account_id: string;
+    subject: string;
+    body_plain: string;
+    body_html: string;
+}
+
+export interface ListTestsParams {
+    cursor?: string;
+    limit?: number;
+}
+
+// --------------------------------------------------------------------
+// Tests
+// --------------------------------------------------------------------
+
+export function listPlacementTests(
+    params: ListTestsParams = {},
+): Promise<PlacementTestsResult> {
+    return Request({
+        method: "GET",
+        url: `/admin/placement/tests${buildSearchQuery(
+            params as Record<string, unknown>,
+        )}`,
+        authorization: true,
+    });
+}
+
+export function getPlacementTest(
+    id: string,
+): Promise<{ data: PlacementTestDetail }> {
+    return Request({
+        method: "GET",
+        url: `/admin/placement/tests/${id}`,
+        authorization: true,
+    });
+}
+
+export function createPlacementTest(
+    body: CreatePlacementTestRequest,
+): Promise<{ data: PlacementTestRow }> {
+    return Request({
+        method: "POST",
+        url: "/admin/placement/tests",
+        data: body,
+        authorization: true,
+    });
+}
+
+// --------------------------------------------------------------------
+// Seeds
+// --------------------------------------------------------------------
+
+export function listSeedMailboxes(): Promise<{ data: SeedAccount[] }> {
+    return Request({
+        method: "GET",
+        url: "/admin/placement/seeds",
+        authorization: true,
+    });
+}
+
+export function listSeedCandidates(
+    search?: string,
+): Promise<{ data: SeedAccount[] }> {
+    return Request({
+        method: "GET",
+        url: `/admin/placement/seeds/candidates${buildSearchQuery({ search })}`,
+        authorization: true,
+    });
+}
+
+export function setSeedMailbox(
+    id: string,
+    isSeed: boolean,
+): Promise<{ ok: true }> {
+    return Request({
+        method: "POST",
+        url: `/admin/placement/seeds/${id}`,
+        data: { is_seed: isSeed },
+        authorization: true,
+    });
+}
diff --git a/admin/src/lib/api/client/admin/warmup.ts b/admin/src/lib/api/client/admin/warmup.ts
index aa0b0cf5..808f52f0 100644
--- a/admin/src/lib/api/client/admin/warmup.ts
+++ b/admin/src/lib/api/client/admin/warmup.ts
@@ -65,9 +65,13 @@ export function unblockWarmupAccount(accountId: string): Promise<void> {
 
 export function listWarmupAppeals(
     status: "pending" | "approved" | "rejected" | "all" = "pending",
+    cursor?: string,
+    limit = 50,
 ): Promise<WarmupAppealsResult> {
     const usp = new URLSearchParams();
     if (status !== "all") usp.set("status", status);
+    if (cursor) usp.set("cursor", cursor);
+    usp.set("limit", String(limit));
     return Request({
         method: "GET",
         url: `/admin/warmup/appeals?${usp.toString()}`,
diff --git a/admin/src/lib/api/client/admin/warmupContent.ts b/admin/src/lib/api/client/admin/warmupContent.ts
new file mode 100644
index 00000000..d015c09c
--- /dev/null
+++ b/admin/src/lib/api/client/admin/warmupContent.ts
@@ -0,0 +1,417 @@
+// /admin/warmup-content/* — admin control + visibility surface for the
+// offline AI warmup-content generator.
+//
+// The generator runs OUT OF BAND: `generate` enqueues a background job and
+// returns a job id; the Jobs view polls for progress. This module just shapes
+// the requests and returns the backend's `{ data }` / `{ pagination }`
+// envelopes. Types are co-located here since this surface is self-contained.
+
+import { Request } from "@/lib/api/client";
+import { buildSearchQuery } from "@/lib/api/client/admin/query";
+
+// --------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------
+
+export interface WarmupContentPoolBreakdown {
+    pool_type: string;
+    segment: string;
+    source: string;
+    active: number;
+    archived: number;
+}
+
+export interface WarmupContentOverview {
+    total_active: number;
+    total_archived: number;
+    by_pool: WarmupContentPoolBreakdown[];
+    last_generated_at: string | null;
+    ai_enabled: boolean;
+    schedule_enabled: boolean;
+}
+
+export interface WarmupConversationRow {
+    id: string;
+    pool_type: string;
+    segment: string;
+    source: string;
+    theme: string;
+    subject: string;
+    description: string;
+    message_count: number;
+    status: string;
+    lint_passed: boolean;
+    usage_count: number;
+    created_at: string;
+}
+
+export interface WarmupConversationDetail {
+    id: string;
+    pool_type: string;
+    segment: string;
+    source: string;
+    theme: string;
+    subject: string;
+    description: string;
+    messages: string[];
+    status: string;
+    lint_passed: boolean;
+    usage_count: number;
+    generated_by_job_id: string | null;
+    created_at: string;
+    updated_at: string;
+}
+
+/** Whether a job ran inline ("sync") or via the OpenAI Batch API ("batch"). */
+export type WarmupGenerationMode = "sync" | "batch";
+
+/**
+ * OpenAI Batch lifecycle status, surfaced verbatim for batch-mode jobs.
+ * Terminal states are `completed`, `failed`, `expired`, and `cancelled`.
+ */
+export type WarmupBatchStatus =
+    | "validating"
+    | "in_progress"
+    | "finalizing"
+    | "completed"
+    | "failed"
+    | "expired"
+    | "cancelling"
+    | "cancelled";
+
+const TERMINAL_BATCH_STATUS: ReadonlySet<string> = new Set([
+    "completed",
+    "failed",
+    "expired",
+    "cancelled",
+]);
+
+const TERMINAL_JOB_STATUS: ReadonlySet<string> = new Set([
+    "completed",
+    "succeeded",
+    "failed",
+    "error",
+    "cancelled",
+    "canceled",
+]);
+
+export interface WarmupGenerationJob {
+    id: string;
+    requested_by: string | null;
+    trigger: string;
+    pool_type: string;
+    segment: string;
+    theme: string;
+    model: string;
+    requested_count: number;
+    generated_count: number;
+    lint_rejected_count: number;
+    failed_count: number;
+    status: string;
+    error: string;
+    started_at: string | null;
+    finished_at: string | null;
+    created_at: string;
+    /** "sync" for inline jobs, "batch" for OpenAI Batch API jobs. */
+    mode?: WarmupGenerationMode;
+    /** Batch-only fields — present when `mode === "batch"`. */
+    batch_id?: string | null;
+    batch_input_file_id?: string | null;
+    batch_output_file_id?: string | null;
+    batch_status?: WarmupBatchStatus | null;
+    completion_window?: string | null;
+}
+
+/**
+ * True while a job is still doing work and should keep being polled. Covers
+ * both the inline `status` lifecycle and the OpenAI `batch_status` lifecycle.
+ */
+export function isJobActive(job: WarmupGenerationJob): boolean {
+    if (job.mode === "batch") {
+        const bs = job.batch_status ?? "";
+        if (bs) return !TERMINAL_BATCH_STATUS.has(bs);
+    }
+    return !TERMINAL_JOB_STATUS.has(job.status);
+}
+
+/** Only batch jobs that are still in flight can be cancelled. */
+export function isJobCancellable(job: WarmupGenerationJob): boolean {
+    if (job.mode !== "batch") return false;
+    const bs = job.batch_status ?? "";
+    if (!bs) return !TERMINAL_JOB_STATUS.has(job.status);
+    return !TERMINAL_BATCH_STATUS.has(bs);
+}
+
+export interface WarmupGenerationPoolConfig {
+    pool_type: string;
+    enabled: boolean;
+    target_active_threads: number;
+    segments: string[];
+}
+
+export interface WarmupGenerationEngagement {
+    spam_rescue_rate: number;
+    mark_important_rate: number;
+    mark_read_rate: number;
+    star_rate: number;
+    min_dwell_seconds: number;
+    max_dwell_seconds: number;
+}
+
+export interface WarmupGenerationSettings {
+    enabled: boolean;
+    schedule_enabled: boolean;
+    cadence_hours: number;
+    model: string;
+    max_messages_per_thread: number;
+    daily_generation_cap: number;
+    /** 0-100 — share of warmup sends that draw from AI-generated content. */
+    ai_selection_share: number;
+    pools: WarmupGenerationPoolConfig[];
+    engagement: WarmupGenerationEngagement;
+}
+
+export interface WarmupAbRow {
+    content_source: string;
+    sent: number;
+    spam_placements: number;
+    spam_placement_rate: number;
+}
+
+export interface Pagination {
+    total: number;
+    has_more: boolean;
+    next_cursor: string | null;
+}
+
+export interface WarmupConversationsResult {
+    data: WarmupConversationRow[];
+    pagination: Pagination;
+}
+
+export interface WarmupGenerationJobsResult {
+    data: WarmupGenerationJob[];
+    pagination: Pagination;
+}
+
+export interface WarmupAbResult {
+    data: WarmupAbRow[];
+    window_days: number;
+}
+
+export interface ListConversationsParams {
+    pool?: string;
+    segment?: string;
+    source?: string;
+    status?: string;
+    cursor?: string;
+    limit?: number;
+}
+
+export interface ListJobsParams {
+    cursor?: string;
+    limit?: number;
+}
+
+export interface GenerateContentRequest {
+    count: number;
+    /**
+     * Reputation pool the threads nominally belong to. Optional — warmup
+     * content is a single shared library, so the UI omits this and the
+     * backend defaults it to "premium".
+     */
+    pool_type?: string;
+    segment?: string;
+    theme?: string;
+    model?: string;
+}
+
+/**
+ * Batch generation request. Every field is optional; the backend applies
+ * defaults. If `themes` is non-empty the backend fans out one batch job per
+ * theme, and `count` is interpreted as threads-per-job (default 100, clamped
+ * to 2000 and the daily cap). `completion_window` defaults to "24h".
+ */
+export interface GenerateBatchRequest {
+    pool_type?: string;
+    segment?: string;
+    theme?: string;
+    themes?: string[];
+    model?: string;
+    count?: number;
+    max_messages?: number;
+    completion_window?: string;
+}
+
+export interface GenerateBatchResult {
+    job_ids: string[];
+}
+
+// --------------------------------------------------------------------
+// Overview
+// --------------------------------------------------------------------
+
+export function getWarmupContentOverview(): Promise<WarmupContentOverview> {
+    return Request({
+        method: "GET",
+        url: "/admin/warmup-content/overview",
+        authorization: true,
+    });
+}
+
+// --------------------------------------------------------------------
+// Library (conversations)
+// --------------------------------------------------------------------
+
+export function listWarmupConversations(
+    params: ListConversationsParams = {},
+): Promise<WarmupConversationsResult> {
+    return Request({
+        method: "GET",
+        url: `/admin/warmup-content/conversations${buildSearchQuery(
+            params as Record<string, unknown>,
+        )}`,
+        authorization: true,
+    });
+}
+
+export function getWarmupConversation(
+    id: string,
+): Promise<{ data: WarmupConversationDetail }> {
+    return Request({
+        method: "GET",
+        url: `/admin/warmup-content/conversations/${id}`,
+        authorization: true,
+    });
+}
+
+export function archiveWarmupConversation(id: string): Promise<{ ok: true }> {
+    return Request({
+        method: "POST",
+        url: `/admin/warmup-content/conversations/${id}/archive`,
+        authorization: true,
+    });
+}
+
+export function unarchiveWarmupConversation(id: string): Promise<{ ok: true }> {
+    return Request({
+        method: "POST",
+        url: `/admin/warmup-content/conversations/${id}/unarchive`,
+        authorization: true,
+    });
+}
+
+export function deleteWarmupConversation(id: string): Promise<{ ok: true }> {
+    return Request({
+        method: "DELETE",
+        url: `/admin/warmup-content/conversations/${id}`,
+        authorization: true,
+    });
+}
+
+// --------------------------------------------------------------------
+// Generate (offline job)
+// --------------------------------------------------------------------
+
+export function generateWarmupContent(
+    body: GenerateContentRequest,
+): Promise<{ job_id: string }> {
+    return Request({
+        method: "POST",
+        url: "/admin/warmup-content/generate",
+        data: body,
+        authorization: true,
+    });
+}
+
+// --------------------------------------------------------------------
+// Batch generate (OpenAI Batch API — async, cheaper, large volume)
+// --------------------------------------------------------------------
+
+/**
+ * Enqueue one or more OpenAI Batch jobs. Returns the created job ids; watch
+ * them on the Jobs view via `listWarmupGenerationJobs`. A 400 with code
+ * `not_configured` / `daily_cap_reached` means generation can't run yet.
+ */
+export function submitWarmupBatch(
+    body: GenerateBatchRequest,
+): Promise<GenerateBatchResult> {
+    return Request({
+        method: "POST",
+        url: "/admin/warmup-content/batch",
+        data: body,
+        authorization: true,
+    });
+}
+
+/** Cancel an in-flight batch job. 400 if it isn't a cancellable batch job. */
+export function cancelWarmupBatch(jobId: string): Promise<{ ok: true }> {
+    return Request({
+        method: "POST",
+        url: `/admin/warmup-content/jobs/${jobId}/cancel`,
+        authorization: true,
+    });
+}
+
+// --------------------------------------------------------------------
+// Jobs
+// --------------------------------------------------------------------
+
+export function listWarmupGenerationJobs(
+    params: ListJobsParams = {},
+): Promise<WarmupGenerationJobsResult> {
+    return Request({
+        method: "GET",
+        url: `/admin/warmup-content/jobs${buildSearchQuery(
+            params as Record<string, unknown>,
+        )}`,
+        authorization: true,
+    });
+}
+
+export function getWarmupGenerationJob(
+    id: string,
+): Promise<{ data: WarmupGenerationJob }> {
+    return Request({
+        method: "GET",
+        url: `/admin/warmup-content/jobs/${id}`,
+        authorization: true,
+    });
+}
+
+// --------------------------------------------------------------------
+// Settings
+// --------------------------------------------------------------------
+
+export function getWarmupGenerationSettings(): Promise<{
+    data: WarmupGenerationSettings;
+}> {
+    return Request({
+        method: "GET",
+        url: "/admin/warmup-content/settings",
+        authorization: true,
+    });
+}
+
+export function updateWarmupGenerationSettings(
+    body: WarmupGenerationSettings,
+): Promise<{ ok: true }> {
+    return Request({
+        method: "PUT",
+        url: "/admin/warmup-content/settings",
+        data: body,
+        authorization: true,
+    });
+}
+
+// --------------------------------------------------------------------
+// A/B (content source vs spam placement)
+// --------------------------------------------------------------------
+
+export function getWarmupContentAb(days?: number): Promise<WarmupAbResult> {
+    return Request({
+        method: "GET",
+        url: `/admin/warmup-content/ab${buildSearchQuery({ days })}`,
+        authorization: true,
+    });
+}
diff --git a/admin/src/lib/api/models/admin.ts b/admin/src/lib/api/models/admin.ts
index 788113df..16c7575c 100644
--- a/admin/src/lib/api/models/admin.ts
+++ b/admin/src/lib/api/models/admin.ts
@@ -1022,6 +1022,7 @@ export interface WarmupPoolHealthSummary {
     by_state: Record<string, number>;
     avg_spam_score: number;
     avg_spam_placement_rate: number;
+    spam_placement_by_provider: Record<string, number>;
     blocked_count: number;
     at_risk_count: number;
 }
diff --git a/admin/src/main.tsx b/admin/src/main.tsx
index ec509ff2..de056054 100644
--- a/admin/src/main.tsx
+++ b/admin/src/main.tsx
@@ -33,6 +33,13 @@ import OrganizationDetailPage from "@/app/dashboard/OrganizationDetailPage";
 import UsersPage from "@/app/dashboard/UsersPage";
 import UserDetailPage from "@/app/dashboard/UserDetailPage";
 import WarmupPage from "@/app/dashboard/WarmupPage";
+import WarmupAppealsPage from "@/app/dashboard/WarmupAppealsPage";
+import WarmupContentLayout from "@/app/dashboard/warmup-content/WarmupContentLayout";
+import WarmupContentOverviewPage from "@/app/dashboard/warmup-content/OverviewPage";
+import WarmupContentLibraryPage from "@/app/dashboard/warmup-content/LibraryPage";
+import WarmupContentGeneratePage from "@/app/dashboard/warmup-content/GeneratePage";
+import WarmupContentJobsPage from "@/app/dashboard/warmup-content/JobsPage";
+import WarmupContentSettingsPage from "@/app/dashboard/warmup-content/SettingsPage";
 import CampaignsPage from "@/app/dashboard/CampaignsPage";
 import EnterprisePage from "@/app/dashboard/EnterprisePage";
 import PlansPage from "@/app/dashboard/PlansPage";
@@ -41,6 +48,7 @@ import LimitRequestsPage from "@/app/dashboard/LimitRequestsPage";
 import OutreachPage from "@/app/dashboard/OutreachPage";
 import AnalyticsPage from "@/app/dashboard/AnalyticsPage";
 import MailboxesPage from "@/app/dashboard/MailboxesPage";
+import PlacementPage from "@/app/dashboard/PlacementPage";
 import { NotFoundPage } from "@/app/dashboard/StubPages";
 
 // Mirror of web/src/main.tsx's tuned defaults. The admin app sees less
@@ -87,6 +95,25 @@ const router = createBrowserRouter([
                     { path: "plans", element: <PlansPage /> },
                     { path: "discounts", element: <DiscountsPage /> },
                     { path: "warmup", element: <WarmupPage /> },
+                    { path: "warmup/appeals", element: <WarmupAppealsPage /> },
+                    {
+                        path: "warmup-content",
+                        element: <WarmupContentLayout />,
+                        children: [
+                            {
+                                index: true,
+                                element: (
+                                    <Navigate to="/warmup-content/overview" replace />
+                                ),
+                            },
+                            { path: "overview", element: <WarmupContentOverviewPage /> },
+                            { path: "library", element: <WarmupContentLibraryPage /> },
+                            { path: "generate", element: <WarmupContentGeneratePage /> },
+                            { path: "jobs", element: <WarmupContentJobsPage /> },
+                            { path: "settings", element: <WarmupContentSettingsPage /> },
+                        ],
+                    },
+                    { path: "placement", element: <PlacementPage /> },
                     { path: "campaigns", element: <CampaignsPage /> },
                     { path: "enterprise", element: <EnterprisePage /> },
                     { path: "limit-requests", element: <LimitRequestsPage /> },
diff --git a/cmd/backend/main.go b/cmd/backend/main.go
index 43796790..400de6dc 100644
--- a/cmd/backend/main.go
+++ b/cmd/backend/main.go
@@ -34,6 +34,7 @@ import (
 	"github.com/warmbly/warmbly/internal/app/discount"
 	"github.com/warmbly/warmbly/internal/app/email"
 	"github.com/warmbly/warmbly/internal/app/emailsend"
+	emailverifyapp "github.com/warmbly/warmbly/internal/app/emailverify"
 	"github.com/warmbly/warmbly/internal/app/feature"
 	"github.com/warmbly/warmbly/internal/app/fleet"
 	"github.com/warmbly/warmbly/internal/app/group"
@@ -41,6 +42,7 @@ import (
 	"github.com/warmbly/warmbly/internal/app/integration"
 	"github.com/warmbly/warmbly/internal/app/organization"
 	"github.com/warmbly/warmbly/internal/app/passkey"
+	"github.com/warmbly/warmbly/internal/app/placement"
 	"github.com/warmbly/warmbly/internal/app/provisioning"
 	"github.com/warmbly/warmbly/internal/app/ratelimit"
 	"github.com/warmbly/warmbly/internal/app/releases"
@@ -56,6 +58,7 @@ import (
 	"github.com/warmbly/warmbly/internal/app/unibox"
 	"github.com/warmbly/warmbly/internal/app/user"
 	warmupapp "github.com/warmbly/warmbly/internal/app/warmup"
+	"github.com/warmbly/warmbly/internal/app/warmupcontent"
 	"github.com/warmbly/warmbly/internal/app/webhook"
 	"github.com/warmbly/warmbly/internal/app/worker"
 	"github.com/warmbly/warmbly/internal/app/worker_orchestrator"
@@ -78,6 +81,8 @@ import (
 	"github.com/warmbly/warmbly/internal/notify"
 	"github.com/warmbly/warmbly/internal/observability"
 	"github.com/warmbly/warmbly/internal/pkg/captcha"
+	"github.com/warmbly/warmbly/internal/pkg/emailverify"
+	"github.com/warmbly/warmbly/internal/pkg/generation"
 	"github.com/warmbly/warmbly/internal/pkg/geo"
 	"github.com/warmbly/warmbly/internal/repository"
 	"github.com/warmbly/warmbly/internal/scheduler"
@@ -116,6 +121,11 @@ func main() {
 	var provisioningPolicyRepo repository.ProvisioningPolicyRepository
 	var tasksService tasks.TasksService
 	var advancedService advanced.Service
+	var warmupContentRepo repository.WarmupContentRepository
+	var warmupContentService warmupcontent.Service
+	var emailVerifyService emailverifyapp.Service
+	var placementRepository repository.PlacementRepository
+	var placementService placement.Service
 
 	var folderService group.GroupService
 	var tagService group.GroupService
@@ -475,6 +485,16 @@ func main() {
 		warmupRepository := repository.NewWarmupRepository(primaryDB.Pool)
 		warmupRoutingRepository := repository.NewWarmupRoutingRepository(primaryDB.Pool)
 		warmupRoutingRepoForHandler = warmupRoutingRepository
+
+		// Warmup content bank + offline AI generator. The generation client is
+		// optional: without OPENAI_API_KEY the live send path simply keeps using
+		// the static library and admin generation returns "not configured".
+		warmupContentRepo = repository.NewWarmupContentRepository(primaryDB.Pool)
+		var generationClient *generation.GenerationClient
+		if openaiKey := cfg.GetSecretOptional(ctx, "OPENAI_API_KEY", "openai_api_key", ""); openaiKey != "" {
+			generationClient = generation.NewClient(openaiKey)
+		}
+		warmupContentService = warmupcontent.NewService(warmupContentRepo, generationClient)
 		webhookRepository := repository.NewWebhookRepository(primaryDB.Pool)
 		webhookService := webhook.NewService(webhookRepository)
 		webhookServiceForHandler = webhookService
@@ -792,7 +812,7 @@ func main() {
 		tasksService = tasks.NewService(
 			tasksClient,
 			kafkaProducer,
-			nil, // AI generation client is optional for task execution
+			generationClient,
 			streamingPublisher,
 			eventsPublisher,
 			schedulerService,
@@ -803,6 +823,7 @@ func main() {
 			taskRepository,
 			warmupRepository,
 			warmupRoutingRepository,
+			warmupContentRepo,
 			campaignProgressRepository,
 			emailRepostory,
 			campaignRepostory,
@@ -856,6 +877,42 @@ func main() {
 		auditRetentionScheduler := jobs.NewAuditRetentionScheduler(auditRetentionJob, 6*time.Hour)
 		go auditRetentionScheduler.Start(ctx)
 
+		// Warmup content generator: tops the AI thread bank up toward the
+		// admin-configured per-pool/segment targets. The internal cadence gate
+		// honours the admin's cadence_hours; it no-ops when generation is
+		// disabled or unconfigured.
+		warmupGenerationJob := jobs.NewWarmupGenerationJob(warmupContentService, warmupContentRepo)
+		warmupGenerationScheduler := jobs.NewWarmupGenerationScheduler(warmupGenerationJob, 30*time.Minute)
+		go warmupGenerationScheduler.Start(ctx)
+
+		// Warmup batch poller: reconciles in-flight OpenAI Batch API generation
+		// jobs (~50% cheaper, async up to 24h), ingesting completed batches into
+		// the content bank and marking failed/expired/cancelled ones. No-ops when
+		// generation is unconfigured or there are no active batch jobs.
+		warmupBatchPoller := jobs.NewWarmupBatchPoller(warmupContentService, 5*time.Minute)
+		go warmupBatchPoller.Start(ctx)
+
+		// Pre-send email verification: verify a capped batch of not-yet-checked
+		// contacts each tick so hard-bouncing addresses are dropped before any
+		// worker sends. CONTROL-PLANE ONLY — the SMTP RCPT probe dials remote MX
+		// on :25 from this backend host (a non-sending IP), never a worker.
+		emailVerifier := emailverify.New(emailverify.Config{
+			HeloHost: os.Getenv("EMAIL_VERIFY_HELO_HOST"), // e.g. verify.warmbly.com
+			MailFrom: os.Getenv("EMAIL_VERIFY_MAIL_FROM"), // e.g. verify@warmbly.com
+		})
+		emailVerifyService = emailverifyapp.NewService(contactRepostory, emailVerifier)
+		emailVerificationJob := jobs.NewEmailVerificationJob(emailVerifyService, 100)
+		emailVerificationScheduler := jobs.NewEmailVerificationScheduler(emailVerificationJob, 15*time.Minute)
+		go emailVerificationScheduler.Start(ctx)
+
+		// Seed inbox-placement testing: send a tokenized copy of a template
+		// through a real sender to the seed panel, then classify where it landed
+		// by looking the token up in each seed's synced unibox entries.
+		placementRepository = repository.NewPlacementRepository(primaryDB)
+		placementService = placement.NewService(placementRepository, emailRepostory, emailSender)
+		placementPoller := jobs.NewPlacementPoller(placementService, 2*time.Minute)
+		go placementPoller.Start(ctx)
+
 		addr = apiCfg.Hostname
 		ginMode = apiCfg.GinMode
 		websocketURI = apiCfg.WebsocketURI
@@ -927,6 +984,17 @@ func main() {
 		WarmupRoutingRepo: warmupRoutingRepoForHandler,
 		WebhookService:    webhookServiceForHandler,
 
+		// Warmup content bank + offline AI generator
+		WarmupContentRepo:    warmupContentRepo,
+		WarmupContentService: warmupContentService,
+
+		// Pre-send email verification
+		EmailVerifyService: emailVerifyService,
+
+		// Seed inbox-placement testing
+		PlacementRepo:    placementRepository,
+		PlacementService: placementService,
+
 		// Third-party integrations
 		IntegrationService: integrationServiceForHandler,
 		ContactRepo:        contactRepoForHandler,
diff --git a/cmd/consumer/main.go b/cmd/consumer/main.go
index f2552711..cb4eea6b 100644
--- a/cmd/consumer/main.go
+++ b/cmd/consumer/main.go
@@ -198,6 +198,13 @@ func main() {
 	integrationRepoC := repository.NewIntegrationRepository(primaryDB.Pool)
 	integrationServiceC := integration.NewService(integrationRepoC, cipherService, integration.NewOAuthManager())
 	webhookService.WireDispatchSink(integrationServiceC.DispatchAny)
+	// Warmup health transitions happen in THIS process (the health sweep + all
+	// event-driven re-evaluations run in the consumer). Without wiring the
+	// webhook dispatcher here, dispatchHealthEvent saw s.webhooks == nil and
+	// every warmup.health_changed / quarantined / blocked event silently fired
+	// no webhook. Dispatch only enqueues delivery rows in Postgres (drained by
+	// the backend's DeliveryWorker), so no worker/PG boundary is crossed.
+	warmupService.WireWebhooks(webhookService, emailRepo)
 
 	advancedService := advanced.NewService(
 		advancedRepo,
@@ -232,6 +239,8 @@ func main() {
 		EmailHistoryIDRepository:    emailHistoryIDRepo,
 		EmailAccountErrorRepository: emailAccountErrorRepo,
 		WarmupRepo:                  warmupRepo,
+		WarmupContentRepo:           repository.NewWarmupContentRepository(primaryDB.Pool),
+		WarmupEngagementRepo:        repository.NewWarmupEngagementRepository(primaryDB.Pool),
 		WarmupService:               warmupService,
 		WorkerRepo:                  workerRepo,
 		Publisher:                   eventsPublisher,
@@ -260,6 +269,11 @@ func main() {
 	// Start warmup health evaluation sweep (every hour)
 	go jobsService.StartWarmupHealthSweep(ctx, 1*time.Hour)
 
+	// Drains the durable delayed-engagement schedule (read/important/star) so the
+	// recipient-side dwell survives worker restarts. Short interval keeps the
+	// effective dwell close to the requested value.
+	go jobsService.StartWarmupEngagementPoller(ctx, 30*time.Second)
+
 	// Start dead worker detection (every 5 minutes)
 	go jobsService.StartDeadWorkerDetection(ctx, 5*time.Minute)
 
diff --git a/internal/api/handler/admin_warmup_batch.go b/internal/api/handler/admin_warmup_batch.go
new file mode 100644
index 00000000..772b467b
--- /dev/null
+++ b/internal/api/handler/admin_warmup_batch.go
@@ -0,0 +1,125 @@
+package handler
+
+import (
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+
+	"github.com/warmbly/warmbly/internal/api/middleware"
+	"github.com/warmbly/warmbly/internal/app/warmupcontent"
+	"github.com/warmbly/warmbly/internal/errx"
+	"github.com/warmbly/warmbly/internal/models"
+)
+
+// submitBatchRequest is the admin payload for an async Batch API generation run.
+// Admins control every parameter; sensible service-side defaults apply when a
+// field is omitted (pool_type=premium, count=100, completion_window=24h, model
+// and max_messages from the generation settings).
+type submitBatchRequest struct {
+	PoolType         string   `json:"pool_type"`
+	Segment          string   `json:"segment"`
+	Theme            string   `json:"theme"`
+	Themes           []string `json:"themes"`
+	Model            string   `json:"model"`
+	Count            int      `json:"count"`
+	MaxMessages      int      `json:"max_messages"`
+	CompletionWindow string   `json:"completion_window"`
+}
+
+// AdminSubmitWarmupBatch submits an async OpenAI Batch API generation run.
+//
+// The Batch API is ~50% cheaper than synchronous generation and processes
+// asynchronously (up to the completion window, typically 24h). Results are
+// ingested into the content bank by the batch poller once OpenAI finishes.
+//
+// When a non-empty `themes` array is supplied, one batch job is submitted per
+// theme (each gets `count` threads of that theme); otherwise a single batch
+// runs with the optional pinned `theme` (empty = rotate the default theme set).
+func (h *Handler) AdminSubmitWarmupBatch(c *gin.Context) {
+	if h.WarmupContentService == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "warmup generation is not configured"))
+		return
+	}
+	var req submitBatchRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid request body"))
+		return
+	}
+
+	adminID := middleware.GetAdminUserID(c)
+
+	// Normalise the theme set: explicit `themes` wins; otherwise fall back to the
+	// single pinned `theme` (which may be empty → service rotates defaults).
+	themes := make([]string, 0, len(req.Themes))
+	for _, t := range req.Themes {
+		if t != "" {
+			themes = append(themes, t)
+		}
+	}
+	if len(themes) == 0 {
+		themes = []string{req.Theme}
+	}
+
+	jobIDs := make([]uuid.UUID, 0, len(themes))
+	for _, theme := range themes {
+		jobID, err := h.WarmupContentService.GenerateBatch(c.Request.Context(), warmupcontent.GenerateRequest{
+			RequestedBy:      adminID,
+			Trigger:          "manual",
+			PoolType:         req.PoolType,
+			Segment:          req.Segment,
+			Theme:            theme,
+			Model:            req.Model,
+			Count:            req.Count,
+			MaxMessages:      req.MaxMessages,
+			CompletionWindow: req.CompletionWindow,
+		})
+		if err != nil {
+			if errors.Is(err, warmupcontent.ErrNotConfigured) {
+				errx.JSON(c, errx.New(errx.BadRequest, "warmup AI generation is not configured (set OPENAI_API_KEY)"))
+				return
+			}
+			errx.JSON(c, errx.New(errx.BadRequest, err.Error()))
+			return
+		}
+		jobIDs = append(jobIDs, jobID)
+	}
+
+	for _, id := range jobIDs {
+		jid := id
+		h.audit(c, models.AuditActionCreate, warmupContentEntity, &jid, map[string]string{
+			"mode":      "batch",
+			"pool_type": req.PoolType,
+			"segment":   req.Segment,
+			"count":     strconv.Itoa(req.Count),
+		})
+	}
+
+	c.JSON(http.StatusOK, gin.H{"job_ids": jobIDs})
+}
+
+// AdminCancelWarmupBatch cancels an in-flight batch generation job (OpenAI + the
+// local job row).
+func (h *Handler) AdminCancelWarmupBatch(c *gin.Context) {
+	if h.WarmupContentService == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "warmup generation is not configured"))
+		return
+	}
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid id"))
+		return
+	}
+	if err := h.WarmupContentService.CancelBatch(c.Request.Context(), id); err != nil {
+		if errors.Is(err, warmupcontent.ErrNotConfigured) {
+			errx.JSON(c, errx.New(errx.BadRequest, "warmup AI generation is not configured (set OPENAI_API_KEY)"))
+			return
+		}
+		errx.JSON(c, errx.New(errx.BadRequest, err.Error()))
+		return
+	}
+	h.audit(c, models.AuditActionUpdate, warmupContentEntity, &id, map[string]string{"action": "cancel_batch"})
+	c.JSON(http.StatusOK, gin.H{"ok": true})
+}
diff --git a/internal/api/handler/admin_warmup_content.go b/internal/api/handler/admin_warmup_content.go
new file mode 100644
index 00000000..e0b3c24b
--- /dev/null
+++ b/internal/api/handler/admin_warmup_content.go
@@ -0,0 +1,343 @@
+package handler
+
+import (
+	"encoding/base64"
+	"errors"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+
+	"github.com/warmbly/warmbly/internal/api/middleware"
+	"github.com/warmbly/warmbly/internal/app/warmupcontent"
+	"github.com/warmbly/warmbly/internal/errx"
+	"github.com/warmbly/warmbly/internal/models"
+	"github.com/warmbly/warmbly/internal/repository"
+)
+
+const warmupContentEntity models.AuditEntityType = "warmup_content"
+
+// --- cursor helpers (opaque base64 offset) ---
+
+func decodeOffsetCursor(s string) (int, bool) {
+	if s == "" {
+		return 0, true
+	}
+	b, err := base64.StdEncoding.DecodeString(s)
+	if err != nil {
+		return 0, false
+	}
+	n, err := strconv.Atoi(string(b))
+	if err != nil || n < 0 {
+		return 0, false
+	}
+	return n, true
+}
+
+func encodeOffsetCursor(n int) string {
+	return base64.StdEncoding.EncodeToString([]byte(strconv.Itoa(n)))
+}
+
+type pageMeta struct {
+	Total      int     `json:"total"`
+	HasMore    bool    `json:"has_more"`
+	NextCursor *string `json:"next_cursor"`
+}
+
+func pageMetaFor(offset, limit, returned, total int) pageMeta {
+	hasMore := offset+returned < total
+	var next *string
+	if hasMore {
+		c := encodeOffsetCursor(offset + limit)
+		next = &c
+	}
+	return pageMeta{Total: total, HasMore: hasMore, NextCursor: next}
+}
+
+// AdminWarmupContentOverview returns content-bank counts + generator status.
+func (h *Handler) AdminWarmupContentOverview(c *gin.Context) {
+	ctx := c.Request.Context()
+	stats, err := h.WarmupContentRepo.ConversationStats(ctx)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	totalActive, totalArchived := 0, 0
+	for _, s := range stats {
+		totalActive += s.Active
+		totalArchived += s.Archived
+	}
+	lastGen, _ := h.WarmupContentRepo.LastGeneratedAt(ctx)
+	settings, _ := h.WarmupContentRepo.GetGenerationSettings(ctx)
+	if settings == nil {
+		def := models.DefaultWarmupGenerationSettings()
+		settings = &def
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"total_active":      totalActive,
+		"total_archived":    totalArchived,
+		"by_pool":           stats,
+		"last_generated_at": lastGen,
+		"ai_enabled":        settings.Enabled,
+		"schedule_enabled":  settings.ScheduleEnabled,
+	})
+}
+
+type conversationListItem struct {
+	ID           uuid.UUID `json:"id"`
+	PoolType     string    `json:"pool_type"`
+	Segment      string    `json:"segment"`
+	Source       string    `json:"source"`
+	Theme        string    `json:"theme"`
+	Subject      string    `json:"subject"`
+	Description  string    `json:"description"`
+	MessageCount int       `json:"message_count"`
+	Status       string    `json:"status"`
+	LintPassed   bool      `json:"lint_passed"`
+	UsageCount   int64     `json:"usage_count"`
+	CreatedAt    time.Time `json:"created_at"`
+}
+
+// AdminListWarmupConversations lists cached conversations with filters.
+func (h *Handler) AdminListWarmupConversations(c *gin.Context) {
+	offset, ok := decodeOffsetCursor(c.Query("cursor"))
+	if !ok {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid cursor"))
+		return
+	}
+	limit := parseLimit(c.Query("limit"), 50)
+
+	f := repository.ConversationFilter{
+		PoolType: c.Query("pool"),
+		Segment:  c.Query("segment"),
+		Source:   c.Query("source"),
+		Status:   c.Query("status"),
+		Limit:    limit,
+		Offset:   offset,
+	}
+	rows, total, err := h.WarmupContentRepo.ListConversations(c.Request.Context(), f)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+
+	items := make([]conversationListItem, 0, len(rows))
+	for _, r := range rows {
+		items = append(items, conversationListItem{
+			ID: r.ID, PoolType: r.PoolType, Segment: r.Segment, Source: r.Source,
+			Theme: r.Theme, Subject: r.Subject, Description: r.Description,
+			MessageCount: len(r.Messages), Status: r.Status, LintPassed: r.LintPassed,
+			UsageCount: r.UsageCount, CreatedAt: r.CreatedAt,
+		})
+	}
+
+	c.JSON(http.StatusOK, gin.H{"data": items, "pagination": pageMetaFor(offset, limit, len(rows), total)})
+}
+
+// AdminGetWarmupConversation returns a single conversation in full.
+func (h *Handler) AdminGetWarmupConversation(c *gin.Context) {
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid id"))
+		return
+	}
+	conv, err := h.WarmupContentRepo.GetConversation(c.Request.Context(), id)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	if conv == nil {
+		errx.JSON(c, errx.New(errx.NotFound, "conversation not found"))
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"data": conv})
+}
+
+func (h *Handler) setConversationStatus(c *gin.Context, status string) {
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid id"))
+		return
+	}
+	if err := h.WarmupContentRepo.SetConversationStatus(c.Request.Context(), id, status); err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	h.audit(c, models.AuditActionUpdate, warmupContentEntity, &id, map[string]string{"status": status})
+	c.JSON(http.StatusOK, gin.H{"ok": true})
+}
+
+// AdminArchiveWarmupConversation archives a conversation (excludes it from selection).
+func (h *Handler) AdminArchiveWarmupConversation(c *gin.Context) {
+	h.setConversationStatus(c, "archived")
+}
+
+// AdminUnarchiveWarmupConversation re-activates a conversation.
+func (h *Handler) AdminUnarchiveWarmupConversation(c *gin.Context) {
+	h.setConversationStatus(c, "active")
+}
+
+// AdminDeleteWarmupConversation permanently removes a conversation.
+func (h *Handler) AdminDeleteWarmupConversation(c *gin.Context) {
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid id"))
+		return
+	}
+	if err := h.WarmupContentRepo.DeleteConversation(c.Request.Context(), id); err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	h.audit(c, models.AuditActionDelete, warmupContentEntity, &id, nil)
+	c.JSON(http.StatusOK, gin.H{"ok": true})
+}
+
+type generateWarmupRequest struct {
+	Count    int    `json:"count"`
+	PoolType string `json:"pool_type"`
+	Segment  string `json:"segment"`
+	Theme    string `json:"theme"`
+	Model    string `json:"model"`
+}
+
+// AdminGenerateWarmupContent kicks off an offline generation run.
+func (h *Handler) AdminGenerateWarmupContent(c *gin.Context) {
+	if h.WarmupContentService == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "warmup generation is not configured"))
+		return
+	}
+	var req generateWarmupRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid request body"))
+		return
+	}
+
+	adminID := middleware.GetAdminUserID(c)
+	jobID, err := h.WarmupContentService.Generate(c.Request.Context(), warmupcontent.GenerateRequest{
+		RequestedBy: adminID,
+		Trigger:     "manual",
+		PoolType:    req.PoolType,
+		Segment:     req.Segment,
+		Theme:       req.Theme,
+		Model:       req.Model,
+		Count:       req.Count,
+	})
+	if err != nil {
+		if errors.Is(err, warmupcontent.ErrNotConfigured) {
+			errx.JSON(c, errx.New(errx.BadRequest, "warmup AI generation is not configured (set OPENAI_API_KEY)"))
+			return
+		}
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+
+	h.audit(c, models.AuditActionCreate, warmupContentEntity, &jobID, map[string]string{
+		"pool_type": req.PoolType,
+		"segment":   req.Segment,
+		"count":     strconv.Itoa(req.Count),
+	})
+	c.JSON(http.StatusOK, gin.H{"job_id": jobID})
+}
+
+// AdminListWarmupGenerationJobs lists generation runs (visibility).
+func (h *Handler) AdminListWarmupGenerationJobs(c *gin.Context) {
+	offset, ok := decodeOffsetCursor(c.Query("cursor"))
+	if !ok {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid cursor"))
+		return
+	}
+	limit := parseLimit(c.Query("limit"), 50)
+
+	jobs, total, err := h.WarmupContentRepo.ListGenerationJobs(c.Request.Context(), limit, offset)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"data": jobs, "pagination": pageMetaFor(offset, limit, len(jobs), total)})
+}
+
+// AdminGetWarmupGenerationJob returns one generation run.
+func (h *Handler) AdminGetWarmupGenerationJob(c *gin.Context) {
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid id"))
+		return
+	}
+	job, err := h.WarmupContentRepo.GetGenerationJob(c.Request.Context(), id)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	if job == nil {
+		errx.JSON(c, errx.New(errx.NotFound, "job not found"))
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"data": job})
+}
+
+// AdminGetWarmupGenerationSettings returns the current generation settings.
+func (h *Handler) AdminGetWarmupGenerationSettings(c *gin.Context) {
+	settings, err := h.WarmupContentRepo.GetGenerationSettings(c.Request.Context())
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"data": settings})
+}
+
+// AdminUpdateWarmupGenerationSettings replaces the generation settings.
+func (h *Handler) AdminUpdateWarmupGenerationSettings(c *gin.Context) {
+	var settings models.WarmupGenerationSettings
+	if err := c.ShouldBindJSON(&settings); err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid request body"))
+		return
+	}
+	adminID := middleware.GetAdminUserID(c)
+	if err := h.WarmupContentRepo.SetGenerationSettings(c.Request.Context(), &settings, adminID); err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	h.audit(c, models.AuditActionUpdate, warmupContentEntity, nil, map[string]string{
+		"enabled":          strconv.FormatBool(settings.Enabled),
+		"schedule_enabled": strconv.FormatBool(settings.ScheduleEnabled),
+	})
+	c.JSON(http.StatusOK, gin.H{"ok": true})
+}
+
+type abRow struct {
+	ContentSource     string  `json:"content_source"`
+	Sent              int     `json:"sent"`
+	SpamPlacements    int     `json:"spam_placements"`
+	SpamPlacementRate float64 `json:"spam_placement_rate"`
+}
+
+// AdminWarmupContentAB returns spam-placement rate by content cohort.
+func (h *Handler) AdminWarmupContentAB(c *gin.Context) {
+	days := 30
+	if v := c.Query("days"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 && n <= 365 {
+			days = n
+		}
+	}
+	since := time.Now().AddDate(0, 0, -days)
+	stats, err := h.WarmupContentRepo.SpamPlacementByCohort(c.Request.Context(), since)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	rows := make([]abRow, 0, len(stats))
+	for _, s := range stats {
+		rate := 0.0
+		if s.Sent > 0 {
+			rate = float64(s.SpamPlacements) / float64(s.Sent) * 100
+		}
+		rows = append(rows, abRow{
+			ContentSource: s.ContentSource, Sent: s.Sent,
+			SpamPlacements: s.SpamPlacements, SpamPlacementRate: rate,
+		})
+	}
+	c.JSON(http.StatusOK, gin.H{"data": rows, "window_days": days})
+}
diff --git a/internal/api/handler/email_authcheck.go b/internal/api/handler/email_authcheck.go
new file mode 100644
index 00000000..79caac01
--- /dev/null
+++ b/internal/api/handler/email_authcheck.go
@@ -0,0 +1,38 @@
+package handler
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/warmbly/warmbly/internal/api/middleware"
+	"github.com/warmbly/warmbly/internal/errx"
+	"github.com/warmbly/warmbly/internal/pkg/dnsauth"
+)
+
+// GetEmailAuthCheck validates SPF/DKIM/DMARC for a mailbox's sending domain on
+// demand. Authentication alignment is a hard bulk-sender requirement and the
+// most common silent deliverability failure, so this lets the user confirm
+// their domain is set up correctly without leaving the dashboard.
+func (h *Handler) GetEmailAuthCheck(c *gin.Context) {
+	userID, err := middleware.GetUserUUID(c)
+	if err != nil {
+		errx.JSON(c, errx.ErrUnauthorized)
+		return
+	}
+
+	account, xerr := h.EmailService.Get(c.Request.Context(), userID.String(), c.Param("id"))
+	if xerr != nil {
+		errx.JSON(c, xerr)
+		return
+	}
+
+	domain := ""
+	if at := strings.LastIndex(account.Email, "@"); at >= 0 {
+		domain = account.Email[at+1:]
+	}
+
+	res := dnsauth.Check(c.Request.Context(), domain, nil)
+	c.JSON(http.StatusOK, res)
+}
diff --git a/internal/api/handler/email_verification.go b/internal/api/handler/email_verification.go
new file mode 100644
index 00000000..5949005e
--- /dev/null
+++ b/internal/api/handler/email_verification.go
@@ -0,0 +1,55 @@
+package handler
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/warmbly/warmbly/internal/api/middleware"
+	"github.com/warmbly/warmbly/internal/errx"
+)
+
+// verifyEmailRequest is the optional JSON body for VerifyEmail. The address may
+// also be passed as the `email` query param; the body takes precedence.
+type verifyEmailRequest struct {
+	Email string `json:"email"`
+}
+
+// VerifyEmail verifies a single email address on demand (syntax -> MX -> SMTP
+// RCPT probe -> catch-all detection) and returns the emailverify.Result. This
+// is pre-send verification: it lets the user/admin confirm an address is
+// deliverable *before* a worker ever sends to it, instead of learning from a
+// hard bounce after the fact.
+//
+// Control-plane only: the SMTP RCPT probe behind this runs from the backend (a
+// non-sending IP). Probing must never run from worker (sending) IPs — see
+// internal/pkg/emailverify.
+//
+// Route registration is intentionally NOT done here; the parent workstream
+// wires it in internal/api/routes.go behind the appropriate permission gates.
+func (h *Handler) VerifyEmail(c *gin.Context) {
+	if _, err := middleware.GetUserUUID(c); err != nil {
+		errx.JSON(c, errx.ErrUnauthorized)
+		return
+	}
+	if h.EmailVerifyService == nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+
+	var req verifyEmailRequest
+	// Body is optional; ignore a bind error and fall back to the query param.
+	_ = c.ShouldBindJSON(&req)
+	email := strings.TrimSpace(req.Email)
+	if email == "" {
+		email = strings.TrimSpace(c.Query("email"))
+	}
+	if email == "" {
+		errx.JSON(c, errx.ErrEmail)
+		return
+	}
+
+	res := h.EmailVerifyService.VerifyAddress(c.Request.Context(), email)
+	c.JSON(http.StatusOK, res)
+}
diff --git a/internal/api/handler/handler.go b/internal/api/handler/handler.go
index f2c4f660..2461d08d 100644
--- a/internal/api/handler/handler.go
+++ b/internal/api/handler/handler.go
@@ -15,11 +15,13 @@ import (
 	"github.com/warmbly/warmbly/internal/app/discount"
 	"github.com/warmbly/warmbly/internal/app/email"
 	"github.com/warmbly/warmbly/internal/app/emailsend"
+	emailverifyapp "github.com/warmbly/warmbly/internal/app/emailverify"
 	"github.com/warmbly/warmbly/internal/app/feature"
 	"github.com/warmbly/warmbly/internal/app/group"
 	"github.com/warmbly/warmbly/internal/app/integration"
 	"github.com/warmbly/warmbly/internal/app/organization"
 	"github.com/warmbly/warmbly/internal/app/passkey"
+	"github.com/warmbly/warmbly/internal/app/placement"
 	"github.com/warmbly/warmbly/internal/app/ratelimit"
 	"github.com/warmbly/warmbly/internal/app/releases"
 	"github.com/warmbly/warmbly/internal/app/sequence"
@@ -33,6 +35,7 @@ import (
 	"github.com/warmbly/warmbly/internal/app/unibox"
 	"github.com/warmbly/warmbly/internal/app/user"
 	"github.com/warmbly/warmbly/internal/app/warmup"
+	"github.com/warmbly/warmbly/internal/app/warmupcontent"
 	"github.com/warmbly/warmbly/internal/app/webhook"
 	"github.com/warmbly/warmbly/internal/app/worker"
 	"github.com/warmbly/warmbly/internal/app/worker_orchestrator"
@@ -104,6 +107,10 @@ type Handler struct {
 	// Advanced outreach controls
 	AdvancedService advanced.Service
 
+	// Pre-send email verification (control-plane SMTP RCPT probe / pluggable
+	// paid backend). Drops hard-bouncing addresses before a worker sends.
+	EmailVerifyService emailverifyapp.Service
+
 	// Warmup health
 	WarmupService warmup.Service
 
@@ -111,6 +118,14 @@ type Handler struct {
 	// partner selection (e.g. Gmail recipients from Google Workspace senders).
 	WarmupRoutingRepo repository.WarmupRoutingRepository
 
+	// Warmup content bank + offline AI generator (admin control/visibility).
+	WarmupContentRepo    repository.WarmupContentRepository
+	WarmupContentService warmupcontent.Service
+
+	// Seed inbox-placement testing.
+	PlacementRepo    repository.PlacementRepository
+	PlacementService placement.Service
+
 	// Customer-facing webhooks (subscribe → HMAC-signed delivery).
 	WebhookService webhook.Service
 
diff --git a/internal/api/handler/placement.go b/internal/api/handler/placement.go
new file mode 100644
index 00000000..b73071e9
--- /dev/null
+++ b/internal/api/handler/placement.go
@@ -0,0 +1,302 @@
+package handler
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+
+	"github.com/warmbly/warmbly/internal/errx"
+	"github.com/warmbly/warmbly/internal/models"
+	"github.com/warmbly/warmbly/internal/repository"
+)
+
+// placementEntity tags placement actions in the admin audit trail.
+const placementEntity models.AuditEntityType = "placement_test"
+
+// --- DTOs --------------------------------------------------------------
+
+type placementTestRow struct {
+	ID              uuid.UUID  `json:"id"`
+	OrganizationID  *uuid.UUID `json:"organization_id"`
+	SenderAccountID uuid.UUID  `json:"sender_account_id"`
+	Subject         string     `json:"subject"`
+	Status          string     `json:"status"`
+	CreatedAt       time.Time  `json:"created_at"`
+	FinishedAt      *time.Time `json:"finished_at"`
+}
+
+func toPlacementTestRow(t repository.PlacementTest) placementTestRow {
+	return placementTestRow{
+		ID:              t.ID,
+		OrganizationID:  t.OrganizationID,
+		SenderAccountID: t.SenderAccountID,
+		Subject:         t.Subject,
+		Status:          t.Status,
+		CreatedAt:       t.CreatedAt,
+		FinishedAt:      t.FinishedAt,
+	}
+}
+
+type placementResultRow struct {
+	SeedAccountID uuid.UUID  `json:"seed_account_id"`
+	Provider      string     `json:"provider"`
+	Folder        string     `json:"folder"`
+	DetectedAt    *time.Time `json:"detected_at"`
+	RawFlags      string     `json:"raw_flags"`
+}
+
+// providerRollup aggregates per-provider folder counts for a test.
+type providerRollup struct {
+	Provider   string `json:"provider"`
+	Inbox      int    `json:"inbox"`
+	Promotions int    `json:"promotions"`
+	Spam       int    `json:"spam"`
+	Other      int    `json:"other"`
+	Pending    int    `json:"pending"`
+	Total      int    `json:"total"`
+}
+
+type seedAccountRow struct {
+	ID       uuid.UUID  `json:"id"`
+	Email    string     `json:"email"`
+	Name     string     `json:"name"`
+	Provider string     `json:"provider"`
+	Status   string     `json:"status"`
+	WorkerID *uuid.UUID `json:"worker_id"`
+	IsSeed   bool       `json:"is_seed"`
+}
+
+func toSeedRow(s repository.SeedAccount) seedAccountRow {
+	return seedAccountRow{
+		ID:       s.ID,
+		Email:    s.Email,
+		Name:     s.Name,
+		Provider: s.Provider,
+		Status:   s.Status,
+		WorkerID: s.WorkerID,
+		IsSeed:   s.IsSeed,
+	}
+}
+
+// --- Tests -------------------------------------------------------------
+
+type createPlacementTestRequest struct {
+	SenderAccountID string `json:"sender_account_id"`
+	Subject         string `json:"subject"`
+	BodyPlain       string `json:"body_plain"`
+	BodyHTML        string `json:"body_html"`
+}
+
+// AdminCreatePlacementTest sends a tokenized copy of a template through a chosen
+// sender to every active seed mailbox, recording one pending result per seed.
+func (h *Handler) AdminCreatePlacementTest(c *gin.Context) {
+	if h.PlacementService == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "placement testing is not configured"))
+		return
+	}
+
+	var req createPlacementTestRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid request body"))
+		return
+	}
+	senderID, err := uuid.Parse(req.SenderAccountID)
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid sender_account_id"))
+		return
+	}
+
+	test, serr := h.PlacementService.CreateTest(c.Request.Context(), nil, senderID, req.Subject, req.BodyPlain, req.BodyHTML)
+	if serr != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, serr.Error()))
+		return
+	}
+
+	h.audit(c, models.AuditActionCreate, placementEntity, &test.ID, map[string]string{
+		"sender_account_id": senderID.String(),
+		"subject":           test.Subject,
+	})
+	c.JSON(http.StatusOK, gin.H{"data": toPlacementTestRow(*test)})
+}
+
+// AdminListPlacementTests lists placement tests, newest first.
+func (h *Handler) AdminListPlacementTests(c *gin.Context) {
+	if h.PlacementRepo == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "placement testing is not configured"))
+		return
+	}
+	offset, ok := decodeOffsetCursor(c.Query("cursor"))
+	if !ok {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid cursor"))
+		return
+	}
+	limit := parseLimit(c.Query("limit"), 25)
+
+	tests, total, err := h.PlacementRepo.ListTests(c.Request.Context(), nil, limit, offset)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	rows := make([]placementTestRow, 0, len(tests))
+	for _, t := range tests {
+		rows = append(rows, toPlacementTestRow(t))
+	}
+	c.JSON(http.StatusOK, gin.H{"data": rows, "pagination": pageMetaFor(offset, limit, len(tests), total)})
+}
+
+// AdminGetPlacementTest returns a test with its per-provider rollup and the
+// per-seed detail rows.
+func (h *Handler) AdminGetPlacementTest(c *gin.Context) {
+	if h.PlacementRepo == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "placement testing is not configured"))
+		return
+	}
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid id"))
+		return
+	}
+
+	test, results, err := h.PlacementRepo.GetTestWithResults(c.Request.Context(), id)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	if test == nil {
+		errx.JSON(c, errx.New(errx.NotFound, "placement test not found"))
+		return
+	}
+
+	rollups := map[string]*providerRollup{}
+	resultRows := make([]placementResultRow, 0, len(results))
+	for _, r := range results {
+		provider := r.Provider
+		if provider == "" {
+			provider = "unknown"
+		}
+		ru, ok := rollups[provider]
+		if !ok {
+			ru = &providerRollup{Provider: provider}
+			rollups[provider] = ru
+		}
+		ru.Total++
+		switch r.Folder {
+		case repository.PlacementFolderInbox:
+			ru.Inbox++
+		case repository.PlacementFolderPromotions:
+			ru.Promotions++
+		case repository.PlacementFolderSpam:
+			ru.Spam++
+		case repository.PlacementFolderOther:
+			ru.Other++
+		default:
+			ru.Pending++
+		}
+		resultRows = append(resultRows, placementResultRow{
+			SeedAccountID: r.SeedAccountID,
+			Provider:      r.Provider,
+			Folder:        r.Folder,
+			DetectedAt:    r.DetectedAt,
+			RawFlags:      r.RawFlags,
+		})
+	}
+
+	rollup := make([]providerRollup, 0, len(rollups))
+	for _, ru := range rollups {
+		rollup = append(rollup, *ru)
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"data": gin.H{
+			"test":    toPlacementTestRow(*test),
+			"rollup":  rollup,
+			"results": resultRows,
+		},
+	})
+}
+
+// --- Seeds -------------------------------------------------------------
+
+// AdminListSeedMailboxes lists the configured seed panel.
+func (h *Handler) AdminListSeedMailboxes(c *gin.Context) {
+	if h.PlacementRepo == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "placement testing is not configured"))
+		return
+	}
+	seeds, err := h.PlacementRepo.ListSeedAccounts(c.Request.Context(), false)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	rows := make([]seedAccountRow, 0, len(seeds))
+	for _, s := range seeds {
+		rows = append(rows, toSeedRow(s))
+	}
+	c.JSON(http.StatusOK, gin.H{"data": rows})
+}
+
+// AdminListSeedCandidates lists connected mailboxes an admin can flag as seeds,
+// optionally filtered by an email substring.
+func (h *Handler) AdminListSeedCandidates(c *gin.Context) {
+	if h.PlacementRepo == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "placement testing is not configured"))
+		return
+	}
+	limit := parseLimit(c.Query("limit"), 50)
+	candidates, err := h.PlacementRepo.ListSeedCandidates(c.Request.Context(), c.Query("search"), limit)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	rows := make([]seedAccountRow, 0, len(candidates))
+	for _, s := range candidates {
+		rows = append(rows, toSeedRow(s))
+	}
+	c.JSON(http.StatusOK, gin.H{"data": rows})
+}
+
+type setSeedRequest struct {
+	IsSeed bool `json:"is_seed"`
+}
+
+// AdminSetSeedMailbox toggles is_seed on a mailbox (register/unregister a seed).
+func (h *Handler) AdminSetSeedMailbox(c *gin.Context) {
+	if h.PlacementRepo == nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "placement testing is not configured"))
+		return
+	}
+	id, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid id"))
+		return
+	}
+	var req setSeedRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid request body"))
+		return
+	}
+
+	seed, err := h.PlacementRepo.GetSeedAccount(c.Request.Context(), id)
+	if err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+	if seed == nil {
+		errx.JSON(c, errx.New(errx.NotFound, "mailbox not found"))
+		return
+	}
+
+	if err := h.PlacementRepo.SetIsSeed(c.Request.Context(), id, req.IsSeed); err != nil {
+		errx.JSON(c, errx.InternalError())
+		return
+	}
+
+	action := models.AuditActionUpdate
+	h.audit(c, action, placementEntity, &id, map[string]string{
+		"is_seed": map[bool]string{true: "true", false: "false"}[req.IsSeed],
+		"email":   seed.Email,
+	})
+	c.JSON(http.StatusOK, gin.H{"ok": true})
+}
diff --git a/internal/api/handler/template_score.go b/internal/api/handler/template_score.go
new file mode 100644
index 00000000..cc890d2b
--- /dev/null
+++ b/internal/api/handler/template_score.go
@@ -0,0 +1,31 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/warmbly/warmbly/internal/errx"
+	"github.com/warmbly/warmbly/internal/pkg/warmlint"
+)
+
+type scoreTemplateRequest struct {
+	Subject   string `json:"subject"`
+	BodyHTML  string `json:"body_html"`
+	BodyPlain string `json:"body_plain"`
+}
+
+// ScoreTemplateContent returns an advisory deliverability content score for a
+// campaign template (subject + body) before it is sent. Advisory only — it
+// never blocks sending — so the user gets content feedback on the mail that
+// actually reaches prospects, which warmup-only linting never covered.
+func (h *Handler) ScoreTemplateContent(c *gin.Context) {
+	var req scoreTemplateRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid request body"))
+		return
+	}
+
+	res := warmlint.Score(req.Subject, req.BodyHTML, req.BodyPlain)
+	c.JSON(http.StatusOK, res)
+}
diff --git a/internal/api/handler/unsubscribe.go b/internal/api/handler/unsubscribe.go
new file mode 100644
index 00000000..5389c359
--- /dev/null
+++ b/internal/api/handler/unsubscribe.go
@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+
+	"github.com/warmbly/warmbly/internal/errx"
+)
+
+// Unsubscribe handles the List-Unsubscribe link and the RFC 8058 one-click POST.
+// It is PUBLIC + unauthenticated — mailbox providers and recipients hit it
+// directly. Both GET (a recipient clicking the link) and POST (the provider's
+// one-click, body "List-Unsubscribe=One-Click") suppress the recipient org-wide.
+// The link shape is /unsubscribe?cid=<campaign>&rid=<contact>.
+func (h *Handler) Unsubscribe(c *gin.Context) {
+	isPost := c.Request.Method == http.MethodPost
+
+	cid, err1 := uuid.Parse(c.Query("cid"))
+	rid, err2 := uuid.Parse(c.Query("rid"))
+	if err1 != nil || err2 != nil {
+		if isPost {
+			c.Status(http.StatusBadRequest)
+			return
+		}
+		c.Data(http.StatusBadRequest, "text/html; charset=utf-8", unsubPage("This unsubscribe link is invalid."))
+		return
+	}
+
+	xerr := h.AdvancedService.Unsubscribe(c.Request.Context(), cid, rid)
+
+	if isPost {
+		// RFC 8058: acknowledge one-click. Return 5xx only on a genuine
+		// server-side failure so the provider can retry; a bad/expired link
+		// (BadRequest) is terminal, so 200 to stop pointless retries.
+		if xerr != nil && xerr.Code != errx.BadRequest {
+			c.Status(http.StatusBadGateway)
+			return
+		}
+		c.Status(http.StatusOK)
+		return
+	}
+
+	msg := "You've been unsubscribed."
+	if xerr != nil {
+		msg = "We couldn't process that unsubscribe link."
+	}
+	c.Data(http.StatusOK, "text/html; charset=utf-8", unsubPage(msg))
+}
+
+func unsubPage(msg string) []byte {
+	return []byte(`<!doctype html><html lang="en"><head><meta charset="utf-8">` +
+		`<meta name="viewport" content="width=device-width,initial-scale=1"><title>Unsubscribe</title></head>` +
+		`<body style="font-family:system-ui,-apple-system,sans-serif;max-width:32rem;margin:4rem auto;padding:0 1rem;color:#0f172a">` +
+		`<h1 style="font-size:1.25rem;margin:0 0 .5rem">` + msg + `</h1>` +
+		`<p style="color:#64748b;margin:0">You will no longer receive emails from this sender.</p></body></html>`)
+}
diff --git a/internal/api/handler/warmup_appeal.go b/internal/api/handler/warmup_appeal.go
new file mode 100644
index 00000000..f5152769
--- /dev/null
+++ b/internal/api/handler/warmup_appeal.go
@@ -0,0 +1,67 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+
+	"github.com/warmbly/warmbly/internal/api/middleware"
+	"github.com/warmbly/warmbly/internal/errx"
+	"github.com/warmbly/warmbly/internal/models"
+)
+
+type submitWarmupAppealRequest struct {
+	Reason string `json:"reason"`
+}
+
+// GetWarmupBanStatus returns whether a mailbox is blocked from warmup, why, and
+// whether the owner can appeal. Powers the dashboard ban banner.
+func (h *Handler) GetWarmupBanStatus(c *gin.Context) {
+	userID, err := middleware.GetUserUUID(c)
+	if err != nil {
+		errx.JSON(c, errx.ErrUnauthorized)
+		return
+	}
+	accountID, perr := uuid.Parse(c.Param("id"))
+	if perr != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid email account id"))
+		return
+	}
+
+	status, xerr := h.WarmupService.GetBanStatus(c.Request.Context(), userID, accountID)
+	if xerr != nil {
+		errx.JSON(c, xerr)
+		return
+	}
+	c.JSON(http.StatusOK, status)
+}
+
+// SubmitWarmupAppeal lets the mailbox owner appeal a warmup ban with a reason.
+func (h *Handler) SubmitWarmupAppeal(c *gin.Context) {
+	userID, err := middleware.GetUserUUID(c)
+	if err != nil {
+		errx.JSON(c, errx.ErrUnauthorized)
+		return
+	}
+	accountID, perr := uuid.Parse(c.Param("id"))
+	if perr != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid email account id"))
+		return
+	}
+
+	var req submitWarmupAppealRequest
+	if bindErr := c.ShouldBindJSON(&req); bindErr != nil {
+		errx.JSON(c, errx.New(errx.BadRequest, "invalid request body"))
+		return
+	}
+
+	appealID, xerr := h.WarmupService.SubmitAppeal(c.Request.Context(), userID, accountID, req.Reason)
+	if xerr != nil {
+		errx.JSON(c, xerr)
+		return
+	}
+
+	h.auditOrg(c, models.AuditActionCreate, models.AuditEntityEmailAccount, &accountID, map[string]string{"warmup_appeal": "submitted"}, nil)
+	c.JSON(http.StatusOK, gin.H{"appeal_id": appealID})
+}
diff --git a/internal/api/routes.go b/internal/api/routes.go
index bf58677e..81741925 100644
--- a/internal/api/routes.go
+++ b/internal/api/routes.go
@@ -55,6 +55,12 @@ func Run(
 	// postMessages code+state to the SPA opener, which calls oauth/finish.
 	r.GET("/integrations/oauth/callback", h.IntegrationOAuthCallback)
 
+	// Public List-Unsubscribe endpoint (RFC 8058). GET = recipient clicks the
+	// link; POST = mailbox provider's one-click (body List-Unsubscribe=One-Click).
+	// Both suppress the recipient org-wide. Unauthenticated by design.
+	r.GET("/unsubscribe", h.Unsubscribe)
+	r.POST("/unsubscribe", h.Unsubscribe)
+
 	// Internal backend-to-backend endpoints. Workers call these instead of
 	// touching Postgres directly, per the no-direct-data-services rule in
 	// CLAUDE.md. Auth: shared bearer token (INTERNAL_API_TOKEN).
@@ -205,6 +211,10 @@ func Run(
 			emails.POST("/:id/warmup/pause", m.RequireAccess(models.PermManageEmails, models.APIPermWriteEmails), middleware.RequireAPIKeyEmailAccountParam("id"), h.PauseWarmup)
 			emails.POST("/:id/warmup/resume", m.RequireAccess(models.PermManageEmails, models.APIPermWriteEmails), middleware.RequireAPIKeyEmailAccountParam("id"), h.ResumeWarmup)
 			emails.POST("/:id/warmup/stop", m.RequireAccess(models.PermManageEmails, models.APIPermWriteEmails), middleware.RequireAPIKeyEmailAccountParam("id"), h.StopWarmup)
+			emails.GET("/:id/auth-check", m.RequireAccess(models.PermViewCampaigns, models.APIPermReadEmails), middleware.RequireAPIKeyEmailAccountParam("id"), h.GetEmailAuthCheck)
+			emails.POST("/verify", m.RequireAccess(models.PermViewCampaigns, models.APIPermReadEmails), h.VerifyEmail)
+			emails.GET("/:id/warmup/ban-status", m.RequireAccess(models.PermViewCampaigns, models.APIPermReadEmails), middleware.RequireAPIKeyEmailAccountParam("id"), h.GetWarmupBanStatus)
+			emails.POST("/:id/warmup/appeal", m.RequireAccess(models.PermManageEmails, models.APIPermWriteEmails), middleware.RequireAPIKeyEmailAccountParam("id"), h.SubmitWarmupAppeal)
 			emails.DELETE("/:id", m.RequireAccess(models.PermManageEmails, models.APIPermWriteEmails), middleware.RequireAPIKeyEmailAccountParam("id"), h.DeleteEmail)
 			emails.POST("/:id/send", m.RequireOrganization(), m.RequireAccess(models.PermSendCampaigns, models.APIPermSendCampaigns), middleware.RequireAPIKeyEmailAccountParam("id"), h.SendEmailFromAccount)
 		}
@@ -457,6 +467,7 @@ func Run(
 			templates.DELETE("/:id", m.RequireAccess(models.PermManageCampaigns, models.APIPermWriteTemplates), h.DeleteTemplate)
 			templates.POST("/:id/duplicate", m.RequireAccess(models.PermManageCampaigns, models.APIPermWriteTemplates), h.DuplicateTemplate)
 			templates.POST("/:id/render", m.RequireAccess(models.PermViewCampaigns, models.APIPermReadTemplates), h.RenderTemplate)
+			templates.POST("/score", m.RequireAccess(models.PermViewCampaigns, models.APIPermReadTemplates), h.ScoreTemplateContent)
 		}
 
 		// CRM routes (require org)
@@ -715,6 +726,32 @@ func Run(
 		adminRoutes.POST("/warmup/appeals/:id/approve", middleware.RequireAdminPermission(models.AdminPermReviewAppeals), h.AdminApproveAppeal)
 		adminRoutes.POST("/warmup/appeals/:id/reject", middleware.RequireAdminPermission(models.AdminPermReviewAppeals), h.AdminRejectAppeal)
 
+		// Warmup content bank + offline AI generator. Reads use the warmup
+		// view permission; the A/B analytics uses the analytics permission;
+		// mutations (generate, archive/delete, settings) use ManageSettings.
+		adminRoutes.GET("/warmup-content/overview", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminWarmupContentOverview)
+		adminRoutes.GET("/warmup-content/conversations", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminListWarmupConversations)
+		adminRoutes.GET("/warmup-content/conversations/:id", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminGetWarmupConversation)
+		adminRoutes.POST("/warmup-content/conversations/:id/archive", middleware.RequireAdminPermission(models.AdminPermManageSettings), h.AdminArchiveWarmupConversation)
+		adminRoutes.POST("/warmup-content/conversations/:id/unarchive", middleware.RequireAdminPermission(models.AdminPermManageSettings), h.AdminUnarchiveWarmupConversation)
+		adminRoutes.DELETE("/warmup-content/conversations/:id", middleware.RequireAdminPermission(models.AdminPermManageSettings), h.AdminDeleteWarmupConversation)
+		adminRoutes.POST("/warmup-content/generate", middleware.RequireAdminPermission(models.AdminPermManageSettings), h.AdminGenerateWarmupContent)
+		adminRoutes.POST("/warmup-content/batch", middleware.RequireAdminPermission(models.AdminPermManageSettings), h.AdminSubmitWarmupBatch)
+		adminRoutes.POST("/warmup-content/jobs/:id/cancel", middleware.RequireAdminPermission(models.AdminPermManageSettings), h.AdminCancelWarmupBatch)
+		// Seed inbox-placement testing.
+		adminRoutes.GET("/placement/tests", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminListPlacementTests)
+		adminRoutes.GET("/placement/tests/:id", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminGetPlacementTest)
+		adminRoutes.POST("/placement/tests", middleware.RequireAdminPermission(models.AdminPermManageWarmupBans), h.AdminCreatePlacementTest)
+		adminRoutes.GET("/placement/seeds", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminListSeedMailboxes)
+		adminRoutes.GET("/placement/seeds/candidates", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminListSeedCandidates)
+		adminRoutes.POST("/placement/seeds/:id", middleware.RequireAdminPermission(models.AdminPermManageWarmupBans), h.AdminSetSeedMailbox)
+
+		adminRoutes.GET("/warmup-content/jobs", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminListWarmupGenerationJobs)
+		adminRoutes.GET("/warmup-content/jobs/:id", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminGetWarmupGenerationJob)
+		adminRoutes.GET("/warmup-content/settings", middleware.RequireAdminPermission(models.AdminPermViewWarmupPool), h.AdminGetWarmupGenerationSettings)
+		adminRoutes.PUT("/warmup-content/settings", middleware.RequireAdminPermission(models.AdminPermManageSettings), h.AdminUpdateWarmupGenerationSettings)
+		adminRoutes.GET("/warmup-content/ab", middleware.RequireAdminPermission(models.AdminPermViewAnalytics), h.AdminWarmupContentAB)
+
 		// Mailbox admin (cross-org). Reuses ViewUsers since mailboxes
 		// are tightly coupled to user/org context; a dedicated bit
 		// can be carved later if mailbox-specific actions land.
diff --git a/internal/app/advanced/service.go b/internal/app/advanced/service.go
index 49df8d1a..79021bca 100644
--- a/internal/app/advanced/service.go
+++ b/internal/app/advanced/service.go
@@ -36,6 +36,10 @@ type Service interface {
 	IngestDeliverabilityEvent(ctx context.Context, organizationID uuid.UUID, req *models.IngestDeliverabilityEventRequest) *errx.Error
 
 	ShouldSuppressRecipient(ctx context.Context, organizationID uuid.UUID, recipient string) (bool, string, *errx.Error)
+	// Unsubscribe suppresses a contact in response to a List-Unsubscribe action
+	// (one-click POST or the manual link). Always suppresses — it's an explicit
+	// recipient request, independent of the auto-suppress settings.
+	Unsubscribe(ctx context.Context, campaignID, contactID uuid.UUID) *errx.Error
 	SelectVariant(ctx context.Context, organizationID, campaignID, contactID uuid.UUID, subject, bodyHTML, bodyPlain string) (*models.VariantSelection, *errx.Error)
 	OptimizeSendTime(ctx context.Context, organizationID uuid.UUID, contact *models.Contact, base time.Time) (time.Time, *errx.Error)
 
@@ -269,6 +273,38 @@ func (s *service) ShouldSuppressRecipient(ctx context.Context, organizationID uu
 	return true, entry.Reason, nil
 }
 
+// Unsubscribe resolves the campaign + contact behind a List-Unsubscribe link and
+// suppresses the recipient org-wide. Always suppresses (an explicit recipient
+// request), then fans out the campaign.unsubscribed event for Slack/CRM.
+func (s *service) Unsubscribe(ctx context.Context, campaignID, contactID uuid.UUID) *errx.Error {
+	campaign, err := s.campaignRepo.GetByID(ctx, campaignID)
+	if err != nil || campaign == nil || campaign.OrganizationID == nil {
+		return errx.New(errx.BadRequest, "invalid unsubscribe link")
+	}
+	contact, cerr := s.contactRepo.GetByID(ctx, contactID)
+	if cerr != nil || contact == nil || contact.Email == "" {
+		return errx.New(errx.BadRequest, "invalid unsubscribe link")
+	}
+
+	if err := s.repo.UpsertSuppressedRecipient(ctx, &models.SuppressedRecipient{
+		OrganizationID: *campaign.OrganizationID,
+		Email:          contact.Email,
+		Reason:         "one-click unsubscribe",
+		Source:         models.DeliverabilityEventUnsubscribe,
+		CampaignID:     &campaignID,
+	}); err != nil {
+		return toErrx(err)
+	}
+
+	s.emit(ctx, *campaign.OrganizationID, models.WebhookEventCampaignUnsubscribed, map[string]any{
+		"campaign_id":   campaignID.String(),
+		"contact_id":    contactID.String(),
+		"contact_email": contact.Email,
+		"source":        "one_click",
+	})
+	return nil
+}
+
 func (s *service) SelectVariant(ctx context.Context, organizationID, campaignID, contactID uuid.UUID, subject, bodyHTML, bodyPlain string) (*models.VariantSelection, *errx.Error) {
 	settings, xerr := s.effectiveSettings(ctx, organizationID, campaignID)
 	if xerr != nil {
@@ -668,24 +704,25 @@ func (s *service) IngestDeliverabilityEvent(ctx context.Context, organizationID
 		_ = s.repo.MarkVariantEvent(ctx, *req.CampaignID, *req.ContactID, string(eventType))
 	}
 
-	// Record bounces in campaign progress so analytics and auto-pause work correctly
+	// Record bounces + complaints in campaign progress so analytics and the
+	// breaker work correctly. Complaints were previously never recorded, which
+	// is why complaint-rate auto-pause could never fire.
 	if req.CampaignID != nil && req.ContactID != nil && req.TaskID != nil &&
-		eventType == models.DeliverabilityEventBounce {
+		(eventType == models.DeliverabilityEventBounce || eventType == models.DeliverabilityEventComplaint) {
 		campaignTask, cErr := s.taskRepo.GetCampaignTask(ctx, *req.TaskID)
 		if cErr == nil && campaignTask != nil && campaignTask.SequenceID != nil {
-			_ = s.campaignProgressRepo.RecordEmailBounced(ctx, *req.CampaignID, *req.ContactID, *campaignTask.SequenceID)
+			switch eventType {
+			case models.DeliverabilityEventBounce:
+				_ = s.campaignProgressRepo.RecordEmailBounced(ctx, *req.CampaignID, *req.ContactID, *campaignTask.SequenceID)
+			case models.DeliverabilityEventComplaint:
+				_ = s.campaignProgressRepo.RecordEmailComplained(ctx, *req.CampaignID, *req.ContactID, *campaignTask.SequenceID)
+			}
 		}
 	}
 
-	if req.CampaignID != nil && settings.BouncePipeline.AutoPauseCampaignOnSpike &&
+	if req.CampaignID != nil &&
 		(eventType == models.DeliverabilityEventBounce || eventType == models.DeliverabilityEventComplaint) {
-		progress, pErr := s.campaignProgressRepo.GetCampaignProgress(ctx, *req.CampaignID)
-		if pErr == nil && progress != nil && progress.EmailsSent > 0 {
-			rate := float64(progress.EmailsBounced) / float64(progress.EmailsSent) * 100
-			if rate >= settings.BouncePipeline.PauseBounceRateThreshold {
-				_ = s.campaignRepo.UpdateStatus(ctx, *req.CampaignID, "paused")
-			}
-		}
+		s.evaluateCampaignBreaker(ctx, organizationID, *req.CampaignID, settings)
 	}
 
 	// Trigger warmup health re-evaluation on bounce or complaint events.
@@ -726,6 +763,85 @@ func (s *service) IngestDeliverabilityEvent(ctx context.Context, organizationID
 	return nil
 }
 
+// Campaign deliverability circuit breaker tuning. Mirrors Instantly's safeguards:
+// a minimum sample before acting (so a single early bounce can't pause a
+// campaign) and a rolling window so the breaker reacts to recent behaviour
+// rather than a campaign's lifetime average.
+const (
+	campaignBreakerWindow    = 7 * 24 * time.Hour
+	campaignBreakerMinSample = 50
+	// Early-warning band: emit a warning webhook at half the pause threshold.
+	campaignBreakerWarnRatio = 0.5
+)
+
+// evaluateCampaignBreaker auto-pauses a campaign when its rolling bounce or
+// complaint rate breaches the configured threshold, and emits an early-warning
+// webhook in the band below. Rolling-first with a cumulative fallback when the
+// recent window is too small a sample.
+func (s *service) evaluateCampaignBreaker(ctx context.Context, orgID, campaignID uuid.UUID, settings *models.AdvancedOutreachSettings) {
+	if settings == nil || !settings.BouncePipeline.AutoPauseCampaignOnSpike {
+		return
+	}
+	bounceThresh := settings.BouncePipeline.PauseBounceRateThreshold
+	complaintThresh := settings.BouncePipeline.PauseComplaintRateThreshold
+	if bounceThresh <= 0 && complaintThresh <= 0 {
+		return
+	}
+
+	sent, bounced, complained := 0, 0, 0
+	if rolling, err := s.campaignProgressRepo.GetCampaignRollingRates(ctx, campaignID, time.Now().Add(-campaignBreakerWindow)); err == nil && rolling != nil && rolling.Sent >= campaignBreakerMinSample {
+		sent, bounced, complained = rolling.Sent, rolling.Bounced, rolling.Complained
+	} else if progress, pErr := s.campaignProgressRepo.GetCampaignProgress(ctx, campaignID); pErr == nil && progress != nil {
+		sent, bounced, complained = progress.EmailsSent, progress.EmailsBounced, progress.EmailsComplained
+	}
+
+	// Not enough delivered volume yet to judge — never pause on a tiny sample.
+	if sent < campaignBreakerMinSample {
+		return
+	}
+
+	bounceRate := float64(bounced) / float64(sent) * 100
+	complaintRate := float64(complained) / float64(sent) * 100
+
+	pauseBounce := bounceThresh > 0 && bounceRate >= bounceThresh
+	pauseComplaint := complaintThresh > 0 && complaintRate >= complaintThresh
+	if pauseBounce || pauseComplaint {
+		if err := s.campaignRepo.UpdateStatus(ctx, campaignID, "paused"); err == nil {
+			s.emit(ctx, orgID, models.WebhookEventCampaignPaused, map[string]any{
+				"campaign_id":    campaignID.String(),
+				"reason":         "deliverability_auto_pause",
+				"bounce_rate":    bounceRate,
+				"complaint_rate": complaintRate,
+				"sample_size":    sent,
+				"breached":       breachLabel(pauseBounce, pauseComplaint),
+			})
+		}
+		return
+	}
+
+	warnBounce := bounceThresh > 0 && bounceRate >= bounceThresh*campaignBreakerWarnRatio
+	warnComplaint := complaintThresh > 0 && complaintRate >= complaintThresh*campaignBreakerWarnRatio
+	if warnBounce || warnComplaint {
+		s.emit(ctx, orgID, models.WebhookEventCampaignDeliverabilityWarning, map[string]any{
+			"campaign_id":    campaignID.String(),
+			"bounce_rate":    bounceRate,
+			"complaint_rate": complaintRate,
+			"sample_size":    sent,
+		})
+	}
+}
+
+func breachLabel(bounce, complaint bool) string {
+	switch {
+	case bounce && complaint:
+		return "bounce_and_complaint"
+	case bounce:
+		return "bounce"
+	default:
+		return "complaint"
+	}
+}
+
 func (s *service) OptimizeSendTime(ctx context.Context, organizationID uuid.UUID, contact *models.Contact, base time.Time) (time.Time, *errx.Error) {
 	settings, err := s.repo.GetOutreachSettings(ctx, organizationID)
 	if err != nil {
diff --git a/internal/app/consumer/event_flags_update.go b/internal/app/consumer/event_flags_update.go
index 73d198b2..10ccf50f 100644
--- a/internal/app/consumer/event_flags_update.go
+++ b/internal/app/consumer/event_flags_update.go
@@ -14,6 +14,23 @@ import (
 )
 
 func (s *JobsService) HandleFlagsAdd(ctx context.Context, e *models.JobEventFlags) error {
+	// Tampering check first: verified warmup mail is NOT in the unibox, so we
+	// detect it via the warmup_received record. If the recipient marked a
+	// warmup email as spam, that harms the pool — penalise the sender for the
+	// spam signal AND ban the harmer (they can appeal). Warmup mail isn't
+	// tracked in the unibox, so there's nothing else to do for it.
+	if s.WarmupRepo != nil {
+		if rec, _ := s.WarmupRepo.GetWarmupReceived(ctx, e.EmailID, e.ID); rec != nil {
+			if containsSpamFlag(e.Flags) && s.WarmupService != nil {
+				hSender, _ := s.WarmupService.ApplySpamReport(ctx, e.EmailID, rec.SenderAccountID, rec.MessageID, "user_complaint")
+				s.markRiskBandFromWarmupHealth(ctx, rec.SenderAccountID, hSender)
+				hHarmer, _ := s.WarmupService.RecordTampering(ctx, e.EmailID, rec.MessageID, "spam_flag")
+				s.markRiskBandFromWarmupHealth(ctx, e.EmailID, hHarmer)
+			}
+			return nil
+		}
+	}
+
 	email, err := s.UniboxRepository.GetByID(ctx, e.UserID, e.ID)
 	if err != nil {
 		CaptureError(e.UserID, e.EmailID, fmt.Errorf("Email (%s): %w", e.ID.String(), err))
@@ -31,8 +48,11 @@ func (s *JobsService) HandleFlagsAdd(ctx context.Context, e *models.JobEventFlag
 						health, _ := s.WarmupService.ApplySpamReport(ctx, e.EmailID, token.SenderAccountID, email.MessageID, "user_complaint")
 						s.markRiskBandFromWarmupHealth(ctx, token.SenderAccountID, health)
 					} else {
+						// Degraded mode (no warmup service): record the raw signal
+						// only. Blocking is owned solely by the banded health model
+						// (evaluateMetrics) so all blocks carry a blocked_until +
+						// appeal path; the old permanent auto-block diverged from it.
 						_, _ = s.WarmupRepo.IncrementSpamScore(ctx, token.SenderAccountID, 10)
-						s.checkAndAutoBlock(ctx, token.SenderAccountID)
 						s.markRiskBandFromWarmupHealth(ctx, token.SenderAccountID, nil)
 					}
 				}
diff --git a/internal/app/consumer/event_new_email.go b/internal/app/consumer/event_new_email.go
index 52735de8..28d54a0c 100644
--- a/internal/app/consumer/event_new_email.go
+++ b/internal/app/consumer/event_new_email.go
@@ -2,12 +2,14 @@ package jobs
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"slices"
 	"strings"
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
 	"github.com/warmbly/warmbly/internal/config"
 	"github.com/warmbly/warmbly/internal/infrastructure/pubsub"
 	"github.com/warmbly/warmbly/internal/models"
@@ -114,13 +116,24 @@ func (s *JobsService) handleWarmupEmail(ctx context.Context, e *models.JobEventN
 	// Valid! Consume the token
 	s.WarmupRepo.ConsumeWarmupToken(ctx, tokenUUID)
 
+	// Record the receipt so a later deletion or spam-flag of THIS message can be
+	// attributed back to warmup and to the sender. Verified warmup mail is not
+	// stored in the unibox, so this is the only record that the message was a
+	// warmup email.
+	if e.Message != nil {
+		_ = s.WarmupRepo.RecordWarmupReceived(ctx, e.Message.EmailID, e.Message.ID, e.Message.MessageID, token.SenderAccountID)
+	}
+
 	// If the warmup mail arrived in a Junk/Spam state, record a
 	// spam_placement event against the sender. This is distinct from a
 	// user_complaint (which fires later via HandleFlagsAdd when a recipient
 	// flags an already-delivered message) because nobody actively rejected
 	// it — the provider classifier placed it there on arrival.
 	if containsSpamFlag(e.Message.Flags) && s.WarmupService != nil {
-		health, _ := s.WarmupService.RecordSpamPlacement(ctx, e.Message.EmailID, token.SenderAccountID, e.Message.MessageID)
+		// Record which recipient provider/domain filtered it into spam so the
+		// placement signal can be segmented per provider, not one flat rate.
+		provider, domain := s.recipientProviderDomain(ctx, e.Message.EmailID)
+		health, _ := s.WarmupService.RecordSpamPlacement(ctx, e.Message.EmailID, token.SenderAccountID, e.Message.MessageID, token.ContentSource, provider, domain)
 		s.markRiskBandFromWarmupHealth(ctx, token.SenderAccountID, health)
 	}
 
@@ -129,28 +142,96 @@ func (s *JobsService) handleWarmupEmail(ctx context.Context, e *models.JobEventN
 	return true, nil
 }
 
-// performWarmupActions publishes warmup action events to the worker
+// performWarmupActions publishes warmup action events to the worker. Action
+// selection is probabilistic and per-mailbox (see engagementPlan) so the pool
+// doesn't behave in detectable lockstep, with a randomised recipient-side
+// dwell before the actions run.
 func (s *JobsService) performWarmupActions(ctx context.Context, e *models.JobEventNewEmail) {
 	if s.Publisher == nil {
 		return
 	}
 
-	action := &models.WarmupEmailAction{
+	settings := s.getGenerationSettings(ctx)
+	actions, delaySeconds := engagementPlan(e.Message.EmailID, settings.Engagement)
+	immediate, delayed := splitEngagementLegs(actions)
+
+	base := models.WarmupEmailAction{
 		UserID:             e.UserID,
 		EmailID:            e.Message.EmailID,
 		GmailID:            e.Message.GmailID,
 		UID:                e.Message.UID,
 		MailboxUIDValidity: e.Message.Mailbox,
-		Actions:            []string{"move_to_warmbly", "mark_read", "remove_from_spam", "mark_important"},
 	}
 
-	// Look up the worker ID from the email account
+	// Resolve the receiving mailbox's worker once.
+	var workerID *uuid.UUID
 	if s.EmailRepository != nil {
-		account, xerr := s.EmailRepository.GetByID(ctx, e.Message.EmailID)
-		if xerr == nil && account != nil && account.WorkerID != nil {
-			s.Publisher.PublishWarmupAction(ctx, *account.WorkerID, action)
+		if account, xerr := s.EmailRepository.GetByID(ctx, e.Message.EmailID); xerr == nil && account != nil {
+			workerID = account.WorkerID
 		}
 	}
+	if workerID == nil {
+		// No assigned worker (mid-migration / just-unassigned / assignment lag):
+		// the warmup mail can't be foldered or engaged with. Log instead of
+		// dropping silently so the gap is observable.
+		log.Warn().
+			Str("email_id", e.Message.EmailID.String()).
+			Msg("Warmup actions skipped: recipient mailbox has no assigned worker")
+		return
+	}
+
+	// Immediate, durable leg (folder + spam-rescue): publish to the worker now.
+	if len(immediate) > 0 {
+		act := base
+		act.Actions = immediate
+		s.Publisher.PublishWarmupAction(ctx, *workerID, &act)
+	}
+
+	if len(delayed) == 0 {
+		return
+	}
+
+	act := base
+	act.Actions = delayed
+
+	// Delayed leg (read / important / star): with no dwell (or no durable store
+	// available) publish immediately; otherwise persist it to the durable
+	// schedule so a worker restart mid-dwell can't drop it. The poller publishes
+	// it when fire_at passes.
+	if delaySeconds <= 0 || s.WarmupEngagementRepo == nil {
+		s.Publisher.PublishWarmupAction(ctx, *workerID, &act)
+		return
+	}
+
+	payload, err := json.Marshal(act)
+	if err != nil {
+		log.Warn().Err(err).Str("email_id", e.Message.EmailID.String()).Msg("Failed to marshal delayed warmup engagement; publishing immediately")
+		s.Publisher.PublishWarmupAction(ctx, *workerID, &act)
+		return
+	}
+	fireAt := time.Now().Add(time.Duration(delaySeconds) * time.Second)
+	if err := s.WarmupEngagementRepo.EnqueuePendingEngagement(ctx, e.Message.EmailID, payload, fireAt); err != nil {
+		log.Warn().Err(err).Str("email_id", e.Message.EmailID.String()).Msg("Failed to enqueue delayed warmup engagement; publishing immediately")
+		s.Publisher.PublishWarmupAction(ctx, *workerID, &act)
+	}
+}
+
+// recipientProviderDomain best-effort resolves a recipient mailbox's provider
+// ("google"/"smtp_imap") and email domain for the per-provider placement
+// dimension. Returns empty strings when the account can't be loaded.
+func (s *JobsService) recipientProviderDomain(ctx context.Context, accountID uuid.UUID) (string, string) {
+	if s.EmailRepository == nil {
+		return "", ""
+	}
+	acc, err := s.EmailRepository.GetByID(ctx, accountID)
+	if err != nil || acc == nil {
+		return "", ""
+	}
+	domain := ""
+	if at := strings.LastIndex(acc.Email, "@"); at >= 0 {
+		domain = strings.ToLower(acc.Email[at+1:])
+	}
+	return acc.Provider, domain
 }
 
 func (s *JobsService) applyInvalidWarmupAttempt(ctx context.Context, accountID uuid.UUID, attemptedToken string, scoreDelta int) {
@@ -165,38 +246,19 @@ func (s *JobsService) applyInvalidWarmupAttempt(ctx context.Context, accountID u
 		return
 	}
 
+	// Degraded mode (no warmup service): record the raw signal only. All
+	// blocking is owned by the banded health model (evaluateMetrics), which
+	// already enforces the invalid-token threshold with a blocked_until and an
+	// appeal path. The old checkAndAutoBlock issued permanent blocks
+	// (blocked_until = NULL) that UpdateParticipantHealth then refused to ever
+	// re-evaluate — a divergent dead-end that is now removed.
 	_ = s.WarmupRepo.RecordInvalidTokenAttempt(ctx, accountID, attemptedToken)
 	if scoreDelta > 0 {
 		_, _ = s.WarmupRepo.IncrementSpamScore(ctx, accountID, scoreDelta)
 	}
-
-	s.checkAndAutoBlock(ctx, accountID)
 	s.markRiskBandFromWarmupHealth(ctx, accountID, nil)
 }
 
-// checkAndAutoBlock checks if an account should be auto-blocked based on invalid token attempts or spam score
-func (s *JobsService) checkAndAutoBlock(ctx context.Context, accountID uuid.UUID) {
-	if s.WarmupRepo == nil {
-		return
-	}
-
-	since := time.Now().Add(-24 * time.Hour)
-	attempts, _ := s.WarmupRepo.CountRecentInvalidAttempts(ctx, accountID, since)
-	if attempts >= 3 {
-		_ = s.WarmupRepo.BlockFromPool(ctx, accountID,
-			fmt.Sprintf("Auto-blocked: %d invalid warmup token attempts in 24h", attempts))
-		s.markRiskBandFromWarmupHealth(ctx, accountID, nil)
-		return
-	}
-
-	score, _ := s.WarmupRepo.GetSpamScore(ctx, accountID)
-	if score > 50 {
-		_ = s.WarmupRepo.BlockFromPool(ctx, accountID,
-			fmt.Sprintf("Auto-blocked: spam score %d exceeds threshold", score))
-		s.markRiskBandFromWarmupHealth(ctx, accountID, nil)
-	}
-}
-
 // containsSpamFlag checks if any flag is a spam flag
 func containsSpamFlag(flags []string) bool {
 	spamFlags := []string{"\\Junk", "\\Spam", "SPAM", "Junk"}
diff --git a/internal/app/consumer/event_remove_email.go b/internal/app/consumer/event_remove_email.go
new file mode 100644
index 00000000..5cf44bc4
--- /dev/null
+++ b/internal/app/consumer/event_remove_email.go
@@ -0,0 +1,31 @@
+package jobs
+
+import (
+	"context"
+
+	"github.com/warmbly/warmbly/internal/models"
+)
+
+// HandleRemoveEmail processes a message removal observed during mailbox sync.
+//
+// Tampering protection: if the removed message was a warmup email (tracked in
+// warmup_received), the recipient deleted pool warmup mail — that harms the
+// pool, so we record a tampering strike against the mailbox and ban it from
+// warmup once the threshold is crossed. The owner can appeal.
+//
+// It also drops the local unibox entry for the removed message (best-effort).
+func (s *JobsService) HandleRemoveEmail(ctx context.Context, e *models.JobEventRemoveEmail) error {
+	if s.WarmupRepo != nil {
+		if rec, _ := s.WarmupRepo.GetWarmupReceived(ctx, e.EmailID, e.ID); rec != nil {
+			if s.WarmupService != nil {
+				health, _ := s.WarmupService.RecordTampering(ctx, e.EmailID, rec.MessageID, "deletion")
+				s.markRiskBandFromWarmupHealth(ctx, e.EmailID, health)
+			}
+		}
+	}
+
+	if s.UniboxRepository != nil {
+		_ = s.UniboxRepository.Delete(ctx, e.UserID, e.ID)
+	}
+	return nil
+}
diff --git a/internal/app/consumer/events.go b/internal/app/consumer/events.go
index 6820763d..53904832 100644
--- a/internal/app/consumer/events.go
+++ b/internal/app/consumer/events.go
@@ -22,6 +22,7 @@ func (w *JobsService) InitEvents() {
 	w.eventHandlers = make(map[models.JobEventType]func(ctx context.Context, body any) error)
 	Register(w, models.JobEventTypeNewEmail, w.HandleNewEmail)
 	Register(w, models.JobEventTypeEmailUpdate, w.HandleUpdateEmail)
+	Register(w, models.JobEventTypeRemoveEmail, w.HandleRemoveEmail)
 	Register(w, models.JobEventTypeFlagsAdd, w.HandleFlagsAdd)
 	Register(w, models.JobEventTypeFlagsRemove, w.HandleFlagsRemove)
 	Register(w, models.JobEventTypeMailboxUpdate, w.HandleMailboxUpdate)
diff --git a/internal/app/consumer/service.go b/internal/app/consumer/service.go
index e9232511..e71d5b5d 100644
--- a/internal/app/consumer/service.go
+++ b/internal/app/consumer/service.go
@@ -22,6 +22,8 @@ type JobsService struct {
 	EmailHistoryIDRepository    repository.EmailHistoryIDRepository
 	EmailAccountErrorRepository repository.EmailAccountErrorRepository
 	WarmupRepo                  repository.WarmupRepository
+	WarmupContentRepo           repository.WarmupContentRepository
+	WarmupEngagementRepo        repository.WarmupEngagementRepository
 	WarmupService               warmupapp.Service
 	WorkerRepo                  repository.WorkerRepository
 
diff --git a/internal/app/consumer/warmup_engagement.go b/internal/app/consumer/warmup_engagement.go
new file mode 100644
index 00000000..111183fb
--- /dev/null
+++ b/internal/app/consumer/warmup_engagement.go
@@ -0,0 +1,134 @@
+package jobs
+
+import (
+	"context"
+	"math/rand"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/warmbly/warmbly/internal/models"
+	"github.com/warmbly/warmbly/internal/pkg/warmpersona"
+)
+
+// engagementSettingsCache is a process-wide TTL cache over the warmup
+// generation settings so performWarmupActions doesn't read Postgres on every
+// incoming warmup email.
+var (
+	engSettingsMu      sync.RWMutex
+	engSettingsVal     models.WarmupGenerationSettings
+	engSettingsFetched time.Time
+)
+
+// getGenerationSettings returns the warmup generation settings (engagement
+// rates live here), cached for 60s. Falls back to defaults when unconfigured.
+func (s *JobsService) getGenerationSettings(ctx context.Context) models.WarmupGenerationSettings {
+	if s.WarmupContentRepo == nil {
+		return models.DefaultWarmupGenerationSettings()
+	}
+	engSettingsMu.RLock()
+	fresh := !engSettingsFetched.IsZero() && time.Since(engSettingsFetched) < 60*time.Second
+	val := engSettingsVal
+	engSettingsMu.RUnlock()
+	if fresh {
+		return val
+	}
+	set, err := s.WarmupContentRepo.GetGenerationSettings(ctx)
+	if err != nil || set == nil {
+		return models.DefaultWarmupGenerationSettings()
+	}
+	engSettingsMu.Lock()
+	engSettingsVal = *set
+	engSettingsFetched = time.Now()
+	engSettingsMu.Unlock()
+	return *set
+}
+
+// engagementPlan decides which recipient-side warmup actions to perform and
+// how long to wait first ("dwell"). Two goals:
+//   - break the uniform "every account marks important, instantly" bot
+//     signature: rates are probabilistic and biased per-mailbox by persona, so
+//     the pool shows a natural distribution rather than lockstep behaviour;
+//   - keep the strong positive signals: foldering always happens, reads happen
+//     most of the time, and spam-rescue (the "not spam" signal warmup exists
+//     for) fires at the configured rate but only actually executes when the
+//     message really landed in spam (the worker guards this).
+//
+// The dwell delay is applied recipient-side by the worker so opens/reads don't
+// all happen milliseconds after delivery.
+func engagementPlan(accountID uuid.UUID, e models.WarmupEngagementSettings) (actions []string, delaySeconds int) {
+	p := warmpersona.For(accountID)
+
+	// Foldering is organisational, not an engagement fingerprint — always do it.
+	actions = append(actions, "move_to_warmbly")
+
+	if rollPct(e.MarkReadRate, p.Bias("read", 0.85, 1.15)) {
+		actions = append(actions, "mark_read")
+	}
+	// Spam-rescue: the worker only actually moves it if it's in spam.
+	if rollPct(e.SpamRescueRate, p.Bias("rescue", 0.8, 1.2)) {
+		actions = append(actions, "remove_from_spam")
+	}
+	if rollPct(e.MarkImportantRate, p.Bias("important", 0.7, 1.3)) {
+		actions = append(actions, "mark_important")
+	}
+	// Starring is a separate, lower-rate positive signal (Gmail STARRED). On
+	// IMAP the worker no-ops it because \Flagged is already covered by
+	// mark_important — so it never double-flags the same message.
+	if rollPct(e.StarRate, p.Bias("star", 0.6, 1.4)) {
+		actions = append(actions, "star")
+	}
+
+	delaySeconds = dwellSeconds(e.MinDwellSeconds, e.MaxDwellSeconds, p.Bias("dwell", 0.7, 1.3))
+	return actions, delaySeconds
+}
+
+// splitEngagementLegs separates the reputation-critical, durable actions
+// (foldering + spam-rescue, published immediately) from the low-stakes
+// engagement-timing signals (read / important / star) that carry the
+// recipient-side dwell. The dwell is now applied durably in the control plane
+// (a fire_at row drained by the poller), not by an in-process worker timer, so
+// a worker restart can no longer drop the delayed leg.
+func splitEngagementLegs(actions []string) (immediate, delayed []string) {
+	for _, a := range actions {
+		if a == "move_to_warmbly" || a == "remove_from_spam" {
+			immediate = append(immediate, a)
+		} else {
+			delayed = append(delayed, a)
+		}
+	}
+	return immediate, delayed
+}
+
+// rollPct rolls a biased percentage chance. The persona bias nudges a given
+// mailbox consistently above/below the configured rate so mailboxes differ.
+func rollPct(rate int, bias float64) bool {
+	if rate <= 0 {
+		return false
+	}
+	if rate >= 100 {
+		return true
+	}
+	effective := float64(rate) * bias
+	return rand.Float64()*100 < effective
+}
+
+// dwellSeconds returns a randomised delay within [min,max], nudged by persona.
+func dwellSeconds(minS, maxS int, bias float64) int {
+	if maxS <= 0 || maxS < minS {
+		return 0
+	}
+	span := maxS - minS
+	base := minS
+	if span > 0 {
+		base += rand.Intn(span + 1)
+	}
+	out := int(float64(base) * bias)
+	if out < minS {
+		out = minS
+	}
+	if out > maxS {
+		out = maxS
+	}
+	return out
+}
diff --git a/internal/app/consumer/warmup_engagement_poller.go b/internal/app/consumer/warmup_engagement_poller.go
new file mode 100644
index 00000000..503e662e
--- /dev/null
+++ b/internal/app/consumer/warmup_engagement_poller.go
@@ -0,0 +1,66 @@
+package jobs
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	"github.com/rs/zerolog/log"
+
+	"github.com/warmbly/warmbly/internal/models"
+)
+
+// StartWarmupEngagementPoller drains due delayed-engagement rows and publishes
+// them to the worker. This is the durable replacement for the worker's old
+// in-process dwell timer: because the schedule lives in Postgres, a worker (or
+// consumer) restart can no longer drop the delayed read/important/star signals.
+func (s *JobsService) StartWarmupEngagementPoller(ctx context.Context, interval time.Duration) {
+	if s.WarmupEngagementRepo == nil || s.Publisher == nil {
+		return
+	}
+
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			s.drainDueEngagements(ctx)
+		}
+	}
+}
+
+func (s *JobsService) drainDueEngagements(ctx context.Context) {
+	cctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+	defer cancel()
+
+	due, err := s.WarmupEngagementRepo.ClaimDuePendingEngagements(cctx, 200)
+	if err != nil {
+		log.Warn().Err(err).Msg("warmup engagement poller: claim failed")
+		return
+	}
+
+	for _, p := range due {
+		var action models.WarmupEmailAction
+		if err := json.Unmarshal(p.Payload, &action); err != nil {
+			log.Warn().Err(err).Str("id", p.ID.String()).Msg("warmup engagement poller: bad payload, dropping")
+			continue
+		}
+
+		// Re-resolve the worker at fire time so a mid-dwell reassignment routes
+		// to the current worker (the payload deliberately doesn't bake one in).
+		if s.EmailRepository == nil {
+			continue
+		}
+		account, xerr := s.EmailRepository.GetByID(cctx, action.EmailID)
+		if xerr != nil || account == nil || account.WorkerID == nil {
+			// Mailbox now unassigned — drop (best-effort low-stakes engagement).
+			continue
+		}
+
+		action.DelaySeconds = 0 // dwell already elapsed; run immediately
+		s.Publisher.PublishWarmupAction(cctx, *account.WorkerID, &action)
+	}
+}
diff --git a/internal/app/emailverify/service.go b/internal/app/emailverify/service.go
new file mode 100644
index 00000000..e9f97f30
--- /dev/null
+++ b/internal/app/emailverify/service.go
@@ -0,0 +1,82 @@
+// Package emailverify (app layer) orchestrates pre-send email verification:
+// it loads contacts, runs them through a pkg/emailverify.Verifier, and persists
+// the result back onto the contact. This is the control-plane home for
+// verification — the SMTP RCPT probe inside the Verifier dials remote MX hosts
+// on :25 and must never run from a worker (a sending IP). See
+// internal/pkg/emailverify for the probing details and the in-repo-vs-paid
+// backend split.
+package emailverify
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+
+	"github.com/warmbly/warmbly/internal/errx"
+	"github.com/warmbly/warmbly/internal/pkg/emailverify"
+	"github.com/warmbly/warmbly/internal/repository"
+)
+
+// Service verifies contact email addresses before they are ever sent to.
+type Service interface {
+	// VerifyContact verifies a single stored contact by id and persists the
+	// result. Returns the Result so callers (admin/on-demand) can surface it.
+	VerifyContact(ctx context.Context, contactID uuid.UUID) (emailverify.Result, *errx.Error)
+
+	// VerifyAddress verifies an arbitrary address without touching the DB. Used
+	// by the on-demand handler for addresses that aren't stored contacts yet.
+	VerifyAddress(ctx context.Context, email string) emailverify.Result
+
+	// VerifyPending verifies up to `limit` not-yet-checked contacts, persisting
+	// each result. Returns the number processed. Driven by the ticker scheduler.
+	VerifyPending(ctx context.Context, limit int) (int, *errx.Error)
+}
+
+type service struct {
+	repo     repository.ContactRepository
+	verifier emailverify.Verifier
+}
+
+// NewService wires the verification service. verifier is the pluggable backend:
+// the in-house emailverify.SMTPVerifier in dev/self-host, or a paid provider
+// (ZeroBounce/NeverBounce/Bouncer) implementing the same interface in prod.
+func NewService(repo repository.ContactRepository, verifier emailverify.Verifier) Service {
+	return &service{repo: repo, verifier: verifier}
+}
+
+func (s *service) VerifyAddress(ctx context.Context, email string) emailverify.Result {
+	return s.verifier.Verify(ctx, email)
+}
+
+func (s *service) VerifyContact(ctx context.Context, contactID uuid.UUID) (emailverify.Result, *errx.Error) {
+	contact, xerr := s.repo.GetByID(ctx, contactID)
+	if xerr != nil {
+		return emailverify.Result{}, xerr
+	}
+	res := s.verifier.Verify(ctx, contact.Email)
+	if xerr := s.repo.UpdateContactVerification(ctx, contactID, res); xerr != nil {
+		return res, xerr
+	}
+	return res, nil
+}
+
+func (s *service) VerifyPending(ctx context.Context, limit int) (int, *errx.Error) {
+	contacts, xerr := s.repo.ListUnverifiedContacts(ctx, limit)
+	if xerr != nil {
+		return 0, xerr
+	}
+	processed := 0
+	for i := range contacts {
+		// Honour cancellation between addresses; each probe can take seconds.
+		if err := ctx.Err(); err != nil {
+			break
+		}
+		res := s.verifier.Verify(ctx, contacts[i].Email)
+		if xerr := s.repo.UpdateContactVerification(ctx, contacts[i].ID, res); xerr != nil {
+			// Skip this one; a transient DB error shouldn't abort the whole tick.
+			continue
+		}
+		processed++
+	}
+	return processed, nil
+}
diff --git a/internal/app/placement/service.go b/internal/app/placement/service.go
new file mode 100644
index 00000000..629d27c6
--- /dev/null
+++ b/internal/app/placement/service.go
@@ -0,0 +1,277 @@
+// Package placement implements seed inbox-placement testing: send a tokenized
+// copy of a real template through a real sender to a panel of Warmbly-controlled
+// SEED mailboxes, then classify where each landed (Inbox / Spam / Promotions /
+// other) per provider.
+//
+// Classification reuses the warmup landing-folder detection (the same `\Junk`
+// /spam-flag logic in the consumer) and reads it out of the UNIBOX — the
+// received-mail store the worker syncs every mailbox into. A seed is an
+// ordinary connected + synced email_account flagged is_seed, so its received
+// mail lands in the unibox like any other mailbox; the poller (ClassifyPending)
+// looks up the test token in the seed's unibox entries and reads the folder
+// flags. No consumer hot-path hook is added.
+package placement
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"github.com/warmbly/warmbly/internal/repository"
+	"github.com/warmbly/warmbly/internal/tasks"
+)
+
+// classifyTimeout bounds how long a result stays pending before the poller
+// gives up and records it as "other" (the message never showed up in the
+// seed's unibox — dropped, blocked at the gateway, or sync lag past the
+// window). Tests are marked completed once every result resolves or this
+// elapses.
+const classifyTimeout = 2 * time.Hour
+
+// subjectTokenMarker prefixes the token embedded in the test subject. The
+// worker injects only the warmup verify header (config.WarmupVerifyHeader),
+// which this control-plane package can't change, so the subject is the token
+// carrier that reliably survives sync into the unibox. Format:
+//
+//	<subject>  [wmpl:<token>]
+//
+// The marker is matched verbatim by the repo's FindTokenInUnibox subject LIKE.
+const subjectTokenMarker = "wmpl:"
+
+// Service is the seed inbox-placement testing service.
+type Service interface {
+	// CreateTest generates a unique token, persists the test plus one pending
+	// result per active seed, and sends a tokenized copy of the template from
+	// the sender to every active seed address.
+	CreateTest(ctx context.Context, orgID *uuid.UUID, senderAccountID uuid.UUID, subject, bodyPlain, bodyHTML string) (*repository.PlacementTest, error)
+	// ClassifyPending resolves pending results by looking up each test's token
+	// in the seed's unibox entries and classifying the folder from flags. It
+	// marks a test completed once all its results resolve or the timeout passes.
+	ClassifyPending(ctx context.Context) error
+}
+
+type service struct {
+	repo      repository.PlacementRepository
+	emailRepo repository.EmailRepository
+	sender    tasks.EmailSender
+}
+
+// NewService wires the placement service. emailRepo resolves sender/seed
+// mailbox rows; sender is the existing send primitive (publishes a SendEmail
+// event to the assigned worker over Kafka — no Cloud Task / task row needed
+// for a one-off probe).
+func NewService(repo repository.PlacementRepository, emailRepo repository.EmailRepository, sender tasks.EmailSender) Service {
+	return &service{repo: repo, emailRepo: emailRepo, sender: sender}
+}
+
+func (s *service) CreateTest(ctx context.Context, orgID *uuid.UUID, senderAccountID uuid.UUID, subject, bodyPlain, bodyHTML string) (*repository.PlacementTest, error) {
+	subject = strings.TrimSpace(subject)
+	if subject == "" {
+		return nil, errors.New("subject is required")
+	}
+	if bodyPlain == "" && bodyHTML == "" {
+		return nil, errors.New("a plaintext or HTML body is required")
+	}
+
+	sender, xerr := s.emailRepo.GetByID(ctx, senderAccountID)
+	if xerr != nil || sender == nil {
+		return nil, fmt.Errorf("sender account not found")
+	}
+	if sender.WorkerID == nil {
+		return nil, fmt.Errorf("sender account %s has no assigned worker", senderAccountID)
+	}
+
+	seeds, err := s.repo.ListSeedAccounts(ctx, true)
+	if err != nil {
+		return nil, fmt.Errorf("list seed accounts: %w", err)
+	}
+	if len(seeds) == 0 {
+		return nil, errors.New("no active seed mailboxes are configured")
+	}
+
+	token := uuid.NewString()
+	test := &repository.PlacementTest{
+		ID:              uuid.New(),
+		OrganizationID:  orgID,
+		SenderAccountID: senderAccountID,
+		Subject:         subject,
+		BodyPlain:       bodyPlain,
+		BodyHTML:        bodyHTML,
+		Token:           token,
+		Status:          repository.PlacementStatusPending,
+	}
+	if err := s.repo.CreateTest(ctx, test); err != nil {
+		return nil, fmt.Errorf("create test: %w", err)
+	}
+
+	// Tokenized subject: the token lives in a marker the unibox subject search
+	// can match. Keeping the original subject first means the seed inbox shows
+	// the real template subject for classification fidelity.
+	taggedSubject := fmt.Sprintf("%s [%s%s]", subject, subjectTokenMarker, token)
+
+	sentCount := 0
+	for _, seed := range seeds {
+		if err := s.repo.CreatePendingResult(ctx, test.ID, seed.ID, seed.Provider); err != nil {
+			log.Warn().Err(err).
+				Str("test_id", test.ID.String()).
+				Str("seed_id", seed.ID.String()).
+				Msg("placement: failed to create pending result")
+			continue
+		}
+
+		msg := tasks.EmailMessage{
+			From:      sender.Email,
+			To:        []string{seed.Email},
+			Subject:   taggedSubject,
+			BodyPlain: bodyPlain,
+			BodyHTML:  bodyHTML,
+			MessageID: fmt.Sprintf("<%s@%s>", uuid.NewString(), domainOf(sender.Email)),
+			UserID:    mustUserID(sender.UserID),
+			// We also pass the token through the warmup verify header lane via
+			// WarmupToken so that, IF a future worker change starts persisting
+			// that header into unibox flags, the same token is already present.
+			// Today the header is consumed by the warmup detector and not stored,
+			// so the subject marker remains the authoritative carrier.
+			WarmupToken: token,
+		}
+
+		if err := s.sender.Send(ctx, uuid.New(), msg, *sender); err != nil {
+			log.Warn().Err(err).
+				Str("test_id", test.ID.String()).
+				Str("seed_id", seed.ID.String()).
+				Msg("placement: failed to publish test send to worker")
+			continue
+		}
+		sentCount++
+	}
+
+	if sentCount == 0 {
+		// Nothing went out — mark the test completed immediately so it doesn't
+		// dangle pending forever. Results remain "pending" for visibility.
+		now := time.Now()
+		_ = s.repo.SetTestStatus(ctx, test.ID, repository.PlacementStatusCompleted, &now)
+		return nil, errors.New("failed to send any placement probes")
+	}
+
+	return test, nil
+}
+
+func (s *service) ClassifyPending(ctx context.Context) error {
+	jobs, err := s.repo.ListPendingResults(ctx, 200)
+	if err != nil {
+		return fmt.Errorf("list pending results: %w", err)
+	}
+
+	touchedTests := map[uuid.UUID]struct{}{}
+
+	for _, j := range jobs {
+		touchedTests[j.TestID] = struct{}{}
+
+		match, err := s.repo.FindTokenInUnibox(ctx, j.SeedUserID, j.SeedAccountID, j.Token, j.TestCreatedAt)
+		if err != nil {
+			log.Warn().Err(err).Str("result_id", j.ResultID.String()).Msg("placement: unibox lookup failed")
+			continue
+		}
+
+		if match != nil {
+			folder := classifyFolder(match.Flags)
+			rawFlags := strings.Join(match.Flags, ",")
+			if err := s.repo.RecordResult(ctx, j.ResultID, folder, rawFlags, time.Now()); err != nil {
+				log.Warn().Err(err).Str("result_id", j.ResultID.String()).Msg("placement: failed to record result")
+			}
+			continue
+		}
+
+		// Not found yet. If the test is older than the classify timeout, the
+		// probe almost certainly never landed in this seat — record "other"
+		// (could be a gateway block, a hard bounce, or a sync gap) so the test
+		// can complete instead of hanging pending forever.
+		if time.Since(j.TestCreatedAt) > classifyTimeout {
+			if err := s.repo.RecordResult(ctx, j.ResultID, repository.PlacementFolderOther, "timeout", time.Now()); err != nil {
+				log.Warn().Err(err).Str("result_id", j.ResultID.String()).Msg("placement: failed to timeout result")
+			}
+		}
+	}
+
+	// Mark any touched test completed once it has no pending results left.
+	for testID := range touchedTests {
+		pending, err := s.repo.CountPendingForTest(ctx, testID)
+		if err != nil {
+			continue
+		}
+		if pending == 0 {
+			now := time.Now()
+			_ = s.repo.SetTestStatus(ctx, testID, repository.PlacementStatusCompleted, &now)
+		}
+	}
+
+	return nil
+}
+
+// classifyFolder maps a synced message's flags/labels to a placement folder.
+// It reuses the SAME spam-flag detection the warmup consumer uses
+// (containsSpamFlag: \Junk / \Spam / SPAM / Junk).
+//
+// Promotions detection requires a Gmail CATEGORY_PROMOTIONS label to be present
+// in the flags. NOTE: the current Gmail sync only maps UNREAD/STARRED/IMPORTANT
+// /DRAFT into flags (internal/client/goog/message.go GmailMessageToEmailData)
+// and does not capture CATEGORY_* tab labels. Capturing those needs a Gmail
+// category-label sync change in the worker — a deliberate follow-up. Until then
+// a Gmail-tab message reads as "inbox" here, which is the correct conservative
+// default (it did reach the inbox, just a tab).
+func classifyFolder(flags []string) string {
+	if containsSpamFlag(flags) {
+		return repository.PlacementFolderSpam
+	}
+	if hasPromotionsLabel(flags) {
+		return repository.PlacementFolderPromotions
+	}
+	return repository.PlacementFolderInbox
+}
+
+// containsSpamFlag mirrors internal/app/consumer/event_new_email.go's
+// containsSpamFlag so placement classification and warmup spam-placement
+// detection agree on what "landed in spam" means.
+func containsSpamFlag(flags []string) bool {
+	spamFlags := []string{"\\Junk", "\\Spam", "SPAM", "Junk"}
+	for _, f := range flags {
+		if slices.Contains(spamFlags, f) {
+			return true
+		}
+	}
+	return false
+}
+
+// hasPromotionsLabel reports whether a Gmail CATEGORY_PROMOTIONS label is
+// present. See classifyFolder for the sync caveat.
+func hasPromotionsLabel(flags []string) bool {
+	for _, f := range flags {
+		if strings.EqualFold(f, "CATEGORY_PROMOTIONS") {
+			return true
+		}
+	}
+	return false
+}
+
+func domainOf(email string) string {
+	if at := strings.LastIndex(email, "@"); at >= 0 && at < len(email)-1 {
+		return email[at+1:]
+	}
+	return "localhost"
+}
+
+// mustUserID parses the email account's string UserID, returning uuid.Nil on a
+// malformed value (the send still goes out; the worker keys off the account).
+func mustUserID(s string) uuid.UUID {
+	id, err := uuid.Parse(s)
+	if err != nil {
+		return uuid.Nil
+	}
+	return id
+}
diff --git a/internal/app/provisioning/rdns_verify.go b/internal/app/provisioning/rdns_verify.go
new file mode 100644
index 00000000..9e37b191
--- /dev/null
+++ b/internal/app/provisioning/rdns_verify.go
@@ -0,0 +1,47 @@
+package provisioning
+
+import (
+	"context"
+	"net"
+	"strings"
+	"time"
+)
+
+const rdnsLookupTimeout = 5 * time.Second
+
+// VerifyReverseDNS confirms a sending IP has a PTR record AND that the PTR name
+// forward-resolves back to the same IP (forward-confirmed reverse DNS / FCrDNS).
+// A missing or mismatched PTR is a classic mailbox-provider rejection cause, so
+// this complements the set-side SetReverseDNS by verifying the record actually
+// took and is self-consistent.
+//
+// Returns the PTR hostname (if any), whether FCrDNS holds, and any lookup error.
+func VerifyReverseDNS(ctx context.Context, ip string) (ptr string, fcrdnsOK bool, err error) {
+	ip = strings.TrimSpace(ip)
+	if ip == "" {
+		return "", false, nil
+	}
+
+	resolver := &net.Resolver{}
+
+	c1, cancel1 := context.WithTimeout(ctx, rdnsLookupTimeout)
+	defer cancel1()
+	names, err := resolver.LookupAddr(c1, ip)
+	if err != nil || len(names) == 0 {
+		return "", false, err
+	}
+	ptr = strings.TrimSuffix(names[0], ".")
+
+	c2, cancel2 := context.WithTimeout(ctx, rdnsLookupTimeout)
+	defer cancel2()
+	addrs, ferr := resolver.LookupHost(c2, ptr)
+	if ferr != nil {
+		return ptr, false, ferr
+	}
+	for _, a := range addrs {
+		if a == ip {
+			return ptr, true, nil
+		}
+	}
+	return ptr, false, nil
+}
diff --git a/internal/app/provisioning/service.go b/internal/app/provisioning/service.go
index a783c6c1..615b86d6 100644
--- a/internal/app/provisioning/service.go
+++ b/internal/app/provisioning/service.go
@@ -23,6 +23,7 @@ import (
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
 	"github.com/warmbly/warmbly/internal/infrastructure/cloudprovider"
 	"github.com/warmbly/warmbly/internal/models"
 	"github.com/warmbly/warmbly/internal/repository"
@@ -200,7 +201,23 @@ func (s *Service) Run(ctx context.Context, jobID uuid.UUID) error {
 					hostname := strings.ReplaceAll(cfg.RDNSPattern, "{{ip}}", strings.ReplaceAll(ip, ".", "-"))
 					if err := provider.SetReverseDNS(ctx, ipID, hostname); err != nil {
 						// rDNS failure is non-fatal — log and continue.
-						_ = err
+						log.Warn().Err(err).Str("ip", ip).Str("hostname", hostname).Msg("provisioning: SetReverseDNS failed")
+						continue
+					}
+					// Verify the PTR actually took and forward-confirms (FCrDNS).
+					// A missing/mismatched PTR is a classic mailbox-provider
+					// rejection cause, so surface it; non-fatal (DNS may still be
+					// propagating). Best-effort — only verify when we know the IP.
+					if ip != "" {
+						ptr, ok, vErr := VerifyReverseDNS(ctx, ip)
+						switch {
+						case vErr != nil:
+							log.Warn().Err(vErr).Str("ip", ip).Msg("provisioning: rDNS verification lookup failed")
+						case !ok:
+							log.Warn().Str("ip", ip).Str("ptr", ptr).Str("expected", hostname).Msg("provisioning: rDNS not yet forward-confirmed (FCrDNS)")
+						default:
+							log.Info().Str("ip", ip).Str("ptr", ptr).Msg("provisioning: rDNS forward-confirmed")
+						}
 					}
 				}
 			}
diff --git a/internal/app/warmup/service.go b/internal/app/warmup/service.go
index 1bc6e039..abfb6423 100644
--- a/internal/app/warmup/service.go
+++ b/internal/app/warmup/service.go
@@ -3,6 +3,7 @@ package warmup
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	"github.com/google/uuid"
@@ -53,6 +54,13 @@ const (
 
 	invalidTokenBlockThreshold = 3
 
+	// Tampering: harming pool warmup mail (deleting it or marking it as spam)
+	// bans the mailbox once this many harm events occur within the window.
+	// Default 1 = ban on first harm (Instantly-style zero tolerance); the
+	// owner can appeal. Bump to forgive accidental actions.
+	warmupTamperingBlockThreshold = 1
+	warmupTamperingWindow         = 7 * 24 * time.Hour
+
 	warmupThrottleDuration   = 3 * 24 * time.Hour
 	warmupQuarantineDuration = 7 * 24 * time.Hour
 	warmupBlockDuration      = 30 * 24 * time.Hour
@@ -68,10 +76,20 @@ type Service interface {
 	// RecordSpamPlacement records that a warmup message landed in the
 	// recipient's Junk/Spam folder on arrival. Counted separately from
 	// user complaints so the two signals can drive distinct thresholds.
-	RecordSpamPlacement(ctx context.Context, reporterAccountID, reportedAccountID uuid.UUID, messageID string) (*models.WarmupParticipantHealth, *errx.Error)
+	RecordSpamPlacement(ctx context.Context, reporterAccountID, reportedAccountID uuid.UUID, messageID, contentSource, recipientProvider, recipientDomain string) (*models.WarmupParticipantHealth, *errx.Error)
 	ApplyInvalidTokenAttempt(ctx context.Context, accountID uuid.UUID, attemptedToken string, scoreDelta int) (*models.WarmupParticipantHealth, *errx.Error)
 	ApplyRateLimitExceeded(ctx context.Context, accountID uuid.UUID, reason string) (*models.WarmupParticipantHealth, *errx.Error)
 
+	// RecordTampering records that a participant harmed a warmup email (deleted
+	// it or marked it as spam) and bans the mailbox from warmup once the harm
+	// count crosses the threshold. The owner can then appeal.
+	RecordTampering(ctx context.Context, accountID uuid.UUID, messageID, kind string) (*models.WarmupParticipantHealth, *errx.Error)
+
+	// SubmitAppeal lets the mailbox owner appeal a warmup ban with a reason.
+	SubmitAppeal(ctx context.Context, userID, accountID uuid.UUID, reason string) (uuid.UUID, *errx.Error)
+	// GetBanStatus returns the user-facing warmup standing for a mailbox.
+	GetBanStatus(ctx context.Context, userID, accountID uuid.UUID) (*models.WarmupBanStatus, *errx.Error)
+
 	// Scheduled health evaluation
 	EvaluateAllParticipants(ctx context.Context) (evaluated int, stateChanges int, err *errx.Error)
 	GetPoolHealthSummary(ctx context.Context) (*models.WarmupPoolHealthSummary, *errx.Error)
@@ -265,13 +283,16 @@ func (s *service) CanParticipate(ctx context.Context, accountID uuid.UUID, poolT
 // 'spam_placement' type and a smaller spam-score delta (placement is a
 // weaker individual signal than a user complaint — it is more likely to
 // reflect content rather than malice).
-func (s *service) RecordSpamPlacement(ctx context.Context, reporterAccountID, reportedAccountID uuid.UUID, messageID string) (*models.WarmupParticipantHealth, *errx.Error) {
+func (s *service) RecordSpamPlacement(ctx context.Context, reporterAccountID, reportedAccountID uuid.UUID, messageID, contentSource, recipientProvider, recipientDomain string) (*models.WarmupParticipantHealth, *errx.Error) {
 	inserted, err := s.repo.RecordSpamReport(ctx, &repository.SpamReport{
 		ID:                uuid.New(),
 		ReporterAccountID: reporterAccountID,
 		ReportedAccountID: reportedAccountID,
 		MessageID:         messageID,
 		ReportType:        "spam_placement",
+		ContentSource:     contentSource,
+		RecipientProvider: recipientProvider,
+		RecipientDomain:   recipientDomain,
 	})
 	if err != nil {
 		return nil, errx.InternalError()
@@ -285,6 +306,128 @@ func (s *service) RecordSpamPlacement(ctx context.Context, reporterAccountID, re
 	return s.evaluateAndPersistAnyPool(ctx, reportedAccountID)
 }
 
+// RecordTampering records that a participant harmed a warmup email (deleted it
+// or marked it as spam) and bans the mailbox from warmup once the harm count
+// crosses the threshold within the window. The block carries a clear,
+// user-facing reason and fires the health transition so the dashboard updates.
+func (s *service) RecordTampering(ctx context.Context, accountID uuid.UUID, messageID, kind string) (*models.WarmupParticipantHealth, *errx.Error) {
+	inserted, err := s.repo.RecordWarmupTampering(ctx, accountID, messageID, kind)
+	if err != nil {
+		return nil, errx.InternalError()
+	}
+	if !inserted {
+		// Already counted this exact harm — don't double-penalise.
+		return s.getParticipantForAnyPool(ctx, accountID)
+	}
+
+	since := s.now().Add(-warmupTamperingWindow)
+	count, err := s.repo.CountWarmupTamperingSince(ctx, accountID, since)
+	if err != nil {
+		return nil, errx.InternalError()
+	}
+
+	if count >= warmupTamperingBlockThreshold {
+		prev, _ := s.getParticipantForAnyPool(ctx, accountID)
+		reason := fmt.Sprintf("Auto-blocked from warmup: %s a warmup email. Warmup mailboxes must let warmup mail be delivered and engaged with. You can appeal this from your dashboard.", tamperingVerb(kind))
+		if count > 1 {
+			reason = fmt.Sprintf("Auto-blocked from warmup: harmed %d warmup emails (deleted or marked as spam) in the last %d days. You can appeal this from your dashboard.", count, int(warmupTamperingWindow.Hours()/24))
+		}
+		if err := s.repo.BlockFromPool(ctx, accountID, reason); err != nil {
+			return nil, errx.InternalError()
+		}
+		if prev != nil && prev.HealthState != models.WarmupHealthBlocked {
+			s.dispatchHealthEvent(ctx, accountID, prev.HealthState, models.WarmupHealthBlocked, reason)
+		}
+	}
+
+	return s.getParticipantForAnyPool(ctx, accountID)
+}
+
+func tamperingVerb(kind string) string {
+	switch kind {
+	case "deletion":
+		return "deleted"
+	case "spam_flag":
+		return "marked as spam"
+	default:
+		return "tampered with"
+	}
+}
+
+// SubmitAppeal records a user's appeal against a warmup ban. Verifies the
+// mailbox belongs to the user, is actually blocked, and has no open appeal.
+func (s *service) SubmitAppeal(ctx context.Context, userID, accountID uuid.UUID, reason string) (uuid.UUID, *errx.Error) {
+	reason = strings.TrimSpace(reason)
+	if reason == "" {
+		return uuid.Nil, errx.New(errx.BadRequest, "an appeal reason is required")
+	}
+	if len(reason) > 2000 {
+		reason = reason[:2000]
+	}
+
+	if s.emailRepo != nil {
+		acc, _ := s.emailRepo.GetByID(ctx, accountID)
+		if acc == nil || acc.UserID != userID.String() {
+			return uuid.Nil, errx.New(errx.Forbidden, "this mailbox does not belong to you")
+		}
+	}
+
+	health, _ := s.getParticipantForAnyPool(ctx, accountID)
+	if health == nil || (health.HealthState != models.WarmupHealthBlocked && health.HealthState != models.WarmupHealthQuarantined) {
+		return uuid.Nil, errx.New(errx.BadRequest, "this mailbox is not blocked from warmup")
+	}
+
+	pending, err := s.repo.HasPendingWarmupAppeal(ctx, accountID)
+	if err != nil {
+		return uuid.Nil, errx.InternalError()
+	}
+	if pending {
+		return uuid.Nil, errx.New(errx.BadRequest, "an appeal is already pending for this mailbox")
+	}
+
+	id, err := s.repo.CreateWarmupAppeal(ctx, accountID, userID, reason)
+	if err != nil {
+		return uuid.Nil, errx.InternalError()
+	}
+	return id, nil
+}
+
+// GetBanStatus returns the user-facing warmup standing for a mailbox.
+func (s *service) GetBanStatus(ctx context.Context, userID, accountID uuid.UUID) (*models.WarmupBanStatus, *errx.Error) {
+	if s.emailRepo != nil {
+		acc, _ := s.emailRepo.GetByID(ctx, accountID)
+		if acc == nil || acc.UserID != userID.String() {
+			return nil, errx.New(errx.Forbidden, "this mailbox does not belong to you")
+		}
+	}
+
+	status := &models.WarmupBanStatus{
+		EmailAccountID: accountID,
+		HealthState:    string(models.WarmupHealthHealthy),
+	}
+
+	health, _ := s.getParticipantForAnyPool(ctx, accountID)
+	if health != nil {
+		status.HealthState = string(health.HealthState)
+		status.BlockedAt = health.BlockedAt
+		status.BlockedUntil = health.BlockedUntil
+		if health.BlockedReason != nil {
+			status.Reason = *health.BlockedReason
+		}
+		if health.HealthState == models.WarmupHealthBlocked || health.HealthState == models.WarmupHealthQuarantined {
+			status.Blocked = true
+		}
+	}
+
+	if status.Blocked {
+		pending, _ := s.repo.HasPendingWarmupAppeal(ctx, accountID)
+		status.PendingAppeal = pending
+		status.CanAppeal = !pending
+	}
+
+	return status, nil
+}
+
 func (s *service) ApplySpamReport(ctx context.Context, reporterAccountID, reportedAccountID uuid.UUID, messageID, reportType string) (*models.WarmupParticipantHealth, *errx.Error) {
 	inserted, err := s.repo.RecordSpamReport(ctx, &repository.SpamReport{
 		ID:                uuid.New(),
@@ -679,6 +822,18 @@ func (s *service) GetPoolHealthSummary(ctx context.Context) (*models.WarmupPoolH
 		return nil, errx.InternalError()
 	}
 
+	// Pool-wide spam-placement rate over the last 7 days. Previously this
+	// summary field was always serialised as 0 because nothing populated it.
+	since := s.now().UTC().Add(-7 * 24 * time.Hour)
+	placementRate, prErr := s.repo.PoolSpamPlacementRate(ctx, since)
+	if prErr != nil {
+		return nil, errx.InternalError()
+	}
+	byProvider, bpErr := s.repo.PoolSpamPlacementsByProvider(ctx, since)
+	if bpErr != nil {
+		return nil, errx.InternalError()
+	}
+
 	total := 0
 	blockedCount := 0
 	atRiskCount := 0
@@ -693,10 +848,12 @@ func (s *service) GetPoolHealthSummary(ctx context.Context) (*models.WarmupPoolH
 	}
 
 	return &models.WarmupPoolHealthSummary{
-		TotalParticipants: total,
-		ByState:           counts,
-		AvgSpamScore:      avgScore,
-		BlockedCount:      blockedCount,
-		AtRiskCount:       atRiskCount,
+		TotalParticipants:       total,
+		ByState:                 counts,
+		AvgSpamScore:            avgScore,
+		AvgSpamPlacement:        placementRate,
+		SpamPlacementByProvider: byProvider,
+		BlockedCount:            blockedCount,
+		AtRiskCount:             atRiskCount,
 	}, nil
 }
diff --git a/internal/app/warmupcontent/batch.go b/internal/app/warmupcontent/batch.go
new file mode 100644
index 00000000..af37d431
--- /dev/null
+++ b/internal/app/warmupcontent/batch.go
@@ -0,0 +1,350 @@
+package warmupcontent
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"github.com/warmbly/warmbly/internal/models"
+	"github.com/warmbly/warmbly/internal/pkg/generation"
+	"github.com/warmbly/warmbly/internal/pkg/humanlint"
+	"github.com/warmbly/warmbly/internal/pkg/warmlint"
+)
+
+// themeForIndex mirrors runJob's theme selection: a pinned theme wins, otherwise
+// rotate through the default theme set so a batch spans varied topics.
+func themeForIndex(pinned string, i int) string {
+	if pinned != "" {
+		return pinned
+	}
+	return defaultThemes[i%len(defaultThemes)]
+}
+
+// GenerateBatch submits an async OpenAI Batch API run. It builds N
+// chat-completion requests (theme rotation identical to the sync runJob),
+// uploads them as a batch, and persists a job row in mode='batch' with the
+// OpenAI batch/file identifiers. It returns immediately — the batch is ingested
+// later by PollBatches when OpenAI finishes processing (up to the completion
+// window, typically 24h).
+func (s *service) GenerateBatch(ctx context.Context, req GenerateRequest) (uuid.UUID, error) {
+	if s.gen == nil {
+		return uuid.Nil, ErrNotConfigured
+	}
+	if req.PoolType == "" {
+		req.PoolType = "premium"
+	}
+	if req.Trigger == "" {
+		req.Trigger = "manual"
+	}
+	if req.Count <= 0 {
+		req.Count = 100
+	}
+	if req.Count > maxPerBatch {
+		req.Count = maxPerBatch
+	}
+
+	settings, _ := s.repo.GetGenerationSettings(ctx)
+	if req.Model == "" && settings != nil {
+		req.Model = settings.Model
+	}
+	maxMessages := 4
+	if settings != nil {
+		maxMessages = settings.MaxMessagesPerThread
+	}
+	if req.MaxMessages > 0 {
+		maxMessages = req.MaxMessages
+	}
+
+	// Respect the daily generation cap (shared with the sync/scheduled paths) so
+	// a huge batch can't blow past the admin's budget for the day.
+	if settings != nil && settings.DailyGenerationCap > 0 {
+		remaining := dailyRemaining(ctx, s.repo, settings.DailyGenerationCap)
+		if remaining <= 0 {
+			return uuid.Nil, fmt.Errorf("daily generation cap reached")
+		}
+		if req.Count > remaining {
+			req.Count = remaining
+		}
+	}
+
+	window := req.CompletionWindow
+	if window == "" {
+		window = "24h"
+	}
+
+	job := &models.WarmupGenerationJob{
+		ID:               uuid.New(),
+		RequestedBy:      req.RequestedBy,
+		Trigger:          req.Trigger,
+		Mode:             models.WarmupGenerationModeBatch,
+		PoolType:         req.PoolType,
+		Segment:          req.Segment,
+		Theme:            req.Theme,
+		Model:            req.Model,
+		RequestedCount:   req.Count,
+		Status:           "pending",
+		CompletionWindow: window,
+	}
+
+	// custom_id → theme so results map back after the (unordered) batch returns.
+	requests := make([]generation.BatchRequest, 0, req.Count)
+	for i := 0; i < req.Count; i++ {
+		theme := themeForIndex(req.Theme, i)
+		requests = append(requests, generation.BatchRequest{
+			CustomID:    fmt.Sprintf("%s-%d", job.ID.String(), i),
+			Theme:       theme,
+			Model:       req.Model,
+			MaxMessages: maxMessages,
+		})
+	}
+
+	batchID, inputFileID, err := s.gen.SubmitBatch(ctx, requests, window)
+	if err != nil {
+		// Persist a failed job row for visibility rather than dropping silently.
+		now := time.Now()
+		job.Status = "failed"
+		job.Error = err.Error()
+		job.StartedAt = &now
+		job.FinishedAt = &now
+		if cerr := s.repo.CreateGenerationJob(ctx, job); cerr != nil {
+			return uuid.Nil, cerr
+		}
+		return uuid.Nil, err
+	}
+
+	now := time.Now()
+	job.Status = "running"
+	job.BatchStatus = "submitted"
+	job.BatchID = batchID
+	job.BatchInputFileID = inputFileID
+	job.StartedAt = &now
+	if err := s.repo.CreateGenerationJob(ctx, job); err != nil {
+		return uuid.Nil, err
+	}
+
+	log.Info().
+		Str("job_id", job.ID.String()).
+		Str("batch_id", batchID).
+		Int("requested", req.Count).
+		Str("completion_window", window).
+		Msg("warmup batch generation submitted")
+
+	return job.ID, nil
+}
+
+// PollBatches reconciles every in-flight batch job against OpenAI. Completed
+// batches are downloaded and ingested (clean + lint + cache, mirroring runJob);
+// failed/expired/cancelled batches mark the job failed; otherwise the latest
+// batch status is persisted so the admin UI reflects progress.
+func (s *service) PollBatches(ctx context.Context) error {
+	if s.gen == nil {
+		return nil
+	}
+	jobs, err := s.repo.ListActiveBatchJobs(ctx)
+	if err != nil {
+		return err
+	}
+	for i := range jobs {
+		job := &jobs[i]
+		if err := s.pollBatchJob(ctx, job); err != nil {
+			sentry.CaptureException(err)
+			log.Warn().Err(err).Str("job_id", job.ID.String()).Str("batch_id", job.BatchID).
+				Msg("warmup batch generation: poll failed")
+		}
+	}
+	return nil
+}
+
+// pollBatchJob reconciles a single batch job.
+func (s *service) pollBatchJob(ctx context.Context, job *models.WarmupGenerationJob) error {
+	status, outputFileID, counts, err := s.gen.GetBatch(ctx, job.BatchID)
+	if err != nil {
+		return err
+	}
+	job.BatchStatus = status
+
+	switch status {
+	case "completed":
+		job.BatchOutputFileID = outputFileID
+		return s.ingestBatch(ctx, job, outputFileID, counts)
+	case "failed", "expired", "cancelled":
+		now := time.Now()
+		job.Status = "failed"
+		job.FinishedAt = &now
+		if job.Error == "" {
+			job.Error = fmt.Sprintf("batch %s", status)
+		}
+		return s.repo.UpdateGenerationJob(ctx, job)
+	default:
+		// validating | in_progress | finalizing | cancelling | submitted —
+		// still running; persist the latest status for visibility.
+		return s.repo.UpdateGenerationJob(ctx, job)
+	}
+}
+
+// ingestBatch downloads a completed batch's output, cleans + lints + caches each
+// conversation (mirroring runJob), and finalises the job row.
+func (s *service) ingestBatch(ctx context.Context, job *models.WarmupGenerationJob, outputFileID string, counts generation.BatchCounts) error {
+	results, err := s.gen.FetchBatchResults(ctx, outputFileID)
+	if err != nil {
+		now := time.Now()
+		job.Status = "failed"
+		job.FinishedAt = &now
+		job.Error = err.Error()
+		_ = s.repo.UpdateGenerationJob(ctx, job)
+		return err
+	}
+
+	// Reset the per-ingest counters; the output file is the source of truth.
+	job.GeneratedCount = 0
+	job.LintRejectedCount = 0
+	job.FailedCount = 0
+
+	for i := range results {
+		r := &results[i]
+		if r.Err != "" || r.Conversation == nil {
+			job.FailedCount++
+			if r.Err != "" {
+				log.Debug().Str("job_id", job.ID.String()).Str("custom_id", r.CustomID).Str("err", r.Err).
+					Msg("warmup batch generation: result line failed")
+			}
+			continue
+		}
+
+		theme := themeForCustomID(r.CustomID, job.Theme)
+
+		subject := strings.TrimSpace(r.Conversation.Subject)
+		description := strings.TrimSpace(r.Conversation.Description)
+		messages := cleanMessages(r.Conversation.Messages)
+		if description == "" || subject == "" {
+			job.FailedCount++
+			continue
+		}
+
+		// Humanize before the gates (identical to the sync runJob path).
+		subject, description, messages = humanizeThread(subject, description, messages)
+
+		lintBody := description
+		if len(messages) > 0 {
+			lintBody += "\n\n" + strings.Join(messages, "\n")
+		}
+		if humanlint.LooksRobotic(lintBody) {
+			job.LintRejectedCount++
+			continue
+		}
+		if err := warmlint.Check(subject, lintBody, false); err != nil {
+			job.LintRejectedCount++
+			continue
+		}
+
+		record := &models.WarmupConversation{
+			ID:             uuid.New(),
+			PoolType:       job.PoolType,
+			Segment:        job.Segment,
+			Source:         models.WarmupContentSourceAI,
+			Theme:          theme,
+			Subject:        subject,
+			Description:    description,
+			Messages:       messages,
+			Status:         "active",
+			LintPassed:     true,
+			GeneratedByJob: &job.ID,
+		}
+		if err := s.repo.InsertConversation(ctx, record); err != nil {
+			job.FailedCount++
+			sentry.CaptureException(err)
+			continue
+		}
+		job.GeneratedCount++
+	}
+
+	// The output file already contains one line per request (success or error),
+	// so iterating results above accounts for every line — including provider
+	// failures, which surface as error lines. counts.Failed is therefore not
+	// added on top (that would double-count); it's reconciled only if the output
+	// reported fewer lines than the batch's total, which shouldn't normally
+	// happen but guards against a truncated/partial download.
+	if missing := counts.Total - len(results); missing > 0 {
+		job.FailedCount += missing
+	}
+
+	now := time.Now()
+	job.FinishedAt = &now
+	job.Status = "completed"
+	if job.GeneratedCount == 0 && (job.FailedCount > 0 || job.Error != "") {
+		job.Status = "failed"
+		if job.Error == "" {
+			job.Error = fmt.Sprintf("all %d batch results failed", job.FailedCount)
+		}
+	}
+	if err := s.repo.UpdateGenerationJob(ctx, job); err != nil {
+		return err
+	}
+	log.Info().
+		Str("job_id", job.ID.String()).
+		Str("batch_id", job.BatchID).
+		Int("generated", job.GeneratedCount).
+		Int("lint_rejected", job.LintRejectedCount).
+		Int("failed", job.FailedCount).
+		Msg("warmup batch generation ingested")
+	return nil
+}
+
+// themeForCustomID recovers the theme for a result. The custom_id is
+// "<jobID>-<index>"; the index re-derives the rotated theme so cached rows carry
+// the right topic even though the batch output is unordered.
+func themeForCustomID(customID, pinnedTheme string) string {
+	if pinnedTheme != "" {
+		return pinnedTheme
+	}
+	idx := strings.LastIndexByte(customID, '-')
+	if idx < 0 || idx+1 >= len(customID) {
+		return defaultThemes[0]
+	}
+	n := 0
+	for _, ch := range customID[idx+1:] {
+		if ch < '0' || ch > '9' {
+			return defaultThemes[0]
+		}
+		n = n*10 + int(ch-'0')
+	}
+	return defaultThemes[n%len(defaultThemes)]
+}
+
+// CancelBatch cancels an in-flight batch job both on OpenAI and locally.
+func (s *service) CancelBatch(ctx context.Context, jobID uuid.UUID) error {
+	if s.gen == nil {
+		return ErrNotConfigured
+	}
+	job, err := s.repo.GetGenerationJob(ctx, jobID)
+	if err != nil {
+		return err
+	}
+	if job == nil {
+		return fmt.Errorf("generation job not found")
+	}
+	if job.Mode != models.WarmupGenerationModeBatch || job.BatchID == "" {
+		return fmt.Errorf("job is not a batch job")
+	}
+	if job.Status == "completed" || job.Status == "failed" {
+		return fmt.Errorf("job already finished")
+	}
+
+	if err := s.gen.CancelBatch(ctx, job.BatchID); err != nil {
+		return err
+	}
+
+	now := time.Now()
+	job.Status = "failed"
+	job.BatchStatus = "cancelling"
+	job.FinishedAt = &now
+	if job.Error == "" {
+		job.Error = "cancelled by admin"
+	}
+	return s.repo.UpdateGenerationJob(ctx, job)
+}
diff --git a/internal/app/warmupcontent/service.go b/internal/app/warmupcontent/service.go
new file mode 100644
index 00000000..99fd98c5
--- /dev/null
+++ b/internal/app/warmupcontent/service.go
@@ -0,0 +1,353 @@
+// Package warmupcontent runs the offline warmup-content generator: it calls
+// the AI client, lints each result, and caches accepted threads in the
+// warmup_conversations bank for the live send path to draw from. Generation is
+// always offline (admin-triggered or scheduled) and never on the send hot path.
+package warmupcontent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"hash/fnv"
+	"strings"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"github.com/warmbly/warmbly/internal/models"
+	"github.com/warmbly/warmbly/internal/pkg/generation"
+	"github.com/warmbly/warmbly/internal/pkg/humanlint"
+	"github.com/warmbly/warmbly/internal/pkg/warmlint"
+	"github.com/warmbly/warmbly/internal/repository"
+)
+
+// ErrNotConfigured is returned when generation is requested but no AI client is
+// wired (OPENAI_API_KEY unset).
+var ErrNotConfigured = errors.New("warmup AI generation is not configured")
+
+// defaultThemes seed topic variety when a generation run doesn't pin a theme.
+var defaultThemes = []string{
+	"productivity", "learning", "collaboration", "industry trends", "tools",
+	"networking", "feedback", "planning", "reading", "wellness", "events",
+	"career growth", "remote work", "meetings", "automation", "team culture",
+	"customer success", "writing", "travel", "community",
+}
+
+// maxPerRun bounds a single sync generation run regardless of request size.
+const maxPerRun = 200
+
+// maxPerBatch bounds a single Batch API submission. Batch is async and cheap so
+// it tolerates a much larger fan-out than the sync path; OpenAI itself allows up
+// to 50,000 requests per batch input file.
+const maxPerBatch = 2000
+
+// GenerateRequest describes one generation run.
+type GenerateRequest struct {
+	RequestedBy *uuid.UUID
+	Trigger     string // "manual" | "schedule"
+	PoolType    string
+	Segment     string
+	Theme       string
+	Model       string
+	Count       int
+	// MaxMessages overrides the per-thread follow-up count for this run; 0 falls
+	// back to the admin generation settings. Used by the batch path so callers
+	// have full control over the thread shape.
+	MaxMessages int
+	// CompletionWindow is the OpenAI Batch API processing window (batch path
+	// only); empty defaults to "24h".
+	CompletionWindow string
+}
+
+// Service drives offline warmup content generation.
+type Service interface {
+	// Generate starts an offline generation run in the background and returns
+	// the job ID immediately so callers can track progress.
+	Generate(ctx context.Context, req GenerateRequest) (uuid.UUID, error)
+	// GenerateBatch submits an async OpenAI Batch API run (~50% cheaper) and
+	// returns the job ID immediately. Results are ingested later by PollBatches.
+	GenerateBatch(ctx context.Context, req GenerateRequest) (uuid.UUID, error)
+	// PollBatches reconciles in-flight batch jobs against OpenAI: it ingests
+	// completed batches and marks failed/expired/cancelled ones.
+	PollBatches(ctx context.Context) error
+	// CancelBatch cancels an in-flight batch job (OpenAI + local job row).
+	CancelBatch(ctx context.Context, jobID uuid.UUID) error
+	// RunScheduled tops every enabled pool/segment up toward its target.
+	RunScheduled(ctx context.Context) error
+	// Enabled reports whether an AI client is configured.
+	Enabled() bool
+}
+
+type service struct {
+	repo repository.WarmupContentRepository
+	gen  *generation.GenerationClient
+}
+
+// NewService creates the generation service. gen may be nil (no OPENAI_API_KEY),
+// in which case generation requests return ErrNotConfigured.
+func NewService(repo repository.WarmupContentRepository, gen *generation.GenerationClient) Service {
+	return &service{repo: repo, gen: gen}
+}
+
+func (s *service) Enabled() bool { return s.gen != nil }
+
+func (s *service) Generate(ctx context.Context, req GenerateRequest) (uuid.UUID, error) {
+	if s.gen == nil {
+		return uuid.Nil, ErrNotConfigured
+	}
+	if req.PoolType == "" {
+		req.PoolType = "premium"
+	}
+	if req.Trigger == "" {
+		req.Trigger = "manual"
+	}
+	if req.Count <= 0 {
+		req.Count = 10
+	}
+	if req.Count > maxPerRun {
+		req.Count = maxPerRun
+	}
+
+	settings, _ := s.repo.GetGenerationSettings(ctx)
+	if req.Model == "" && settings != nil {
+		req.Model = settings.Model
+	}
+
+	job := &models.WarmupGenerationJob{
+		ID:             uuid.New(),
+		RequestedBy:    req.RequestedBy,
+		Trigger:        req.Trigger,
+		PoolType:       req.PoolType,
+		Segment:        req.Segment,
+		Theme:          req.Theme,
+		Model:          req.Model,
+		RequestedCount: req.Count,
+		Status:         "pending",
+	}
+	if err := s.repo.CreateGenerationJob(ctx, job); err != nil {
+		return uuid.Nil, err
+	}
+
+	// Run in the background so the admin request returns immediately; the job
+	// row is the progress/visibility surface.
+	go func() {
+		bg, cancel := context.WithTimeout(context.Background(), time.Duration(req.Count)*45*time.Second+time.Minute)
+		defer cancel()
+		s.runJob(bg, job)
+	}()
+
+	return job.ID, nil
+}
+
+func (s *service) RunScheduled(ctx context.Context) error {
+	if s.gen == nil {
+		return nil
+	}
+	settings, err := s.repo.GetGenerationSettings(ctx)
+	if err != nil || settings == nil {
+		return err
+	}
+	if !settings.ScheduleEnabled {
+		return nil
+	}
+
+	remaining := dailyRemaining(ctx, s.repo, settings.DailyGenerationCap)
+	if settings.DailyGenerationCap > 0 && remaining <= 0 {
+		log.Info().Msg("warmup generation: daily cap reached; scheduled run skipped")
+		return nil
+	}
+
+	for _, pool := range settings.Pools {
+		if !pool.Enabled {
+			continue
+		}
+		segments := pool.Segments
+		if len(segments) == 0 {
+			segments = []string{""}
+		}
+		for _, segment := range segments {
+			active, _ := s.repo.CountActiveConversations(ctx, pool.PoolType, segment)
+			deficit := pool.TargetActiveThreads - active
+			if deficit <= 0 {
+				continue
+			}
+			count := deficit
+			if count > 25 {
+				count = 25 // per-segment per-run cap so one run doesn't monopolise
+			}
+			if settings.DailyGenerationCap > 0 && count > remaining {
+				count = remaining
+			}
+			if count <= 0 {
+				continue
+			}
+
+			job := &models.WarmupGenerationJob{
+				ID:             uuid.New(),
+				Trigger:        "schedule",
+				PoolType:       pool.PoolType,
+				Segment:        segment,
+				Model:          settings.Model,
+				RequestedCount: count,
+				Status:         "pending",
+			}
+			if err := s.repo.CreateGenerationJob(ctx, job); err != nil {
+				log.Warn().Err(err).Msg("warmup generation: failed to create scheduled job")
+				continue
+			}
+			generated := s.runJob(ctx, job)
+			if settings.DailyGenerationCap > 0 {
+				remaining -= generated
+				if remaining <= 0 {
+					return nil
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// runJob executes a generation job, updating its row as it goes. Returns the
+// number of conversations successfully cached.
+func (s *service) runJob(ctx context.Context, job *models.WarmupGenerationJob) int {
+	now := time.Now()
+	job.StartedAt = &now
+	job.Status = "running"
+	if err := s.repo.UpdateGenerationJob(ctx, job); err != nil {
+		log.Warn().Err(err).Str("job_id", job.ID.String()).Msg("warmup generation: failed to mark job running")
+	}
+
+	settings, _ := s.repo.GetGenerationSettings(ctx)
+	maxMessages := 4
+	if settings != nil {
+		maxMessages = settings.MaxMessagesPerThread
+	}
+
+	for i := 0; i < job.RequestedCount; i++ {
+		if ctx.Err() != nil {
+			job.Error = ctx.Err().Error()
+			break
+		}
+		theme := job.Theme
+		if theme == "" {
+			theme = defaultThemes[i%len(defaultThemes)]
+		}
+
+		conv, err := s.gen.GenerateConversation(ctx, theme, job.Model, maxMessages)
+		if err != nil {
+			job.FailedCount++
+			log.Warn().Err(err).Str("job_id", job.ID.String()).Str("theme", theme).Msg("warmup generation: model call failed")
+			continue
+		}
+
+		subject := strings.TrimSpace(conv.Subject)
+		description := strings.TrimSpace(conv.Description)
+		messages := cleanMessages(conv.Messages)
+		if description == "" || subject == "" {
+			job.FailedCount++
+			continue
+		}
+
+		// Humanize BEFORE the gates: strip AI tells (em-dashes, stock openers,
+		// AI-accent vocabulary, "not only X but also Y") and apply casual
+		// contractions, so the cached copy reads like a person wrote it.
+		subject, description, messages = humanizeThread(subject, description, messages)
+
+		lintBody := description
+		if len(messages) > 0 {
+			lintBody += "\n\n" + strings.Join(messages, "\n")
+		}
+		// Reject threads that still read machine-generated after cleanup.
+		if humanlint.LooksRobotic(lintBody) {
+			job.LintRejectedCount++
+			continue
+		}
+		if err := warmlint.Check(subject, lintBody, false); err != nil {
+			job.LintRejectedCount++
+			log.Debug().Err(err).Str("job_id", job.ID.String()).Msg("warmup generation: lint rejected a thread")
+			continue
+		}
+
+		record := &models.WarmupConversation{
+			ID:             uuid.New(),
+			PoolType:       job.PoolType,
+			Segment:        job.Segment,
+			Source:         models.WarmupContentSourceAI,
+			Theme:          theme,
+			Subject:        subject,
+			Description:    description,
+			Messages:       messages,
+			Status:         "active",
+			LintPassed:     true,
+			GeneratedByJob: &job.ID,
+		}
+		if err := s.repo.InsertConversation(ctx, record); err != nil {
+			job.FailedCount++
+			sentry.CaptureException(err)
+			continue
+		}
+		job.GeneratedCount++
+	}
+
+	finished := time.Now()
+	job.FinishedAt = &finished
+	job.Status = "completed"
+	if job.GeneratedCount == 0 && (job.FailedCount > 0 || job.Error != "") {
+		job.Status = "failed"
+		if job.Error == "" {
+			job.Error = fmt.Sprintf("all %d generations failed", job.FailedCount)
+		}
+	}
+	if err := s.repo.UpdateGenerationJob(ctx, job); err != nil {
+		log.Warn().Err(err).Str("job_id", job.ID.String()).Msg("warmup generation: failed to finalise job")
+	}
+	log.Info().
+		Str("job_id", job.ID.String()).
+		Int("generated", job.GeneratedCount).
+		Int("lint_rejected", job.LintRejectedCount).
+		Int("failed", job.FailedCount).
+		Msg("warmup generation run finished")
+	return job.GeneratedCount
+}
+
+func cleanMessages(in []string) []string {
+	out := make([]string, 0, len(in))
+	for _, m := range in {
+		m = strings.TrimSpace(m)
+		if m != "" {
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
+// humanizeThread runs the deterministic humanizer over a generated thread's
+// subject, opening line, and follow-ups, seeded by content so the same thread
+// humanizes identically (reproducible) while differing across threads. Shared
+// by the sync (runJob) and batch (ingestBatch) ingest paths.
+func humanizeThread(subject, description string, messages []string) (string, string, []string) {
+	h := fnv.New64a()
+	_, _ = h.Write([]byte(subject + "|" + description))
+	seed := int64(h.Sum64())
+
+	subject = humanlint.HumanizeSubject(subject, seed)
+	description = humanlint.Humanize(description, seed+1)
+	for i := range messages {
+		messages[i] = humanlint.Humanize(messages[i], seed+int64(i)+2)
+	}
+	return subject, description, messages
+}
+
+func dailyRemaining(ctx context.Context, repo repository.WarmupContentRepository, dailyCap int) int {
+	if dailyCap <= 0 {
+		return 1 << 30 // effectively unlimited
+	}
+	since := time.Now().Truncate(24 * time.Hour)
+	used, err := repo.GeneratedCountSince(ctx, since)
+	if err != nil {
+		return dailyCap
+	}
+	return dailyCap - used
+}
diff --git a/internal/app/worker/event_send_email.go b/internal/app/worker/event_send_email.go
index 3cb8801d..be0fa937 100644
--- a/internal/app/worker/event_send_email.go
+++ b/internal/app/worker/event_send_email.go
@@ -64,18 +64,19 @@ func (w *WorkerService) HandleSendEmail(ctx context.Context, body any) error {
 	w.recordSendAttempt()
 	sendStart := time.Now()
 	result := mail.Send(ctx, &wmail.SendRequest{
-		TaskID:      sendEmail.TaskID,
-		To:          sendEmail.To,
-		Cc:          sendEmail.Cc,
-		Bcc:         sendEmail.Bcc,
-		MessageID:   sendEmail.MessageID,
-		Subject:     subject,
-		BodyPlain:   bodyPlain,
-		BodyHTML:    bodyHTML,
-		InReplyTo:   sendEmail.InReplyTo,
-		Parent:      sendEmail.Parent,
-		IsWarmup:    sendEmail.IsWarmup,
-		WarmupToken: sendEmail.WarmupToken,
+		TaskID:         sendEmail.TaskID,
+		To:             sendEmail.To,
+		Cc:             sendEmail.Cc,
+		Bcc:            sendEmail.Bcc,
+		MessageID:      sendEmail.MessageID,
+		Subject:        subject,
+		BodyPlain:      bodyPlain,
+		BodyHTML:       bodyHTML,
+		InReplyTo:      sendEmail.InReplyTo,
+		Parent:         sendEmail.Parent,
+		IsWarmup:       sendEmail.IsWarmup,
+		WarmupToken:    sendEmail.WarmupToken,
+		UnsubscribeURL: sendEmail.UnsubscribeURL,
 	})
 	w.recordSendLatency(time.Since(sendStart))
 	w.recordSendOutcome(result)
diff --git a/internal/app/worker/event_warmup_action.go b/internal/app/worker/event_warmup_action.go
index f99ad89a..003882e6 100644
--- a/internal/app/worker/event_warmup_action.go
+++ b/internal/app/worker/event_warmup_action.go
@@ -10,6 +10,15 @@ import (
 	"github.com/warmbly/warmbly/internal/models"
 )
 
+// HandleWarmupAction executes recipient-side warmup actions on the mailbox.
+//
+// The worker just runs whatever actions it receives, immediately. The
+// recipient-side "dwell" and the immediate-vs-delayed split are now owned by the
+// CONSUMER's durable schedule (internal/app/consumer/warmup_engagement_poller):
+// the consumer publishes the immediate leg (folder + spam-rescue) right away and
+// the delayed leg (read / important / star) when its fire_at passes, each with
+// DelaySeconds=0. That makes the dwell survive a worker restart, which the old
+// in-process time.AfterFunc here could not.
 func (w *WorkerService) HandleWarmupAction(ctx context.Context, body any) error {
 	action, ok := body.(models.WarmupEmailAction)
 	if !ok {
@@ -25,13 +34,16 @@ func (w *WorkerService) HandleWarmupAction(ctx context.Context, body any) error
 		Strs("actions", action.Actions).
 		Msg("Processing warmup email action")
 
+	if len(action.Actions) == 0 {
+		return nil
+	}
+
 	w.mailManager.RLock()
 	mail, exists := w.mailManager.Emails[action.EmailID]
 	w.mailManager.RUnlock()
-
 	if !exists {
 		log.Warn().Str("email_id", action.EmailID.String()).Msg("Email account not found for warmup action")
-		return fmt.Errorf("email account %s not found", action.EmailID.String())
+		return nil
 	}
 
 	switch {
@@ -44,11 +56,6 @@ func (w *WorkerService) HandleWarmupAction(ctx context.Context, body any) error
 			Str("email_id", action.EmailID.String()).
 			Msg("No mail client available for warmup actions; skipping")
 	}
-
-	log.Info().
-		Str("email_id", action.EmailID.String()).
-		Msg("Warmup email actions completed")
-
 	return nil
 }
 
@@ -71,6 +78,10 @@ func (w *WorkerService) runGoogleWarmupActions(ctx context.Context, mail *wmail.
 			if err := mail.GoogleData.Client.MarkImportant(ctx, action.GmailID); err != nil {
 				log.Error().Err(err).Str("gmail_id", action.GmailID).Msg("Failed to mark important")
 			}
+		case "star":
+			if err := mail.GoogleData.Client.AddStar(ctx, action.GmailID); err != nil {
+				log.Error().Err(err).Str("gmail_id", action.GmailID).Msg("Failed to star warmup message")
+			}
 		default:
 			log.Warn().Str("action", act).Msg("Unknown warmup action")
 		}
@@ -117,6 +128,11 @@ func (w *WorkerService) runImapWarmupActions(ctx context.Context, mail *wmail.WM
 			if err := imapClient.MarkImportant(ctx, sourceBox.Name, uid); err != nil {
 				log.Error().Err(err).Uint32("uid", uid).Msg("Failed to mark important (IMAP)")
 			}
+		case "star":
+			// No-op on IMAP: \Flagged is already set by mark_important, so
+			// starring here would just re-flag the same message. Star is a
+			// Gmail-only distinct signal.
+			continue
 		default:
 			log.Warn().Str("action", act).Msg("Unknown warmup action")
 		}
diff --git a/internal/app/worker/wmail/send.go b/internal/app/worker/wmail/send.go
index 4040fd47..4e736bd0 100644
--- a/internal/app/worker/wmail/send.go
+++ b/internal/app/worker/wmail/send.go
@@ -26,6 +26,29 @@ type SendRequest struct {
 	Parent      *models.EmailParent
 	IsWarmup    bool
 	WarmupToken string
+	// UnsubscribeURL, when set (campaign sends with the unsubscribe header
+	// enabled), produces RFC 8058 one-click unsubscribe headers.
+	UnsubscribeURL string
+}
+
+// buildSendHeaders assembles the outbound custom headers: the warmup
+// verification token (warmup sends) and RFC 8058 one-click unsubscribe headers
+// (campaign sends). Returns nil when there are none so callers can branch.
+func buildSendHeaders(req *SendRequest) map[string]string {
+	h := map[string]string{}
+	if req.WarmupToken != "" {
+		h[config.WarmupVerifyHeader] = req.WarmupToken
+	}
+	if req.UnsubscribeURL != "" {
+		// RFC 8058: the HTTPS URI in List-Unsubscribe plus the one-click marker
+		// tells Gmail/Yahoo/Microsoft to POST List-Unsubscribe=One-Click here.
+		h["List-Unsubscribe"] = "<" + req.UnsubscribeURL + ">"
+		h["List-Unsubscribe-Post"] = "List-Unsubscribe=One-Click"
+	}
+	if len(h) == 0 {
+		return nil
+	}
+	return h
 }
 
 // SendResult contains the result of a send operation
@@ -119,13 +142,8 @@ func (w *WMail) sendViaGmail(ctx context.Context, req *SendRequest, bodyHTML str
 		}
 	}
 
-	// Build custom headers for warmup token
-	var customHeaders map[string]string
-	if req.WarmupToken != "" {
-		customHeaders = map[string]string{
-			config.WarmupVerifyHeader: req.WarmupToken,
-		}
-	}
+	// Build custom headers (warmup token + RFC 8058 one-click unsubscribe).
+	customHeaders := buildSendHeaders(req)
 
 	// Send via Gmail API
 	gmailMsg, err := w.GoogleData.Client.SendMessage(
@@ -179,13 +197,8 @@ func (w *WMail) sendViaSMTP(ctx context.Context, req *SendRequest, bodyHTML stri
 		return result
 	}
 
-	// Build custom headers for warmup token
-	var smtpCustomHeaders map[string]string
-	if req.WarmupToken != "" {
-		smtpCustomHeaders = map[string]string{
-			config.WarmupVerifyHeader: req.WarmupToken,
-		}
-	}
+	// Build custom headers (warmup token + RFC 8058 one-click unsubscribe).
+	smtpCustomHeaders := buildSendHeaders(req)
 
 	// Send via SMTP
 	var merr *errx.MailError
diff --git a/internal/client/goog/send.go b/internal/client/goog/send.go
index 9c722d01..9f891f11 100644
--- a/internal/client/goog/send.go
+++ b/internal/client/goog/send.go
@@ -41,9 +41,12 @@ func (c *Client) SendMessage(
 	}
 
 	if parent != nil && parent.MessageID != "" {
+		// Trim any existing <...> before re-wrapping so we don't emit <<id>>,
+		// which won't match the original Message-ID header and breaks threading.
+		mid := "<" + strings.Trim(parent.MessageID, "<>") + ">"
 		headers = append(headers,
-			&gmail.MessagePartHeader{Name: "In-Reply-To", Value: fmt.Sprintf("<%s>", parent.MessageID)},
-			&gmail.MessagePartHeader{Name: "References", Value: fmt.Sprintf("<%s>", parent.MessageID)},
+			&gmail.MessagePartHeader{Name: "In-Reply-To", Value: mid},
+			&gmail.MessagePartHeader{Name: "References", Value: mid},
 		)
 	}
 
diff --git a/internal/client/goog/warmup_actions.go b/internal/client/goog/warmup_actions.go
index 9c07198b..67bf9b2c 100644
--- a/internal/client/goog/warmup_actions.go
+++ b/internal/client/goog/warmup_actions.go
@@ -62,6 +62,24 @@ func (c *Client) RemoveFromSpam(ctx context.Context, messageID string) error {
 	return nil
 }
 
+// AddStar stars a message by adding the STARRED system label. Distinct from
+// MarkImportant (the IMPORTANT label): a star is a deliberate, visible positive
+// signal, so providers weight it as genuine engagement.
+func (c *Client) AddStar(ctx context.Context, messageID string) error {
+	if c.srv == nil {
+		return fmt.Errorf("gmail service not initialized")
+	}
+
+	_, err := c.srv.Users.Messages.Modify("me", messageID, &gmail.ModifyMessageRequest{
+		AddLabelIds: []string{Starred},
+	}).Context(ctx).Do()
+	if err != nil {
+		return fmt.Errorf("failed to add star: %w", err)
+	}
+
+	return nil
+}
+
 // MarkImportant marks a message as important
 func (c *Client) MarkImportant(ctx context.Context, messageID string) error {
 	if c.srv == nil {
diff --git a/internal/client/smtpimap/smtp/client.go b/internal/client/smtpimap/smtp/client.go
index bde972df..1567fed4 100644
--- a/internal/client/smtpimap/smtp/client.go
+++ b/internal/client/smtpimap/smtp/client.go
@@ -56,8 +56,12 @@ func (c *Client) Send(
 		headers["Cc"] = strings.Join(cc, ", ")
 	}
 	if inReplyTo != "" {
-		headers["In-Reply-To"] = fmt.Sprintf("<%s>", inReplyTo)
-		headers["References"] = fmt.Sprintf("<%s>", inReplyTo)
+		// The parent Message-ID may arrive already wrapped in <...>; trim before
+		// re-wrapping so we don't emit <<id>>, which won't match the original
+		// Message-ID header and breaks Gmail/Outlook threading.
+		mid := "<" + strings.Trim(inReplyTo, "<>") + ">"
+		headers["In-Reply-To"] = mid
+		headers["References"] = mid
 	}
 
 	// Add custom headers (e.g., X-Warmbly-Token for warmup)
diff --git a/internal/infrastructure/db/migrations/000004_warmup_content.down.sql b/internal/infrastructure/db/migrations/000004_warmup_content.down.sql
new file mode 100644
index 00000000..ea6f8fdb
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000004_warmup_content.down.sql
@@ -0,0 +1,10 @@
+DROP INDEX IF EXISTS public.idx_warmup_spam_reports_cohort;
+DROP INDEX IF EXISTS public.idx_warmup_tokens_cohort;
+
+ALTER TABLE IF EXISTS public.warmup_spam_reports DROP COLUMN IF EXISTS content_source;
+ALTER TABLE IF EXISTS public.warmup_tokens DROP COLUMN IF EXISTS conversation_id;
+ALTER TABLE IF EXISTS public.warmup_tokens DROP COLUMN IF EXISTS content_source;
+
+DROP TABLE IF EXISTS public.admin_settings;
+DROP TABLE IF EXISTS public.warmup_generation_jobs;
+DROP TABLE IF EXISTS public.warmup_conversations;
diff --git a/internal/infrastructure/db/migrations/000004_warmup_content.up.sql b/internal/infrastructure/db/migrations/000004_warmup_content.up.sql
new file mode 100644
index 00000000..5d0e2455
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000004_warmup_content.up.sql
@@ -0,0 +1,95 @@
+-- Warmup content system.
+--
+-- The live warmup send flow previously drew message bodies from a small,
+-- fixed in-code library (~30 conversations). Reusing the same handful of
+-- bodies across every mailbox in the pool is the documented content-
+-- fingerprinting risk: collaborative bulk-checksum systems (DCC/Razor/Pyzor)
+-- and provider ML learn to recognise the "Warmbly warmup dialect". This
+-- migration adds the control-plane plumbing to fix that:
+--
+--  1. warmup_conversations    — a DB-backed bank of conversation threads that
+--                               an offline generator (OpenAI, run as a job)
+--                               continuously refills per pool + segment. The
+--                               static in-code library remains the fallback,
+--                               so an outage or empty bank never stops warmup.
+--  2. warmup_generation_jobs  — observability for every generation run
+--                               (manual or scheduled): how many were asked
+--                               for, generated, lint-rejected, failed.
+--  3. admin_settings          — a generic key/value JSON settings store; the
+--                               warmup generation + engagement config lives
+--                               under the 'warmup_generation' key so admins
+--                               have full control over volume, cadence, model,
+--                               per-pool segments and engagement rates.
+--  4. content-cohort columns  — content_source / conversation_id on
+--                               warmup_tokens and content_source on
+--                               warmup_spam_reports, so the A/B harness can
+--                               compare spam-placement rate by content cohort
+--                               (static vs AI) without fragile time-window joins.
+
+CREATE TABLE public.warmup_conversations (
+    id uuid DEFAULT gen_random_uuid() NOT NULL,
+    pool_type text NOT NULL,
+    segment text DEFAULT ''::text NOT NULL,
+    source text NOT NULL,
+    theme text DEFAULT ''::text NOT NULL,
+    subject text DEFAULT ''::text NOT NULL,
+    description text DEFAULT ''::text NOT NULL,
+    messages jsonb DEFAULT '[]'::jsonb NOT NULL,
+    status text DEFAULT 'active'::text NOT NULL,
+    lint_passed boolean DEFAULT true NOT NULL,
+    usage_count bigint DEFAULT 0 NOT NULL,
+    generated_by_job_id uuid,
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    updated_at timestamp with time zone DEFAULT now() NOT NULL,
+    CONSTRAINT warmup_conversations_pkey PRIMARY KEY (id),
+    CONSTRAINT warmup_conversations_pool_type_check CHECK ((pool_type = ANY (ARRAY['free'::text, 'premium'::text]))),
+    CONSTRAINT warmup_conversations_source_check CHECK ((source = ANY (ARRAY['ai'::text, 'static'::text]))),
+    CONSTRAINT warmup_conversations_status_check CHECK ((status = ANY (ARRAY['active'::text, 'archived'::text])))
+);
+
+CREATE INDEX idx_warmup_conversations_pick ON public.warmup_conversations USING btree (pool_type, segment, status);
+CREATE INDEX idx_warmup_conversations_source ON public.warmup_conversations USING btree (source);
+CREATE INDEX idx_warmup_conversations_created ON public.warmup_conversations USING btree (created_at DESC);
+
+CREATE TABLE public.warmup_generation_jobs (
+    id uuid DEFAULT gen_random_uuid() NOT NULL,
+    requested_by uuid,
+    trigger text DEFAULT 'manual'::text NOT NULL,
+    pool_type text DEFAULT ''::text NOT NULL,
+    segment text DEFAULT ''::text NOT NULL,
+    theme text DEFAULT ''::text NOT NULL,
+    model text DEFAULT ''::text NOT NULL,
+    requested_count integer DEFAULT 0 NOT NULL,
+    generated_count integer DEFAULT 0 NOT NULL,
+    lint_rejected_count integer DEFAULT 0 NOT NULL,
+    failed_count integer DEFAULT 0 NOT NULL,
+    status text DEFAULT 'pending'::text NOT NULL,
+    error text DEFAULT ''::text NOT NULL,
+    started_at timestamp with time zone,
+    finished_at timestamp with time zone,
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    updated_at timestamp with time zone DEFAULT now() NOT NULL,
+    CONSTRAINT warmup_generation_jobs_pkey PRIMARY KEY (id)
+);
+
+CREATE INDEX idx_warmup_generation_jobs_created ON public.warmup_generation_jobs USING btree (created_at DESC);
+CREATE INDEX idx_warmup_generation_jobs_status ON public.warmup_generation_jobs USING btree (status);
+
+CREATE TABLE public.admin_settings (
+    key text NOT NULL,
+    value jsonb DEFAULT '{}'::jsonb NOT NULL,
+    updated_by uuid,
+    updated_at timestamp with time zone DEFAULT now() NOT NULL,
+    CONSTRAINT admin_settings_pkey PRIMARY KEY (key)
+);
+
+ALTER TABLE ONLY public.warmup_tokens
+    ADD COLUMN content_source text DEFAULT ''::text NOT NULL;
+ALTER TABLE ONLY public.warmup_tokens
+    ADD COLUMN conversation_id uuid;
+
+ALTER TABLE ONLY public.warmup_spam_reports
+    ADD COLUMN content_source text DEFAULT ''::text NOT NULL;
+
+CREATE INDEX idx_warmup_tokens_cohort ON public.warmup_tokens USING btree (content_source, created_at DESC);
+CREATE INDEX idx_warmup_spam_reports_cohort ON public.warmup_spam_reports USING btree (content_source, report_type, created_at DESC);
diff --git a/internal/infrastructure/db/migrations/000005_warmup_tampering.down.sql b/internal/infrastructure/db/migrations/000005_warmup_tampering.down.sql
new file mode 100644
index 00000000..cb76a204
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000005_warmup_tampering.down.sql
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS public.warmup_tampering_events;
+DROP TABLE IF EXISTS public.warmup_received;
diff --git a/internal/infrastructure/db/migrations/000005_warmup_tampering.up.sql b/internal/infrastructure/db/migrations/000005_warmup_tampering.up.sql
new file mode 100644
index 00000000..77c246df
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000005_warmup_tampering.up.sql
@@ -0,0 +1,41 @@
+-- Warmup tampering protection.
+--
+-- Verified warmup mail is NOT stored in the unibox (handleWarmupEmail returns
+-- "handled" before CreateEntry), so there is otherwise no record that a given
+-- message in a recipient's mailbox was a warmup email. Without that, a later
+-- flag-change (mark-as-spam) or deletion event — which only carries the
+-- internal message id — can't be attributed to warmup.
+--
+--  1. warmup_received   — records every verified warmup email delivered to a
+--                         participant, keyed by (recipient mailbox, internal
+--                         message id) so a later delete/flag event can be
+--                         matched back to warmup and to the sender.
+--  2. warmup_tampering_events — one row per "harm" a participant does to a
+--                         warmup email (deleted it, or marked it as spam).
+--                         Crossing the threshold bans the mailbox from warmup
+--                         (BlockFromPool); the user can then appeal
+--                         (warmup_appeals, already present).
+
+CREATE TABLE public.warmup_received (
+    email_account_id uuid NOT NULL,
+    internal_id uuid NOT NULL,
+    message_id text DEFAULT ''::text NOT NULL,
+    sender_account_id uuid NOT NULL,
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    CONSTRAINT warmup_received_pkey PRIMARY KEY (email_account_id, internal_id)
+);
+
+CREATE INDEX idx_warmup_received_created ON public.warmup_received USING btree (created_at);
+
+CREATE TABLE public.warmup_tampering_events (
+    id uuid DEFAULT gen_random_uuid() NOT NULL,
+    email_account_id uuid NOT NULL,
+    message_id text DEFAULT ''::text NOT NULL,
+    kind text NOT NULL,
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    CONSTRAINT warmup_tampering_events_pkey PRIMARY KEY (id),
+    CONSTRAINT warmup_tampering_events_uniq UNIQUE (email_account_id, message_id, kind),
+    CONSTRAINT warmup_tampering_events_kind_check CHECK ((kind = ANY (ARRAY['deletion'::text, 'spam_flag'::text, 'other'::text])))
+);
+
+CREATE INDEX idx_warmup_tampering_account_created ON public.warmup_tampering_events USING btree (email_account_id, created_at DESC);
diff --git a/internal/infrastructure/db/migrations/000006_warmup_analytics.down.sql b/internal/infrastructure/db/migrations/000006_warmup_analytics.down.sql
new file mode 100644
index 00000000..def8d612
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000006_warmup_analytics.down.sql
@@ -0,0 +1,6 @@
+ALTER TABLE public.email_accounts ALTER COLUMN warmup_tag DROP DEFAULT;
+
+DROP INDEX IF EXISTS public.idx_warmup_spam_reports_provider;
+
+ALTER TABLE public.warmup_spam_reports DROP COLUMN IF EXISTS recipient_domain;
+ALTER TABLE public.warmup_spam_reports DROP COLUMN IF EXISTS recipient_provider;
diff --git a/internal/infrastructure/db/migrations/000006_warmup_analytics.up.sql b/internal/infrastructure/db/migrations/000006_warmup_analytics.up.sql
new file mode 100644
index 00000000..778d961f
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000006_warmup_analytics.up.sql
@@ -0,0 +1,24 @@
+-- Warmup analytics correctness + content-segment fix.
+--
+--  1. per-provider placement (B3): warmup_spam_reports records which recipient
+--     provider/domain a warmup message was filtered into spam at, so placement
+--     can be segmented (Gmail-spam vs Outlook-inbox) instead of a single flat
+--     rate. Both columns default '' so existing rows and callers that don't yet
+--     supply the dimension keep working.
+--
+--  2. content-segment fix (B11): warmup_tag was bound to a random RID(8) at
+--     account creation and then used as the warmup content segment, so the
+--     segment-aware AI bank never matched and every mailbox silently drew only
+--     generic content. Default it to '' going forward; it is now a real,
+--     user/admin-settable content segment (slug). Existing random tags simply
+--     fall back to generic content, which is the safe behaviour, so no backfill
+--     is required.
+
+ALTER TABLE public.warmup_spam_reports
+    ADD COLUMN recipient_provider text DEFAULT ''::text NOT NULL,
+    ADD COLUMN recipient_domain text DEFAULT ''::text NOT NULL;
+
+CREATE INDEX idx_warmup_spam_reports_provider
+    ON public.warmup_spam_reports USING btree (report_type, recipient_provider, created_at DESC);
+
+ALTER TABLE public.email_accounts ALTER COLUMN warmup_tag SET DEFAULT ''::text;
diff --git a/internal/infrastructure/db/migrations/000007_campaign_breaker.down.sql b/internal/infrastructure/db/migrations/000007_campaign_breaker.down.sql
new file mode 100644
index 00000000..cf63b00a
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000007_campaign_breaker.down.sql
@@ -0,0 +1 @@
+ALTER TABLE public.campaign_contact_progress DROP COLUMN IF EXISTS complained_at;
diff --git a/internal/infrastructure/db/migrations/000007_campaign_breaker.up.sql b/internal/infrastructure/db/migrations/000007_campaign_breaker.up.sql
new file mode 100644
index 00000000..01b895cf
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000007_campaign_breaker.up.sql
@@ -0,0 +1,9 @@
+-- Campaign deliverability circuit breaker.
+--
+-- The auto-pause logic computed only a cumulative bounce rate and never read
+-- PauseComplaintRateThreshold, so complaint-rate protection was dead. Record
+-- per-contact complaint events alongside bounces so the breaker can enforce a
+-- complaint-rate threshold and compute rolling rates from the same table.
+
+ALTER TABLE public.campaign_contact_progress
+    ADD COLUMN complained_at timestamp with time zone;
diff --git a/internal/infrastructure/db/migrations/000008_warmup_pending_engagements.down.sql b/internal/infrastructure/db/migrations/000008_warmup_pending_engagements.down.sql
new file mode 100644
index 00000000..5ad6d30b
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000008_warmup_pending_engagements.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS public.warmup_pending_engagements;
diff --git a/internal/infrastructure/db/migrations/000008_warmup_pending_engagements.up.sql b/internal/infrastructure/db/migrations/000008_warmup_pending_engagements.up.sql
new file mode 100644
index 00000000..14ffff42
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000008_warmup_pending_engagements.up.sql
@@ -0,0 +1,23 @@
+-- Durable dwell for delayed warmup engagement actions.
+--
+-- The recipient-side "dwell" delay for the low-stakes engagement signals
+-- (mark_read / mark_important / star) previously lived only in a worker-process
+-- time.AfterFunc timer, so a worker restart mid-dwell dropped those signals with
+-- no trace. This table is the durable schedule: the consumer enqueues the
+-- delayed leg here with a fire_at, and a consumer-side poller publishes it to
+-- the worker when due. The reputation-critical leg (folder + spam-rescue) is
+-- still published immediately and is unaffected.
+--
+-- Control-plane only: written and drained by the consumer (Postgres-backed),
+-- never by the worker.
+
+CREATE TABLE public.warmup_pending_engagements (
+    id uuid DEFAULT gen_random_uuid() NOT NULL,
+    email_account_id uuid NOT NULL,
+    payload jsonb NOT NULL,
+    fire_at timestamp with time zone NOT NULL,
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    CONSTRAINT warmup_pending_engagements_pkey PRIMARY KEY (id)
+);
+
+CREATE INDEX idx_warmup_pending_engagements_due ON public.warmup_pending_engagements USING btree (fire_at);
diff --git a/internal/infrastructure/db/migrations/000009_warmup_batch_generation.down.sql b/internal/infrastructure/db/migrations/000009_warmup_batch_generation.down.sql
new file mode 100644
index 00000000..1a46da7c
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000009_warmup_batch_generation.down.sql
@@ -0,0 +1,9 @@
+DROP INDEX IF EXISTS idx_warmup_generation_jobs_batch;
+
+ALTER TABLE ONLY public.warmup_generation_jobs
+    DROP COLUMN IF EXISTS mode,
+    DROP COLUMN IF EXISTS batch_id,
+    DROP COLUMN IF EXISTS batch_input_file_id,
+    DROP COLUMN IF EXISTS batch_output_file_id,
+    DROP COLUMN IF EXISTS batch_status,
+    DROP COLUMN IF EXISTS completion_window;
diff --git a/internal/infrastructure/db/migrations/000009_warmup_batch_generation.up.sql b/internal/infrastructure/db/migrations/000009_warmup_batch_generation.up.sql
new file mode 100644
index 00000000..1735fe1f
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000009_warmup_batch_generation.up.sql
@@ -0,0 +1,25 @@
+-- Warmup batch generation.
+--
+-- The offline warmup-content generator originally ran every model call
+-- synchronously (one chat-completion per thread). The OpenAI Batch API is ~50%
+-- cheaper and processes asynchronously (up to a 24h window), which is a much
+-- better fit for bulk thread-bank refills where latency does not matter.
+--
+-- This migration extends warmup_generation_jobs so one job row can represent
+-- either a synchronous run (mode='sync', the existing behaviour) or an async
+-- batch run (mode='batch'). For batch runs we track the OpenAI batch ID, the
+-- uploaded input file ID, the output file ID (populated when the batch
+-- completes), the last-observed OpenAI batch status, and the requested
+-- completion window. A background poller reconciles in-flight batch jobs against
+-- the OpenAI batch status and ingests results when they finish.
+
+ALTER TABLE ONLY public.warmup_generation_jobs
+    ADD COLUMN mode text NOT NULL DEFAULT 'sync',
+    ADD COLUMN batch_id text NOT NULL DEFAULT '',
+    ADD COLUMN batch_input_file_id text NOT NULL DEFAULT '',
+    ADD COLUMN batch_output_file_id text NOT NULL DEFAULT '',
+    ADD COLUMN batch_status text NOT NULL DEFAULT '',
+    ADD COLUMN completion_window text NOT NULL DEFAULT '24h';
+
+-- The poller scans for in-flight batch jobs by mode + status, so index that.
+CREATE INDEX idx_warmup_generation_jobs_batch ON public.warmup_generation_jobs USING btree (mode, status, batch_status);
diff --git a/internal/infrastructure/db/migrations/000010_warmup_pick_index.down.sql b/internal/infrastructure/db/migrations/000010_warmup_pick_index.down.sql
new file mode 100644
index 00000000..3722de0f
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000010_warmup_pick_index.down.sql
@@ -0,0 +1,4 @@
+DROP INDEX IF EXISTS public.idx_warmup_conversations_pick;
+
+CREATE INDEX idx_warmup_conversations_pick ON public.warmup_conversations
+    USING btree (pool_type, segment, status);
diff --git a/internal/infrastructure/db/migrations/000010_warmup_pick_index.up.sql b/internal/infrastructure/db/migrations/000010_warmup_pick_index.up.sql
new file mode 100644
index 00000000..5cd6b67a
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000010_warmup_pick_index.up.sql
@@ -0,0 +1,13 @@
+-- Realign the content-pick index with the shared-library selection predicate.
+--
+-- PickConversation no longer filters by pool_type (content is one shared library;
+-- pools only isolate mailbox reputation). It now selects:
+--   WHERE status = 'active' AND (segment = $1 OR segment = '')
+-- so the old idx_warmup_conversations_pick (pool_type, segment, status) — which
+-- leads on the unused pool_type column — no longer matches. Replace it with a
+-- partial index on the columns actually filtered.
+
+DROP INDEX IF EXISTS public.idx_warmup_conversations_pick;
+
+CREATE INDEX idx_warmup_conversations_pick ON public.warmup_conversations
+    USING btree (segment) WHERE (status = 'active'::text);
diff --git a/internal/infrastructure/db/migrations/000011_email_verification.down.sql b/internal/infrastructure/db/migrations/000011_email_verification.down.sql
new file mode 100644
index 00000000..cb5b7fc7
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000011_email_verification.down.sql
@@ -0,0 +1,8 @@
+DROP INDEX IF EXISTS public.idx_contacts_verification_status;
+DROP INDEX IF EXISTS public.idx_contacts_verification_pending;
+
+ALTER TABLE public.contacts
+    DROP COLUMN IF EXISTS verification_checked_at,
+    DROP COLUMN IF EXISTS is_catch_all,
+    DROP COLUMN IF EXISTS verification_reason,
+    DROP COLUMN IF EXISTS verification_status;
diff --git a/internal/infrastructure/db/migrations/000011_email_verification.up.sql b/internal/infrastructure/db/migrations/000011_email_verification.up.sql
new file mode 100644
index 00000000..b12fecbc
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000011_email_verification.up.sql
@@ -0,0 +1,28 @@
+-- Pre-send email verification columns on contacts.
+--
+-- Suppression today is reactive: we only stop sending to an address *after* it
+-- hard-bounces or complains, so every bad address costs a real bounce against
+-- our sending reputation. These columns let the control plane verify an address
+-- (syntax -> MX -> SMTP RCPT probe -> catch-all detection) before any worker
+-- sends to it, turning a future hard bounce into a zero-cost pre-send drop.
+--
+-- status values mirror emailverify.Status: 'valid' | 'risky' | 'invalid' |
+-- 'unknown'. New contacts default to 'unknown' so the verification scheduler
+-- picks them up; the pre-send gate only ever drops 'invalid'.
+
+ALTER TABLE public.contacts
+    ADD COLUMN IF NOT EXISTS verification_status text NOT NULL DEFAULT 'unknown',
+    ADD COLUMN IF NOT EXISTS verification_reason text NOT NULL DEFAULT '',
+    ADD COLUMN IF NOT EXISTS is_catch_all boolean NOT NULL DEFAULT false,
+    ADD COLUMN IF NOT EXISTS verification_checked_at timestamptz;
+
+-- Partial index over the addresses the batch scheduler scans for: anything not
+-- yet conclusively checked (status = 'unknown' AND never verified). Keeps
+-- ListUnverifiedContacts a cheap index scan instead of a full table sweep.
+CREATE INDEX IF NOT EXISTS idx_contacts_verification_pending
+    ON public.contacts (verification_checked_at)
+    WHERE verification_status = 'unknown' AND verification_checked_at IS NULL;
+
+-- Supports the pre-send gate's "is this contact invalid?" lookups.
+CREATE INDEX IF NOT EXISTS idx_contacts_verification_status
+    ON public.contacts (verification_status);
diff --git a/internal/infrastructure/db/migrations/000012_seed_placement.down.sql b/internal/infrastructure/db/migrations/000012_seed_placement.down.sql
new file mode 100644
index 00000000..0b349bec
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000012_seed_placement.down.sql
@@ -0,0 +1,5 @@
+DROP TABLE IF EXISTS placement_results;
+DROP TABLE IF EXISTS placement_tests;
+
+DROP INDEX IF EXISTS idx_email_accounts_is_seed;
+ALTER TABLE email_accounts DROP COLUMN IF EXISTS is_seed;
diff --git a/internal/infrastructure/db/migrations/000012_seed_placement.up.sql b/internal/infrastructure/db/migrations/000012_seed_placement.up.sql
new file mode 100644
index 00000000..776b9f76
--- /dev/null
+++ b/internal/infrastructure/db/migrations/000012_seed_placement.up.sql
@@ -0,0 +1,54 @@
+-- Seed inbox-placement testing.
+--
+-- A "seed" mailbox is an ordinary connected + synced email_account that we
+-- flag with is_seed. Because it syncs like any other mailbox, mail it receives
+-- lands in unibox_emails — which is exactly where the placement poller looks
+-- up the per-test token and reads the folder/flags to classify where the test
+-- message landed (Inbox / Spam / Promotions / other), per provider.
+
+ALTER TABLE email_accounts
+    ADD COLUMN is_seed boolean NOT NULL DEFAULT false;
+
+-- Cheap lookup of the active seed panel.
+CREATE INDEX idx_email_accounts_is_seed
+    ON email_accounts (is_seed)
+    WHERE is_seed = true;
+
+-- A placement test: one tokenized copy of a template is sent from a chosen
+-- sender mailbox to every active seed. Status is "pending" while results are
+-- still being classified, "completed" once all resolve or the timeout passes.
+CREATE TABLE placement_tests (
+    id                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    organization_id   uuid REFERENCES organizations (id) ON DELETE CASCADE,
+    sender_account_id uuid NOT NULL REFERENCES email_accounts (id) ON DELETE CASCADE,
+    subject           text NOT NULL,
+    body_plain        text NOT NULL DEFAULT '',
+    body_html         text NOT NULL DEFAULT '',
+    token             text NOT NULL UNIQUE,
+    status            text NOT NULL DEFAULT 'pending',
+    created_at        timestamptz NOT NULL DEFAULT NOW(),
+    finished_at       timestamptz
+);
+
+CREATE INDEX idx_placement_tests_status ON placement_tests (status);
+CREATE INDEX idx_placement_tests_org ON placement_tests (organization_id, created_at DESC);
+
+-- One row per (test, seed). folder starts "pending" and is set when the
+-- token is found in that seed's unibox entries. provider records the seed
+-- mailbox's provider so results roll up per provider, not one flat rate.
+CREATE TABLE placement_results (
+    id              uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    test_id         uuid NOT NULL REFERENCES placement_tests (id) ON DELETE CASCADE,
+    seed_account_id uuid NOT NULL REFERENCES email_accounts (id) ON DELETE CASCADE,
+    provider        text NOT NULL DEFAULT '',
+    folder          text NOT NULL DEFAULT 'pending'
+        CHECK (folder IN ('inbox', 'promotions', 'spam', 'other', 'pending')),
+    detected_at     timestamptz,
+    raw_flags       text NOT NULL DEFAULT '',
+    UNIQUE (test_id, seed_account_id)
+);
+
+CREATE INDEX idx_placement_results_test ON placement_results (test_id);
+CREATE INDEX idx_placement_results_pending
+    ON placement_results (folder)
+    WHERE folder = 'pending';
diff --git a/internal/jobs/email_verification.go b/internal/jobs/email_verification.go
new file mode 100644
index 00000000..7e26e1e0
--- /dev/null
+++ b/internal/jobs/email_verification.go
@@ -0,0 +1,84 @@
+package jobs
+
+import (
+	"context"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+
+	emailverifyapp "github.com/warmbly/warmbly/internal/app/emailverify"
+)
+
+// EmailVerificationJob verifies a capped batch of not-yet-checked contacts each
+// run, so the platform can drop hard-bouncing addresses before any worker sends
+// to them. It is a thin wrapper around emailverify.Service.VerifyPending; the
+// per-tick cap bounds how much outbound SMTP-probe work one pass does.
+//
+// Control-plane only: the underlying verifier dials remote MX hosts on :25 and
+// must run from the backend/consumer, never a worker (sending) IP.
+type EmailVerificationJob struct {
+	svc       emailverifyapp.Service
+	batchSize int
+}
+
+// NewEmailVerificationJob creates the job. batchSize caps how many contacts are
+// verified per tick (defaults to 100 when non-positive).
+func NewEmailVerificationJob(svc emailverifyapp.Service, batchSize int) *EmailVerificationJob {
+	if batchSize <= 0 {
+		batchSize = 100
+	}
+	return &EmailVerificationJob{svc: svc, batchSize: batchSize}
+}
+
+// Run performs one capped verification pass. Safe to call frequently — it
+// no-ops when there are no unverified contacts.
+func (j *EmailVerificationJob) Run(ctx context.Context) error {
+	if j.svc == nil {
+		return nil
+	}
+	if _, err := j.svc.VerifyPending(ctx, j.batchSize); err != nil {
+		sentry.CaptureException(err)
+		return err
+	}
+	return nil
+}
+
+// EmailVerificationScheduler runs the job on a fixed interval.
+type EmailVerificationScheduler struct {
+	job      *EmailVerificationJob
+	interval time.Duration
+	stopCh   chan struct{}
+}
+
+// NewEmailVerificationScheduler creates the scheduler.
+func NewEmailVerificationScheduler(job *EmailVerificationJob, interval time.Duration) *EmailVerificationScheduler {
+	return &EmailVerificationScheduler{
+		job:      job,
+		interval: interval,
+		stopCh:   make(chan struct{}),
+	}
+}
+
+// Start begins scheduled execution.
+func (s *EmailVerificationScheduler) Start(ctx context.Context) {
+	ticker := time.NewTicker(s.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if err := s.job.Run(ctx); err != nil {
+				sentry.CaptureException(err)
+			}
+		case <-s.stopCh:
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// Stop halts the scheduled execution.
+func (s *EmailVerificationScheduler) Stop() {
+	close(s.stopCh)
+}
diff --git a/internal/jobs/placement_poller.go b/internal/jobs/placement_poller.go
new file mode 100644
index 00000000..fba25481
--- /dev/null
+++ b/internal/jobs/placement_poller.go
@@ -0,0 +1,72 @@
+package jobs
+
+import (
+	"context"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+
+	"github.com/warmbly/warmbly/internal/app/placement"
+)
+
+// PlacementPoller reconciles pending seed inbox-placement results: each tick it
+// looks up each in-flight test's token in the receiving seed's unibox entries
+// and classifies where the probe landed (Inbox / Spam / Promotions / other),
+// completing the test once every result resolves or the classify timeout
+// passes. It is a thin scheduler around placement.Service.ClassifyPending; all
+// policy lives in the service. A ~2-minute tick balances responsiveness against
+// the latency of mailbox sync delivering the probe into the unibox.
+type PlacementPoller struct {
+	svc      placement.Service
+	interval time.Duration
+	stopCh   chan struct{}
+}
+
+// NewPlacementPoller creates the poller.
+func NewPlacementPoller(svc placement.Service, interval time.Duration) *PlacementPoller {
+	if interval <= 0 {
+		interval = 2 * time.Minute
+	}
+	return &PlacementPoller{
+		svc:      svc,
+		interval: interval,
+		stopCh:   make(chan struct{}),
+	}
+}
+
+// Run performs one classification pass. Safe to call frequently — ClassifyPending
+// no-ops when there are no pending results.
+func (p *PlacementPoller) Run(ctx context.Context) error {
+	if p.svc == nil {
+		return nil
+	}
+	if err := p.svc.ClassifyPending(ctx); err != nil {
+		sentry.CaptureException(err)
+		return err
+	}
+	return nil
+}
+
+// Start begins scheduled execution on the configured interval.
+func (p *PlacementPoller) Start(ctx context.Context) {
+	ticker := time.NewTicker(p.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if err := p.Run(ctx); err != nil {
+				sentry.CaptureException(err)
+			}
+		case <-p.stopCh:
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// Stop halts scheduled execution.
+func (p *PlacementPoller) Stop() {
+	close(p.stopCh)
+}
diff --git a/internal/jobs/warmup_batch_poller.go b/internal/jobs/warmup_batch_poller.go
new file mode 100644
index 00000000..4e364f0a
--- /dev/null
+++ b/internal/jobs/warmup_batch_poller.go
@@ -0,0 +1,70 @@
+package jobs
+
+import (
+	"context"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+
+	"github.com/warmbly/warmbly/internal/app/warmupcontent"
+)
+
+// WarmupBatchPoller reconciles in-flight OpenAI Batch API warmup-generation jobs:
+// it polls each active batch, ingests completed ones into the content bank, and
+// marks failed/expired/cancelled ones. It is a thin scheduler around
+// warmupcontent.Service.PollBatches; all policy lives in the service. Batches run
+// async (up to a 24h window) so a coarse 5-minute tick is plenty.
+type WarmupBatchPoller struct {
+	svc      warmupcontent.Service
+	interval time.Duration
+	stopCh   chan struct{}
+}
+
+// NewWarmupBatchPoller creates the poller.
+func NewWarmupBatchPoller(svc warmupcontent.Service, interval time.Duration) *WarmupBatchPoller {
+	if interval <= 0 {
+		interval = 5 * time.Minute
+	}
+	return &WarmupBatchPoller{
+		svc:      svc,
+		interval: interval,
+		stopCh:   make(chan struct{}),
+	}
+}
+
+// Run performs one reconciliation pass. Safe to call frequently — PollBatches
+// no-ops when generation is unconfigured or there are no active batch jobs.
+func (p *WarmupBatchPoller) Run(ctx context.Context) error {
+	if p.svc == nil || !p.svc.Enabled() {
+		return nil
+	}
+	if err := p.svc.PollBatches(ctx); err != nil {
+		sentry.CaptureException(err)
+		return err
+	}
+	return nil
+}
+
+// Start begins scheduled execution on the configured interval.
+func (p *WarmupBatchPoller) Start(ctx context.Context) {
+	ticker := time.NewTicker(p.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if err := p.Run(ctx); err != nil {
+				sentry.CaptureException(err)
+			}
+		case <-p.stopCh:
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// Stop halts scheduled execution.
+func (p *WarmupBatchPoller) Stop() {
+	close(p.stopCh)
+}
diff --git a/internal/jobs/warmup_generation.go b/internal/jobs/warmup_generation.go
new file mode 100644
index 00000000..6607f848
--- /dev/null
+++ b/internal/jobs/warmup_generation.go
@@ -0,0 +1,102 @@
+package jobs
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+
+	"github.com/warmbly/warmbly/internal/app/warmupcontent"
+	"github.com/warmbly/warmbly/internal/repository"
+)
+
+// WarmupGenerationJob periodically tops up the warmup content bank toward the
+// per-pool/segment targets in the admin settings. It is a thin scheduler around
+// warmupcontent.Service.RunScheduled; all policy (enabled, cadence, caps,
+// targets) lives in the settings so admins keep full control.
+type WarmupGenerationJob struct {
+	svc  warmupcontent.Service
+	repo repository.WarmupContentRepository
+
+	mu      sync.Mutex
+	lastRun time.Time
+}
+
+// NewWarmupGenerationJob creates the job.
+func NewWarmupGenerationJob(svc warmupcontent.Service, repo repository.WarmupContentRepository) *WarmupGenerationJob {
+	return &WarmupGenerationJob{svc: svc, repo: repo}
+}
+
+// Run performs one top-up pass when scheduling is enabled and the configured
+// cadence has elapsed. Safe to call frequently — it no-ops when there's nothing
+// to do.
+func (j *WarmupGenerationJob) Run(ctx context.Context) error {
+	if j.svc == nil || j.repo == nil || !j.svc.Enabled() {
+		return nil
+	}
+	settings, err := j.repo.GetGenerationSettings(ctx)
+	if err != nil {
+		sentry.CaptureException(err)
+		return err
+	}
+	if settings == nil || !settings.ScheduleEnabled {
+		return nil
+	}
+
+	cadence := time.Duration(settings.CadenceHours) * time.Hour
+	j.mu.Lock()
+	if !j.lastRun.IsZero() && cadence > 0 && time.Since(j.lastRun) < cadence {
+		j.mu.Unlock()
+		return nil
+	}
+	j.lastRun = time.Now()
+	j.mu.Unlock()
+
+	if err := j.svc.RunScheduled(ctx); err != nil {
+		sentry.CaptureException(err)
+		return err
+	}
+	return nil
+}
+
+// WarmupGenerationScheduler runs the job on a fixed interval (the per-run
+// cadence gate inside Run honours the admin's configured cadence_hours).
+type WarmupGenerationScheduler struct {
+	job      *WarmupGenerationJob
+	interval time.Duration
+	stopCh   chan struct{}
+}
+
+// NewWarmupGenerationScheduler creates the scheduler.
+func NewWarmupGenerationScheduler(job *WarmupGenerationJob, interval time.Duration) *WarmupGenerationScheduler {
+	return &WarmupGenerationScheduler{
+		job:      job,
+		interval: interval,
+		stopCh:   make(chan struct{}),
+	}
+}
+
+// Start begins scheduled execution.
+func (s *WarmupGenerationScheduler) Start(ctx context.Context) {
+	ticker := time.NewTicker(s.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if err := s.job.Run(ctx); err != nil {
+				sentry.CaptureException(err)
+			}
+		case <-s.stopCh:
+			return
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// Stop halts the scheduled execution.
+func (s *WarmupGenerationScheduler) Stop() {
+	close(s.stopCh)
+}
diff --git a/internal/models/contact.go b/internal/models/contact.go
index eea4d237..97337611 100644
--- a/internal/models/contact.go
+++ b/internal/models/contact.go
@@ -30,6 +30,15 @@ type Contact struct {
 	Campaigns  []MiniCampaign `json:"campaigns"`
 	Categories []MiniCategory `json:"categories"`
 
+	// Pre-send verification state (see internal/pkg/emailverify). Populated by
+	// the verification scheduler / on-demand verify; the campaign send path uses
+	// VerificationStatus == "invalid" to drop addresses before a worker sends.
+	// VerificationStatus is one of: valid | risky | invalid | unknown.
+	VerificationStatus    string     `json:"verification_status"`
+	VerificationReason    string     `json:"verification_reason"`
+	IsCatchAll            bool       `json:"is_catch_all"`
+	VerificationCheckedAt *time.Time `json:"verification_checked_at,omitempty"`
+
 	UpdatedAt time.Time `json:"updated_at"`
 	CreatedAt time.Time `json:"created_at"`
 }
diff --git a/internal/models/email.go b/internal/models/email.go
index 94c0275a..78508886 100644
--- a/internal/models/email.go
+++ b/internal/models/email.go
@@ -165,6 +165,7 @@ type UpdateEmail struct {
 	WarmupMax       *int    `json:"warmup_max"`
 	WarmupIncrease  *int    `json:"warmup_increase"`
 	WarmupReplyRate *int    `json:"warmup_reply_rate"`
+	WarmupTag       *string `json:"warmup_tag"`
 	WarmupStartTime *string `json:"warmup_start_time"`
 	WarmupEndTime   *string `json:"warmup_end_time"`
 	WarmupDays      *int    `json:"warmup_days"`
diff --git a/internal/models/warmup.go b/internal/models/warmup.go
index fbd91070..fc5d9295 100644
--- a/internal/models/warmup.go
+++ b/internal/models/warmup.go
@@ -7,14 +7,20 @@ import (
 )
 
 type WarmupToken struct {
-	Token              uuid.UUID  `json:"token"`
-	TaskID             uuid.UUID  `json:"task_id"`
-	SenderAccountID    uuid.UUID  `json:"sender_account_id"`
-	RecipientAccountID uuid.UUID  `json:"recipient_account_id"`
-	ConversationTheme  string     `json:"conversation_theme"`
-	CreatedAt          time.Time  `json:"created_at"`
-	ConsumedAt         *time.Time `json:"consumed_at,omitempty"`
-	ExpiresAt          time.Time  `json:"expires_at"`
+	Token              uuid.UUID `json:"token"`
+	TaskID             uuid.UUID `json:"task_id"`
+	SenderAccountID    uuid.UUID `json:"sender_account_id"`
+	RecipientAccountID uuid.UUID `json:"recipient_account_id"`
+	ConversationTheme  string    `json:"conversation_theme"`
+	// ContentSource records which content cohort produced this send
+	// ("static" or "ai") so the A/B harness can compare spam-placement
+	// rate by cohort. ConversationID points at the cached warmup_conversations
+	// row when the body came from the AI bank (nil for static content).
+	ContentSource  string     `json:"content_source"`
+	ConversationID *uuid.UUID `json:"conversation_id,omitempty"`
+	CreatedAt      time.Time  `json:"created_at"`
+	ConsumedAt     *time.Time `json:"consumed_at,omitempty"`
+	ExpiresAt      time.Time  `json:"expires_at"`
 }
 
 // WarmupEmailAction represents actions to perform on a detected warmup email.
@@ -30,6 +36,15 @@ type WarmupEmailAction struct {
 	UID                uint32    `json:"uid"`
 	MailboxUIDValidity uint32    `json:"mailbox_uid_validity"`
 	Actions            []string  `json:"actions"` // "move_to_warmbly", "mark_read", "remove_from_spam", "mark_important"
+
+	// DelaySeconds is retained for wire compatibility but is now always 0: the
+	// recipient-side "dwell" is owned by the consumer's durable schedule
+	// (warmup_pending_engagements + the engagement poller), which publishes the
+	// immediate leg (folder + spam-rescue) now and the delayed leg (read /
+	// important / star) when due. The worker runs whatever it receives
+	// immediately. This survives a worker restart, which the old in-process
+	// timer did not.
+	DelaySeconds int `json:"delay_seconds,omitempty"`
 }
 
 type WarmupHealthState string
@@ -57,13 +72,31 @@ type WarmupParticipantHealth struct {
 	LastHealthEvaluatedAt *time.Time        `json:"last_health_evaluated_at,omitempty"`
 }
 
+// WarmupBanStatus is the user-facing view of a mailbox's warmup standing,
+// returned by GetBanStatus so the dashboard can show why warmup is blocked and
+// whether the user can appeal.
+type WarmupBanStatus struct {
+	EmailAccountID uuid.UUID  `json:"email_account_id"`
+	Blocked        bool       `json:"blocked"`
+	HealthState    string     `json:"health_state"`
+	Reason         string     `json:"reason,omitempty"`
+	BlockedAt      *time.Time `json:"blocked_at,omitempty"`
+	BlockedUntil   *time.Time `json:"blocked_until,omitempty"`
+	CanAppeal      bool       `json:"can_appeal"`
+	PendingAppeal  bool       `json:"pending_appeal"`
+}
+
 type WarmupPoolHealthSummary struct {
 	TotalParticipants int            `json:"total_participants"`
 	ByState           map[string]int `json:"by_state"`
 	AvgSpamScore      float64        `json:"avg_spam_score"`
 	AvgSpamPlacement  float64        `json:"avg_spam_placement_rate"`
-	BlockedCount      int            `json:"blocked_count"`
-	AtRiskCount       int            `json:"at_risk_count"`
+	// SpamPlacementByProvider breaks recent spam-placement counts down by the
+	// recipient provider so the admin can see where warmup mail is being
+	// filtered (e.g. mostly at Outlook vs Gmail) rather than one flat rate.
+	SpamPlacementByProvider map[string]int `json:"spam_placement_by_provider"`
+	BlockedCount            int            `json:"blocked_count"`
+	AtRiskCount             int            `json:"at_risk_count"`
 }
 
 type WarmupHealthMetrics struct {
diff --git a/internal/models/warmup_content.go b/internal/models/warmup_content.go
new file mode 100644
index 00000000..137abf57
--- /dev/null
+++ b/internal/models/warmup_content.go
@@ -0,0 +1,226 @@
+package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// Content sources for warmup message bodies. "static" is the in-code library;
+// "ai" is a thread drawn from the offline-generated warmup_conversations bank.
+const (
+	WarmupContentSourceStatic = "static"
+	WarmupContentSourceAI     = "ai"
+)
+
+// AdminSettingsKeyWarmupGeneration is the admin_settings key under which the
+// warmup generation + engagement config document is stored.
+const AdminSettingsKeyWarmupGeneration = "warmup_generation"
+
+// WarmupConversation is a cached conversation thread used as warmup content.
+// Messages are the follow-up question lines the sender can pick from; the
+// Description is the opening body line. Both may contain {a|b|c} spintax,
+// which is expanded at render time.
+type WarmupConversation struct {
+	ID             uuid.UUID  `json:"id"`
+	PoolType       string     `json:"pool_type"`
+	Segment        string     `json:"segment"`
+	Source         string     `json:"source"`
+	Theme          string     `json:"theme"`
+	Subject        string     `json:"subject"`
+	Description    string     `json:"description"`
+	Messages       []string   `json:"messages"`
+	Status         string     `json:"status"`
+	LintPassed     bool       `json:"lint_passed"`
+	UsageCount     int64      `json:"usage_count"`
+	GeneratedByJob *uuid.UUID `json:"generated_by_job_id,omitempty"`
+	CreatedAt      time.Time  `json:"created_at"`
+	UpdatedAt      time.Time  `json:"updated_at"`
+}
+
+// Warmup generation job modes. "sync" runs every model call inline (the
+// original behaviour); "batch" submits one OpenAI Batch API job and ingests its
+// results asynchronously when the batch completes.
+const (
+	WarmupGenerationModeSync  = "sync"
+	WarmupGenerationModeBatch = "batch"
+)
+
+// WarmupGenerationJob records one offline generation run for observability.
+// Batch runs additionally carry the OpenAI batch/file identifiers and the
+// last-observed batch status so the poller can reconcile them.
+type WarmupGenerationJob struct {
+	ID                uuid.UUID  `json:"id"`
+	RequestedBy       *uuid.UUID `json:"requested_by,omitempty"`
+	Trigger           string     `json:"trigger"` // "manual" | "schedule"
+	Mode              string     `json:"mode"`    // "sync" | "batch"
+	PoolType          string     `json:"pool_type"`
+	Segment           string     `json:"segment"`
+	Theme             string     `json:"theme"`
+	Model             string     `json:"model"`
+	RequestedCount    int        `json:"requested_count"`
+	GeneratedCount    int        `json:"generated_count"`
+	LintRejectedCount int        `json:"lint_rejected_count"`
+	FailedCount       int        `json:"failed_count"`
+	Status            string     `json:"status"` // pending | running | completed | failed
+	Error             string     `json:"error"`
+	// Batch-only fields. BatchStatus is the last status reported by OpenAI
+	// (validating | in_progress | finalizing | completed | failed | expired |
+	// cancelling | cancelled); empty for sync jobs.
+	BatchID           string     `json:"batch_id,omitempty"`
+	BatchInputFileID  string     `json:"batch_input_file_id,omitempty"`
+	BatchOutputFileID string     `json:"batch_output_file_id,omitempty"`
+	BatchStatus       string     `json:"batch_status,omitempty"`
+	CompletionWindow  string     `json:"completion_window,omitempty"`
+	StartedAt         *time.Time `json:"started_at,omitempty"`
+	FinishedAt        *time.Time `json:"finished_at,omitempty"`
+	CreatedAt         time.Time  `json:"created_at"`
+	UpdatedAt         time.Time  `json:"updated_at"`
+}
+
+// WarmupGenerationPoolConfig is per-pool generation policy.
+type WarmupGenerationPoolConfig struct {
+	PoolType            string   `json:"pool_type"`
+	Enabled             bool     `json:"enabled"`
+	TargetActiveThreads int      `json:"target_active_threads"`
+	Segments            []string `json:"segments"`
+}
+
+// WarmupEngagementSettings controls how recipient-side warmup engagement
+// actions are selected. Rates are percentages (0-100). Defaults preserve the
+// previous always-on rescue behaviour but break the uniform "every account
+// marks important, instantly" bot signature with per-mailbox probability and
+// a randomised dwell delay.
+type WarmupEngagementSettings struct {
+	SpamRescueRate    int `json:"spam_rescue_rate"`
+	MarkImportantRate int `json:"mark_important_rate"`
+	MarkReadRate      int `json:"mark_read_rate"`
+	// StarRate is the chance a warmup message is starred (Gmail STARRED). A
+	// star is a deliberate positive signal distinct from "important"; kept
+	// lower than read/important so the pool doesn't star in lockstep.
+	StarRate        int `json:"star_rate"`
+	MinDwellSeconds int `json:"min_dwell_seconds"`
+	MaxDwellSeconds int `json:"max_dwell_seconds"`
+}
+
+// WarmupGenerationSettings is the admin-controlled config document for the
+// offline AI thread-bank and recipient engagement. Stored as JSON in
+// admin_settings under AdminSettingsKeyWarmupGeneration.
+type WarmupGenerationSettings struct {
+	// Enabled is the master switch for using AI-generated content in the
+	// live send selection. When false the static library is used exclusively.
+	Enabled bool `json:"enabled"`
+	// ScheduleEnabled runs the background generation job on CadenceHours.
+	ScheduleEnabled      bool                         `json:"schedule_enabled"`
+	CadenceHours         int                          `json:"cadence_hours"`
+	Model                string                       `json:"model"`
+	MaxMessagesPerThread int                          `json:"max_messages_per_thread"`
+	DailyGenerationCap   int                          `json:"daily_generation_cap"`
+	AISelectionShare     int                          `json:"ai_selection_share"` // 0-100
+	Pools                []WarmupGenerationPoolConfig `json:"pools"`
+	Engagement           WarmupEngagementSettings     `json:"engagement"`
+}
+
+// DefaultWarmupGenerationSettings returns conservative defaults: AI off (static
+// library only) and engagement rates that keep the strong "not spam" rescue
+// signal while adding variation and dwell. Content is ONE shared library
+// (free/premium pools only isolate mailbox reputation, not content), so there's
+// a single library config; "premium" is just its canonical bucket label.
+func DefaultWarmupGenerationSettings() WarmupGenerationSettings {
+	return WarmupGenerationSettings{
+		Enabled:              false,
+		ScheduleEnabled:      false,
+		CadenceHours:         24,
+		Model:                "gpt-4o-mini",
+		MaxMessagesPerThread: 6,
+		DailyGenerationCap:   200,
+		AISelectionShare:     50,
+		Pools: []WarmupGenerationPoolConfig{
+			{PoolType: "premium", Enabled: true, TargetActiveThreads: 60, Segments: []string{""}},
+		},
+		Engagement: WarmupEngagementSettings{
+			SpamRescueRate:    85,
+			MarkImportantRate: 30,
+			MarkReadRate:      95,
+			StarRate:          20,
+			MinDwellSeconds:   20,
+			MaxDwellSeconds:   240,
+		},
+	}
+}
+
+// Normalize clamps settings into safe ranges so a bad admin payload can't
+// produce nonsense (negative counts, percentages over 100, inverted dwell).
+func (s *WarmupGenerationSettings) Normalize() {
+	if s.CadenceHours < 1 {
+		s.CadenceHours = 1
+	}
+	if s.Model == "" {
+		s.Model = "gpt-4o-mini"
+	}
+	if s.MaxMessagesPerThread < 1 {
+		s.MaxMessagesPerThread = 1
+	}
+	if s.MaxMessagesPerThread > 20 {
+		s.MaxMessagesPerThread = 20
+	}
+	if s.DailyGenerationCap < 0 {
+		s.DailyGenerationCap = 0
+	}
+	s.AISelectionShare = clampPct(s.AISelectionShare)
+	s.Engagement.SpamRescueRate = clampPct(s.Engagement.SpamRescueRate)
+	s.Engagement.MarkImportantRate = clampPct(s.Engagement.MarkImportantRate)
+	s.Engagement.MarkReadRate = clampPct(s.Engagement.MarkReadRate)
+	s.Engagement.StarRate = clampPct(s.Engagement.StarRate)
+	if s.Engagement.MinDwellSeconds < 0 {
+		s.Engagement.MinDwellSeconds = 0
+	}
+	if s.Engagement.MaxDwellSeconds < s.Engagement.MinDwellSeconds {
+		s.Engagement.MaxDwellSeconds = s.Engagement.MinDwellSeconds
+	}
+	if s.Engagement.MaxDwellSeconds > 3600 {
+		s.Engagement.MaxDwellSeconds = 3600
+	}
+
+	// Collapse to a single shared content library. Content isn't split by tier
+	// (PickConversation ignores pool_type), so a multi-pool config would leave a
+	// dead, never-topped-up branch and contradict the single-library admin UI.
+	// Keep one entry under the canonical "premium" bucket, preferring an enabled
+	// one from any legacy multi-pool doc.
+	s.collapsePools()
+}
+
+func (s *WarmupGenerationSettings) collapsePools() {
+	chosen := WarmupGenerationPoolConfig{PoolType: "premium", Enabled: true, TargetActiveThreads: 60, Segments: []string{""}}
+	for _, p := range s.Pools {
+		chosen = p
+		if p.Enabled {
+			break // prefer an enabled entry
+		}
+	}
+	chosen.PoolType = "premium"
+	if len(chosen.Segments) == 0 {
+		chosen.Segments = []string{""}
+	}
+	s.Pools = []WarmupGenerationPoolConfig{chosen}
+}
+
+func clampPct(v int) int {
+	if v < 0 {
+		return 0
+	}
+	if v > 100 {
+		return 100
+	}
+	return v
+}
+
+// PoolConfig returns the config for a pool type, or false when absent/disabled.
+func (s *WarmupGenerationSettings) PoolConfig(poolType string) (WarmupGenerationPoolConfig, bool) {
+	for _, p := range s.Pools {
+		if p.PoolType == poolType {
+			return p, true
+		}
+	}
+	return WarmupGenerationPoolConfig{}, false
+}
diff --git a/internal/models/webhook.go b/internal/models/webhook.go
index 06d9fdd1..6258d925 100644
--- a/internal/models/webhook.go
+++ b/internal/models/webhook.go
@@ -28,6 +28,10 @@ const (
 	WebhookEventCampaignStarted        WebhookEventType = "campaign.started"
 	WebhookEventCampaignPaused         WebhookEventType = "campaign.paused"
 	WebhookEventCampaignCompleted      WebhookEventType = "campaign.completed"
+	// campaign.deliverability_warning fires when a campaign's rolling
+	// bounce/complaint rate enters the early-warning band (half the pause
+	// threshold) — a graduated signal short of an auto-pause.
+	WebhookEventCampaignDeliverabilityWarning WebhookEventType = "campaign.deliverability_warning"
 
 	// Warmup
 	WebhookEventWarmupEmailSent       WebhookEventType = "warmup.email_sent"
@@ -56,6 +60,7 @@ var AllWebhookEventTypes = []WebhookEventType{
 	WebhookEventCampaignStarted,
 	WebhookEventCampaignPaused,
 	WebhookEventCampaignCompleted,
+	WebhookEventCampaignDeliverabilityWarning,
 	WebhookEventWarmupEmailSent,
 	WebhookEventWarmupHealthChanged,
 	WebhookEventWarmupPlacementInSpam,
diff --git a/internal/pkg/dnsauth/dnsauth.go b/internal/pkg/dnsauth/dnsauth.go
new file mode 100644
index 00000000..7f5c0cae
--- /dev/null
+++ b/internal/pkg/dnsauth/dnsauth.go
@@ -0,0 +1,125 @@
+// Package dnsauth validates a sending domain's email authentication records
+// (SPF, DKIM, DMARC) via DNS TXT lookups. Authentication alignment is a hard
+// Google/Yahoo bulk-sender requirement and the most common silent deliverability
+// failure, so this lets the platform surface missing/misconfigured records.
+//
+// Control-plane only: this performs outbound DNS lookups and is meant to run in
+// the backend (on demand or on a schedule), never in the worker.
+package dnsauth
+
+import (
+	"context"
+	"net"
+	"strings"
+	"time"
+)
+
+// Result is the outcome of an authentication check for one domain.
+type Result struct {
+	Domain        string   `json:"domain"`
+	SPFFound      bool     `json:"spf_found"`
+	SPFRecord     string   `json:"spf_record,omitempty"`
+	DKIMFound     bool     `json:"dkim_found"`
+	DKIMSelectors []string `json:"dkim_selectors,omitempty"`
+	DMARCFound    bool     `json:"dmarc_found"`
+	DMARCPolicy   string   `json:"dmarc_policy,omitempty"`
+	AllAligned    bool     `json:"all_aligned"`
+	Summary       string   `json:"summary"`
+}
+
+// defaultSelectors are common DKIM selectors to probe when the caller doesn't
+// know the domain's selector. DKIM selectors aren't discoverable from DNS, so a
+// "not found" only means none of these matched, not that DKIM is absent.
+var defaultSelectors = []string{"google", "default", "selector1", "selector2", "k1", "mail", "dkim", "s1", "s2"}
+
+const lookupTimeout = 5 * time.Second
+
+// Check validates SPF, DKIM and DMARC for the domain. dkimSelectors may be nil
+// to probe a default selector set.
+func Check(ctx context.Context, domain string, dkimSelectors []string) Result {
+	domain = strings.ToLower(strings.TrimSpace(domain))
+	res := Result{Domain: domain}
+	if domain == "" {
+		res.Summary = "no domain to check"
+		return res
+	}
+
+	resolver := &net.Resolver{}
+	lookup := func(name string) []string {
+		c, cancel := context.WithTimeout(ctx, lookupTimeout)
+		defer cancel()
+		txts, err := resolver.LookupTXT(c, name)
+		if err != nil {
+			return nil
+		}
+		return txts
+	}
+
+	// SPF: a TXT record on the root domain beginning v=spf1.
+	for _, t := range lookup(domain) {
+		if strings.HasPrefix(strings.ToLower(strings.TrimSpace(t)), "v=spf1") {
+			res.SPFFound = true
+			res.SPFRecord = strings.TrimSpace(t)
+			break
+		}
+	}
+
+	// DMARC: a TXT record at _dmarc.<domain> containing v=DMARC1; capture p=.
+	for _, t := range lookup("_dmarc." + domain) {
+		if strings.Contains(strings.ToLower(t), "v=dmarc1") {
+			res.DMARCFound = true
+			res.DMARCPolicy = parseDMARCPolicy(t)
+			break
+		}
+	}
+
+	// DKIM: a TXT record at <selector>._domainkey.<domain>.
+	if len(dkimSelectors) == 0 {
+		dkimSelectors = defaultSelectors
+	}
+	for _, sel := range dkimSelectors {
+		for _, t := range lookup(sel + "._domainkey." + domain) {
+			lt := strings.ToLower(t)
+			if strings.Contains(lt, "v=dkim1") || strings.Contains(lt, "k=rsa") || strings.Contains(lt, "p=") {
+				res.DKIMFound = true
+				res.DKIMSelectors = append(res.DKIMSelectors, sel)
+				break
+			}
+		}
+	}
+
+	res.AllAligned = res.SPFFound && res.DKIMFound && res.DMARCFound
+	res.Summary = summarize(res)
+	return res
+}
+
+func parseDMARCPolicy(record string) string {
+	for _, part := range strings.Split(record, ";") {
+		part = strings.TrimSpace(strings.ToLower(part))
+		if strings.HasPrefix(part, "p=") {
+			return strings.TrimSpace(strings.TrimPrefix(part, "p="))
+		}
+	}
+	return ""
+}
+
+func summarize(r Result) string {
+	var missing []string
+	if !r.SPFFound {
+		missing = append(missing, "SPF")
+	}
+	if !r.DKIMFound {
+		missing = append(missing, "DKIM")
+	}
+	if !r.DMARCFound {
+		missing = append(missing, "DMARC")
+	}
+	if len(missing) == 0 {
+		policy := r.DMARCPolicy
+		if policy == "" {
+			policy = "none"
+		}
+		return "SPF, DKIM and DMARC all present (DMARC policy: " + policy + ")"
+	}
+	return "missing or unverifiable: " + strings.Join(missing, ", ")
+}
diff --git a/internal/pkg/emailverify/emailverify.go b/internal/pkg/emailverify/emailverify.go
new file mode 100644
index 00000000..04a4a666
--- /dev/null
+++ b/internal/pkg/emailverify/emailverify.go
@@ -0,0 +1,350 @@
+// Package emailverify performs pre-send email verification so the platform can
+// drop addresses that would hard-bounce *before* a worker ever sends to them.
+// Today suppression is purely reactive (we only suppress after a bounce/complaint
+// lands), which means every bad address costs us one real bounce against our
+// sending reputation. Verifying up front turns that into a zero-bounce drop.
+//
+// CONTROL-PLANE ONLY. This package dials remote MX hosts on :25 to run an SMTP
+// RCPT probe. That probe MUST run from the backend/consumer (a dedicated,
+// non-sending IP), never from a worker. Workers are our sending IPs, and running
+// RCPT probes from them pollutes the exact reputation this feature exists to
+// protect — recipient servers treat probe traffic from a sending IP as
+// suspicious, and a probe that gets greylisted/tarpitted ties up a sending
+// connection. Keep all probing on the control plane.
+//
+// Operational caveats baked into the design:
+//   - Many cloud providers (AWS, GCP, most consumer ISPs) block *outbound* :25.
+//     On such a host the SMTP probe will always time out and every address
+//     degrades to Status "unknown". Run the prober from a host with open
+//     outbound :25, or plug in a paid backend (see below).
+//   - Greylisting is normal and correct server behaviour: a first-contact RCPT
+//     often gets a 4xx "try again later". We deliberately map 4xx -> "unknown"
+//     (never "invalid") so greylisting can't cause us to drop a real contact.
+//   - Catch-all domains accept *every* localpart, so a 250 on the real address
+//     proves nothing. We detect catch-all by probing a random localpart; if that
+//     is also accepted the real address is downgraded to "risky", not "valid".
+//
+// For production-grade accuracy the Verifier interface is intentionally the only
+// contract the rest of the platform depends on. A paid provider (ZeroBounce,
+// NeverBounce, Bouncer, etc.) can be dropped in as an alternate Verifier
+// implementation without touching the service, repo, scheduler, or handler.
+package emailverify
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"net"
+	"net/mail"
+	"net/smtp"
+	"net/textproto"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Status is the verification outcome for a single address. It is a small closed
+// set so callers (and the DB column) can reason about it without parsing free
+// text.
+type Status string
+
+const (
+	// StatusValid means syntax + MX + an accepted RCPT on a non-catch-all domain.
+	StatusValid Status = "valid"
+	// StatusRisky means deliverable-looking but unsafe to trust — primarily a
+	// catch-all domain where acceptance proves nothing.
+	StatusRisky Status = "risky"
+	// StatusInvalid means a hard failure: bad syntax, no MX, or a 550-class RCPT
+	// rejection. These are the addresses the pre-send gate should drop.
+	StatusInvalid Status = "invalid"
+	// StatusUnknown means we couldn't determine deliverability — timeout, 4xx
+	// greylisting, blocked outbound :25, or any transient/ambiguous condition.
+	// Unknown is never dropped; it is retried or sent cautiously.
+	StatusUnknown Status = "unknown"
+)
+
+// Result is the outcome of verifying one address. It round-trips into the
+// contacts table (verification_status / verification_reason / is_catch_all /
+// verification_checked_at).
+type Result struct {
+	Email      string    `json:"email"`
+	Status     Status    `json:"status"`
+	Reason     string    `json:"reason"`
+	IsCatchAll bool      `json:"is_catch_all"`
+	HasMX      bool      `json:"has_mx"`
+	CheckedAt  time.Time `json:"checked_at"`
+}
+
+// Verifier is the single contract the rest of the platform depends on. The
+// in-house SMTPVerifier implements it; a paid provider can implement the same
+// interface and be swapped in at wiring time with no other code changes.
+type Verifier interface {
+	Verify(ctx context.Context, email string) Result
+}
+
+// Config tunes the in-house SMTP prober. HeloHost is the hostname sent in
+// EHLO/HELO and MailFrom is the envelope sender used in MAIL FROM. Both should
+// be real, attributable values for the verifying (non-sending) host so remote
+// servers see consistent, non-spoofed probe identity. Timeouts default to sane
+// values when zero.
+type Config struct {
+	// HeloHost is the hostname announced in EHLO/HELO, e.g. "verify.warmbly.com".
+	HeloHost string
+	// MailFrom is the envelope sender for the probe, e.g. "verify@warmbly.com".
+	// An empty MAIL FROM ("<>") is technically valid but more often filtered, so
+	// a real address on the verifying host is preferred.
+	MailFrom string
+	// DialTimeout bounds the TCP connect to a single MX host. Default 5s.
+	DialTimeout time.Duration
+	// CommandTimeout bounds each SMTP command exchange. Default 5s.
+	CommandTimeout time.Duration
+	// MXTimeout bounds the MX DNS lookup. Default 5s.
+	MXTimeout time.Duration
+}
+
+func (c Config) withDefaults() Config {
+	if c.HeloHost == "" {
+		c.HeloHost = "localhost"
+	}
+	if c.MailFrom == "" {
+		c.MailFrom = "verify@" + c.HeloHost
+	}
+	if c.DialTimeout <= 0 {
+		c.DialTimeout = 5 * time.Second
+	}
+	if c.CommandTimeout <= 0 {
+		c.CommandTimeout = 5 * time.Second
+	}
+	if c.MXTimeout <= 0 {
+		c.MXTimeout = 5 * time.Second
+	}
+	return c
+}
+
+// SMTPVerifier is the in-house Verifier: syntax -> MX -> SMTP RCPT probe ->
+// catch-all detection. It opens exactly one connection to the lowest-preference
+// MX and probes both the real address and a random localpart on the same
+// session, so catch-all detection costs no extra connection.
+type SMTPVerifier struct {
+	cfg      Config
+	resolver *net.Resolver
+}
+
+// New constructs the in-house SMTP verifier. The resolver mirrors dnsauth's
+// net.Resolver usage (context-bounded lookups, no custom dialer needed).
+func New(cfg Config) *SMTPVerifier {
+	return &SMTPVerifier{
+		cfg:      cfg.withDefaults(),
+		resolver: &net.Resolver{},
+	}
+}
+
+// Verify runs the full pipeline for one address. It never returns an error; an
+// undeterminable result is encoded as StatusUnknown so callers have a single
+// code path.
+func (v *SMTPVerifier) Verify(ctx context.Context, email string) Result {
+	now := time.Now().UTC()
+	res := Result{Email: email, CheckedAt: now, Status: StatusUnknown}
+
+	// 1. Syntax (RFC 5322-ish via net/mail). A parse failure is a hard invalid.
+	addr, err := mail.ParseAddress(email)
+	if err != nil {
+		res.Status = StatusInvalid
+		res.Reason = "invalid syntax"
+		return res
+	}
+	normalized := strings.ToLower(strings.TrimSpace(addr.Address))
+	res.Email = normalized
+	at := strings.LastIndex(normalized, "@")
+	if at <= 0 || at == len(normalized)-1 {
+		res.Status = StatusInvalid
+		res.Reason = "invalid syntax"
+		return res
+	}
+	localpart := normalized[:at]
+	domain := normalized[at+1:]
+
+	// 2. MX lookup. No MX (and no usable fallback) is a hard invalid: nowhere to
+	// deliver. A lookup *error* (timeout/SERVFAIL) is unknown, not invalid.
+	hosts, mxErr := v.lookupMXHosts(ctx, domain)
+	if mxErr != nil {
+		res.Status = StatusUnknown
+		res.Reason = "mx lookup failed: " + mxErr.Error()
+		return res
+	}
+	if len(hosts) == 0 {
+		res.Status = StatusInvalid
+		res.Reason = "no MX records"
+		return res
+	}
+	res.HasMX = true
+
+	// 3. SMTP RCPT probe against the lowest-preference (highest priority) MX.
+	probe := v.probe(ctx, hosts[0], localpart, domain)
+	switch probe.outcome {
+	case probeAccepted:
+		// 4. Catch-all check already folded into probe(): if the random control
+		// localpart was also accepted, the 250 on the real address is meaningless.
+		if probe.catchAll {
+			res.IsCatchAll = true
+			res.Status = StatusRisky
+			res.Reason = "catch-all domain; acceptance is not conclusive"
+			return res
+		}
+		res.Status = StatusValid
+		res.Reason = "recipient accepted"
+		return res
+	case probeRejected:
+		res.Status = StatusInvalid
+		res.Reason = probe.reason
+		return res
+	default: // probeUnknown
+		res.Status = StatusUnknown
+		res.Reason = probe.reason
+		return res
+	}
+}
+
+// lookupMXHosts returns MX hosts ordered by ascending preference (most-preferred
+// first). When a domain publishes no MX, RFC 5321 permits implicit-MX fallback
+// to the A/AAAA record of the domain itself; we honour that so apex-only mail
+// domains aren't misjudged as invalid.
+func (v *SMTPVerifier) lookupMXHosts(ctx context.Context, domain string) ([]string, error) {
+	c, cancel := context.WithTimeout(ctx, v.cfg.MXTimeout)
+	defer cancel()
+
+	mxs, err := v.resolver.LookupMX(c, domain)
+	if err != nil {
+		// A "no such host" / "no MX" style miss is not a transport error; treat
+		// it as "no MX" and let the implicit-MX fallback below decide.
+		var dnsErr *net.DNSError
+		if errors.As(err, &dnsErr) && (dnsErr.IsNotFound || dnsErr.Err == "no such host") {
+			mxs = nil
+		} else {
+			return nil, err
+		}
+	}
+
+	if len(mxs) > 0 {
+		sort.SliceStable(mxs, func(i, j int) bool { return mxs[i].Pref < mxs[j].Pref })
+		hosts := make([]string, 0, len(mxs))
+		for _, mx := range mxs {
+			h := strings.TrimSuffix(strings.TrimSpace(mx.Host), ".")
+			if h != "" {
+				hosts = append(hosts, h)
+			}
+		}
+		if len(hosts) > 0 {
+			return hosts, nil
+		}
+	}
+
+	// Implicit MX: fall back to the domain's own A/AAAA if it resolves.
+	ac, acancel := context.WithTimeout(ctx, v.cfg.MXTimeout)
+	defer acancel()
+	if addrs, aerr := v.resolver.LookupHost(ac, domain); aerr == nil && len(addrs) > 0 {
+		return []string{domain}, nil
+	}
+	return nil, nil
+}
+
+type probeOutcome int
+
+const (
+	probeUnknown probeOutcome = iota
+	probeAccepted
+	probeRejected
+)
+
+type probeResult struct {
+	outcome  probeOutcome
+	catchAll bool
+	reason   string
+}
+
+// probe opens one SMTP session to host:25, greets it, sets the envelope sender,
+// and issues RCPT TO for the real address. If the real address is accepted it
+// also issues RCPT TO for a random control localpart on the same domain to
+// detect catch-all behaviour. Interpretation:
+//
+//	250          -> accepted
+//	550 (5xx)    -> rejected (hard invalid)
+//	4xx / timeout/ dial error -> unknown (greylist, blocked :25, transient)
+func (v *SMTPVerifier) probe(ctx context.Context, host, localpart, domain string) probeResult {
+	dialer := net.Dialer{Timeout: v.cfg.DialTimeout}
+	conn, err := dialer.DialContext(ctx, "tcp", net.JoinHostPort(host, "25"))
+	if err != nil {
+		// Most commonly: outbound :25 blocked by the cloud provider, or the MX is
+		// firewalled/tarpitting. Either way we cannot conclude invalid.
+		return probeResult{outcome: probeUnknown, reason: "smtp dial failed (port 25 may be blocked): " + err.Error()}
+	}
+	// Bound the whole session.
+	deadline := time.Now().Add(v.cfg.CommandTimeout * 4)
+	if d, ok := ctx.Deadline(); ok && d.Before(deadline) {
+		deadline = d
+	}
+	_ = conn.SetDeadline(deadline)
+
+	client, err := smtp.NewClient(conn, host)
+	if err != nil {
+		_ = conn.Close()
+		return probeResult{outcome: probeUnknown, reason: "smtp handshake failed: " + err.Error()}
+	}
+	defer func() { _ = client.Close() }()
+
+	if err := client.Hello(v.cfg.HeloHost); err != nil {
+		return probeResult{outcome: probeUnknown, reason: "EHLO/HELO rejected: " + err.Error()}
+	}
+	if err := client.Mail(v.cfg.MailFrom); err != nil {
+		return probeResult{outcome: probeUnknown, reason: "MAIL FROM rejected: " + err.Error()}
+	}
+
+	realOutcome, realReason := classifyRcpt(client.Rcpt(localpart + "@" + domain))
+	switch realOutcome {
+	case probeRejected:
+		return probeResult{outcome: probeRejected, reason: realReason}
+	case probeUnknown:
+		return probeResult{outcome: probeUnknown, reason: realReason}
+	}
+
+	// Real address accepted — probe a random control localpart to detect a
+	// catch-all. If that is also accepted, the domain accepts everything and the
+	// real 250 proves nothing.
+	control := randomLocalpart()
+	controlOutcome, _ := classifyRcpt(client.Rcpt(control + "@" + domain))
+
+	return probeResult{outcome: probeAccepted, catchAll: controlOutcome == probeAccepted}
+}
+
+// classifyRcpt maps the error from smtp.Client.Rcpt to a probe outcome. The
+// stdlib surfaces the SMTP reply code on *textproto.Error; 5xx is a hard
+// rejection, 4xx is transient (unknown), and a nil error is acceptance.
+func classifyRcpt(err error) (probeOutcome, string) {
+	if err == nil {
+		return probeAccepted, "recipient accepted"
+	}
+	var protoErr *textproto.Error
+	if errors.As(err, &protoErr) {
+		code := protoErr.Code
+		switch {
+		case code >= 500 && code < 600:
+			return probeRejected, "recipient rejected (" + strconv.Itoa(code) + "): " + protoErr.Msg
+		case code >= 400 && code < 500:
+			return probeUnknown, "transient/greylisted (" + strconv.Itoa(code) + "): " + protoErr.Msg
+		}
+	}
+	// Connection reset, timeout mid-command, or an unparseable reply.
+	return probeUnknown, "rcpt indeterminate: " + err.Error()
+}
+
+func randomLocalpart() string {
+	b := make([]byte, 12)
+	if _, err := rand.Read(b); err != nil {
+		// Fall back to a fixed-but-unlikely localpart; the worst case is a
+		// false-negative catch-all check, never a wrong invalid verdict.
+		return "no-such-mailbox-warmbly-probe"
+	}
+	return "wb-verify-" + hex.EncodeToString(b)
+}
diff --git a/internal/pkg/generation/batch.go b/internal/pkg/generation/batch.go
new file mode 100644
index 00000000..673dea91
--- /dev/null
+++ b/internal/pkg/generation/batch.go
@@ -0,0 +1,206 @@
+package generation
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/openai/openai-go/v2"
+)
+
+// BatchRequest is one warmup thread to generate via the OpenAI Batch API. The
+// CustomID round-trips through the batch so results can be mapped back to their
+// theme (the batch output is unordered and may drop failed lines).
+type BatchRequest struct {
+	CustomID    string
+	Theme       string
+	Model       string
+	MaxMessages int
+}
+
+// BatchResult is one parsed line from a completed batch's output file. Exactly
+// one of Conversation or Err is set per line; Err carries a per-line failure so
+// a single bad response never fails the whole ingest.
+type BatchResult struct {
+	CustomID     string
+	Theme        string
+	Conversation *Conversation
+	Err          string
+}
+
+// BatchCounts mirrors the OpenAI batch request_counts object.
+type BatchCounts struct {
+	Completed int
+	Failed    int
+	Total     int
+}
+
+// batchInputLine is one line of the Batch API JSONL input file. The body is the
+// same chat-completion request the sync path sends, so sync and batch produce
+// identical threads.
+type batchInputLine struct {
+	CustomID string                         `json:"custom_id"`
+	Method   string                         `json:"method"`
+	URL      string                         `json:"url"`
+	Body     openai.ChatCompletionNewParams `json:"body"`
+}
+
+// batchOutputLine is one line of the Batch API JSONL output file.
+type batchOutputLine struct {
+	CustomID string `json:"custom_id"`
+	Response *struct {
+		StatusCode int                   `json:"status_code"`
+		Body       openai.ChatCompletion `json:"body"`
+	} `json:"response"`
+	Error *struct {
+		Message string `json:"message"`
+		Code    string `json:"code"`
+	} `json:"error"`
+}
+
+// SubmitBatch uploads a JSONL of chat-completion requests as a batch input file
+// and creates a batch over the /v1/chat/completions endpoint. It returns the
+// batch ID and the uploaded input file ID. completionWindow is the Batch API
+// processing window (only "24h" is currently accepted by OpenAI; empty defaults
+// to "24h").
+func (c *GenerationClient) SubmitBatch(ctx context.Context, requests []BatchRequest, completionWindow string) (batchID, inputFileID string, err error) {
+	if len(requests) == 0 {
+		return "", "", fmt.Errorf("submit batch: no requests")
+	}
+
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	for _, r := range requests {
+		body := buildConversationParams(r.Theme, r.Model, normalizeMaxMessages(r.MaxMessages))
+		line := batchInputLine{
+			CustomID: r.CustomID,
+			Method:   "POST",
+			URL:      "/v1/chat/completions",
+			Body:     body,
+		}
+		if err := enc.Encode(line); err != nil {
+			return "", "", fmt.Errorf("submit batch: encode line %s: %w", r.CustomID, err)
+		}
+	}
+
+	file, err := c.client.Files.New(ctx, openai.FileNewParams{
+		File:    namedReader{Reader: bytes.NewReader(buf.Bytes()), name: "warmup_batch.jsonl"},
+		Purpose: openai.FilePurposeBatch,
+	})
+	if err != nil {
+		return "", "", fmt.Errorf("submit batch: upload input file: %w", err)
+	}
+
+	window := openai.BatchNewParamsCompletionWindow24h
+	if completionWindow != "" {
+		window = openai.BatchNewParamsCompletionWindow(completionWindow)
+	}
+
+	batch, err := c.client.Batches.New(ctx, openai.BatchNewParams{
+		CompletionWindow: window,
+		Endpoint:         openai.BatchNewParamsEndpointV1ChatCompletions,
+		InputFileID:      file.ID,
+	})
+	if err != nil {
+		return "", "", fmt.Errorf("submit batch: create batch: %w", err)
+	}
+
+	return batch.ID, file.ID, nil
+}
+
+// GetBatch returns the current status, output file ID (when completed), and
+// request counts for a batch.
+func (c *GenerationClient) GetBatch(ctx context.Context, batchID string) (status, outputFileID string, counts BatchCounts, err error) {
+	batch, err := c.client.Batches.Get(ctx, batchID)
+	if err != nil {
+		return "", "", BatchCounts{}, err
+	}
+	counts = BatchCounts{
+		Completed: int(batch.RequestCounts.Completed),
+		Failed:    int(batch.RequestCounts.Failed),
+		Total:     int(batch.RequestCounts.Total),
+	}
+	return string(batch.Status), batch.OutputFileID, counts, nil
+}
+
+// CancelBatch requests cancellation of an in-flight batch.
+func (c *GenerationClient) CancelBatch(ctx context.Context, batchID string) error {
+	_, err := c.client.Batches.Cancel(ctx, batchID)
+	return err
+}
+
+// FetchBatchResults downloads a completed batch's output file and parses each
+// JSONL line back into a Conversation. Per-line failures (HTTP error, malformed
+// body, JSON parse error) are reported on the individual BatchResult rather than
+// failing the whole fetch, so a few bad lines don't discard the good ones.
+func (c *GenerationClient) FetchBatchResults(ctx context.Context, outputFileID string) ([]BatchResult, error) {
+	if outputFileID == "" {
+		return nil, fmt.Errorf("fetch batch results: empty output file id")
+	}
+	resp, err := c.client.Files.Content(ctx, outputFileID)
+	if err != nil {
+		return nil, fmt.Errorf("fetch batch results: download output file: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var out []BatchResult
+	scanner := bufio.NewScanner(resp.Body)
+	// Output bodies can be large; raise the line buffer well above the default 64KiB.
+	scanner.Buffer(make([]byte, 0, 1024*1024), 8*1024*1024)
+	for scanner.Scan() {
+		raw := strings.TrimSpace(scanner.Text())
+		if raw == "" {
+			continue
+		}
+		out = append(out, parseBatchOutputLine(raw))
+	}
+	if err := scanner.Err(); err != nil {
+		return out, fmt.Errorf("fetch batch results: read output file: %w", err)
+	}
+	return out, nil
+}
+
+// parseBatchOutputLine decodes one output JSONL line, tolerating per-line errors.
+func parseBatchOutputLine(raw string) BatchResult {
+	var line batchOutputLine
+	if err := json.Unmarshal([]byte(raw), &line); err != nil {
+		return BatchResult{Err: fmt.Sprintf("parse output line: %v", err)}
+	}
+	res := BatchResult{CustomID: line.CustomID}
+	if line.Error != nil && line.Error.Message != "" {
+		res.Err = line.Error.Message
+		return res
+	}
+	if line.Response == nil {
+		res.Err = "missing response in output line"
+		return res
+	}
+	if line.Response.StatusCode < 200 || line.Response.StatusCode >= 300 {
+		res.Err = fmt.Sprintf("response status %d", line.Response.StatusCode)
+		return res
+	}
+	if len(line.Response.Body.Choices) == 0 {
+		res.Err = "response returned no choices"
+		return res
+	}
+	var conv Conversation
+	if err := json.Unmarshal([]byte(line.Response.Body.Choices[0].Message.Content), &conv); err != nil {
+		res.Err = fmt.Sprintf("parse conversation: %v", err)
+		return res
+	}
+	res.Conversation = &conv
+	return res
+}
+
+// namedReader adapts a reader so the multipart upload carries a filename, which
+// the Files endpoint requires for the JSONL input.
+type namedReader struct {
+	io.Reader
+	name string
+}
+
+func (n namedReader) Name() string { return n.name }
diff --git a/internal/pkg/generation/conversation.go b/internal/pkg/generation/conversation.go
index d8b3468e..0879d215 100644
--- a/internal/pkg/generation/conversation.go
+++ b/internal/pkg/generation/conversation.go
@@ -10,42 +10,119 @@ import (
 
 var ConversationSchema = GenerateSchema[Conversation]()
 
-func (c *GenerationClient) GenerateConversation(ctx context.Context, theme string) (*Conversation, error) {
-	systemPrompt := fmt.Sprintf(`
-Output valid JSON only.
+// normalizeMaxMessages clamps the admin-controlled follow-up count into the
+// range the warmup prompt is tuned for. Shared so the sync and batch paths
+// produce identical thread shapes.
+func normalizeMaxMessages(maxMessages int) int {
+	if maxMessages <= 0 {
+		return 4
+	}
+	if maxMessages > 5 {
+		return 5
+	}
+	return maxMessages
+}
 
-Positive realistic warmup email thread for theme: %s
+// warmupSystemPrompt builds the deliverability-tuned system prompt for one
+// theme. Extracted so the sync path (GenerateConversation) and the Batch API
+// path (SubmitBatch) send the exact same instruction, keeping the two
+// generation modes byte-for-byte identical.
+func warmupSystemPrompt(theme string, maxMessages int) string {
+	// The prompt is grounded in the ACTUAL signals AI-text detectors key on
+	// (burstiness, contractions, AI-accent vocabulary, stock openers, symmetric
+	// templates), not a vague "sound human". A deterministic post-processing
+	// pass (internal/pkg/humanlint) then strips residual tells before the
+	// content is cached, so this is the first of two coordinated layers.
+	return fmt.Sprintf(`Output valid JSON only.
 
-- Friendly colleague tone, occasional 😊👍, always ask questions to continue
-- Use {{.FirstName}} {{.LastName}} {{.Email}} {{.Company}} {{.Signature}} naturally
-- Every body = only text sender writes + {{.Signature}} at end (no headers, no quotes, no "On ...")
-- Aim for 10–14 messages total across branches
-- Include at least 4 branch points with 2–4 variants each (short/long/different questions)
-- Keep replies natural & positive
-`, theme)
+Write a short, real message a busy colleague would actually send to someone they
+already know, about: %s. You are that person, NOT an assistant.
 
+Return:
+- subject: 2-6 words, lowercase-natural, never prefixed with "Re:" or "Fwd:".
+- description: the OPENING body only (no greeting, sign-off, signature, or the
+  subject) — 1 to 3 sentences.
+- messages: %d short follow-up lines (one sentence each) that could continue it.
+
+Write like a person, by following how people actually write — not by trying to
+"sound human":
+- Use contractions naturally (I'm, don't, you're, it's, can't, I'll, that's,
+  we've, didn't). Don't contract every single one; leave a couple expanded.
+- Vary sentence length hard. Put at least one very short line or fragment
+  (2-5 words, e.g. "Makes sense." / "No rush.") next to a longer one. Never let
+  every sentence land at the same length.
+- Include exactly one concrete, specific detail a stranger couldn't guess — a
+  day ("Tuesday"), a time ("after lunch"), a named thing ("the second draft",
+  "the deck"), or a small number.
+- Start with the actual point or a bare "hey" — never a stock opener ("I hope
+  this email finds you well", "I wanted to reach out", "I just wanted to").
+- No intro-body-conclusion shape, no restating, no "in conclusion".
+
+Hard bans (these are the strongest AI tells):
+- NO AI-accent words: delve, leverage, utilize, harness, robust, seamless,
+  underscore, showcase, foster, streamline, elevate, pivotal, comprehensive,
+  testament, tapestry, realm, synergy, paradigm, furthermore, moreover,
+  additionally. Use plain words (use, show, solid, smooth, key, full, also).
+- NO "not only X but also Y", NO "it's not X, it's Y", NO rule-of-three lists
+  ("fast, reliable, and affordable"). Use at most one dash; prefer none.
+- NO hedging/corporate filler: "it's worth noting", "in order to", "circle
+  back", "touch base", "at the end of the day". It's fine to start with "And"
+  or "But".
+- Plain text only. No links, URLs, phone numbers, attachments, emoji, ALL-CAPS,
+  or marketing/sales language. At most one "!", prefer zero.
+
+Vary the shape across messages — sometimes a fragment plus a question, sometimes
+one longer line — so a batch isn't uniform.`, theme, maxMessages)
+}
+
+// conversationResponseFormat returns the strict JSON-schema response format
+// shared by sync and batch generation.
+func conversationResponseFormat() openai.ChatCompletionNewParamsResponseFormatUnion {
 	schemaParam := openai.ResponseFormatJSONSchemaJSONSchemaParam{
 		Name:        "conversation",
 		Description: openai.String("Realistic branched email warmup thread"),
 		Schema:      ConversationSchema,
 		Strict:      openai.Bool(true),
 	}
+	return openai.ChatCompletionNewParamsResponseFormatUnion{
+		OfJSONSchema: &openai.ResponseFormatJSONSchemaParam{JSONSchema: schemaParam},
+	}
+}
 
-	req := openai.ChatCompletionNewParams{
-		Model: openai.ChatModelGPT4oMini,
+// buildConversationParams assembles the chat-completion request for one warmup
+// thread. Both GenerateConversation (sync) and SubmitBatch (Batch API) use this
+// so the request bodies are identical; the only difference is the transport.
+func buildConversationParams(theme, model string, maxMessages int) openai.ChatCompletionNewParams {
+	chatModel := openai.ChatModelGPT4oMini
+	if model != "" {
+		chatModel = openai.ChatModel(model)
+	}
+	return openai.ChatCompletionNewParams{
+		Model: chatModel,
 		Messages: []openai.ChatCompletionMessageParamUnion{
-			openai.SystemMessage(systemPrompt),
+			openai.SystemMessage(warmupSystemPrompt(theme, maxMessages)),
 			openai.UserMessage("Generate one complete thread now."),
 		},
-		ResponseFormat: openai.ChatCompletionNewParamsResponseFormatUnion{
-			OfJSONSchema: &openai.ResponseFormatJSONSchemaParam{JSONSchema: schemaParam},
-		},
+		ResponseFormat: conversationResponseFormat(),
 	}
+}
+
+// GenerateConversation produces one realistic warmup email thread for a theme.
+//
+// The prompt is tuned for warmup deliverability: plaintext, a few short
+// sentences, one natural question, and explicitly NO links, phone numbers,
+// attachments, emoji, or marketing language (all of which raise spam scores).
+// model and maxMessages are admin-controlled (empty model → gpt-4o-mini).
+func (c *GenerationClient) GenerateConversation(ctx context.Context, theme, model string, maxMessages int) (*Conversation, error) {
+	req := buildConversationParams(theme, model, normalizeMaxMessages(maxMessages))
 
 	resp, err := c.client.Chat.Completions.New(ctx, req)
 	if err != nil {
 		return nil, err
 	}
+	if len(resp.Choices) == 0 {
+		return nil, fmt.Errorf("generation returned no choices")
+	}
 
 	var parsed Conversation
 	if err := json.Unmarshal([]byte(resp.Choices[0].Message.Content), &parsed); err != nil {
diff --git a/internal/pkg/generation/model.go b/internal/pkg/generation/model.go
index 68e40445..e70d66ab 100644
--- a/internal/pkg/generation/model.go
+++ b/internal/pkg/generation/model.go
@@ -1,13 +1,11 @@
 package generation
 
+// Conversation is the structured output of warmup content generation. The
+// shape matches how the warmup renderer consumes content: it composes the
+// greeting, sign-off and signature itself, so Description is the opening body
+// text only (no greeting/signature) and Messages are follow-up question lines.
 type Conversation struct {
-	Title       string                `json:"title" jsonschema:"description=Short descriptive title"`
-	Description string                `json:"description" jsonschema:"description=1-2 sentence summary"`
-	Subject     string                `json:"subject" jsonschema:"description=Initial subject line (no Re:)"`
-	Messages    []ConversationMessage `json:"messages" jsonschema:"minItems=1"`
-}
-
-type ConversationMessage struct {
-	Body     string                `json:"body" jsonschema:"description=Plaintext content the sender actually types. Greeting + message + sign-off + {{.Signature}} at the very bottom. No email headers, no quoting, no 'On ... wrote:'. Keep positive and natural."`
-	Messages []ConversationMessage `json:"messages" jsonschema:"description=Alternative replies (0-4). Use to create branches with different tones/lengths/questions. Aim for deep threads."`
+	Subject     string   `json:"subject" jsonschema:"description=Short lowercase-natural subject line, 2-6 words, never prefixed with Re:"`
+	Description string   `json:"description" jsonschema:"description=The opening message body ONLY: a couple of short natural sentences. No greeting, no sign-off, no signature, no subject line."`
+	Messages    []string `json:"messages" jsonschema:"description=Short natural follow-up question lines, one sentence each, that could continue the thread. No greeting or sign-off."`
 }
diff --git a/internal/pkg/humanlint/humanlint.go b/internal/pkg/humanlint/humanlint.go
new file mode 100644
index 00000000..55a56ea3
--- /dev/null
+++ b/internal/pkg/humanlint/humanlint.go
@@ -0,0 +1,465 @@
+// Package humanlint makes generated warmup copy read like a real person wrote
+// it, using the actual signals AI-text detectors and linguists key on rather
+// than just telling the model to "sound human".
+//
+// It does two things, both with NO ML model:
+//
+//   - Humanize(text, seed): conservative, meaning-preserving transforms that
+//     remove the strongest AI tells — em-dashes, stock openers ("I hope this
+//     email finds you well"), AI-accent vocabulary (delve/leverage/robust...),
+//     the "not only X but also Y" template, curly quotes, exclamation spam — and
+//     applies contractions PROBABILISTICALLY (~0.7, seeded) so the result isn't
+//     itself a uniform fingerprint.
+//   - Score(text): an advisory AI-likeness score (0 clean .. 100 robotic) from
+//     tell density + burstiness (sentence-length variation, the most-cited
+//     non-ML human/AI separator). LooksRobotic gates content offline.
+//
+// Hard safety constraints for warmup mail (see the research): every transform
+// preserves meaning and NEVER adds a spam signal — no fake typos/leetspeak, no
+// urgency/marketing, no links, exclamations capped. Humanized output must still
+// pass the existing warmlint spam gate; the score is advisory ("remove obvious
+// tells + read naturally"), never a "guaranteed undetectable" claim, and never
+// overrides warmlint.
+package humanlint
+
+import (
+	"math/rand"
+	"regexp"
+	"strings"
+)
+
+// contractionProbability is how often an eligible formal phrase is contracted.
+// NOT 1.0 on purpose: contracting 100% is its own uniform fingerprint; humans
+// leave some expanded.
+const contractionProbability = 0.72
+
+// aiTellWords are single-word "AI accent" terms. Their presence raises the
+// robotic score; a subset with a safe plain equivalent is also swapped by
+// Humanize (see wordSwaps). The rest are penalized/regenerated, not mangled.
+var aiTellWords = map[string]struct{}{
+	"delve": {}, "leverage": {}, "utilize": {}, "utilise": {}, "harness": {},
+	"streamline": {}, "underscore": {}, "foster": {}, "fostering": {},
+	"navigating": {}, "showcase": {}, "showcasing": {}, "emphasize": {},
+	"enhance": {}, "unlock": {}, "unveil": {}, "embark": {}, "elevate": {},
+	"amplify": {}, "galvanize": {}, "illuminate": {}, "resonate": {},
+	"boasts": {}, "garner": {}, "facilitate": {}, "robust": {}, "seamless": {},
+	"pivotal": {}, "multifaceted": {}, "comprehensive": {}, "intricate": {},
+	"intricacies": {}, "meticulous": {}, "nuanced": {}, "bespoke": {},
+	"cutting-edge": {}, "transformative": {}, "groundbreaking": {},
+	"compelling": {}, "holistic": {}, "proactive": {}, "iterative": {},
+	"palpable": {}, "bolstered": {}, "tapestry": {}, "realm": {},
+	"testament": {}, "synergy": {}, "paradigm": {}, "ecosystem": {},
+	"beacon": {}, "bastion": {}, "camaraderie": {}, "interplay": {},
+	"furthermore": {}, "moreover": {}, "additionally": {}, "consequently": {},
+	"notably": {}, "amidst": {},
+}
+
+// wordSwaps maps an AI-accent word to a safe, plainer, meaning-preserving
+// equivalent for casual email. Only high-confidence 1:1 swaps live here; words
+// without a clean swap stay in aiTellWords (scored, not transformed).
+var wordSwaps = map[string]string{
+	"leverage":      "use",
+	"utilize":       "use",
+	"utilise":       "use",
+	"harness":       "use",
+	"streamline":    "simplify",
+	"underscore":    "stress",
+	"showcase":      "show",
+	"showcasing":    "showing",
+	"foster":        "build",
+	"facilitate":    "help",
+	"garner":        "get",
+	"enhance":       "improve",
+	"robust":        "solid",
+	"seamless":      "smooth",
+	"pivotal":       "key",
+	"comprehensive": "full",
+	"delve":         "dig",
+	"furthermore":   "also",
+	"moreover":      "also",
+	"additionally":  "also",
+	"consequently":  "so",
+}
+
+// aiTellPhrases are multi-word stock LLM/corporate constructions. Scored; the
+// fillerStrips subset is also removed/rewritten by Humanize.
+var aiTellPhrases = []string{
+	"i hope this email finds you well", "i hope this message finds you well",
+	"i hope this note finds you well", "i wanted to reach out",
+	"i just wanted to reach out", "i am reaching out to", "i just wanted to",
+	"in today's fast-paced world", "in today's digital age",
+	"in today's digital landscape", "in the realm of", "when it comes to",
+	"it is worth noting that", "it's worth noting", "it is important to note",
+	"it's important to note", "it bears mentioning", "that being said",
+	"a wide range of", "a wide array of", "a testament to",
+	"due to the fact that", "embark on a journey", "at the end of the day",
+	"rest assured", "please be advised", "at your earliest convenience",
+	"as previously mentioned", "circle back", "touch base", "in order to",
+	"in conclusion", "to sum up", "in summary", "in essence",
+	"serves as a", "stands as a", "plays a pivotal role", "not only", "but also",
+}
+
+// clicheOpeners are formulaic email first lines. If the text starts with one,
+// Humanize drops that leading clause.
+var clicheOpeners = []string{
+	"i hope this email finds you well", "i hope this message finds you well",
+	"i hope this note finds you well", "i hope you're doing well",
+	"i hope you are doing well", "i hope all is well", "i wanted to reach out",
+	"i just wanted to reach out", "i am reaching out", "i'm reaching out",
+	"i just wanted to touch base", "i wanted to touch base",
+	"dear sir or madam", "to whom it may concern", "i hope this finds you well",
+}
+
+// fillerStrips are phrases Humanize rewrites to plainer equivalents (empty = drop).
+var fillerStrips = []struct{ from, to string }{
+	{"due to the fact that", "because"},
+	{"in order to", "to"},
+	{"it is worth noting that ", ""},
+	{"it's worth noting that ", ""},
+	{"it is worth mentioning that ", ""},
+	{"it's worth mentioning that ", ""},
+	{"that being said, ", ""},
+	{"at the end of the day, ", ""},
+	{"to be honest, ", ""},
+	{"as previously mentioned, ", ""},
+}
+
+// contractions are ordered so longer/negation forms apply before shorter ones.
+var contractions = []struct{ from, to string }{
+	{"do not", "don't"}, {"does not", "doesn't"}, {"did not", "didn't"},
+	{"is not", "isn't"}, {"are not", "aren't"}, {"was not", "wasn't"},
+	{"were not", "weren't"}, {"has not", "hasn't"}, {"have not", "haven't"},
+	{"had not", "hadn't"}, {"will not", "won't"}, {"would not", "wouldn't"},
+	{"should not", "shouldn't"}, {"could not", "couldn't"}, {"cannot", "can't"},
+	{"can not", "can't"}, {"I will", "I'll"}, {"I am", "I'm"}, {"I have", "I've"},
+	{"I would", "I'd"}, {"we are", "we're"}, {"we will", "we'll"},
+	{"we have", "we've"}, {"you are", "you're"}, {"you will", "you'll"},
+	{"you have", "you've"}, {"they are", "they're"}, {"they will", "they'll"},
+	{"it is", "it's"}, {"that is", "that's"}, {"there is", "there's"},
+	{"here is", "here's"}, {"let us", "let's"}, {"what is", "what's"},
+	{"who is", "who's"},
+}
+
+var (
+	emDash         = regexp.MustCompile(`\s*[\x{2014}\x{2013}]\s*`)
+	spacedDash     = regexp.MustCompile(`\s+-{1,2}\s+`)
+	notOnlyButAlso = regexp.MustCompile(`(?i)\bnot only\b(.+?)\bbut also\b`)
+	multiSpace     = regexp.MustCompile(`[ \t]{2,}`)
+	sentenceSplit  = regexp.MustCompile(`[.!?]+`)
+	wordRe         = regexp.MustCompile(`[A-Za-z0-9'%-]+`)
+	tricolon       = regexp.MustCompile(`(?i)\b([a-z]+), ([a-z]+),? and ([a-z]+)\b`)
+)
+
+// Humanize applies conservative, meaning-preserving transforms that strip the
+// strongest AI tells and contract probabilistically. seed makes it
+// deterministic per call (so the same content humanizes identically) while
+// still varying across different content.
+func Humanize(text string, seed int64) string {
+	if strings.TrimSpace(text) == "" {
+		return text
+	}
+	rng := rand.New(rand.NewSource(seed))
+
+	out := normalizePunctuation(text)
+	out = stripLeadingOpener(out)
+	out = applyFillerStrips(out)
+	out = applyWordSwaps(out)
+	out = flattenNotOnlyButAlso(out)
+	out = applyContractions(out, rng)
+	out = capExclamations(out)
+	out = multiSpace.ReplaceAllString(out, " ")
+	return strings.TrimSpace(out)
+}
+
+// HumanizeSubject is Humanize tuned for short subject lines. It applies only the
+// safe normalizations (punctuation, AI-word swaps, contractions, exclamation
+// cap) and skips the clause-level transforms meant for multi-sentence bodies
+// (opener stripping, filler strips, "not only X but also Y" flattening) — those
+// can mangle a 2-6 word subject, e.g. turning "I'm reaching out re Tuesday" into
+// a stray "Re Tuesday".
+func HumanizeSubject(text string, seed int64) string {
+	if strings.TrimSpace(text) == "" {
+		return text
+	}
+	rng := rand.New(rand.NewSource(seed))
+
+	out := normalizePunctuation(text)
+	out = applyWordSwaps(out)
+	out = applyContractions(out, rng)
+	out = capExclamations(out)
+	out = multiSpace.ReplaceAllString(out, " ")
+	return strings.TrimSpace(out)
+}
+
+// normalizePunctuation straightens curly quotes/ellipsis and turns em/spaced
+// dashes into commas (a clause join) — the single most cited punctuation tell.
+func normalizePunctuation(s string) string {
+	r := strings.NewReplacer(
+		"‘", "'", "’", "'", "“", "\"", "”", "\"",
+		"…", "...",
+	)
+	s = r.Replace(s)
+	s = emDash.ReplaceAllString(s, ", ")
+	s = spacedDash.ReplaceAllString(s, ", ")
+	return s
+}
+
+func stripLeadingOpener(s string) string {
+	trimmed := strings.TrimLeft(s, " \t")
+	// Defensive: don't strip clause-level openers off subject-shaped text (a
+	// short line with no sentence terminator). Stripping "I'm reaching out" off
+	// the subject "I'm reaching out re Tuesday" would leave a stray "Re
+	// Tuesday". HumanizeSubject already avoids this; this guard covers any
+	// other caller.
+	if !strings.ContainsAny(trimmed, ".!?") && len(wordRe.FindAllString(trimmed, -1)) <= 6 {
+		return s
+	}
+	lower := strings.ToLower(trimmed)
+	for _, op := range clicheOpeners {
+		if strings.HasPrefix(lower, op) {
+			rest := strings.TrimLeft(trimmed[len(op):], " ,.!:;-")
+			if rest == "" {
+				return trimmed // opener was the whole thing — keep something
+			}
+			// Capitalize the new first letter.
+			return upperFirst(rest)
+		}
+	}
+	return s
+}
+
+func applyFillerStrips(s string) string {
+	for _, f := range fillerStrips {
+		s = replaceFold(s, f.from, f.to)
+	}
+	return s
+}
+
+func applyWordSwaps(s string) string {
+	return wordRe.ReplaceAllStringFunc(s, func(w string) string {
+		repl, ok := wordSwaps[strings.ToLower(w)]
+		if !ok {
+			return w
+		}
+		if isUpperFirst(w) {
+			return upperFirst(repl)
+		}
+		return repl
+	})
+}
+
+func flattenNotOnlyButAlso(s string) string {
+	return notOnlyButAlso.ReplaceAllString(s, "$1 and ")
+}
+
+func applyContractions(s string, rng *rand.Rand) string {
+	for _, c := range contractions {
+		re := regexp.MustCompile(`(?i)\b` + regexp.QuoteMeta(c.from) + `\b`)
+		s = re.ReplaceAllStringFunc(s, func(m string) string {
+			if rng.Float64() > contractionProbability {
+				return m // leave a fraction expanded
+			}
+			if isUpperFirst(m) {
+				return upperFirst(c.to)
+			}
+			return c.to
+		})
+	}
+	return s
+}
+
+// capExclamations keeps at most one '!' and never stacked punctuation.
+func capExclamations(s string) string {
+	s = strings.ReplaceAll(s, "!!", "!")
+	s = strings.ReplaceAll(s, "?!", "?")
+	if strings.Count(s, "!") <= 1 {
+		return s
+	}
+	seen := false
+	var b strings.Builder
+	for _, r := range s {
+		if r == '!' {
+			if seen {
+				b.WriteRune('.')
+				continue
+			}
+			seen = true
+		}
+		b.WriteRune(r)
+	}
+	return b.String()
+}
+
+// Issue is one robotic signal found by Score.
+type Issue struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}
+
+// Score returns an advisory AI-likeness score (0 = reads human, 100 = robotic)
+// plus the signals found. It is advisory only — never a pass/fail "undetectable"
+// gate, and it must never override the warmlint spam gate.
+func Score(text string) (int, []Issue) {
+	lower := strings.ToLower(text)
+	score := 0
+	var issues []Issue
+	add := func(n int, code, msg string) {
+		score += n
+		issues = append(issues, Issue{Code: code, Message: msg})
+	}
+
+	for _, op := range clicheOpeners {
+		if strings.HasPrefix(strings.TrimSpace(lower), op) {
+			add(30, "stock_opener", "opens with a stock line: "+op)
+			break
+		}
+	}
+
+	tellWords := 0
+	for _, w := range wordRe.FindAllString(lower, -1) {
+		if _, ok := aiTellWords[w]; ok {
+			tellWords++
+		}
+	}
+	if tellWords > 0 {
+		add(min(40, tellWords*12), "ai_vocabulary", "uses AI-accent vocabulary")
+	}
+
+	phraseHits := 0
+	for _, p := range aiTellPhrases {
+		if strings.Contains(lower, p) {
+			phraseHits++
+		}
+	}
+	if phraseHits > 0 {
+		add(min(35, phraseHits*12), "stock_phrases", "uses stock LLM phrasing")
+	}
+
+	if strings.ContainsAny(text, "—–") {
+		add(15, "em_dash", "contains an em-dash")
+	}
+	if notOnlyButAlso.MatchString(text) {
+		add(20, "not_only_but_also", "uses the 'not only X but also Y' template")
+	}
+	if tricolon.MatchString(text) {
+		add(8, "tricolon", "uses a rule-of-three list")
+	}
+
+	// Formal (uncontracted) forms present where a human would contract.
+	formal := 0
+	for _, c := range contractions {
+		if regexpFoldContains(lower, c.from) {
+			formal++
+		}
+	}
+	if formal >= 2 {
+		add(min(20, formal*5), "no_contractions", "formal/uncontracted phrasing")
+	}
+
+	// Burstiness: low sentence-length variation reads robotic. Only meaningful
+	// for multi-sentence text; single-line messages skip it (CV undefined).
+	if cv, ok := sentenceLengthCV(text); ok && cv < 0.5 {
+		add(18, "low_burstiness", "uniform sentence length (low burstiness)")
+	}
+
+	if score > 100 {
+		score = 100
+	}
+	return score, issues
+}
+
+// LooksRobotic reports whether text still reads machine-generated after
+// humanization (used as an offline content-quality gate, not a hard spam gate).
+func LooksRobotic(text string) bool {
+	s, _ := Score(text)
+	return s >= 45
+}
+
+// sentenceLengthCV returns the coefficient of variation of per-sentence word
+// counts and whether it's defined (needs >=2 sentences with words).
+func sentenceLengthCV(text string) (float64, bool) {
+	parts := sentenceSplit.Split(text, -1)
+	var lens []float64
+	for _, p := range parts {
+		n := len(wordRe.FindAllString(p, -1))
+		if n > 0 {
+			lens = append(lens, float64(n))
+		}
+	}
+	if len(lens) < 2 {
+		return 0, false
+	}
+	var sum float64
+	for _, l := range lens {
+		sum += l
+	}
+	mean := sum / float64(len(lens))
+	if mean == 0 {
+		return 0, false
+	}
+	var variance float64
+	for _, l := range lens {
+		d := l - mean
+		variance += d * d
+	}
+	variance /= float64(len(lens))
+	return sqrt(variance) / mean, true
+}
+
+// ---- small helpers (kept dependency-free) ----
+
+func replaceFold(s, from, to string) string {
+	if from == "" {
+		return s
+	}
+	re := regexp.MustCompile(`(?i)` + regexp.QuoteMeta(from))
+	return re.ReplaceAllStringFunc(s, func(m string) string {
+		if to != "" && isUpperFirst(m) {
+			return upperFirst(to)
+		}
+		return to
+	})
+}
+
+func regexpFoldContains(lowerText, phrase string) bool {
+	re := regexp.MustCompile(`\b` + regexp.QuoteMeta(strings.ToLower(phrase)) + `\b`)
+	return re.MatchString(lowerText)
+}
+
+func isUpperFirst(s string) bool {
+	if s == "" {
+		return false
+	}
+	r := rune(s[0])
+	return r >= 'A' && r <= 'Z'
+}
+
+func upperFirst(s string) string {
+	if s == "" {
+		return s
+	}
+	r := rune(s[0])
+	if r >= 'a' && r <= 'z' {
+		return string(r-32) + s[1:]
+	}
+	return s
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func sqrt(x float64) float64 {
+	if x <= 0 {
+		return 0
+	}
+	// Newton's method — avoids importing math for one call.
+	z := x
+	for i := 0; i < 24; i++ {
+		z -= (z*z - x) / (2 * z)
+	}
+	return z
+}
diff --git a/internal/pkg/humanlint/humanlint_test.go b/internal/pkg/humanlint/humanlint_test.go
new file mode 100644
index 00000000..85256fd7
--- /dev/null
+++ b/internal/pkg/humanlint/humanlint_test.go
@@ -0,0 +1,115 @@
+package humanlint
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/warmbly/warmbly/internal/pkg/warmlint"
+)
+
+func TestHumanizeStripsEmDash(t *testing.T) {
+	out := Humanize("I tried the new setup — it worked great.", 1)
+	if strings.ContainsAny(out, "—–") {
+		t.Fatalf("em-dash not removed: %q", out)
+	}
+}
+
+func TestHumanizeStripsClicheOpener(t *testing.T) {
+	out := Humanize("I hope this email finds you well. How did the demo go?", 1)
+	if strings.Contains(strings.ToLower(out), "hope this email finds you well") {
+		t.Fatalf("cliche opener not stripped: %q", out)
+	}
+	if !strings.Contains(out, "demo") {
+		t.Fatalf("content after opener was lost: %q", out)
+	}
+}
+
+func TestHumanizeSwapsAIVocabulary(t *testing.T) {
+	out := strings.ToLower(Humanize("Can we leverage the robust new framework?", 1))
+	if strings.Contains(out, "leverage") || strings.Contains(out, "robust") {
+		t.Fatalf("AI vocabulary not swapped: %q", out)
+	}
+}
+
+func TestHumanizeFlattensNotOnlyButAlso(t *testing.T) {
+	out := strings.ToLower(Humanize("It was not only fast but also cheap.", 1))
+	if strings.Contains(out, "not only") || strings.Contains(out, "but also") {
+		t.Fatalf("not-only-but-also not flattened: %q", out)
+	}
+}
+
+func TestHumanizeNormalizesQuotes(t *testing.T) {
+	out := Humanize("It’s the “best” one…", 1)
+	if strings.ContainsAny(out, "‘’“”…") {
+		t.Fatalf("smart punctuation not normalized: %q", out)
+	}
+}
+
+func TestHumanizeAppliesSomeContractions(t *testing.T) {
+	// Across several seeds at least one should contract (probabilistic ~0.72).
+	in := "I am sure you do not mind. It is fine."
+	contracted := false
+	for seed := int64(0); seed < 20; seed++ {
+		if strings.Contains(Humanize(in, seed), "'") {
+			contracted = true
+			break
+		}
+	}
+	if !contracted {
+		t.Fatal("no contractions applied across 20 seeds")
+	}
+}
+
+func TestHumanizeSubjectDoesNotFabricateReplyPrefix(t *testing.T) {
+	// A short subject starting with a stock-opener fragment must NOT have the
+	// opener stripped into a stray "Re ..." prefix.
+	for seed := int64(0); seed < 5; seed++ {
+		out := HumanizeSubject("I'm reaching out re Tuesday", seed)
+		if strings.HasPrefix(out, "Re ") || strings.HasPrefix(strings.ToLower(out), "re:") {
+			t.Fatalf("subject mangled into reply-prefix: %q", out)
+		}
+	}
+	// The defensive guard also protects plain Humanize on subject-shaped text
+	// (short, no sentence terminator): the opener must not be clause-stripped.
+	if got := Humanize("I'm reaching out re Tuesday", 1); strings.HasPrefix(got, "Re ") {
+		t.Fatalf("short opener-stripping not guarded: %q", got)
+	}
+}
+
+func TestHumanizeIsDeterministic(t *testing.T) {
+	in := "I am reaching out. It is not only fast but also smooth — really."
+	if Humanize(in, 42) != Humanize(in, 42) {
+		t.Fatal("Humanize is not deterministic for a fixed seed")
+	}
+}
+
+func TestHumanizeDoesNotIntroduceSpam(t *testing.T) {
+	// Humanizing clean warmup-ish copy must never trip the spam gate.
+	inputs := []string{
+		"I hope this email finds you well. I wanted to reach out about the deck.",
+		"We should leverage the robust framework — it is seamless.",
+		"How did Tuesday go? No rush, just curious.",
+	}
+	for _, in := range inputs {
+		out := Humanize(in, 7)
+		if err := warmlint.Check("quick note", out, false); err != nil {
+			t.Fatalf("humanized output tripped warmlint for %q -> %q: %v", in, out, err)
+		}
+	}
+}
+
+func TestScoreFlagsRoboticHigherThanHuman(t *testing.T) {
+	robotic := "I hope this email finds you well. I wanted to reach out to underscore that our robust, seamless, and comprehensive framework will leverage synergy. It is worth noting that this is not only pivotal but also transformative."
+	human := "hey, how did Tuesday go? no rush. I'll send the second draft over after lunch."
+	rs, _ := Score(robotic)
+	hs, _ := Score(human)
+	if rs <= hs {
+		t.Fatalf("expected robotic (%d) > human (%d)", rs, hs)
+	}
+	if !LooksRobotic(robotic) {
+		t.Fatalf("robotic text not flagged (score %d)", rs)
+	}
+	if LooksRobotic(human) {
+		t.Fatalf("human text wrongly flagged (score %d)", hs)
+	}
+}
diff --git a/internal/pkg/warmlint/lint.go b/internal/pkg/warmlint/lint.go
new file mode 100644
index 00000000..fac34e3e
--- /dev/null
+++ b/internal/pkg/warmlint/lint.go
@@ -0,0 +1,167 @@
+// Package warmlint is a small content-safety check shared by the live warmup
+// send path and the offline AI generator. Warmup mail must look unremarkable;
+// this rejects content that would raise the sending mailbox's own spam score.
+package warmlint
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+var (
+	stackedPunct = regexp.MustCompile(`[!?]{2,}`)
+	wordToken    = regexp.MustCompile(`[a-z0-9%]+`)
+	linkPattern  = regexp.MustCompile(`https?://`)
+	htmlTag      = regexp.MustCompile(`(?i)<[a-z!/][^>]*>`)
+)
+
+// triggerWords are single-token terms that raise SpamAssassin-style content
+// scores. Warmup content should read like a normal personal email, so any
+// accumulation of these is a red flag (usually an LLM drifting into ad tone).
+var triggerWords = map[string]struct{}{
+	"free": {}, "guarantee": {}, "guaranteed": {}, "winner": {}, "congratulations": {},
+	"cash": {}, "prize": {}, "cheap": {}, "discount": {}, "viagra": {}, "casino": {},
+	"loan": {}, "credit": {}, "bitcoin": {}, "crypto": {}, "urgent": {}, "bonus": {},
+	"promo": {}, "refinance": {}, "mortgage": {}, "investment": {}, "deal": {},
+	"100%": {}, "sale": {}, "income": {}, "earnings": {}, "clearance": {},
+}
+
+var triggerPhrases = []string{
+	"act now", "click here", "risk free", "risk-free", "limited time", "buy now",
+	"earn money", "make money", "dear friend", "order now", "100% free",
+	"double your", "extra income", "work from home", "this is not spam",
+	"cash bonus", "no cost", "for free", "money back", "satisfaction guaranteed",
+}
+
+// Check rejects warmup content that would look spammy:
+//   - a fabricated Re:/Fwd: prefix on a NEW (non-reply) message;
+//   - an ALL-CAPS subject;
+//   - stacked punctuation (!!!, ?!);
+//   - three or more distinct spam-trigger terms.
+func Check(subject, body string, isReply bool) error {
+	subj := strings.TrimSpace(subject)
+	lowerSubj := strings.ToLower(subj)
+
+	if !isReply && (strings.HasPrefix(lowerSubj, "re:") ||
+		strings.HasPrefix(lowerSubj, "fwd:") ||
+		strings.HasPrefix(lowerSubj, "fw:")) {
+		return fmt.Errorf("fabricated reply/forward prefix on a new send")
+	}
+	if isAllCaps(subj) {
+		return fmt.Errorf("subject is all caps")
+	}
+
+	combined := subject + "\n" + body
+	if stackedPunct.MatchString(combined) {
+		return fmt.Errorf("stacked punctuation")
+	}
+	if n := countTriggerTerms(combined); n >= 3 {
+		return fmt.Errorf("content has %d spam-trigger terms", n)
+	}
+	return nil
+}
+
+// Issue is a single advisory content problem found by Score.
+type Issue struct {
+	Severity string `json:"severity"` // "warn" | "high"
+	Code     string `json:"code"`
+	Message  string `json:"message"`
+}
+
+// ScoreResult is an advisory content assessment for a campaign template.
+type ScoreResult struct {
+	Score  int     `json:"score"` // 0-100, higher = safer
+	Issues []Issue `json:"issues"`
+}
+
+// Score gives an ADVISORY 0-100 content-safety score (higher = safer) for a
+// campaign template, plus the issues found. Unlike Check — a hard gate for
+// warmup mail — Score never blocks: it surfaces guidance before the user sends
+// the mail that actually reaches prospects and drives complaints. It reuses the
+// same trigger-term and ALL-CAPS heuristics as the warmup lint.
+func Score(subject, bodyHTML, bodyPlain string) ScoreResult {
+	res := ScoreResult{Score: 100, Issues: []Issue{}}
+	deduct := func(n int, severity, code, msg string) {
+		res.Score -= n
+		res.Issues = append(res.Issues, Issue{Severity: severity, Code: code, Message: msg})
+	}
+
+	subj := strings.TrimSpace(subject)
+	body := bodyPlain
+	if strings.TrimSpace(body) == "" {
+		body = stripTags(bodyHTML)
+	}
+	combined := subj + "\n" + body
+
+	if subj == "" {
+		deduct(20, "high", "empty_subject", "Subject is empty.")
+	} else if isAllCaps(subj) {
+		deduct(15, "high", "all_caps_subject", "Subject is all caps — a strong spam signal.")
+	}
+	if stackedPunct.MatchString(combined) {
+		deduct(10, "warn", "stacked_punctuation", "Stacked punctuation (e.g. !!! or ?!) reads as promotional.")
+	}
+	if n := countTriggerTerms(combined); n > 0 {
+		d := n * 8
+		if d > 40 {
+			d = 40
+		}
+		severity := "warn"
+		if n >= 3 {
+			severity = "high"
+		}
+		deduct(d, severity, "spam_trigger_terms", fmt.Sprintf("%d spam-trigger term(s) found in subject/body.", n))
+	}
+	if links := len(linkPattern.FindAllString(combined, -1)); links > 3 {
+		d := (links - 3) * 5
+		if d > 20 {
+			d = 20
+		}
+		deduct(d, "warn", "too_many_links", fmt.Sprintf("%d links — keep cold-email link count low.", links))
+	}
+	if strings.TrimSpace(body) == "" {
+		deduct(25, "high", "empty_body", "Body has no text content (image-only or empty body hurts deliverability).")
+	} else if len(body) > 15000 {
+		deduct(10, "warn", "oversized_body", "Body is very large; trim it for deliverability.")
+	}
+
+	if res.Score < 0 {
+		res.Score = 0
+	}
+	return res
+}
+
+func stripTags(s string) string {
+	return strings.TrimSpace(htmlTag.ReplaceAllString(s, " "))
+}
+
+func isAllCaps(s string) bool {
+	letters := 0
+	for _, r := range s {
+		if unicode.IsLower(r) {
+			return false
+		}
+		if unicode.IsLetter(r) {
+			letters++
+		}
+	}
+	return letters >= 4
+}
+
+func countTriggerTerms(text string) int {
+	lower := strings.ToLower(text)
+	found := map[string]struct{}{}
+	for _, w := range wordToken.FindAllString(lower, -1) {
+		if _, ok := triggerWords[w]; ok {
+			found[w] = struct{}{}
+		}
+	}
+	for _, p := range triggerPhrases {
+		if strings.Contains(lower, p) {
+			found[p] = struct{}{}
+		}
+	}
+	return len(found)
+}
diff --git a/internal/pkg/warmpersona/persona.go b/internal/pkg/warmpersona/persona.go
new file mode 100644
index 00000000..8912fe8a
--- /dev/null
+++ b/internal/pkg/warmpersona/persona.go
@@ -0,0 +1,91 @@
+// Package warmpersona derives a stable, per-mailbox "personality" from the
+// mailbox account ID. The goal is to make warmup traffic from different
+// mailboxes look behaviourally distinct (different voice, dwell, engagement
+// propensity) instead of every mailbox in the pool behaving identically — a
+// uniform pool is a fingerprint. The persona is deterministic (same mailbox →
+// same persona) and requires no stored state.
+package warmpersona
+
+import (
+	"hash/fnv"
+
+	"github.com/google/uuid"
+)
+
+// Persona is a deterministic source of per-mailbox biases.
+type Persona struct {
+	seed uint64
+}
+
+// For derives the persona for a mailbox account ID.
+func For(id uuid.UUID) Persona {
+	h := fnv.New64a()
+	_, _ = h.Write(id[:])
+	return Persona{seed: h.Sum64()}
+}
+
+// axisValue returns a stable uint64 derived from the persona seed and a named
+// axis, so independent axes (greeting, dwell, importance...) don't correlate.
+func (p Persona) axisValue(axis string) uint64 {
+	h := fnv.New64a()
+	var b [8]byte
+	for i := 0; i < 8; i++ {
+		b[i] = byte(p.seed >> (8 * i))
+	}
+	_, _ = h.Write(b[:])
+	_, _ = h.Write([]byte(axis))
+	return h.Sum64()
+}
+
+// unit returns a deterministic float in [0,1) for the given axis.
+func (p Persona) unit(axis string) float64 {
+	// Top 53 bits → float64 in [0,1), matching math/rand's Float64 precision.
+	return float64(p.axisValue(axis)>>11) / float64(uint64(1)<<53)
+}
+
+// Bias returns a deterministic multiplier in [lo, hi] for the given axis.
+func (p Persona) Bias(axis string, lo, hi float64) float64 {
+	if hi < lo {
+		lo, hi = hi, lo
+	}
+	return lo + p.unit(axis)*(hi-lo)
+}
+
+// Index returns a deterministic index in [0, n) for the given axis.
+func (p Persona) Index(axis string, n int) int {
+	if n <= 0 {
+		return 0
+	}
+	return int(p.axisValue(axis) % uint64(n))
+}
+
+// Subset returns k distinct deterministic indices in [0, n) for the axis — the
+// mailbox's preferred subset (e.g. the greetings it tends to use). Callers then
+// pick randomly within this subset so each mailbox has a consistent "voice"
+// while individual messages still vary. Order is deterministic.
+func (p Persona) Subset(axis string, n, k int) []int {
+	if n <= 0 || k <= 0 {
+		return nil
+	}
+	if k >= n {
+		out := make([]int, n)
+		for i := range out {
+			out[i] = i
+		}
+		return out
+	}
+	seen := make(map[int]struct{}, k)
+	out := make([]int, 0, k)
+	v := p.axisValue(axis)
+	// Linear congruential walk seeded by the axis value; deterministic and
+	// well-spread for the small n/k we use here.
+	for len(out) < k {
+		idx := int(v % uint64(n))
+		if _, ok := seen[idx]; !ok {
+			seen[idx] = struct{}{}
+			out = append(out, idx)
+		}
+		v = v*6364136223846793005 + 1442695040888963407
+	}
+	return out
+}
diff --git a/internal/repository/pg_campaign_progress.go b/internal/repository/pg_campaign_progress.go
index 2f3a137b..f3f7058e 100644
--- a/internal/repository/pg_campaign_progress.go
+++ b/internal/repository/pg_campaign_progress.go
@@ -11,26 +11,37 @@ import (
 
 // CampaignContactProgress represents the progress of a contact in a campaign
 type CampaignContactProgress struct {
-	CampaignID uuid.UUID
-	ContactID  uuid.UUID
-	SequenceID uuid.UUID
-	SentAt     *time.Time
-	OpenedAt   *time.Time
-	ClickedAt  *time.Time
-	RepliedAt  *time.Time
-	BouncedAt  *time.Time
+	CampaignID   uuid.UUID
+	ContactID    uuid.UUID
+	SequenceID   uuid.UUID
+	SentAt       *time.Time
+	OpenedAt     *time.Time
+	ClickedAt    *time.Time
+	RepliedAt    *time.Time
+	BouncedAt    *time.Time
+	ComplainedAt *time.Time
 }
 
 // CampaignProgress represents overall campaign progress
 type CampaignProgress struct {
-	TotalContacts  int
-	TotalSequences int
-	EmailsSent     int
-	EmailsPending  int
-	EmailsOpened   int
-	EmailsClicked  int
-	EmailsReplied  int
-	EmailsBounced  int
+	TotalContacts    int
+	TotalSequences   int
+	EmailsSent       int
+	EmailsPending    int
+	EmailsOpened     int
+	EmailsClicked    int
+	EmailsReplied    int
+	EmailsBounced    int
+	EmailsComplained int
+}
+
+// CampaignRollingRates holds windowed send/bounce/complaint counts for a
+// campaign, used by the deliverability circuit breaker so it reacts to recent
+// behaviour rather than a campaign's lifetime average.
+type CampaignRollingRates struct {
+	Sent       int
+	Bounced    int
+	Complained int
 }
 
 // ContactSequencePair represents a contact and sequence combination
@@ -52,9 +63,11 @@ type CampaignProgressRepository interface {
 	RecordEmailClicked(ctx context.Context, campaignID, contactID, sequenceID uuid.UUID) error
 	RecordEmailReplied(ctx context.Context, campaignID, contactID, sequenceID uuid.UUID) error
 	RecordEmailBounced(ctx context.Context, campaignID, contactID, sequenceID uuid.UUID) error
+	RecordEmailComplained(ctx context.Context, campaignID, contactID, sequenceID uuid.UUID) error
 
 	// Query methods
 	GetCampaignProgress(ctx context.Context, campaignID uuid.UUID) (*CampaignProgress, error)
+	GetCampaignRollingRates(ctx context.Context, campaignID uuid.UUID, since time.Time) (*CampaignRollingRates, error)
 	GetContactProgress(ctx context.Context, campaignID, contactID uuid.UUID) ([]CampaignContactProgress, error)
 	GetContactLastSequenceTime(ctx context.Context, contactID, campaignID uuid.UUID) (*time.Time, error)
 	CheckContactHasReplied(ctx context.Context, contactID, campaignID uuid.UUID) (bool, error)
@@ -147,6 +160,21 @@ func (r *campaignProgressRepository) RecordEmailBounced(ctx context.Context, cam
 	return err
 }
 
+// RecordEmailComplained records that a contact filed a spam complaint
+func (r *campaignProgressRepository) RecordEmailComplained(ctx context.Context, campaignID, contactID, sequenceID uuid.UUID) error {
+	query := `
+		UPDATE campaign_contact_progress
+		SET complained_at = NOW()
+		WHERE campaign_id = $1
+		  AND contact_id = $2
+		  AND sequence_id = $3
+		  AND complained_at IS NULL
+	`
+
+	_, err := r.db.Exec(ctx, query, campaignID, contactID, sequenceID)
+	return err
+}
+
 // GetCampaignProgress retrieves overall campaign progress statistics
 func (r *campaignProgressRepository) GetCampaignProgress(ctx context.Context, campaignID uuid.UUID) (*CampaignProgress, error) {
 	query := `
@@ -158,7 +186,8 @@ func (r *campaignProgressRepository) GetCampaignProgress(ctx context.Context, ca
 				COUNT(CASE WHEN ccp.opened_at IS NOT NULL THEN 1 END) as emails_opened,
 				COUNT(CASE WHEN ccp.clicked_at IS NOT NULL THEN 1 END) as emails_clicked,
 				COUNT(CASE WHEN ccp.replied_at IS NOT NULL THEN 1 END) as emails_replied,
-				COUNT(CASE WHEN ccp.bounced_at IS NOT NULL THEN 1 END) as emails_bounced
+				COUNT(CASE WHEN ccp.bounced_at IS NOT NULL THEN 1 END) as emails_bounced,
+				COUNT(CASE WHEN ccp.complained_at IS NOT NULL THEN 1 END) as emails_complained
 			FROM campaigns c
 			LEFT JOIN campaign_leads cl ON c.id = cl.campaign_id
 			LEFT JOIN sequences s ON c.id = s.campaign_id
@@ -174,7 +203,8 @@ func (r *campaignProgressRepository) GetCampaignProgress(ctx context.Context, ca
 			emails_opened,
 			emails_clicked,
 			emails_replied,
-			emails_bounced
+			emails_bounced,
+			emails_complained
 		FROM campaign_stats
 	`
 
@@ -188,6 +218,7 @@ func (r *campaignProgressRepository) GetCampaignProgress(ctx context.Context, ca
 		&progress.EmailsClicked,
 		&progress.EmailsReplied,
 		&progress.EmailsBounced,
+		&progress.EmailsComplained,
 	)
 
 	if err == sql.ErrNoRows {
@@ -197,10 +228,30 @@ func (r *campaignProgressRepository) GetCampaignProgress(ctx context.Context, ca
 	return progress, err
 }
 
+// GetCampaignRollingRates returns send/bounce/complaint counts for a campaign
+// within the window [since, now], computed from the per-contact progress
+// timestamps so the breaker can react to recent behaviour.
+func (r *campaignProgressRepository) GetCampaignRollingRates(ctx context.Context, campaignID uuid.UUID, since time.Time) (*CampaignRollingRates, error) {
+	query := `
+		SELECT
+			COUNT(*) FILTER (WHERE sent_at IS NOT NULL AND sent_at >= $2)             AS sent,
+			COUNT(*) FILTER (WHERE bounced_at IS NOT NULL AND bounced_at >= $2)       AS bounced,
+			COUNT(*) FILTER (WHERE complained_at IS NOT NULL AND complained_at >= $2) AS complained
+		FROM campaign_contact_progress
+		WHERE campaign_id = $1
+	`
+	out := &CampaignRollingRates{}
+	err := r.db.QueryRow(ctx, query, campaignID, since).Scan(&out.Sent, &out.Bounced, &out.Complained)
+	if err == sql.ErrNoRows {
+		return &CampaignRollingRates{}, nil
+	}
+	return out, err
+}
+
 // GetContactProgress retrieves progress for a specific contact in a campaign
 func (r *campaignProgressRepository) GetContactProgress(ctx context.Context, campaignID, contactID uuid.UUID) ([]CampaignContactProgress, error) {
 	query := `
-		SELECT campaign_id, contact_id, sequence_id, sent_at, opened_at, clicked_at, replied_at, bounced_at
+		SELECT campaign_id, contact_id, sequence_id, sent_at, opened_at, clicked_at, replied_at, bounced_at, complained_at
 		FROM campaign_contact_progress
 		WHERE campaign_id = $1 AND contact_id = $2
 		ORDER BY sent_at ASC
@@ -224,6 +275,7 @@ func (r *campaignProgressRepository) GetContactProgress(ctx context.Context, cam
 			&progress.ClickedAt,
 			&progress.RepliedAt,
 			&progress.BouncedAt,
+			&progress.ComplainedAt,
 		)
 		if err != nil {
 			return nil, err
diff --git a/internal/repository/pg_contact.go b/internal/repository/pg_contact.go
index c621b661..6a267e55 100644
--- a/internal/repository/pg_contact.go
+++ b/internal/repository/pg_contact.go
@@ -16,6 +16,7 @@ import (
 	"github.com/warmbly/warmbly/internal/errx"
 	"github.com/warmbly/warmbly/internal/infrastructure/db"
 	"github.com/warmbly/warmbly/internal/models"
+	"github.com/warmbly/warmbly/internal/pkg/emailverify"
 	"github.com/warmbly/warmbly/internal/pkg/encrypt"
 	"github.com/warmbly/warmbly/internal/utils"
 )
@@ -24,6 +25,13 @@ type ContactRepository interface {
 	Add(ctx context.Context, userID string, contacts []models.AddContact) ([]models.Contact, *errx.Error)
 	GetByID(ctx context.Context, contactID uuid.UUID) (*models.Contact, *errx.Error)
 	GetByEmailAndOrganization(ctx context.Context, organizationID uuid.UUID, email string) (*models.Contact, *errx.Error)
+
+	// Pre-send email verification round-trip. UpdateContactVerification stores
+	// the outcome of a verify pass; ListUnverifiedContacts returns contacts that
+	// have never been conclusively checked (status 'unknown', never verified) so
+	// the batch scheduler can work them off a cap per tick.
+	UpdateContactVerification(ctx context.Context, contactID uuid.UUID, res emailverify.Result) *errx.Error
+	ListUnverifiedContacts(ctx context.Context, limit int) ([]models.Contact, *errx.Error)
 	GetByEmailsAndUser(ctx context.Context, userID uuid.UUID, emails []string) (map[string]models.Contact, *errx.Error)
 	Search(ctx context.Context, userID string, category, cursor *string, filters models.SearchContacts, limit int32) (*models.ContactsResult, *errx.Error)
 	ExportAll(ctx context.Context, userID string, filters *models.SearchContacts, contactIDs []string, max int) ([]models.Contact, *errx.Error)
@@ -331,7 +339,8 @@ func (r *contactRepository) GetByID(ctx context.Context, contactID uuid.UUID) (*
 	query := `
 		SELECT
 			c.id, c.first_name, c.last_name, c.email, c.company, c.phone,
-			c.custom_fields, c.subscribed, c.updated_at, c.created_at
+			c.custom_fields, c.subscribed, c.updated_at, c.created_at,
+			c.verification_status, c.verification_reason, c.is_catch_all, c.verification_checked_at
 		FROM contacts c
 		WHERE c.id = $1
 	`
@@ -341,6 +350,7 @@ func (r *contactRepository) GetByID(ctx context.Context, contactID uuid.UUID) (*
 		&contact.ID, &contact.FirstName, &contact.LastName, &contact.Email,
 		&contact.Company, &contact.Phone, &contact.CustomFields, &contact.Subscribed,
 		&contact.UpdatedAt, &contact.CreatedAt,
+		&contact.VerificationStatus, &contact.VerificationReason, &contact.IsCatchAll, &contact.VerificationCheckedAt,
 	)
 	if err != nil {
 		if err == pgx.ErrNoRows {
@@ -355,6 +365,89 @@ func (r *contactRepository) GetByID(ctx context.Context, contactID uuid.UUID) (*
 	return &contact, nil
 }
 
+// UpdateContactVerification stores the outcome of a verification pass on the
+// contact. It is keyed only by contact id (the verifier runs in the control
+// plane, not in a user request) and is a no-op-safe single UPDATE.
+func (r *contactRepository) UpdateContactVerification(ctx context.Context, contactID uuid.UUID, res emailverify.Result) *errx.Error {
+	status := string(res.Status)
+	if status == "" {
+		status = string(emailverify.StatusUnknown)
+	}
+	checkedAt := res.CheckedAt
+	if checkedAt.IsZero() {
+		checkedAt = time.Now().UTC()
+	}
+
+	query := `
+		UPDATE contacts
+		SET verification_status = $2,
+		    verification_reason = $3,
+		    is_catch_all = $4,
+		    verification_checked_at = $5,
+		    updated_at = NOW()
+		WHERE id = $1
+	`
+	params := []any{contactID, status, res.Reason, res.IsCatchAll, checkedAt}
+	cmd, err := r.DB.Exec(ctx, query, params...)
+	if err != nil {
+		db.CaptureError(err, query, params, "exec")
+		return errx.InternalError()
+	}
+	if cmd.RowsAffected() == 0 {
+		return errx.ErrNotFound
+	}
+	return nil
+}
+
+// ListUnverifiedContacts returns up to `limit` contacts that have never been
+// conclusively verified (status 'unknown' and no recorded check). Oldest
+// contacts first so a backlog drains in creation order. The pre-send gate only
+// drops 'invalid', so 'risky'/'valid'/already-checked rows are intentionally
+// excluded here — they don't need re-verification on every tick.
+func (r *contactRepository) ListUnverifiedContacts(ctx context.Context, limit int) ([]models.Contact, *errx.Error) {
+	if limit <= 0 {
+		limit = 100
+	}
+	query := `
+		SELECT
+			c.id, c.first_name, c.last_name, c.email, c.company, c.phone,
+			c.custom_fields, c.subscribed, c.updated_at, c.created_at,
+			c.verification_status, c.verification_reason, c.is_catch_all, c.verification_checked_at
+		FROM contacts c
+		WHERE c.verification_status = 'unknown' AND c.verification_checked_at IS NULL
+		ORDER BY c.created_at ASC
+		LIMIT $1
+	`
+	rows, err := r.DB.Query(ctx, query, limit)
+	if err != nil {
+		db.CaptureError(err, query, []any{limit}, "query")
+		return nil, errx.InternalError()
+	}
+	defer rows.Close()
+
+	out := make([]models.Contact, 0, limit)
+	for rows.Next() {
+		var c models.Contact
+		if err := rows.Scan(
+			&c.ID, &c.FirstName, &c.LastName, &c.Email,
+			&c.Company, &c.Phone, &c.CustomFields, &c.Subscribed,
+			&c.UpdatedAt, &c.CreatedAt,
+			&c.VerificationStatus, &c.VerificationReason, &c.IsCatchAll, &c.VerificationCheckedAt,
+		); err != nil {
+			db.CaptureError(err, "", nil, "ListUnverifiedContacts scan")
+			return nil, errx.InternalError()
+		}
+		c.Campaigns = []models.MiniCampaign{}
+		c.Categories = []models.MiniCategory{}
+		out = append(out, c)
+	}
+	if err := rows.Err(); err != nil {
+		db.CaptureError(err, "", nil, "ListUnverifiedContacts rows")
+		return nil, errx.InternalError()
+	}
+	return out, nil
+}
+
 func (r *contactRepository) GetByEmailAndOrganization(ctx context.Context, organizationID uuid.UUID, email string) (*models.Contact, *errx.Error) {
 	query := `
 		SELECT
diff --git a/internal/repository/pg_email.go b/internal/repository/pg_email.go
index c4db04a4..53542ec0 100644
--- a/internal/repository/pg_email.go
+++ b/internal/repository/pg_email.go
@@ -14,7 +14,6 @@ import (
 	"github.com/warmbly/warmbly/internal/errx"
 	"github.com/warmbly/warmbly/internal/infrastructure/db"
 	"github.com/warmbly/warmbly/internal/models"
-	"github.com/warmbly/warmbly/internal/pkg/crypt"
 	"github.com/warmbly/warmbly/internal/pkg/encrypt"
 	"github.com/warmbly/warmbly/internal/utils"
 	"github.com/warmbly/warmbly/internal/utils/validate"
@@ -166,12 +165,10 @@ func (r *emailRepository) NewOauthAccount(ctx context.Context, userID string, da
 
 	t := time.Now()
 	id := uuid.New()
-	rid, err := crypt.RID(8)
-	if err != nil {
-		sentry.CaptureException(err)
-		return nil, errx.InternalError()
-	}
 
+	// warmup_tag is the content segment (defaults to '' = generic). It used to
+	// be seeded with a random RID, which silently broke segment-aware content
+	// selection because a random tag never matches a real segment.
 	query := `
 		INSERT INTO email_accounts (id, user_id, organization_id, email, name, provider, signature_plain, signature_html, tracking_domain, last_synced_at, created_at, updated_at, warmup_tag)
 		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $10, $10, $11)
@@ -188,7 +185,7 @@ func (r *emailRepository) NewOauthAccount(ctx context.Context, userID string, da
 		sightml,
 		"",
 		t,
-		rid,
+		"",
 	}
 
 	_, err = tx.Exec(
@@ -274,11 +271,6 @@ func (r *emailRepository) NewSMTPIMAPAccount(ctx context.Context, userID string,
 
 	id := uuid.New()
 	t := time.Now()
-	rid, err := crypt.RID(8)
-	if err != nil {
-		sentry.CaptureException(err)
-		return nil, errx.InternalError()
-	}
 
 	query := `
 		INSERT INTO email_accounts (id, user_id, organization_id, email, name, provider, signature_plain, signature_html, tracking_domain, last_synced_at, updated_at, created_at, warmup_tag)
@@ -295,7 +287,7 @@ func (r *emailRepository) NewSMTPIMAPAccount(ctx context.Context, userID string,
 		sightml,
 		"",
 		t,
-		rid,
+		"",
 	}
 
 	_, err = tx.Exec(
@@ -701,6 +693,24 @@ func (r *emailRepository) Update(ctx context.Context, userID, emailAccountID str
 		args = append(args, *udata.WarmupReplyRate)
 		argPos++
 	}
+	if udata.WarmupTag != nil {
+		// warmup_tag is the content segment: a lowercase slug (e.g. "saas",
+		// "agency") that the segment-aware AI content bank is keyed on. Empty
+		// = generic content. Reject anything that isn't a simple slug so it
+		// can't smuggle arbitrary text into the content-selection path.
+		seg := strings.ToLower(strings.TrimSpace(*udata.WarmupTag))
+		if len(seg) > 32 {
+			return nil, errx.ErrInvalid
+		}
+		for _, r := range seg {
+			if !((r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '-') {
+				return nil, errx.ErrInvalid
+			}
+		}
+		setClauses = append(setClauses, fmt.Sprintf("%s = $%d", "warmup_tag", argPos))
+		args = append(args, seg)
+		argPos++
+	}
 	if udata.WarmupStartTime != nil {
 		if err := validate.CampaignTime(*udata.WarmupStartTime); err != nil {
 			return nil, err
diff --git a/internal/repository/pg_placement.go b/internal/repository/pg_placement.go
new file mode 100644
index 00000000..a0937040
--- /dev/null
+++ b/internal/repository/pg_placement.go
@@ -0,0 +1,424 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/warmbly/warmbly/internal/infrastructure/db"
+)
+
+// Placement folder classifications. These mirror the CHECK constraint on
+// placement_results.folder.
+const (
+	PlacementFolderPending    = "pending"
+	PlacementFolderInbox      = "inbox"
+	PlacementFolderPromotions = "promotions"
+	PlacementFolderSpam       = "spam"
+	PlacementFolderOther      = "other"
+)
+
+// Placement test statuses.
+const (
+	PlacementStatusPending   = "pending"
+	PlacementStatusCompleted = "completed"
+)
+
+// PlacementTest is one inbox-placement run: a tokenized copy of a template
+// sent from one sender mailbox to the active seed panel.
+type PlacementTest struct {
+	ID              uuid.UUID
+	OrganizationID  *uuid.UUID
+	SenderAccountID uuid.UUID
+	Subject         string
+	BodyPlain       string
+	BodyHTML        string
+	Token           string
+	Status          string
+	CreatedAt       time.Time
+	FinishedAt      *time.Time
+}
+
+// PlacementResult is the classification for one (test, seed) pair.
+type PlacementResult struct {
+	ID            uuid.UUID
+	TestID        uuid.UUID
+	SeedAccountID uuid.UUID
+	Provider      string
+	Folder        string
+	DetectedAt    *time.Time
+	RawFlags      string
+}
+
+// SeedAccount is a connected mailbox flagged is_seed, used as a placement
+// recipient. UserID is needed to query that seed's unibox entries (unibox is
+// keyed by the owning user, not the org).
+type SeedAccount struct {
+	ID       uuid.UUID
+	UserID   uuid.UUID
+	Email    string
+	Name     string
+	Provider string
+	Status   string
+	WorkerID *uuid.UUID
+	IsSeed   bool
+}
+
+// PendingResultJob is the minimal view the poller needs to classify one
+// pending result: which seed, which user owns its unibox, and the test token.
+type PendingResultJob struct {
+	ResultID      uuid.UUID
+	TestID        uuid.UUID
+	SeedAccountID uuid.UUID
+	SeedUserID    uuid.UUID
+	Provider      string
+	Token         string
+	TestCreatedAt time.Time
+}
+
+// UniboxTokenMatch is a unibox entry whose subject (or stored token) matched a
+// placement token, with the flags/labels needed to classify the folder.
+type UniboxTokenMatch struct {
+	InternalID uuid.UUID
+	Subject    string
+	Flags      []string
+}
+
+// PlacementRepository is the data access surface for seed inbox-placement
+// testing. It deliberately does not depend on the worker (control plane only).
+type PlacementRepository interface {
+	CreateTest(ctx context.Context, t *PlacementTest) error
+	GetTest(ctx context.Context, id uuid.UUID) (*PlacementTest, error)
+	ListTests(ctx context.Context, orgID *uuid.UUID, limit, offset int) ([]PlacementTest, int, error)
+	SetTestStatus(ctx context.Context, id uuid.UUID, status string, finishedAt *time.Time) error
+
+	CreatePendingResult(ctx context.Context, testID, seedAccountID uuid.UUID, provider string) error
+	GetTestWithResults(ctx context.Context, id uuid.UUID) (*PlacementTest, []PlacementResult, error)
+	RecordResult(ctx context.Context, resultID uuid.UUID, folder, rawFlags string, detectedAt time.Time) error
+
+	// ListPendingResults returns unresolved results joined to their seed's
+	// owning user + the test token, so the poller can look each one up.
+	ListPendingResults(ctx context.Context, limit int) ([]PendingResultJob, error)
+	// CountPendingForTest reports how many results are still pending, used to
+	// decide when a test is fully resolved.
+	CountPendingForTest(ctx context.Context, testID uuid.UUID) (int, error)
+
+	// ListSeedAccounts returns seed mailboxes. activeOnly restricts to
+	// status='active' (the send/classify panel); pass false for management UI.
+	ListSeedAccounts(ctx context.Context, activeOnly bool) ([]SeedAccount, error)
+	GetSeedAccount(ctx context.Context, id uuid.UUID) (*SeedAccount, error)
+	SetIsSeed(ctx context.Context, accountID uuid.UUID, isSeed bool) error
+	// ListSeedCandidates lists connected mailboxes (optionally filtered by
+	// substring) so an admin can pick which to flag as seeds.
+	ListSeedCandidates(ctx context.Context, search string, limit int) ([]SeedAccount, error)
+
+	// FindTokenInUnibox looks for a placement token inside a seed's received
+	// mail. Reuses the unibox store (unibox_emails) the worker syncs into. We
+	// match the token embedded in the subject (the only token carrier that
+	// survives sync without a worker change — see service.go) and return the
+	// matching entry's flags/labels for classification.
+	FindTokenInUnibox(ctx context.Context, userID, seedAccountID uuid.UUID, token string, since time.Time) (*UniboxTokenMatch, error)
+}
+
+type placementRepository struct {
+	db *db.DB
+}
+
+func NewPlacementRepository(db *db.DB) PlacementRepository {
+	return &placementRepository{db: db}
+}
+
+func (r *placementRepository) CreateTest(ctx context.Context, t *PlacementTest) error {
+	query := `
+		INSERT INTO placement_tests (id, organization_id, sender_account_id, subject, body_plain, body_html, token, status, created_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW())
+	`
+	_, err := r.db.Exec(ctx, query,
+		t.ID, t.OrganizationID, t.SenderAccountID, t.Subject, t.BodyPlain, t.BodyHTML, t.Token, t.Status,
+	)
+	return err
+}
+
+func (r *placementRepository) GetTest(ctx context.Context, id uuid.UUID) (*PlacementTest, error) {
+	query := `
+		SELECT id, organization_id, sender_account_id, subject, body_plain, body_html, token, status, created_at, finished_at
+		FROM placement_tests
+		WHERE id = $1
+	`
+	var t PlacementTest
+	err := r.db.QueryRow(ctx, query, id).Scan(
+		&t.ID, &t.OrganizationID, &t.SenderAccountID, &t.Subject, &t.BodyPlain, &t.BodyHTML, &t.Token, &t.Status, &t.CreatedAt, &t.FinishedAt,
+	)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &t, nil
+}
+
+func (r *placementRepository) ListTests(ctx context.Context, orgID *uuid.UUID, limit, offset int) ([]PlacementTest, int, error) {
+	if limit <= 0 {
+		limit = 25
+	}
+
+	var total int
+	countQuery := `SELECT COUNT(*) FROM placement_tests WHERE ($1::uuid IS NULL OR organization_id = $1)`
+	if err := r.db.QueryRow(ctx, countQuery, orgID).Scan(&total); err != nil {
+		return nil, 0, err
+	}
+
+	query := `
+		SELECT id, organization_id, sender_account_id, subject, body_plain, body_html, token, status, created_at, finished_at
+		FROM placement_tests
+		WHERE ($1::uuid IS NULL OR organization_id = $1)
+		ORDER BY created_at DESC
+		LIMIT $2 OFFSET $3
+	`
+	rows, err := r.db.Query(ctx, query, orgID, limit, offset)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+
+	tests := make([]PlacementTest, 0, limit)
+	for rows.Next() {
+		var t PlacementTest
+		if err := rows.Scan(
+			&t.ID, &t.OrganizationID, &t.SenderAccountID, &t.Subject, &t.BodyPlain, &t.BodyHTML, &t.Token, &t.Status, &t.CreatedAt, &t.FinishedAt,
+		); err != nil {
+			return nil, 0, err
+		}
+		tests = append(tests, t)
+	}
+	return tests, total, rows.Err()
+}
+
+func (r *placementRepository) SetTestStatus(ctx context.Context, id uuid.UUID, status string, finishedAt *time.Time) error {
+	_, err := r.db.Exec(ctx,
+		`UPDATE placement_tests SET status = $2, finished_at = $3 WHERE id = $1`,
+		id, status, finishedAt,
+	)
+	return err
+}
+
+func (r *placementRepository) CreatePendingResult(ctx context.Context, testID, seedAccountID uuid.UUID, provider string) error {
+	_, err := r.db.Exec(ctx, `
+		INSERT INTO placement_results (test_id, seed_account_id, provider, folder)
+		VALUES ($1, $2, $3, 'pending')
+		ON CONFLICT (test_id, seed_account_id) DO NOTHING
+	`, testID, seedAccountID, provider)
+	return err
+}
+
+func (r *placementRepository) GetTestWithResults(ctx context.Context, id uuid.UUID) (*PlacementTest, []PlacementResult, error) {
+	test, err := r.GetTest(ctx, id)
+	if err != nil || test == nil {
+		return test, nil, err
+	}
+
+	rows, err := r.db.Query(ctx, `
+		SELECT id, test_id, seed_account_id, provider, folder, detected_at, raw_flags
+		FROM placement_results
+		WHERE test_id = $1
+		ORDER BY provider ASC, seed_account_id ASC
+	`, id)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	results := make([]PlacementResult, 0)
+	for rows.Next() {
+		var res PlacementResult
+		if err := rows.Scan(
+			&res.ID, &res.TestID, &res.SeedAccountID, &res.Provider, &res.Folder, &res.DetectedAt, &res.RawFlags,
+		); err != nil {
+			return nil, nil, err
+		}
+		results = append(results, res)
+	}
+	return test, results, rows.Err()
+}
+
+func (r *placementRepository) RecordResult(ctx context.Context, resultID uuid.UUID, folder, rawFlags string, detectedAt time.Time) error {
+	_, err := r.db.Exec(ctx, `
+		UPDATE placement_results
+		SET folder = $2, raw_flags = $3, detected_at = $4
+		WHERE id = $1 AND folder = 'pending'
+	`, resultID, folder, rawFlags, detectedAt)
+	return err
+}
+
+func (r *placementRepository) ListPendingResults(ctx context.Context, limit int) ([]PendingResultJob, error) {
+	if limit <= 0 {
+		limit = 200
+	}
+	rows, err := r.db.Query(ctx, `
+		SELECT pr.id, pr.test_id, pr.seed_account_id, ea.user_id, pr.provider, pt.token, pt.created_at
+		FROM placement_results pr
+		JOIN placement_tests pt ON pt.id = pr.test_id
+		JOIN email_accounts ea ON ea.id = pr.seed_account_id
+		WHERE pr.folder = 'pending'
+		ORDER BY pt.created_at ASC
+		LIMIT $1
+	`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	jobs := make([]PendingResultJob, 0, limit)
+	for rows.Next() {
+		var j PendingResultJob
+		if err := rows.Scan(
+			&j.ResultID, &j.TestID, &j.SeedAccountID, &j.SeedUserID, &j.Provider, &j.Token, &j.TestCreatedAt,
+		); err != nil {
+			return nil, err
+		}
+		jobs = append(jobs, j)
+	}
+	return jobs, rows.Err()
+}
+
+func (r *placementRepository) CountPendingForTest(ctx context.Context, testID uuid.UUID) (int, error) {
+	var n int
+	err := r.db.QueryRow(ctx,
+		`SELECT COUNT(*) FROM placement_results WHERE test_id = $1 AND folder = 'pending'`,
+		testID,
+	).Scan(&n)
+	return n, err
+}
+
+const seedSelectCols = `ea.id, ea.user_id, ea.email, ea.name, ea.provider, ea.status, ea.worker_id, ea.is_seed`
+
+func scanSeed(rows pgx.Rows) (SeedAccount, error) {
+	var s SeedAccount
+	err := rows.Scan(&s.ID, &s.UserID, &s.Email, &s.Name, &s.Provider, &s.Status, &s.WorkerID, &s.IsSeed)
+	return s, err
+}
+
+func (r *placementRepository) ListSeedAccounts(ctx context.Context, activeOnly bool) ([]SeedAccount, error) {
+	query := `
+		SELECT ` + seedSelectCols + `
+		FROM email_accounts ea
+		WHERE ea.is_seed = true
+	`
+	if activeOnly {
+		query += ` AND ea.status = 'active'`
+	}
+	query += ` ORDER BY ea.email ASC`
+
+	rows, err := r.db.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := make([]SeedAccount, 0)
+	for rows.Next() {
+		s, err := scanSeed(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, s)
+	}
+	return out, rows.Err()
+}
+
+func (r *placementRepository) GetSeedAccount(ctx context.Context, id uuid.UUID) (*SeedAccount, error) {
+	rows, err := r.db.Query(ctx, `
+		SELECT `+seedSelectCols+`
+		FROM email_accounts ea
+		WHERE ea.id = $1
+	`, id)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	if !rows.Next() {
+		return nil, nil
+	}
+	s, err := scanSeed(rows)
+	if err != nil {
+		return nil, err
+	}
+	return &s, nil
+}
+
+func (r *placementRepository) SetIsSeed(ctx context.Context, accountID uuid.UUID, isSeed bool) error {
+	_, err := r.db.Exec(ctx,
+		`UPDATE email_accounts SET is_seed = $2, updated_at = NOW() WHERE id = $1`,
+		accountID, isSeed,
+	)
+	return err
+}
+
+func (r *placementRepository) ListSeedCandidates(ctx context.Context, search string, limit int) ([]SeedAccount, error) {
+	if limit <= 0 || limit > 100 {
+		limit = 50
+	}
+	query := `
+		SELECT ` + seedSelectCols + `
+		FROM email_accounts ea
+		WHERE ea.status = 'active'
+	`
+	args := []any{}
+	if search != "" {
+		query += ` AND ea.email ILIKE $1`
+		args = append(args, "%"+search+"%")
+		query += ` ORDER BY ea.is_seed DESC, ea.email ASC LIMIT $2`
+		args = append(args, limit)
+	} else {
+		query += ` ORDER BY ea.is_seed DESC, ea.email ASC LIMIT $1`
+		args = append(args, limit)
+	}
+
+	rows, err := r.db.Query(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := make([]SeedAccount, 0)
+	for rows.Next() {
+		s, err := scanSeed(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, s)
+	}
+	return out, rows.Err()
+}
+
+func (r *placementRepository) FindTokenInUnibox(ctx context.Context, userID, seedAccountID uuid.UUID, token string, since time.Time) (*UniboxTokenMatch, error) {
+	// The placement token is embedded in the message subject (see
+	// placement.Service — the worker injects only the warmup verify header,
+	// which we don't control here, so the subject is the carrier that survives
+	// sync into the unibox without a worker change). We match the most recent
+	// entry for this seed whose subject contains the token. `since` bounds the
+	// scan to mail that arrived after the test was created.
+	query := `
+		SELECT id, subject, flags
+		FROM unibox_emails
+		WHERE user_id = $1
+		  AND email_id = $2
+		  AND subject LIKE '%' || $3 || '%'
+		  AND internal_date >= $4
+		ORDER BY internal_date DESC
+		LIMIT 1
+	`
+	var m UniboxTokenMatch
+	err := r.db.QueryRow(ctx, query, userID, seedAccountID, token, since).Scan(&m.InternalID, &m.Subject, &m.Flags)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
diff --git a/internal/repository/pg_task.go b/internal/repository/pg_task.go
index 2e7a170c..285eeed1 100644
--- a/internal/repository/pg_task.go
+++ b/internal/repository/pg_task.go
@@ -124,6 +124,7 @@ type TaskRepository interface {
 	CreateTaskWithLock(ctx context.Context, task *Task, campaignTask *CampaignTask) (bool, error)
 	CreateWarmupTaskWithLock(ctx context.Context, task *Task, warmupTask *WarmupTask) (bool, error)
 	UpdateTaskStatusWithLock(ctx context.Context, taskID uuid.UUID, status string) error
+	UpdateTaskMessageID(ctx context.Context, taskID uuid.UUID, messageID string) error
 
 	// Update campaign task with contact/sequence IDs (for tracking)
 	UpdateCampaignTaskTracking(ctx context.Context, taskID, contactID, sequenceID uuid.UUID) error
@@ -730,6 +731,17 @@ func (r *taskRepository) UpdateTaskStatusWithLock(ctx context.Context, taskID uu
 	return tx.Commit(ctx)
 }
 
+// UpdateTaskMessageID persists the outbound Message-ID on the task row. Warmup
+// reply threading depends on this: GetLatestReplyCandidate filters on
+// message_id <> ”, so without persisting it here the reply path never finds a
+// prior message to reply to and warmup conversations never thread.
+func (r *taskRepository) UpdateTaskMessageID(ctx context.Context, taskID uuid.UUID, messageID string) error {
+	_, err := r.db.Exec(ctx,
+		`UPDATE tasks SET message_id = $1, updated_at = NOW() WHERE id = $2`,
+		messageID, taskID)
+	return err
+}
+
 // UpdateCampaignTaskTracking updates the campaign task with contact_id and sequence_id
 // This is called when the task is processed and we know which contact/sequence to send to
 // These IDs are needed for tracking pixel/click events to record progress
diff --git a/internal/repository/pg_warmup.go b/internal/repository/pg_warmup.go
index f5378481..3161eba8 100644
--- a/internal/repository/pg_warmup.go
+++ b/internal/repository/pg_warmup.go
@@ -43,6 +43,16 @@ type SpamReport struct {
 	ReportedAccountID uuid.UUID
 	MessageID         string
 	ReportType        string
+	// ContentSource is the content cohort ("static"/"ai") of the warmup send
+	// that landed in spam, denormalised here from the warmup token so the A/B
+	// harness can aggregate spam-placement rate by cohort.
+	ContentSource string
+	// RecipientProvider / RecipientDomain record where the message was filtered
+	// into spam (the recipient mailbox's provider, e.g. "google"/"smtp_imap",
+	// and domain, e.g. "outlook.com") so placement can be segmented per provider
+	// instead of one flat rate. Empty when the dimension isn't known.
+	RecipientProvider string
+	RecipientDomain   string
 	CreatedAt         time.Time
 }
 
@@ -63,6 +73,17 @@ type WarmupReplyCandidate struct {
 	ConversationTheme string
 }
 
+// WarmupReceived records a verified warmup email delivered to a participant
+// mailbox, so a later deletion/flag event (which carries only the internal
+// message id) can be matched back to warmup and to the sender.
+type WarmupReceived struct {
+	EmailAccountID  uuid.UUID
+	InternalID      uuid.UUID
+	MessageID       string
+	SenderAccountID uuid.UUID
+	CreatedAt       time.Time
+}
+
 // WarmupRepository defines methods for warmup data access
 type WarmupRepository interface {
 	// Pool management
@@ -73,6 +94,11 @@ type WarmupRepository interface {
 	SetParticipantRole(ctx context.Context, poolID, accountID uuid.UUID, role string) error
 	LeavePool(ctx context.Context, poolID, accountID uuid.UUID) error
 	BlockFromPool(ctx context.Context, accountID uuid.UUID, reason string) error
+	// GetHealthState returns the WORST current warmup health state across the
+	// account's pool memberships plus its blocked_until, so non-warmup callers
+	// (e.g. the campaign scheduler) can gate cold sends on warmup health without
+	// needing a pool type. Returns ("healthy", nil) when the account is in no pool.
+	GetHealthState(ctx context.Context, accountID uuid.UUID) (models.WarmupHealthState, *time.Time, error)
 	UnblockFromPool(ctx context.Context, accountID uuid.UUID) error
 	IsInPool(ctx context.Context, accountID uuid.UUID, poolType string) (bool, error)
 	GetParticipantHealth(ctx context.Context, accountID uuid.UUID, poolType string) (*models.WarmupParticipantHealth, error)
@@ -96,9 +122,14 @@ type WarmupRepository interface {
 
 	// Statistics
 	IncrementDailyCount(ctx context.Context, accountID uuid.UUID, date time.Time) error
+	IncrementReplyCount(ctx context.Context, accountID uuid.UUID, date time.Time) error
 	GetWarmupStatistics(ctx context.Context, accountID uuid.UUID, from, to time.Time) ([]WarmupStatistic, error)
 	GetOrCreateDailyStats(ctx context.Context, accountID uuid.UUID, date time.Time, targetVolume int) (*WarmupStatistic, error)
 
+	// Pool-wide placement analytics (admin overview)
+	PoolSpamPlacementRate(ctx context.Context, since time.Time) (float64, error)
+	PoolSpamPlacementsByProvider(ctx context.Context, since time.Time) (map[string]int, error)
+
 	// Warmup token management
 	CreateWarmupToken(ctx context.Context, token *models.WarmupToken) error
 	GetWarmupToken(ctx context.Context, tokenID uuid.UUID) (*models.WarmupToken, error)
@@ -109,6 +140,7 @@ type WarmupRepository interface {
 
 	// Warmup conversation support
 	GetRecentlyUsedPartners(ctx context.Context, accountID uuid.UUID, since time.Time) ([]uuid.UUID, error)
+	GetRecentPartnerCounts(ctx context.Context, accountID uuid.UUID, since time.Time) (map[uuid.UUID]int, error)
 	GetLatestReplyCandidate(ctx context.Context, senderAccountID, recipientAccountID uuid.UUID) (*WarmupReplyCandidate, error)
 
 	// Partner diversity support
@@ -116,6 +148,17 @@ type WarmupRepository interface {
 	GetPoolParticipantEmails(ctx context.Context, poolType string, excludeBlocked bool) (map[uuid.UUID]string, error)
 	CountEligibleRecipients(ctx context.Context, poolType string, excludeAccountID uuid.UUID) (int, error)
 	GetRecentPartnerDomainCounts(ctx context.Context, accountID uuid.UUID, since time.Time) (map[string]int, error)
+
+	// Tampering protection: track delivered warmup mail so a later deletion or
+	// spam-flag can be attributed, and count "harm" events per mailbox.
+	RecordWarmupReceived(ctx context.Context, accountID, internalID uuid.UUID, messageID string, senderAccountID uuid.UUID) error
+	GetWarmupReceived(ctx context.Context, accountID, internalID uuid.UUID) (*WarmupReceived, error)
+	RecordWarmupTampering(ctx context.Context, accountID uuid.UUID, messageID, kind string) (bool, error)
+	CountWarmupTamperingSince(ctx context.Context, accountID uuid.UUID, since time.Time) (int, error)
+
+	// Appeals (user-facing submission; admin review lives in the admin repo).
+	CreateWarmupAppeal(ctx context.Context, accountID, userID uuid.UUID, reason string) (uuid.UUID, error)
+	HasPendingWarmupAppeal(ctx context.Context, accountID uuid.UUID) (bool, error)
 }
 
 type warmupRepository struct {
@@ -301,6 +344,36 @@ func (r *warmupRepository) BlockFromPool(ctx context.Context, accountID uuid.UUI
 	return err
 }
 
+// GetHealthState returns the worst current health state across the account's
+// pool memberships and that row's blocked_until. Worst-wins so a mailbox that's
+// blocked in any pool is treated as blocked for cold-send gating.
+func (r *warmupRepository) GetHealthState(ctx context.Context, accountID uuid.UUID) (models.WarmupHealthState, *time.Time, error) {
+	query := `
+		SELECT health_state, blocked_until
+		FROM warmup_pool_participants
+		WHERE email_account_id = $1
+		ORDER BY CASE health_state
+			WHEN 'blocked' THEN 5
+			WHEN 'quarantined' THEN 4
+			WHEN 'throttled' THEN 3
+			WHEN 'watch' THEN 2
+			WHEN 'healthy' THEN 1
+			ELSE 0
+		END DESC
+		LIMIT 1
+	`
+	var state string
+	var blockedUntil *time.Time
+	err := r.db.QueryRow(ctx, query, accountID).Scan(&state, &blockedUntil)
+	if err == sql.ErrNoRows {
+		return models.WarmupHealthHealthy, nil, nil
+	}
+	if err != nil {
+		return models.WarmupHealthHealthy, nil, err
+	}
+	return models.WarmupHealthState(state), blockedUntil, nil
+}
+
 // UnblockFromPool unblocks an account from all warmup pools
 func (r *warmupRepository) UnblockFromPool(ctx context.Context, accountID uuid.UUID) error {
 	query := `
@@ -351,8 +424,8 @@ func (r *warmupRepository) IsInPool(ctx context.Context, accountID uuid.UUID, po
 // RecordSpamReport records a spam report
 func (r *warmupRepository) RecordSpamReport(ctx context.Context, report *SpamReport) (bool, error) {
 	query := `
-		INSERT INTO warmup_spam_reports (id, reporter_account_id, reported_account_id, message_id, report_type, created_at)
-		VALUES ($1, $2, $3, $4, $5, NOW())
+		INSERT INTO warmup_spam_reports (id, reporter_account_id, reported_account_id, message_id, report_type, content_source, recipient_provider, recipient_domain, created_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW())
 		ON CONFLICT (reporter_account_id, message_id) DO NOTHING
 	`
 
@@ -362,6 +435,9 @@ func (r *warmupRepository) RecordSpamReport(ctx context.Context, report *SpamRep
 		report.ReportedAccountID,
 		report.MessageID,
 		report.ReportType,
+		report.ContentSource,
+		report.RecipientProvider,
+		report.RecipientDomain,
 	)
 
 	if err != nil {
@@ -588,6 +664,66 @@ func (r *warmupRepository) IncrementDailyCount(ctx context.Context, accountID uu
 	return err
 }
 
+// IncrementReplyCount increments the daily warmup reply count. Upserts the row
+// so it is order-independent with IncrementDailyCount (either may run first).
+func (r *warmupRepository) IncrementReplyCount(ctx context.Context, accountID uuid.UUID, date time.Time) error {
+	query := `
+		INSERT INTO warmup_statistics (email_account_id, date, emails_sent, emails_replied, target_volume)
+		VALUES ($1, DATE($2), 0, 1, 0)
+		ON CONFLICT (email_account_id, date)
+		DO UPDATE SET emails_replied = warmup_statistics.emails_replied + 1
+	`
+	_, err := r.db.Exec(ctx, query, accountID, date)
+	return err
+}
+
+// PoolSpamPlacementRate returns the pool-wide warmup spam-placement rate (%)
+// over the window: spam_placement events divided by total warmup sends. This is
+// the number surfaced as avg_spam_placement_rate in the admin health summary.
+func (r *warmupRepository) PoolSpamPlacementRate(ctx context.Context, since time.Time) (float64, error) {
+	query := `
+		SELECT
+			(SELECT COUNT(*) FROM warmup_spam_reports WHERE report_type = 'spam_placement' AND created_at >= $1) AS placements,
+			(SELECT COALESCE(SUM(emails_sent), 0) FROM warmup_statistics WHERE date >= DATE($1)) AS sent
+	`
+	var placements, sent int
+	if err := r.db.QueryRow(ctx, query, since).Scan(&placements, &sent); err != nil {
+		return 0, err
+	}
+	if sent == 0 {
+		return 0, nil
+	}
+	return float64(placements) / float64(sent) * 100, nil
+}
+
+// PoolSpamPlacementsByProvider returns spam-placement counts grouped by the
+// recipient provider over the window, so the admin overview can show where
+// warmup mail is being filtered (e.g. mostly at Outlook vs Gmail).
+func (r *warmupRepository) PoolSpamPlacementsByProvider(ctx context.Context, since time.Time) (map[string]int, error) {
+	query := `
+		SELECT COALESCE(NULLIF(recipient_provider, ''), 'unknown'), COUNT(*)
+		FROM warmup_spam_reports
+		WHERE report_type = 'spam_placement' AND created_at >= $1
+		GROUP BY 1
+	`
+	rows, err := r.db.Query(ctx, query, since)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := make(map[string]int)
+	for rows.Next() {
+		var provider string
+		var n int
+		if err := rows.Scan(&provider, &n); err != nil {
+			return nil, err
+		}
+		out[provider] = n
+	}
+	return out, rows.Err()
+}
+
 // GetWarmupStatistics retrieves warmup statistics for a date range
 func (r *warmupRepository) GetWarmupStatistics(ctx context.Context, accountID uuid.UUID, from, to time.Time) ([]WarmupStatistic, error) {
 	query := `
@@ -649,8 +785,8 @@ func (r *warmupRepository) GetOrCreateDailyStats(ctx context.Context, accountID
 // CreateWarmupToken creates a warmup verification token
 func (r *warmupRepository) CreateWarmupToken(ctx context.Context, token *models.WarmupToken) error {
 	query := `
-		INSERT INTO warmup_tokens (token, task_id, sender_account_id, recipient_account_id, conversation_theme, expires_at)
-		VALUES ($1, $2, $3, $4, $5, $6)
+		INSERT INTO warmup_tokens (token, task_id, sender_account_id, recipient_account_id, conversation_theme, content_source, conversation_id, expires_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
 	`
 	_, err := r.db.Exec(ctx, query,
 		token.Token,
@@ -658,6 +794,8 @@ func (r *warmupRepository) CreateWarmupToken(ctx context.Context, token *models.
 		token.SenderAccountID,
 		token.RecipientAccountID,
 		token.ConversationTheme,
+		token.ContentSource,
+		token.ConversationID,
 		token.ExpiresAt,
 	)
 	return err
@@ -666,7 +804,7 @@ func (r *warmupRepository) CreateWarmupToken(ctx context.Context, token *models.
 // GetWarmupToken retrieves a valid (unconsumed, unexpired) warmup token
 func (r *warmupRepository) GetWarmupToken(ctx context.Context, tokenID uuid.UUID) (*models.WarmupToken, error) {
 	query := `
-		SELECT token, task_id, sender_account_id, recipient_account_id, COALESCE(conversation_theme, ''), created_at, consumed_at, expires_at
+		SELECT token, task_id, sender_account_id, recipient_account_id, COALESCE(conversation_theme, ''), COALESCE(content_source, ''), conversation_id, created_at, consumed_at, expires_at
 		FROM warmup_tokens
 		WHERE token = $1 AND consumed_at IS NULL AND expires_at > NOW()
 	`
@@ -678,6 +816,8 @@ func (r *warmupRepository) GetWarmupToken(ctx context.Context, tokenID uuid.UUID
 		&t.SenderAccountID,
 		&t.RecipientAccountID,
 		&t.ConversationTheme,
+		&t.ContentSource,
+		&t.ConversationID,
 		&t.CreatedAt,
 		&t.ConsumedAt,
 		&t.ExpiresAt,
@@ -692,7 +832,7 @@ func (r *warmupRepository) GetWarmupToken(ctx context.Context, tokenID uuid.UUID
 
 func (r *warmupRepository) FindWarmupToken(ctx context.Context, tokenID uuid.UUID) (*models.WarmupToken, error) {
 	query := `
-		SELECT token, task_id, sender_account_id, recipient_account_id, COALESCE(conversation_theme, ''), created_at, consumed_at, expires_at
+		SELECT token, task_id, sender_account_id, recipient_account_id, COALESCE(conversation_theme, ''), COALESCE(content_source, ''), conversation_id, created_at, consumed_at, expires_at
 		FROM warmup_tokens
 		WHERE token = $1
 	`
@@ -704,6 +844,8 @@ func (r *warmupRepository) FindWarmupToken(ctx context.Context, tokenID uuid.UUI
 		&t.SenderAccountID,
 		&t.RecipientAccountID,
 		&t.ConversationTheme,
+		&t.ContentSource,
+		&t.ConversationID,
 		&t.CreatedAt,
 		&t.ConsumedAt,
 		&t.ExpiresAt,
@@ -773,6 +915,113 @@ func (r *warmupRepository) GetRecentlyUsedPartners(ctx context.Context, accountI
 	return partnerIDs, rows.Err()
 }
 
+// GetRecentPartnerCounts returns how many times the sender has targeted each
+// partner since the provided timestamp. Used to enforce an explicit
+// partner-diversity target — no single partner should absorb a large share of
+// one mailbox's warmup traffic (a reciprocal-graph detection signal).
+func (r *warmupRepository) GetRecentPartnerCounts(ctx context.Context, accountID uuid.UUID, since time.Time) (map[uuid.UUID]int, error) {
+	query := `
+		SELECT recipient_account_id, COUNT(*)
+		FROM warmup_tokens
+		WHERE sender_account_id = $1
+		  AND created_at >= $2
+		GROUP BY recipient_account_id
+	`
+
+	rows, err := r.db.Query(ctx, query, accountID, since)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	counts := make(map[uuid.UUID]int)
+	for rows.Next() {
+		var partnerID uuid.UUID
+		var n int
+		if err := rows.Scan(&partnerID, &n); err != nil {
+			return nil, err
+		}
+		counts[partnerID] = n
+	}
+
+	return counts, rows.Err()
+}
+
+// RecordWarmupReceived stores a delivered warmup email keyed by recipient +
+// internal message id. Idempotent on re-delivery of the same message.
+func (r *warmupRepository) RecordWarmupReceived(ctx context.Context, accountID, internalID uuid.UUID, messageID string, senderAccountID uuid.UUID) error {
+	query := `
+		INSERT INTO warmup_received (email_account_id, internal_id, message_id, sender_account_id)
+		VALUES ($1, $2, $3, $4)
+		ON CONFLICT (email_account_id, internal_id) DO NOTHING
+	`
+	_, err := r.db.Exec(ctx, query, accountID, internalID, messageID, senderAccountID)
+	return err
+}
+
+// GetWarmupReceived looks up a delivered warmup email by recipient + internal
+// message id. Returns nil when the message was not a warmup email.
+func (r *warmupRepository) GetWarmupReceived(ctx context.Context, accountID, internalID uuid.UUID) (*WarmupReceived, error) {
+	query := `
+		SELECT email_account_id, internal_id, message_id, sender_account_id, created_at
+		FROM warmup_received
+		WHERE email_account_id = $1 AND internal_id = $2
+	`
+	var w WarmupReceived
+	err := r.db.QueryRow(ctx, query, accountID, internalID).Scan(
+		&w.EmailAccountID, &w.InternalID, &w.MessageID, &w.SenderAccountID, &w.CreatedAt,
+	)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &w, nil
+}
+
+// RecordWarmupTampering records one "harm" a participant did to a warmup email.
+// Returns whether a new row was inserted (deduped per account+message+kind).
+func (r *warmupRepository) RecordWarmupTampering(ctx context.Context, accountID uuid.UUID, messageID, kind string) (bool, error) {
+	query := `
+		INSERT INTO warmup_tampering_events (email_account_id, message_id, kind)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (email_account_id, message_id, kind) DO NOTHING
+	`
+	cmd, err := r.db.Exec(ctx, query, accountID, messageID, kind)
+	if err != nil {
+		return false, err
+	}
+	return cmd.RowsAffected() > 0, nil
+}
+
+// CountWarmupTamperingSince counts distinct tampering events for a mailbox.
+func (r *warmupRepository) CountWarmupTamperingSince(ctx context.Context, accountID uuid.UUID, since time.Time) (int, error) {
+	query := `SELECT COUNT(*) FROM warmup_tampering_events WHERE email_account_id = $1 AND created_at >= $2`
+	var n int
+	err := r.db.QueryRow(ctx, query, accountID, since).Scan(&n)
+	return n, err
+}
+
+// CreateWarmupAppeal inserts a pending appeal for a blocked mailbox.
+func (r *warmupRepository) CreateWarmupAppeal(ctx context.Context, accountID, userID uuid.UUID, reason string) (uuid.UUID, error) {
+	id := uuid.New()
+	query := `
+		INSERT INTO warmup_appeals (id, email_account_id, user_id, reason, status)
+		VALUES ($1, $2, $3, $4, 'pending')
+	`
+	_, err := r.db.Exec(ctx, query, id, accountID, userID, reason)
+	return id, err
+}
+
+// HasPendingWarmupAppeal reports whether the mailbox already has an open appeal.
+func (r *warmupRepository) HasPendingWarmupAppeal(ctx context.Context, accountID uuid.UUID) (bool, error) {
+	query := `SELECT EXISTS(SELECT 1 FROM warmup_appeals WHERE email_account_id = $1 AND status = 'pending')`
+	var exists bool
+	err := r.db.QueryRow(ctx, query, accountID).Scan(&exists)
+	return exists, err
+}
+
 // GetPoolParticipantDomains returns a map from email_account_id to lowercased
 // domain (the part after '@') for every active participant in the given pool.
 // Used by the partner selector to weight selection toward under-represented
diff --git a/internal/repository/pg_warmup_content.go b/internal/repository/pg_warmup_content.go
new file mode 100644
index 00000000..9017bf51
--- /dev/null
+++ b/internal/repository/pg_warmup_content.go
@@ -0,0 +1,491 @@
+package repository
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/warmbly/warmbly/internal/models"
+)
+
+// ConversationFilter narrows a warmup_conversations listing.
+type ConversationFilter struct {
+	PoolType string
+	Segment  string
+	Source   string
+	Status   string
+	Limit    int
+	Offset   int
+}
+
+// WarmupConversationStat is a grouped count for the admin overview.
+type WarmupConversationStat struct {
+	PoolType string `json:"pool_type"`
+	Segment  string `json:"segment"`
+	Source   string `json:"source"`
+	Active   int    `json:"active"`
+	Archived int    `json:"archived"`
+}
+
+// WarmupCohortStat is the per-content-source spam-placement aggregate.
+type WarmupCohortStat struct {
+	ContentSource  string `json:"content_source"`
+	Sent           int    `json:"sent"`
+	SpamPlacements int    `json:"spam_placements"`
+}
+
+// WarmupContentRepository is the data access for the warmup content bank,
+// offline generation jobs, generation settings, and content-cohort analytics.
+type WarmupContentRepository interface {
+	// Conversation bank
+	InsertConversation(ctx context.Context, c *models.WarmupConversation) error
+	// PickConversation draws an active thread for the segment from the SHARED
+	// content library, regardless of tier: free/premium separate which mailboxes
+	// warm together (reputation isolation), not what they say, so content is not
+	// split by pool. Prefers an exact segment match, falls back to generic.
+	PickConversation(ctx context.Context, segment string) (*models.WarmupConversation, error)
+	GetConversation(ctx context.Context, id uuid.UUID) (*models.WarmupConversation, error)
+	ListConversations(ctx context.Context, f ConversationFilter) ([]models.WarmupConversation, int, error)
+	SetConversationStatus(ctx context.Context, id uuid.UUID, status string) error
+	DeleteConversation(ctx context.Context, id uuid.UUID) error
+	IncrementConversationUsage(ctx context.Context, id uuid.UUID) error
+	CountActiveConversations(ctx context.Context, poolType, segment string) (int, error)
+	ConversationStats(ctx context.Context) ([]WarmupConversationStat, error)
+	LastGeneratedAt(ctx context.Context) (*time.Time, error)
+
+	// Generation jobs
+	CreateGenerationJob(ctx context.Context, j *models.WarmupGenerationJob) error
+	UpdateGenerationJob(ctx context.Context, j *models.WarmupGenerationJob) error
+	GetGenerationJob(ctx context.Context, id uuid.UUID) (*models.WarmupGenerationJob, error)
+	ListGenerationJobs(ctx context.Context, limit, offset int) ([]models.WarmupGenerationJob, int, error)
+	// ListActiveBatchJobs returns batch-mode jobs still in flight (running with a
+	// non-terminal OpenAI batch status), for the poller to reconcile.
+	ListActiveBatchJobs(ctx context.Context) ([]models.WarmupGenerationJob, error)
+	GeneratedCountSince(ctx context.Context, since time.Time) (int, error)
+
+	// Settings (admin_settings key/value)
+	GetGenerationSettings(ctx context.Context) (*models.WarmupGenerationSettings, error)
+	SetGenerationSettings(ctx context.Context, s *models.WarmupGenerationSettings, updatedBy *uuid.UUID) error
+
+	// Content-cohort A/B analytics
+	SpamPlacementByCohort(ctx context.Context, since time.Time) ([]WarmupCohortStat, error)
+}
+
+type warmupContentRepository struct {
+	db *pgxpool.Pool
+}
+
+// NewWarmupContentRepository creates a new warmup content repository.
+func NewWarmupContentRepository(db *pgxpool.Pool) WarmupContentRepository {
+	return &warmupContentRepository{db: db}
+}
+
+func (r *warmupContentRepository) InsertConversation(ctx context.Context, c *models.WarmupConversation) error {
+	if c.ID == uuid.Nil {
+		c.ID = uuid.New()
+	}
+	msgs, err := json.Marshal(c.Messages)
+	if err != nil {
+		return err
+	}
+	query := `
+		INSERT INTO warmup_conversations
+			(id, pool_type, segment, source, theme, subject, description, messages, status, lint_passed, usage_count, generated_by_job_id)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+	`
+	_, err = r.db.Exec(ctx, query,
+		c.ID, c.PoolType, c.Segment, c.Source, c.Theme, c.Subject, c.Description,
+		msgs, c.Status, c.LintPassed, c.UsageCount, c.GeneratedByJob,
+	)
+	return err
+}
+
+func scanConversation(row pgx.Row) (*models.WarmupConversation, error) {
+	var c models.WarmupConversation
+	var msgs []byte
+	err := row.Scan(
+		&c.ID, &c.PoolType, &c.Segment, &c.Source, &c.Theme, &c.Subject, &c.Description,
+		&msgs, &c.Status, &c.LintPassed, &c.UsageCount, &c.GeneratedByJob, &c.CreatedAt, &c.UpdatedAt,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if len(msgs) > 0 {
+		_ = json.Unmarshal(msgs, &c.Messages)
+	}
+	return &c, nil
+}
+
+const conversationCols = `id, pool_type, segment, source, theme, subject, description, messages, status, lint_passed, usage_count, generated_by_job_id, created_at, updated_at`
+
+// PickConversation returns a random active conversation from the shared library,
+// preferring an exact segment match and falling back to generic (segment=”)
+// content. Tier (free/premium) is intentionally NOT a filter — content is shared
+// across pools; only mailbox reputation is isolated by pool.
+func (r *warmupContentRepository) PickConversation(ctx context.Context, segment string) (*models.WarmupConversation, error) {
+	query := `
+		SELECT ` + conversationCols + `
+		FROM warmup_conversations
+		WHERE status = 'active' AND (segment = $1 OR segment = '')
+		ORDER BY (segment = $1) DESC, random()
+		LIMIT 1
+	`
+	c, err := scanConversation(r.db.QueryRow(ctx, query, segment))
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, nil
+	}
+	return c, err
+}
+
+func (r *warmupContentRepository) GetConversation(ctx context.Context, id uuid.UUID) (*models.WarmupConversation, error) {
+	query := `SELECT ` + conversationCols + ` FROM warmup_conversations WHERE id = $1`
+	c, err := scanConversation(r.db.QueryRow(ctx, query, id))
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, nil
+	}
+	return c, err
+}
+
+func (r *warmupContentRepository) ListConversations(ctx context.Context, f ConversationFilter) ([]models.WarmupConversation, int, error) {
+	where := `WHERE 1=1`
+	args := []any{}
+	add := func(clause string, val any) {
+		args = append(args, val)
+		where += clause
+	}
+	if f.PoolType != "" {
+		add(" AND pool_type = $"+itoa(len(args)+1), f.PoolType)
+	}
+	if f.Segment != "" {
+		add(" AND segment = $"+itoa(len(args)+1), f.Segment)
+	}
+	if f.Source != "" {
+		add(" AND source = $"+itoa(len(args)+1), f.Source)
+	}
+	if f.Status != "" {
+		add(" AND status = $"+itoa(len(args)+1), f.Status)
+	}
+
+	var total int
+	if err := r.db.QueryRow(ctx, `SELECT COUNT(*) FROM warmup_conversations `+where, args...).Scan(&total); err != nil {
+		return nil, 0, err
+	}
+
+	limit := f.Limit
+	if limit <= 0 || limit > 200 {
+		limit = 50
+	}
+	args = append(args, limit)
+	limitIdx := itoa(len(args))
+	args = append(args, f.Offset)
+	offsetIdx := itoa(len(args))
+
+	query := `SELECT ` + conversationCols + ` FROM warmup_conversations ` + where +
+		` ORDER BY created_at DESC LIMIT $` + limitIdx + ` OFFSET $` + offsetIdx
+	rows, err := r.db.Query(ctx, query, args...)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+
+	out := []models.WarmupConversation{}
+	for rows.Next() {
+		c, err := scanConversation(rows)
+		if err != nil {
+			return nil, 0, err
+		}
+		out = append(out, *c)
+	}
+	return out, total, rows.Err()
+}
+
+func (r *warmupContentRepository) SetConversationStatus(ctx context.Context, id uuid.UUID, status string) error {
+	_, err := r.db.Exec(ctx, `UPDATE warmup_conversations SET status = $2, updated_at = NOW() WHERE id = $1`, id, status)
+	return err
+}
+
+func (r *warmupContentRepository) DeleteConversation(ctx context.Context, id uuid.UUID) error {
+	_, err := r.db.Exec(ctx, `DELETE FROM warmup_conversations WHERE id = $1`, id)
+	return err
+}
+
+func (r *warmupContentRepository) IncrementConversationUsage(ctx context.Context, id uuid.UUID) error {
+	_, err := r.db.Exec(ctx, `UPDATE warmup_conversations SET usage_count = usage_count + 1 WHERE id = $1`, id)
+	return err
+}
+
+func (r *warmupContentRepository) CountActiveConversations(ctx context.Context, poolType, segment string) (int, error) {
+	var n int
+	err := r.db.QueryRow(ctx,
+		`SELECT COUNT(*) FROM warmup_conversations WHERE pool_type = $1 AND segment = $2 AND status = 'active'`,
+		poolType, segment).Scan(&n)
+	return n, err
+}
+
+func (r *warmupContentRepository) ConversationStats(ctx context.Context) ([]WarmupConversationStat, error) {
+	query := `
+		SELECT pool_type, segment, source,
+			COUNT(*) FILTER (WHERE status = 'active')   AS active,
+			COUNT(*) FILTER (WHERE status = 'archived') AS archived
+		FROM warmup_conversations
+		GROUP BY pool_type, segment, source
+		ORDER BY pool_type, segment, source
+	`
+	rows, err := r.db.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := []WarmupConversationStat{}
+	for rows.Next() {
+		var s WarmupConversationStat
+		if err := rows.Scan(&s.PoolType, &s.Segment, &s.Source, &s.Active, &s.Archived); err != nil {
+			return nil, err
+		}
+		out = append(out, s)
+	}
+	return out, rows.Err()
+}
+
+func (r *warmupContentRepository) LastGeneratedAt(ctx context.Context) (*time.Time, error) {
+	var t *time.Time
+	err := r.db.QueryRow(ctx, `SELECT MAX(created_at) FROM warmup_conversations WHERE source = 'ai'`).Scan(&t)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, nil
+	}
+	return t, err
+}
+
+func (r *warmupContentRepository) CreateGenerationJob(ctx context.Context, j *models.WarmupGenerationJob) error {
+	if j.ID == uuid.Nil {
+		j.ID = uuid.New()
+	}
+	if j.Mode == "" {
+		j.Mode = models.WarmupGenerationModeSync
+	}
+	if j.CompletionWindow == "" {
+		j.CompletionWindow = "24h"
+	}
+	query := `
+		INSERT INTO warmup_generation_jobs
+			(id, requested_by, trigger, mode, pool_type, segment, theme, model, requested_count, status,
+			 batch_id, batch_input_file_id, batch_output_file_id, batch_status, completion_window)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+	`
+	_, err := r.db.Exec(ctx, query,
+		j.ID, j.RequestedBy, j.Trigger, j.Mode, j.PoolType, j.Segment, j.Theme, j.Model, j.RequestedCount, j.Status,
+		j.BatchID, j.BatchInputFileID, j.BatchOutputFileID, j.BatchStatus, j.CompletionWindow,
+	)
+	return err
+}
+
+func (r *warmupContentRepository) UpdateGenerationJob(ctx context.Context, j *models.WarmupGenerationJob) error {
+	query := `
+		UPDATE warmup_generation_jobs SET
+			generated_count = $2,
+			lint_rejected_count = $3,
+			failed_count = $4,
+			status = $5,
+			error = $6,
+			started_at = $7,
+			finished_at = $8,
+			batch_id = $9,
+			batch_input_file_id = $10,
+			batch_output_file_id = $11,
+			batch_status = $12,
+			completion_window = $13,
+			updated_at = NOW()
+		WHERE id = $1
+	`
+	_, err := r.db.Exec(ctx, query,
+		j.ID, j.GeneratedCount, j.LintRejectedCount, j.FailedCount, j.Status, j.Error, j.StartedAt, j.FinishedAt,
+		j.BatchID, j.BatchInputFileID, j.BatchOutputFileID, j.BatchStatus, j.CompletionWindow,
+	)
+	return err
+}
+
+const generationJobCols = `id, requested_by, trigger, mode, pool_type, segment, theme, model, requested_count, generated_count, lint_rejected_count, failed_count, status, error, batch_id, batch_input_file_id, batch_output_file_id, batch_status, completion_window, started_at, finished_at, created_at, updated_at`
+
+func scanGenerationJob(row pgx.Row) (*models.WarmupGenerationJob, error) {
+	var j models.WarmupGenerationJob
+	err := row.Scan(
+		&j.ID, &j.RequestedBy, &j.Trigger, &j.Mode, &j.PoolType, &j.Segment, &j.Theme, &j.Model,
+		&j.RequestedCount, &j.GeneratedCount, &j.LintRejectedCount, &j.FailedCount,
+		&j.Status, &j.Error, &j.BatchID, &j.BatchInputFileID, &j.BatchOutputFileID, &j.BatchStatus, &j.CompletionWindow,
+		&j.StartedAt, &j.FinishedAt, &j.CreatedAt, &j.UpdatedAt,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return &j, nil
+}
+
+func (r *warmupContentRepository) GetGenerationJob(ctx context.Context, id uuid.UUID) (*models.WarmupGenerationJob, error) {
+	j, err := scanGenerationJob(r.db.QueryRow(ctx, `SELECT `+generationJobCols+` FROM warmup_generation_jobs WHERE id = $1`, id))
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, nil
+	}
+	return j, err
+}
+
+func (r *warmupContentRepository) ListGenerationJobs(ctx context.Context, limit, offset int) ([]models.WarmupGenerationJob, int, error) {
+	var total int
+	if err := r.db.QueryRow(ctx, `SELECT COUNT(*) FROM warmup_generation_jobs`).Scan(&total); err != nil {
+		return nil, 0, err
+	}
+	if limit <= 0 || limit > 200 {
+		limit = 50
+	}
+	rows, err := r.db.Query(ctx,
+		`SELECT `+generationJobCols+` FROM warmup_generation_jobs ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
+		limit, offset)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+
+	out := []models.WarmupGenerationJob{}
+	for rows.Next() {
+		j, err := scanGenerationJob(rows)
+		if err != nil {
+			return nil, 0, err
+		}
+		out = append(out, *j)
+	}
+	return out, total, rows.Err()
+}
+
+// ListActiveBatchJobs returns batch-mode jobs that are still running with a
+// non-terminal OpenAI batch status. Terminal statuses (completed/failed/expired/
+// cancelled) and a terminal job status are excluded so the poller only touches
+// in-flight work. An empty batch_status (just submitted, not yet polled) is
+// treated as active.
+func (r *warmupContentRepository) ListActiveBatchJobs(ctx context.Context) ([]models.WarmupGenerationJob, error) {
+	query := `SELECT ` + generationJobCols + ` FROM warmup_generation_jobs
+		WHERE mode = 'batch'
+		  AND status = 'running'
+		  AND batch_status NOT IN ('completed', 'failed', 'expired', 'cancelled')
+		  AND batch_id <> ''
+		ORDER BY created_at ASC`
+	rows, err := r.db.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := []models.WarmupGenerationJob{}
+	for rows.Next() {
+		j, err := scanGenerationJob(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, *j)
+	}
+	return out, rows.Err()
+}
+
+func (r *warmupContentRepository) GeneratedCountSince(ctx context.Context, since time.Time) (int, error) {
+	var n int
+	err := r.db.QueryRow(ctx,
+		`SELECT COALESCE(SUM(generated_count), 0) FROM warmup_generation_jobs WHERE created_at >= $1`, since).Scan(&n)
+	return n, err
+}
+
+func (r *warmupContentRepository) GetGenerationSettings(ctx context.Context) (*models.WarmupGenerationSettings, error) {
+	var raw []byte
+	err := r.db.QueryRow(ctx, `SELECT value FROM admin_settings WHERE key = $1`, models.AdminSettingsKeyWarmupGeneration).Scan(&raw)
+	if errors.Is(err, pgx.ErrNoRows) {
+		def := models.DefaultWarmupGenerationSettings()
+		return &def, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	s := models.DefaultWarmupGenerationSettings()
+	if len(raw) > 0 {
+		if err := json.Unmarshal(raw, &s); err != nil {
+			return nil, err
+		}
+	}
+	s.Normalize()
+	return &s, nil
+}
+
+func (r *warmupContentRepository) SetGenerationSettings(ctx context.Context, s *models.WarmupGenerationSettings, updatedBy *uuid.UUID) error {
+	s.Normalize()
+	raw, err := json.Marshal(s)
+	if err != nil {
+		return err
+	}
+	query := `
+		INSERT INTO admin_settings (key, value, updated_by, updated_at)
+		VALUES ($1, $2, $3, NOW())
+		ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_by = EXCLUDED.updated_by, updated_at = NOW()
+	`
+	_, err = r.db.Exec(ctx, query, models.AdminSettingsKeyWarmupGeneration, raw, updatedBy)
+	return err
+}
+
+func (r *warmupContentRepository) SpamPlacementByCohort(ctx context.Context, since time.Time) ([]WarmupCohortStat, error) {
+	stats := map[string]*WarmupCohortStat{}
+	get := func(src string) *WarmupCohortStat {
+		if src == "" {
+			src = models.WarmupContentSourceStatic
+		}
+		if s, ok := stats[src]; ok {
+			return s
+		}
+		s := &WarmupCohortStat{ContentSource: src}
+		stats[src] = s
+		return s
+	}
+
+	sentRows, err := r.db.Query(ctx,
+		`SELECT content_source, COUNT(*) FROM warmup_tokens WHERE created_at >= $1 GROUP BY content_source`, since)
+	if err != nil {
+		return nil, err
+	}
+	for sentRows.Next() {
+		var src string
+		var n int
+		if err := sentRows.Scan(&src, &n); err != nil {
+			sentRows.Close()
+			return nil, err
+		}
+		get(src).Sent += n
+	}
+	sentRows.Close()
+	if err := sentRows.Err(); err != nil {
+		return nil, err
+	}
+
+	placeRows, err := r.db.Query(ctx,
+		`SELECT content_source, COUNT(*) FROM warmup_spam_reports WHERE report_type = 'spam_placement' AND created_at >= $1 GROUP BY content_source`, since)
+	if err != nil {
+		return nil, err
+	}
+	for placeRows.Next() {
+		var src string
+		var n int
+		if err := placeRows.Scan(&src, &n); err != nil {
+			placeRows.Close()
+			return nil, err
+		}
+		get(src).SpamPlacements += n
+	}
+	placeRows.Close()
+	if err := placeRows.Err(); err != nil {
+		return nil, err
+	}
+
+	out := make([]WarmupCohortStat, 0, len(stats))
+	for _, s := range stats {
+		out = append(out, *s)
+	}
+	return out, nil
+}
diff --git a/internal/repository/pg_warmup_engagement.go b/internal/repository/pg_warmup_engagement.go
new file mode 100644
index 00000000..ce527a1c
--- /dev/null
+++ b/internal/repository/pg_warmup_engagement.go
@@ -0,0 +1,81 @@
+package repository
+
+import (
+	"context"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// PendingEngagement is a delayed warmup engagement action awaiting its dwell.
+// Payload is a JSON-encoded models.WarmupEmailAction (the delayed leg, with
+// DelaySeconds already consumed — the worker runs it immediately on receipt).
+type PendingEngagement struct {
+	ID             uuid.UUID
+	EmailAccountID uuid.UUID
+	Payload        []byte
+	FireAt         time.Time
+}
+
+// WarmupEngagementRepository is the durable schedule for dwell-delayed warmup
+// engagement actions, so a worker restart can't drop them (the old in-process
+// timer did). Control-plane only; drained by the consumer-side poller.
+type WarmupEngagementRepository interface {
+	// EnqueuePendingEngagement stores a delayed engagement leg to fire at fireAt.
+	EnqueuePendingEngagement(ctx context.Context, accountID uuid.UUID, payload []byte, fireAt time.Time) error
+	// ClaimDuePendingEngagements atomically removes and returns up to limit rows
+	// whose fire_at has passed, so each is delivered exactly once across pollers.
+	ClaimDuePendingEngagements(ctx context.Context, limit int) ([]PendingEngagement, error)
+}
+
+type warmupEngagementRepository struct {
+	db *pgxpool.Pool
+}
+
+// NewWarmupEngagementRepository creates a new warmup engagement repository.
+func NewWarmupEngagementRepository(db *pgxpool.Pool) WarmupEngagementRepository {
+	return &warmupEngagementRepository{db: db}
+}
+
+func (r *warmupEngagementRepository) EnqueuePendingEngagement(ctx context.Context, accountID uuid.UUID, payload []byte, fireAt time.Time) error {
+	_, err := r.db.Exec(ctx,
+		`INSERT INTO warmup_pending_engagements (email_account_id, payload, fire_at) VALUES ($1, $2, $3)`,
+		accountID, payload, fireAt)
+	return err
+}
+
+// ClaimDuePendingEngagements uses DELETE ... RETURNING over a FOR UPDATE SKIP
+// LOCKED subselect so concurrent pollers never claim the same row and a claimed
+// row is removed in the same statement (delivered at most once).
+func (r *warmupEngagementRepository) ClaimDuePendingEngagements(ctx context.Context, limit int) ([]PendingEngagement, error) {
+	if limit <= 0 {
+		limit = 100
+	}
+	query := `
+		DELETE FROM warmup_pending_engagements
+		WHERE id IN (
+			SELECT id FROM warmup_pending_engagements
+			WHERE fire_at <= NOW()
+			ORDER BY fire_at
+			LIMIT $1
+			FOR UPDATE SKIP LOCKED
+		)
+		RETURNING id, email_account_id, payload, fire_at
+	`
+	rows, err := r.db.Query(ctx, query, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []PendingEngagement
+	for rows.Next() {
+		var p PendingEngagement
+		if err := rows.Scan(&p.ID, &p.EmailAccountID, &p.Payload, &p.FireAt); err != nil {
+			return nil, err
+		}
+		out = append(out, p)
+	}
+	return out, rows.Err()
+}
diff --git a/internal/scheduler/campaign_scheduler.go b/internal/scheduler/campaign_scheduler.go
index 258bc12e..05cb24b1 100644
--- a/internal/scheduler/campaign_scheduler.go
+++ b/internal/scheduler/campaign_scheduler.go
@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/warmbly/warmbly/internal/models"
 	"github.com/warmbly/warmbly/internal/repository"
 )
 
@@ -110,6 +111,25 @@ func (s *schedulerService) CalculateNextCampaignTime(ctx context.Context, campai
 			continue
 		}
 
+		// Health-gate cold sends on the SAME warmup health state used for pool
+		// selection, so a mailbox in deliverability trouble doesn't keep blasting
+		// cold volume (the concentration risk the safety policy warns about):
+		//   - quarantined/blocked (still within blocked_until) → don't send at all
+		//   - throttled → halve today's budget (and the wider min-gap still applies)
+		if state, blockedUntil, herr := s.warmupRepo.GetHealthState(ctx, acct.ID); herr == nil {
+			switch state {
+			case models.WarmupHealthQuarantined, models.WarmupHealthBlocked:
+				if blockedUntil == nil || blockedUntil.After(time.Now()) {
+					continue
+				}
+			case models.WarmupHealthThrottled:
+				remaining /= 2
+				if remaining <= 0 {
+					continue
+				}
+			}
+		}
+
 		// If the account has its own timezone, check it is within business hours
 		if acct.Timezone != "" && acct.Timezone != campaign.Timezone {
 			acctTZ := loadLocation(acct.Timezone)
diff --git a/internal/tasks/campaign_task.go b/internal/tasks/campaign_task.go
index cb273fb2..50eabb6b 100644
--- a/internal/tasks/campaign_task.go
+++ b/internal/tasks/campaign_task.go
@@ -219,6 +219,24 @@ func (s *tasksService) HandleCampaignTask(task *proto.ProcessTask) *errx.Error {
 		}
 	}
 
+	// Pre-send verification gate: drop addresses already known to be invalid
+	// (bad syntax / no MX / 550 RCPT) before a worker sends and earns a hard
+	// bounce. Only 'invalid' is dropped — 'risky'/'unknown'/'valid' still send.
+	if contact.VerificationStatus == "invalid" {
+		_ = s.taskRepo.UpdateTaskStatusWithLock(ctx, taskID, "skipped_suppressed")
+		if s.campaignLogRepo != nil {
+			_ = s.campaignLogRepo.CreateLog(ctx, &repository.CampaignLogEntry{
+				CampaignID: campaign.ID,
+				EventType:  "suppressed",
+				Message:    fmt.Sprintf("Unverifiable recipient skipped: %s", contact.Email),
+				Metadata:   map[string]interface{}{"reason": contact.VerificationReason},
+			})
+		}
+		_ = s.createCampaignTask(ctx, campaign.ID, accountID, nextTime)
+		executionStatus = "completed"
+		return nil
+	}
+
 	sequence, err := s.campaignRepo.GetSequenceByID(ctx, nextPair.SequenceID)
 	if err != nil {
 		sentry.CaptureException(err)
diff --git a/internal/tasks/content_lint.go b/internal/tasks/content_lint.go
new file mode 100644
index 00000000..99a30cbb
--- /dev/null
+++ b/internal/tasks/content_lint.go
@@ -0,0 +1,11 @@
+package tasks
+
+import "github.com/warmbly/warmbly/internal/pkg/warmlint"
+
+// lintWarmupContent rejects content that would raise the sending mailbox's own
+// spam score (ALL-CAPS subjects, stacked punctuation, stacked spam triggers, a
+// fabricated Re:/Fwd: on a non-reply). Shared with the offline AI generator via
+// the warmlint package so static and AI content are held to the same bar.
+func lintWarmupContent(subject, body string, isReply bool) error {
+	return warmlint.Check(subject, body, isReply)
+}
diff --git a/internal/tasks/email_task.go b/internal/tasks/email_task.go
index 9899200d..a81cf141 100644
--- a/internal/tasks/email_task.go
+++ b/internal/tasks/email_task.go
@@ -173,7 +173,8 @@ func (s *tasksService) HandleEmailTask(task *proto.ProcessTask) *errx.Error {
 	// the original send so the thread stays topically coherent.
 	replyRate := account.WarmupReplyRate
 	shouldReply := rand.Float64()*100 < float64(replyRate)
-	var subject, emailBody, conversationTheme string
+	var subject, emailBody, conversationTheme, contentSource string
+	var conversationID *uuid.UUID
 	var inReplyTo string
 
 	if shouldReply {
@@ -184,23 +185,55 @@ func (s *tasksService) HandleEmailTask(task *proto.ProcessTask) *errx.Error {
 			if subject == "" {
 				subject = generateWarmupSubject()
 			}
+			// "Re:" is legitimate here — this is a genuine reply with a real
+			// In-Reply-To header (synthesizeWarmupSubject no longer fabricates
+			// "Re:" on first-touch sends).
 			if !strings.HasPrefix(strings.ToLower(subject), "re:") {
 				subject = "Re: " + subject
 			}
 			conv := conversationForTheme(candidate.ConversationTheme)
 			conversationTheme = conv.Theme
+			contentSource = models.WarmupContentSourceStatic
 			emailBody = GenerateConversationEmail(conv, *account, true)
 		} else {
 			shouldReply = false
 		}
 	}
 
-	// STEP 7: Build a new warmup message when not replying
+	// STEP 7: Build a new warmup message when not replying. Content comes from
+	// the AI bank (segment-aware) when enabled, else the static library.
 	if !shouldReply {
-		conversation := randomWarmupConversation()
-		conversationTheme = conversation.Theme
+		content := s.pickNewWarmupContent(ctx, *account)
+		subject = content.subject
+		emailBody = content.body
+		conversationTheme = content.theme
+		contentSource = content.contentSource
+		conversationID = content.conversationID
+	}
+
+	// STEP 7.5: Content-safety lint. Warmup mail must look unremarkable; if the
+	// chosen content trips the lint (most likely AI drift) fall back to clean
+	// static content so we never send spammy-looking warmup.
+	if err := lintWarmupContent(subject, emailBody, shouldReply); err != nil {
+		log.Warn().Err(err).
+			Str("email_account_id", account.ID.String()).
+			Str("content_source", contentSource).
+			Msg("warmup content failed lint; falling back to static")
+		conv := randomWarmupConversation()
+		conversationTheme = conv.Theme
+		fallbackID := conv.ID
+		conversationID = &fallbackID
+		contentSource = models.WarmupContentSourceStatic
 		subject = generateWarmupSubject()
-		emailBody = GenerateConversationEmail(conversation, *account, false)
+		emailBody = GenerateConversationEmail(conv, *account, false)
+		if err2 := lintWarmupContent(subject, emailBody, false); err2 != nil {
+			subject = "Quick note"
+			emailBody = GenerateConversationEmail(Conversation{
+				Theme:       "checkin",
+				Description: "Just checking in — hope all is well.",
+				Messages:    []string{"How have things been lately?"},
+			}, *account, false)
+		}
 	}
 
 	// STEP 8: Parse sender user ID for the outbound message.
@@ -215,6 +248,12 @@ func (s *tasksService) HandleEmailTask(task *proto.ProcessTask) *errx.Error {
 
 	// STEP 9: Generate Message-ID
 	messageID := generateMessageID(account.Email)
+	// Persist it now so the reply path (GetLatestReplyCandidate, which filters
+	// message_id <> '') can find this send as a thread parent on a later turn.
+	// Without this the warmup reply/threading path never fires.
+	if err := s.taskRepo.UpdateTaskMessageID(ctx, taskID, messageID); err != nil {
+		log.Warn().Err(err).Str("task_id", taskID.String()).Msg("Failed to persist warmup task message_id")
+	}
 
 	// STEP 9.5: Generate warmup verification token
 	var warmupTokenStr string
@@ -225,6 +264,8 @@ func (s *tasksService) HandleEmailTask(task *proto.ProcessTask) *errx.Error {
 		SenderAccountID:    account.ID,
 		RecipientAccountID: partner.ID,
 		ConversationTheme:  conversationTheme,
+		ContentSource:      contentSource,
+		ConversationID:     conversationID,
 		ExpiresAt:          time.Now().Add(7 * 24 * time.Hour),
 	}
 	if err := s.warmupRepo.CreateWarmupToken(ctx, tokenRecord); err != nil {
@@ -267,6 +308,13 @@ func (s *tasksService) HandleEmailTask(task *proto.ProcessTask) *errx.Error {
 	if err := s.warmupRepo.IncrementDailyCount(ctx, account.ID, time.Now()); err != nil {
 		log.Warn().Err(err).Str("task_id", taskID.String()).Str("email_account_id", account.ID.String()).Msg("Failed to increment warmup daily count")
 	}
+	// Track replies separately so warmup reply analytics (emails_replied) is no
+	// longer always zero. Conversational replies are a healthy-traffic signal.
+	if shouldReply {
+		if err := s.warmupRepo.IncrementReplyCount(ctx, account.ID, time.Now()); err != nil {
+			log.Warn().Err(err).Str("task_id", taskID.String()).Str("email_account_id", account.ID.String()).Msg("Failed to increment warmup reply count")
+		}
+	}
 
 	// STEP 13: Mark task completed (with advisory lock)
 	if err := s.taskRepo.UpdateTaskStatusWithLock(ctx, taskID, "completed"); err != nil {
@@ -322,6 +370,18 @@ const recentDomainWindow = 7 * 24 * time.Hour
 // that mailbox providers can cluster on.
 const smallPoolWarnThreshold = 8
 
+// partnerDiversityWindow / partnerMaxSharedWindow set the explicit
+// partner-diversity target: within partnerDiversityWindow, a sender should not
+// send to the same partner more than partnerMaxSharedWindow times. Over-used
+// partners are demoted to the fallback tier so warmup traffic spreads across
+// many partners rather than forming a tight reciprocal pair (a closed-loop
+// graph signal). This is a soft target — it only applies while enough other
+// partners remain available.
+const (
+	partnerDiversityWindow = 7 * 24 * time.Hour
+	partnerMaxSharedWindow = 3
+)
+
 func warmupPartnerRecheckTime() time.Time {
 	return time.Now().Add(time.Duration(240+rand.Intn(240)) * time.Minute)
 }
@@ -390,6 +450,14 @@ func (s *tasksService) selectWarmupPartner(ctx context.Context, account Email) (
 		domainCounts = nil
 	}
 
+	// Explicit partner-diversity target: how many times each partner has been
+	// used in the diversity window, so partners the sender already leans on
+	// heavily get demoted out of the preferred tier.
+	partnerCounts, err := s.warmupRepo.GetRecentPartnerCounts(ctx, account.ID, time.Now().Add(-partnerDiversityWindow))
+	if err != nil {
+		partnerCounts = nil
+	}
+
 	var availablePartners []uuid.UUID
 	var fallbackPartners []uuid.UUID
 	for _, id := range participantIDs {
@@ -400,7 +468,9 @@ func (s *tasksService) selectWarmupPartner(ctx context.Context, account Email) (
 			continue
 		}
 		fallbackPartners = append(fallbackPartners, id)
-		if _, recentlyUsed := recentPartnerSet[id]; !recentlyUsed {
+		_, recentlyUsed := recentPartnerSet[id]
+		overUsed := partnerCounts[id] >= partnerMaxSharedWindow
+		if !recentlyUsed && !overUsed {
 			availablePartners = append(availablePartners, id)
 		}
 	}
@@ -413,14 +483,43 @@ func (s *tasksService) selectWarmupPartner(ctx context.Context, account Email) (
 		return nil, fmt.Errorf("no available warmup partners")
 	}
 
-	partnerID := pickWeightedPartner(availablePartners, domainsByID, domainCounts, routingRules, account.Email, emailsByID)
+	// Pick a partner, then gate it through the SAME health re-evaluation the
+	// sender passes (email_task STEP 5). The recipient-selection SQL re-admits a
+	// row the instant blocked_until elapses — before the hourly sweep
+	// reclassifies it — so without this gate a just-expired quarantined/blocked
+	// mailbox could be chosen as a recipient with no re-qualification.
+	// CanParticipate re-evaluates and forces just-unblocked mailboxes into
+	// probation, matching the CLAUDE.md re-entry policy on the recipient surface.
+	for attempts := 0; attempts < 5 && len(availablePartners) > 0; attempts++ {
+		partnerID := pickWeightedPartner(availablePartners, domainsByID, domainCounts, routingRules, account.Email, emailsByID)
 
-	partner, err := s.emailRepo.GetByID(ctx, partnerID)
-	if err != nil {
-		return nil, err
+		if s.warmupHealth != nil {
+			if ok, _, _ := s.warmupHealth.CanParticipate(ctx, partnerID, poolType); !ok {
+				availablePartners = removePartnerID(availablePartners, partnerID)
+				continue
+			}
+		}
+
+		partner, err := s.emailRepo.GetByID(ctx, partnerID)
+		if err != nil {
+			return nil, err
+		}
+		return partner, nil
 	}
 
-	return partner, nil
+	return nil, fmt.Errorf("no eligible warmup partners after health gate")
+}
+
+// removePartnerID returns ids without the first occurrence of target. Used to
+// drop a partner that failed the health gate before re-picking.
+func removePartnerID(ids []uuid.UUID, target uuid.UUID) []uuid.UUID {
+	out := make([]uuid.UUID, 0, len(ids))
+	for _, id := range ids {
+		if id != target {
+			out = append(out, id)
+		}
+	}
+	return out
 }
 
 // pickWeightedPartner picks a partner ID using a composite weight:
@@ -620,7 +719,10 @@ func synthesizeWarmupSubject() string {
 		"{question} about {noun}",
 		"{timeRef} {noun}",
 		"{noun} {timeRef}",
-		"Re: {noun}",
+		// NB: no "Re:"/"Fwd:" template here — a fabricated reply prefix on a
+		// first-touch send is a deception signal and CAN-SPAM exposure. The
+		// genuine reply path adds "Re:" itself when there is a real
+		// In-Reply-To header.
 	}
 	adj := []string{"quick", "small", "short", "tiny", "casual", "friendly", "useful", "interesting", "brief", "minor"}
 	noun := []string{"check-in", "follow up", "note", "ping", "thought", "update", "idea", "heads up", "favor", "question", "nudge", "share"}
@@ -732,65 +834,80 @@ func randomWarmupConversation() Conversation {
 	return conversations[rand.Intn(len(conversations))]
 }
 
+// staticConvID derives a STABLE id for a static-library conversation from its
+// content. Previously each call to warmupConversations() minted fresh uuid.New()
+// ids, so the conversation_id recorded on a warmup token never matched across
+// sends — defeating cohort correlation and dedupe. A deterministic id makes the
+// static library traceable the same way the AI bank rows are.
+func staticConvID(theme, description string) uuid.UUID {
+	return uuid.NewSHA1(uuid.NameSpaceOID, []byte("warmup-static:"+theme+"|"+description))
+}
+
 func warmupConversations() []Conversation {
 	conversations := []Conversation{
 		// Productivity & workflow
-		{ID: uuid.New(), Theme: "productivity", Description: "I have been trying a few workflow changes and wondered what worked best for your week.", Messages: []string{"How do you structure focused work blocks?", "Do you batch similar tasks or tackle them as they come?"}},
-		{ID: uuid.New(), Theme: "productivity", Description: "I started time-blocking my calendar this month and the results have been interesting so far.", Messages: []string{"Have you tried any time management methods that actually stuck?", "What does your typical morning routine look like?"}},
-		{ID: uuid.New(), Theme: "automation", Description: "I automated a couple of repetitive tasks recently and it freed up more time than I expected.", Messages: []string{"Are there any repetitive tasks in your day that you have managed to streamline?"}},
+		{Theme: "productivity", Description: "I have been trying a few workflow changes and wondered what worked best for your week.", Messages: []string{"How do you structure focused work blocks?", "Do you batch similar tasks or tackle them as they come?"}},
+		{Theme: "productivity", Description: "I started time-blocking my calendar this month and the results have been interesting so far.", Messages: []string{"Have you tried any time management methods that actually stuck?", "What does your typical morning routine look like?"}},
+		{Theme: "automation", Description: "I automated a couple of repetitive tasks recently and it freed up more time than I expected.", Messages: []string{"Are there any repetitive tasks in your day that you have managed to streamline?"}},
 
 		// Learning & growth
-		{ID: uuid.New(), Theme: "learning", Description: "I came across a useful article and it got me curious about what resources you rely on lately.", Messages: []string{"Any newsletter or podcast you consistently recommend?", "What is the best thing you have learned recently?"}},
-		{ID: uuid.New(), Theme: "learning", Description: "I have been dedicating an hour each week to learning something new and it has been surprisingly rewarding.", Messages: []string{"How do you make time for professional development?"}},
-		{ID: uuid.New(), Theme: "courses", Description: "I just wrapped up an online course that was really practical and well-structured.", Messages: []string{"Have you taken any courses lately that were worth the investment?"}},
+		{Theme: "learning", Description: "I came across a useful article and it got me curious about what resources you rely on lately.", Messages: []string{"Any newsletter or podcast you consistently recommend?", "What is the best thing you have learned recently?"}},
+		{Theme: "learning", Description: "I have been dedicating an hour each week to learning something new and it has been surprisingly rewarding.", Messages: []string{"How do you make time for professional development?"}},
+		{Theme: "courses", Description: "I just wrapped up an online course that was really practical and well-structured.", Messages: []string{"Have you taken any courses lately that were worth the investment?"}},
 
 		// Collaboration & teams
-		{ID: uuid.New(), Theme: "collaboration", Description: "I was thinking about how teams keep communication clear when work gets busy.", Messages: []string{"What has helped your team keep projects moving smoothly?", "How do you handle async communication across time zones?"}},
-		{ID: uuid.New(), Theme: "meetings", Description: "We cut our meeting load in half last month and the team seems more productive overall.", Messages: []string{"How do you decide which meetings are actually necessary?", "Have you found a good balance between sync and async?"}},
+		{Theme: "collaboration", Description: "I was thinking about how teams keep communication clear when work gets busy.", Messages: []string{"What has helped your team keep projects moving smoothly?", "How do you handle async communication across time zones?"}},
+		{Theme: "meetings", Description: "We cut our meeting load in half last month and the team seems more productive overall.", Messages: []string{"How do you decide which meetings are actually necessary?", "Have you found a good balance between sync and async?"}},
 
 		// Industry & trends
-		{ID: uuid.New(), Theme: "industry", Description: "I noticed a shift in how people are approaching this topic and wanted to get your take.", Messages: []string{"Have you seen any changes in how your industry handles this?", "What trends are you paying attention to right now?"}},
-		{ID: uuid.New(), Theme: "market", Description: "The market has been moving fast lately and I have been trying to figure out what matters most.", Messages: []string{"How are you adapting your approach given recent changes?"}},
+		{Theme: "industry", Description: "I noticed a shift in how people are approaching this topic and wanted to get your take.", Messages: []string{"Have you seen any changes in how your industry handles this?", "What trends are you paying attention to right now?"}},
+		{Theme: "market", Description: "The market has been moving fast lately and I have been trying to figure out what matters most.", Messages: []string{"How are you adapting your approach given recent changes?"}},
 
 		// Tools & technology
-		{ID: uuid.New(), Theme: "tools", Description: "I recently switched up a few tools in my daily workflow and the difference has been noticeable.", Messages: []string{"What tools have made the biggest impact for you this year?", "Have you found a good alternative for that?"}},
-		{ID: uuid.New(), Theme: "software", Description: "I have been testing a new project management setup and wondering if I am overcomplicating things.", Messages: []string{"What is your go-to for keeping projects organized?", "Do you prefer simple tools or full-featured platforms?"}},
+		{Theme: "tools", Description: "I recently switched up a few tools in my daily workflow and the difference has been noticeable.", Messages: []string{"What tools have made the biggest impact for you this year?", "Have you found a good alternative for that?"}},
+		{Theme: "software", Description: "I have been testing a new project management setup and wondering if I am overcomplicating things.", Messages: []string{"What is your go-to for keeping projects organized?", "Do you prefer simple tools or full-featured platforms?"}},
 
 		// Networking & catch-ups
-		{ID: uuid.New(), Theme: "networking", Description: "It has been a while since we last connected and I wanted to see how things are going on your end.", Messages: []string{"Any new projects or goals you are excited about?", "What has been keeping you busy lately?"}},
-		{ID: uuid.New(), Theme: "catchup", Description: "I was cleaning up my contacts list and realized we have not caught up in ages.", Messages: []string{"How has your year been going so far?", "Anything interesting happening on your side?"}},
-		{ID: uuid.New(), Theme: "introduction", Description: "I met someone recently who reminded me of the work you do and thought you two should connect.", Messages: []string{"Would you be open to a quick intro?"}},
+		{Theme: "networking", Description: "It has been a while since we last connected and I wanted to see how things are going on your end.", Messages: []string{"Any new projects or goals you are excited about?", "What has been keeping you busy lately?"}},
+		{Theme: "catchup", Description: "I was cleaning up my contacts list and realized we have not caught up in ages.", Messages: []string{"How has your year been going so far?", "Anything interesting happening on your side?"}},
+		{Theme: "introduction", Description: "I met someone recently who reminded me of the work you do and thought you two should connect.", Messages: []string{"Would you be open to a quick intro?"}},
 
 		// Feedback & advice
-		{ID: uuid.New(), Theme: "feedback", Description: "I have been working on something and would really value a second opinion before moving forward.", Messages: []string{"Would you mind taking a quick look when you have a moment?", "I would appreciate your honest feedback on this."}},
-		{ID: uuid.New(), Theme: "advice", Description: "I am facing a decision and I think your perspective could really help me think it through.", Messages: []string{"Have you dealt with anything similar before?", "What would you do in this situation?"}},
+		{Theme: "feedback", Description: "I have been working on something and would really value a second opinion before moving forward.", Messages: []string{"Would you mind taking a quick look when you have a moment?", "I would appreciate your honest feedback on this."}},
+		{Theme: "advice", Description: "I am facing a decision and I think your perspective could really help me think it through.", Messages: []string{"Have you dealt with anything similar before?", "What would you do in this situation?"}},
 
 		// Planning & strategy
-		{ID: uuid.New(), Theme: "planning", Description: "I am mapping out priorities for the next quarter and trying to stay realistic about what is achievable.", Messages: []string{"How do you decide what to focus on when everything feels urgent?", "What is your process for setting quarterly goals?"}},
-		{ID: uuid.New(), Theme: "strategy", Description: "I have been rethinking how we allocate resources across projects and it is harder than it sounds.", Messages: []string{"How do you balance long-term bets with short-term wins?"}},
+		{Theme: "planning", Description: "I am mapping out priorities for the next quarter and trying to stay realistic about what is achievable.", Messages: []string{"How do you decide what to focus on when everything feels urgent?", "What is your process for setting quarterly goals?"}},
+		{Theme: "strategy", Description: "I have been rethinking how we allocate resources across projects and it is harder than it sounds.", Messages: []string{"How do you balance long-term bets with short-term wins?"}},
 
 		// Reading & content
-		{ID: uuid.New(), Theme: "reading", Description: "I just finished a great book that changed how I think about a few things at work.", Messages: []string{"Read anything good lately that stuck with you?", "Any books you keep recommending to people?"}},
-		{ID: uuid.New(), Theme: "content", Description: "I have been curating a reading list and looking for suggestions outside my usual topics.", Messages: []string{"What is the most surprising thing you have read recently?"}},
+		{Theme: "reading", Description: "I just finished a great book that changed how I think about a few things at work.", Messages: []string{"Read anything good lately that stuck with you?", "Any books you keep recommending to people?"}},
+		{Theme: "content", Description: "I have been curating a reading list and looking for suggestions outside my usual topics.", Messages: []string{"What is the most surprising thing you have read recently?"}},
 
 		// Travel & experiences
-		{ID: uuid.New(), Theme: "travel", Description: "I am starting to plan a trip and looking for recommendations from people who have been there.", Messages: []string{"Any travel tips or favorite destinations you would suggest?", "Where was the last place you traveled that exceeded expectations?"}},
-		{ID: uuid.New(), Theme: "food", Description: "I tried a new restaurant last week that was genuinely impressive and thought you might enjoy it too.", Messages: []string{"Have you discovered any great spots lately?"}},
+		{Theme: "travel", Description: "I am starting to plan a trip and looking for recommendations from people who have been there.", Messages: []string{"Any travel tips or favorite destinations you would suggest?", "Where was the last place you traveled that exceeded expectations?"}},
+		{Theme: "food", Description: "I tried a new restaurant last week that was genuinely impressive and thought you might enjoy it too.", Messages: []string{"Have you discovered any great spots lately?"}},
 
 		// Wellness & balance
-		{ID: uuid.New(), Theme: "wellness", Description: "I have been trying to be more intentional about work-life balance and curious how others handle it.", Messages: []string{"What do you do to recharge after a busy stretch?", "Have you found any habits that help you stay consistent?"}},
-		{ID: uuid.New(), Theme: "fitness", Description: "I recently picked up a new workout routine and it has been making a real difference in my energy levels.", Messages: []string{"Do you have a go-to way to stay active during busy weeks?"}},
+		{Theme: "wellness", Description: "I have been trying to be more intentional about work-life balance and curious how others handle it.", Messages: []string{"What do you do to recharge after a busy stretch?", "Have you found any habits that help you stay consistent?"}},
+		{Theme: "fitness", Description: "I recently picked up a new workout routine and it has been making a real difference in my energy levels.", Messages: []string{"Do you have a go-to way to stay active during busy weeks?"}},
 
 		// Events & community
-		{ID: uuid.New(), Theme: "events", Description: "I saw a conference coming up that might be relevant and wanted to flag it for you.", Messages: []string{"Are you attending any events or meetups soon?", "What was the last event you went to that was actually worthwhile?"}},
-		{ID: uuid.New(), Theme: "community", Description: "I have been getting more involved in a professional community and it has been a great source of ideas.", Messages: []string{"Are you part of any groups or communities you find valuable?"}},
+		{Theme: "events", Description: "I saw a conference coming up that might be relevant and wanted to flag it for you.", Messages: []string{"Are you attending any events or meetups soon?", "What was the last event you went to that was actually worthwhile?"}},
+		{Theme: "community", Description: "I have been getting more involved in a professional community and it has been a great source of ideas.", Messages: []string{"Are you part of any groups or communities you find valuable?"}},
 
 		// Hiring & careers
-		{ID: uuid.New(), Theme: "hiring", Description: "We have been expanding the team and I have been learning a lot about what makes a strong hire.", Messages: []string{"What do you look for when bringing someone new on board?"}},
-		{ID: uuid.New(), Theme: "career", Description: "I have been reflecting on where I want to be in the next few years and it is a useful exercise.", Messages: []string{"How do you think about career growth without burning out?"}},
+		{Theme: "hiring", Description: "We have been expanding the team and I have been learning a lot about what makes a strong hire.", Messages: []string{"What do you look for when bringing someone new on board?"}},
+		{Theme: "career", Description: "I have been reflecting on where I want to be in the next few years and it is a useful exercise.", Messages: []string{"How do you think about career growth without burning out?"}},
 
 		// Gratitude & appreciation
-		{ID: uuid.New(), Theme: "gratitude", Description: "I was thinking about the people who have been helpful to me this year and you came to mind.", Messages: []string{"Just wanted to say thanks for being a great connection.", "Appreciate you always being willing to share your perspective."}},
+		{Theme: "gratitude", Description: "I was thinking about the people who have been helpful to me this year and you came to mind.", Messages: []string{"Just wanted to say thanks for being a great connection.", "Appreciate you always being willing to share your perspective."}},
+	}
+
+	// Assign stable, content-derived ids so a given static conversation has the
+	// same id on every send (see staticConvID).
+	for i := range conversations {
+		conversations[i].ID = staticConvID(conversations[i].Theme, conversations[i].Description)
 	}
 
 	return conversations
diff --git a/internal/tasks/service.go b/internal/tasks/service.go
index e03d1ec9..f0e50d77 100644
--- a/internal/tasks/service.go
+++ b/internal/tasks/service.go
@@ -2,6 +2,7 @@ package tasks
 
 import (
 	"context"
+	"sync"
 	"time"
 
 	"github.com/google/uuid"
@@ -71,11 +72,23 @@ type tasksService struct {
 	taskRepo             repository.TaskRepository
 	warmupRepo           repository.WarmupRepository
 	warmupRoutingRepo    repository.WarmupRoutingRepository
+	warmupContentRepo    repository.WarmupContentRepository
 	campaignProgressRepo repository.CampaignProgressRepository
 	emailRepo            repository.EmailRepository
 	campaignRepo         repository.CampaignRepository
 	contactRepo          repository.ContactRepository
 	campaignLogRepo      repository.CampaignLogRepository
+
+	// warmupSettings caches the warmup generation settings in-process so the
+	// per-send AI-vs-static decision doesn't hit Postgres on every warmup.
+	warmupSettings *warmupSettingsCache
+}
+
+// warmupSettingsCache is a tiny TTL cache over the generation settings.
+type warmupSettingsCache struct {
+	mu      sync.RWMutex
+	val     models.WarmupGenerationSettings
+	fetched time.Time
 }
 
 func NewService(
@@ -92,6 +105,7 @@ func NewService(
 	taskRepo repository.TaskRepository,
 	warmupRepo repository.WarmupRepository,
 	warmupRoutingRepo repository.WarmupRoutingRepository,
+	warmupContentRepo repository.WarmupContentRepository,
 	campaignProgressRepo repository.CampaignProgressRepository,
 	emailRepo repository.EmailRepository,
 	campaignRepo repository.CampaignRepository,
@@ -114,10 +128,12 @@ func NewService(
 		taskRepo:             taskRepo,
 		warmupRepo:           warmupRepo,
 		warmupRoutingRepo:    warmupRoutingRepo,
+		warmupContentRepo:    warmupContentRepo,
 		campaignProgressRepo: campaignProgressRepo,
 		emailRepo:            emailRepo,
 		campaignRepo:         campaignRepo,
 		contactRepo:          contactRepo,
 		campaignLogRepo:      campaignLogRepo,
+		warmupSettings:       &warmupSettingsCache{},
 	}
 }
diff --git a/internal/tasks/spintax.go b/internal/tasks/spintax.go
new file mode 100644
index 00000000..5f823ac8
--- /dev/null
+++ b/internal/tasks/spintax.go
@@ -0,0 +1,38 @@
+package tasks
+
+import (
+	"math/rand"
+	"regexp"
+	"strings"
+)
+
+// spintaxGroup matches an innermost {a|b|c} alternation group (no nested braces
+// inside). Nested groups are resolved by repeated passes, innermost first.
+var spintaxGroup = regexp.MustCompile(`\{([^{}]*)\}`)
+
+// spin expands {a|b|c} spintax: each alternation group is replaced by one of
+// its options chosen at random. This is the body-level analogue of the subject
+// synthesiser — it multiplies the number of distinct rendered bodies so the
+// warmup corpus isn't a small fixed set that filters can fingerprint. Text
+// containing no braces is returned unchanged. A group with no '|' is treated as
+// literal text with the braces stripped.
+func spin(s string) string {
+	// Bounded loop: each pass resolves the current innermost groups; the cap
+	// guards against pathological/malformed input that never fully resolves.
+	for i := 0; i < 20 && strings.Contains(s, "{"); i++ {
+		s = spintaxGroup.ReplaceAllStringFunc(s, func(m string) string {
+			inner := m[1 : len(m)-1]
+			opts := strings.Split(inner, "|")
+			return opts[rand.Intn(len(opts))]
+		})
+	}
+	return s
+}
+
+// spinClean expands spintax and tidies whitespace introduced by optional
+// fragments (e.g. an empty option leaving a double space).
+func spinClean(s string) string {
+	out := spin(s)
+	out = strings.ReplaceAll(out, "  ", " ")
+	return strings.TrimSpace(out)
+}
diff --git a/internal/tasks/template.go b/internal/tasks/template.go
index 14f8136d..4dde13f5 100644
--- a/internal/tasks/template.go
+++ b/internal/tasks/template.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/warmbly/warmbly/internal/models"
+	"github.com/warmbly/warmbly/internal/pkg/warmpersona"
 )
 
 // Conversation represents a warmup conversation for AI generation
@@ -137,29 +138,52 @@ func WrapLinksForTracking(htmlBody string, taskID uuid.UUID, trackingDomain stri
 	return result
 }
 
-// GenerateConversationEmail generates email content from AI conversation
+// personaPick chooses from a mailbox's preferred subset of phrasing options so
+// each mailbox keeps a consistent "voice" while still varying message to
+// message. Falls back gracefully for tiny option sets.
+func personaPick(p warmpersona.Persona, axis string, opts []string) string {
+	if len(opts) == 0 {
+		return ""
+	}
+	k := 3
+	if k > len(opts) {
+		k = len(opts)
+	}
+	subset := p.Subset(axis, len(opts), k)
+	if len(subset) == 0 {
+		return opts[rand.Intn(len(opts))]
+	}
+	return opts[subset[rand.Intn(len(subset))]]
+}
+
+// GenerateConversationEmail renders a plaintext warmup body from a conversation.
+//
+// Bodies vary three ways to avoid the small-fixed-corpus fingerprint: a
+// per-mailbox persona biases the greeting/sign-off "voice", {a|b|c} spintax in
+// the description/messages is expanded per send, and the structure (optional
+// opener line, optional follow-up question) is randomised. Plaintext only — no
+// links, no HTML, in line with warmup policy.
 func GenerateConversationEmail(conversation Conversation, account models.Email, isReply bool) string {
 	signature := account.Name
 	if signature == "" {
 		signature = account.Email
 	}
 
+	persona := warmpersona.For(account.ID)
+
+	greetings := []string{"Hi,", "Hey,", "Hi there,", "Hello,", "Hey there,", "Morning,", "Hello there,"}
+	signoffs := []string{"Best regards,", "Best,", "Cheers,", "Thanks,", "Talk soon,", "All the best,", "Speak soon,", "Take care,"}
+
+	greeting := personaPick(persona, "greeting", greetings)
+	signoff := personaPick(persona, "signoff", signoffs)
+
 	pickMessage := func() string {
 		if len(conversation.Messages) == 0 {
 			return ""
 		}
-		return conversation.Messages[rand.Intn(len(conversation.Messages))]
+		return spinClean(conversation.Messages[rand.Intn(len(conversation.Messages))])
 	}
 
-	greetings := []string{"Hi,", "Hey,", "Hi there,", "Hello,", "Hey there,"}
-	greeting := greetings[rand.Intn(len(greetings))]
-
-	signoffs := []string{"Best regards,", "Best,", "Cheers,", "Thanks,", "Talk soon,", "All the best,"}
-	signoff := signoffs[rand.Intn(len(signoffs))]
-
-	description := strings.TrimSpace(conversation.Description)
-	message := strings.TrimSpace(pickMessage())
-
 	if isReply {
 		replyStarters := []string{
 			"Thanks for your message.",
@@ -167,23 +191,57 @@ func GenerateConversationEmail(conversation Conversation, account models.Email,
 			"Good to hear from you.",
 			"Thanks for the reply.",
 			"Great to hear back.",
+			"Thanks for the note — good timing.",
 		}
-		replyLine := replyStarters[rand.Intn(len(replyStarters))]
-		if message != "" {
-			replyLine = message
+		lead := replyStarters[rand.Intn(len(replyStarters))]
+		question := pickMessage()
+
+		var sb strings.Builder
+		sb.WriteString(lead)
+		if question != "" {
+			sb.WriteString("\n\n")
+			sb.WriteString(question)
 		}
-		return fmt.Sprintf("%s\n\n%s\n%s", replyLine, signoff, signature)
+		sb.WriteString("\n\n")
+		sb.WriteString(signoff)
+		sb.WriteString("\n")
+		sb.WriteString(signature)
+		return sb.String()
 	}
 
-	body := description
-	if body == "" {
-		body = "Just checking in with a quick note."
-	}
-	if message != "" {
-		body = body + "\n\n" + message
+	description := spinClean(conversation.Description)
+	if description == "" {
+		description = "Just wanted to check in with a quick note."
 	}
 
-	return fmt.Sprintf("%s\n\n%s\n\n%s\n%s", greeting, body, signoff, signature)
+	openers := []string{
+		"Hope your week is going well.",
+		"Hope you're doing well.",
+		"Hope things are good on your end.",
+		"Hope you've had a good start to the week.",
+		"Hope all's well with you.",
+	}
+
+	var sb strings.Builder
+	sb.WriteString(greeting)
+	sb.WriteString("\n\n")
+	// ~60% include a short opener for a warmer, less terse message.
+	if rand.Float64() < 0.6 {
+		sb.WriteString(openers[rand.Intn(len(openers))])
+		sb.WriteString(" ")
+	}
+	sb.WriteString(description)
+
+	if question := pickMessage(); question != "" {
+		sb.WriteString("\n\n")
+		sb.WriteString(question)
+	}
+
+	sb.WriteString("\n\n")
+	sb.WriteString(signoff)
+	sb.WriteString("\n")
+	sb.WriteString(signature)
+	return sb.String()
 }
 
 // ExtractPlainTextFromHTML converts HTML to plain text (basic implementation)
diff --git a/internal/tasks/warmup_content.go b/internal/tasks/warmup_content.go
new file mode 100644
index 00000000..18fb3908
--- /dev/null
+++ b/internal/tasks/warmup_content.go
@@ -0,0 +1,93 @@
+package tasks
+
+import (
+	"context"
+	"math/rand"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/warmbly/warmbly/internal/models"
+)
+
+// warmupContent is the rendered content for one warmup send plus the cohort
+// metadata recorded on the verification token for the A/B harness.
+type warmupContent struct {
+	subject        string
+	body           string
+	theme          string
+	contentSource  string
+	conversationID *uuid.UUID
+}
+
+// getWarmupSettings returns the warmup generation settings with a short
+// in-process TTL cache so the per-send AI-vs-static decision doesn't hit
+// Postgres on every warmup send. Falls back to defaults when unconfigured.
+func (s *tasksService) getWarmupSettings(ctx context.Context) models.WarmupGenerationSettings {
+	if s.warmupContentRepo == nil {
+		return models.DefaultWarmupGenerationSettings()
+	}
+	if c := s.warmupSettings; c != nil {
+		c.mu.RLock()
+		fresh := !c.fetched.IsZero() && time.Since(c.fetched) < 60*time.Second
+		val := c.val
+		c.mu.RUnlock()
+		if fresh {
+			return val
+		}
+	}
+	set, err := s.warmupContentRepo.GetGenerationSettings(ctx)
+	if err != nil || set == nil {
+		return models.DefaultWarmupGenerationSettings()
+	}
+	if c := s.warmupSettings; c != nil {
+		c.mu.Lock()
+		c.val = *set
+		c.fetched = time.Now()
+		c.mu.Unlock()
+	}
+	return *set
+}
+
+// pickNewWarmupContent selects content for a NEW (non-reply) warmup send. When
+// AI enrichment is enabled and the dice roll falls within AISelectionShare it
+// draws a thread from the cached, segment-aware AI bank; otherwise it uses the
+// static in-code library. The static library is always the safe fallback, so
+// an empty bank or disabled generator never stops warmup.
+func (s *tasksService) pickNewWarmupContent(ctx context.Context, account Email) warmupContent {
+	settings := s.getWarmupSettings(ctx)
+
+	if settings.Enabled && s.warmupContentRepo != nil && rand.Intn(100) < settings.AISelectionShare {
+		// Content is drawn from the shared library by segment; tier doesn't
+		// affect content (only mailbox reputation isolation uses the pool).
+		segment := strings.TrimSpace(account.WarmupTag)
+		conv, err := s.warmupContentRepo.PickConversation(ctx, segment)
+		if err == nil && conv != nil {
+			c := Conversation{ID: conv.ID, Theme: conv.Theme, Description: conv.Description, Messages: conv.Messages}
+			body := GenerateConversationEmail(c, account, false)
+			subject := spinClean(conv.Subject)
+			if subject == "" {
+				subject = generateWarmupSubject()
+			}
+			_ = s.warmupContentRepo.IncrementConversationUsage(ctx, conv.ID)
+			id := conv.ID
+			return warmupContent{
+				subject:        subject,
+				body:           body,
+				theme:          conv.Theme,
+				contentSource:  models.WarmupContentSourceAI,
+				conversationID: &id,
+			}
+		}
+	}
+
+	conversation := randomWarmupConversation()
+	staticID := conversation.ID
+	return warmupContent{
+		subject:        generateWarmupSubject(),
+		body:           GenerateConversationEmail(conversation, account, false),
+		theme:          conversation.Theme,
+		contentSource:  models.WarmupContentSourceStatic,
+		conversationID: &staticID,
+	}
+}
diff --git a/web/src/components/app/campaigns/ContentScore.tsx b/web/src/components/app/campaigns/ContentScore.tsx
new file mode 100644
index 00000000..ad5528fa
--- /dev/null
+++ b/web/src/components/app/campaigns/ContentScore.tsx
@@ -0,0 +1,96 @@
+// Advisory campaign-template content check. A "Check content" button POSTs the
+// current subject + body to /templates/score and renders a 0-100 score (higher
+// = safer) plus a list of non-blocking issues. Purely advisory — it never
+// blocks saving or sending, it just surfaces deliverability hints.
+
+import { ShieldCheckIcon, AlertTriangleIcon, AlertCircleIcon } from "lucide-react";
+import useScoreTemplate from "@/lib/api/hooks/app/campaigns/useScoreTemplate";
+import type { TemplateScoreIssue } from "@/lib/api/models/app/campaigns/TemplateScore";
+import { Loading } from "@/components/loader";
+import { cn } from "@/lib/utils";
+
+function scoreTone(score: number) {
+    if (score >= 80) return { text: "text-emerald-600", bar: "bg-emerald-500", label: "Looks good" };
+    if (score >= 50) return { text: "text-amber-600", bar: "bg-amber-500", label: "Could improve" };
+    return { text: "text-rose-600", bar: "bg-rose-500", label: "Needs work" };
+}
+
+function IssueRow({ issue }: { issue: TemplateScoreIssue }) {
+    const high = issue.severity === "high";
+    const Icon = high ? AlertCircleIcon : AlertTriangleIcon;
+    return (
+        <li className="flex items-start gap-2 py-1.5">
+            <Icon className={cn("w-3.5 h-3.5 shrink-0 mt-0.5", high ? "text-rose-500" : "text-amber-500")} />
+            <div className="min-w-0">
+                <span className="text-[12px] text-slate-700 leading-relaxed">{issue.message}</span>
+                <span className="ml-1.5 text-[10px] text-slate-400 font-mono">{issue.code}</span>
+            </div>
+        </li>
+    );
+}
+
+export default function ContentScore({
+    subject,
+    bodyHtml,
+    bodyPlain,
+}: {
+    subject: string;
+    bodyHtml: string;
+    bodyPlain: string;
+}) {
+    const score = useScoreTemplate();
+    const data = score.data;
+
+    const run = () =>
+        score.mutate({ subject, body_html: bodyHtml, body_plain: bodyPlain });
+
+    const tone = data ? scoreTone(data.score) : null;
+
+    return (
+        <div className="rounded-md border border-slate-200 bg-white">
+            <div className="flex items-center justify-between gap-3 px-3 py-2.5">
+                <div className="min-w-0">
+                    <div className="text-[10px] uppercase tracking-[0.14em] text-slate-400 font-medium">Content check</div>
+                    <p className="mt-0.5 text-[11px] text-slate-400 leading-relaxed">Advisory deliverability score — never blocks sending.</p>
+                </div>
+                <button
+                    type="button"
+                    onClick={run}
+                    disabled={score.isPending}
+                    className="h-8 px-3 rounded-md border border-slate-200 hover:border-slate-300 text-[12px] font-medium text-slate-700 hover:text-slate-900 inline-flex items-center gap-1.5 transition-colors disabled:opacity-60 shrink-0"
+                >
+                    {score.isPending ? <Loading className="!w-3.5 h-3.5" /> : <ShieldCheckIcon className="w-3.5 h-3.5" />}
+                    {data ? "Re-check" : "Check content"}
+                </button>
+            </div>
+
+            {score.isError && (
+                <div className="px-3 pb-3 text-[11.5px] text-rose-600">Couldn&apos;t score this template. Try again.</div>
+            )}
+
+            {data && tone && (
+                <div className="px-3 pb-3 border-t border-slate-200/60 pt-3">
+                    <div className="flex items-center gap-2">
+                        <span className={cn("text-[22px] font-light leading-none tabular-nums", tone.text)}>{data.score}</span>
+                        <span className="text-[11px] text-slate-400 mb-0.5">/ 100</span>
+                        <span className={cn("ml-auto text-[11px] font-medium", tone.text)}>{tone.label}</span>
+                    </div>
+                    <div className="mt-2 h-1.5 w-full rounded-full bg-slate-100 overflow-hidden">
+                        <div className={cn("h-full rounded-full transition-all", tone.bar)} style={{ width: `${Math.max(0, Math.min(100, data.score))}%` }} />
+                    </div>
+                    {data.issues.length > 0 ? (
+                        <ul className="mt-2 divide-y divide-slate-200/60">
+                            {data.issues.map((issue, i) => (
+                                <IssueRow key={`${issue.code}-${i}`} issue={issue} />
+                            ))}
+                        </ul>
+                    ) : (
+                        <p className="mt-2 inline-flex items-center gap-1.5 text-[11.5px] text-emerald-600">
+                            <ShieldCheckIcon className="w-3.5 h-3.5" /> No content issues found.
+                        </p>
+                    )}
+                </div>
+            )}
+        </div>
+    );
+}
diff --git a/web/src/components/app/campaigns/sequences/SequenceView.tsx b/web/src/components/app/campaigns/sequences/SequenceView.tsx
index e7281bd7..ba59c212 100644
--- a/web/src/components/app/campaigns/sequences/SequenceView.tsx
+++ b/web/src/components/app/campaigns/sequences/SequenceView.tsx
@@ -3,6 +3,7 @@ import type Sequence from "@/lib/api/models/app/campaigns/sequences/Sequence";
 import SubTitle from "../../text/SubTitle";
 import MiniInput from "../../popup/MiniInput";
 import EmailEditor from "../../EmailEditor";
+import ContentScore from "../ContentScore";
 import { Loading } from "@/components/loader";
 import useUpdateSequence from "@/lib/api/hooks/app/campaigns/sequences/useUpdateSequence";
 import toast from "react-hot-toast";
@@ -105,6 +106,11 @@ export default function SequenceView({
                     />
                 </div>
             </div>
+            <ContentScore
+                subject={sequence.subject}
+                bodyHtml={sequence.body_html}
+                bodyPlain={sequence.body_plain}
+            />
             <div className="flex relative justify-end gap-2">
                 <button
                     className={`bg-slate-200 select-none ripple transition flex justify-center items-center cursor-pointer ${!load && "hover:bg-slate-300"} px-3 py-2 rounded-lg text-slate-600`}
diff --git a/web/src/components/app/emails/InboxDetails.tsx b/web/src/components/app/emails/InboxDetails.tsx
index 71db33b2..1d2f4f4f 100644
--- a/web/src/components/app/emails/InboxDetails.tsx
+++ b/web/src/components/app/emails/InboxDetails.tsx
@@ -27,6 +27,11 @@ import {
     PlayIcon,
     PauseIcon,
     ShieldCheckIcon,
+    ShieldAlertIcon,
+    BanIcon,
+    HourglassIcon,
+    XCircleIcon,
+    RefreshCwIcon,
     type LucideIcon,
 } from "lucide-react";
 import toast from "react-hot-toast";
@@ -38,6 +43,9 @@ import useAccountStatus from "@/lib/api/hooks/app/analytics/useAccountStatus";
 import useWarmupAnalytics from "@/lib/api/hooks/app/analytics/useWarmupAnalytics";
 import useUpdateEmail from "@/lib/api/hooks/app/emails/useUpdateEmail";
 import useWarmupLifecycle from "@/lib/api/hooks/app/emails/useWarmupLifecycle";
+import useWarmupBanStatus from "@/lib/api/hooks/app/emails/useWarmupBanStatus";
+import useAppealWarmupBan from "@/lib/api/hooks/app/emails/useAppealWarmupBan";
+import useAuthCheck from "@/lib/api/hooks/app/emails/useAuthCheck";
 import useUpdateEmailTrackingDomain from "@/lib/api/hooks/app/emails/useUpdateEmailTrackingDomain";
 import type { AppError } from "@/lib/api/client/normalizeError";
 import buildError from "@/lib/helper/buildError";
@@ -167,7 +175,7 @@ const EDITABLE: (keyof Inbox)[] = [
     "name", "signature_html", "signature_plain", "signature_sync", "signature_code",
     "tags", "campaign_limit", "min_wait_time", "reply_to",
     "warmup_base", "warmup_max", "warmup_increase", "warmup_reply_rate",
-    "warmup_start_time", "warmup_end_time", "warmup_days",
+    "warmup_tag", "warmup_start_time", "warmup_end_time", "warmup_days",
 ];
 
 function Detail({ mailbox, onClose, initialTab = "overview", canWarmup = true }: { mailbox: Inbox; onClose: () => void; initialTab?: string; canWarmup?: boolean }) {
@@ -441,6 +449,208 @@ const warmupStateTone: Record<string, { text: string; bar: string; label: string
     blocked: { text: "text-rose-700", bar: "bg-rose-600", label: "Blocked" },
 };
 
+/* ── Warmup ban banner + appeal form ─────────────────────── */
+
+// Shown at the top of the Warmup tab when a mailbox has been blocked from the
+// warmup pool (e.g. for deleting or spam-marking warmup mail). Explains why,
+// lets the owner submit an appeal, and flips to "under review" once one is
+// pending. Renders nothing while loading or when the mailbox isn't blocked.
+function WarmupBanBanner({ emailId }: { emailId: string }) {
+    const ban = useWarmupBanStatus(emailId);
+    const appeal = useAppealWarmupBan(emailId);
+    const [open, setOpen] = useState(false);
+    const [reason, setReason] = useState("");
+
+    const data = ban.data;
+    if (!data || !data.blocked) return null;
+
+    const submit = async () => {
+        const trimmed = reason.trim();
+        if (!trimmed) {
+            toast.error("Please describe why this mailbox should be reinstated.");
+            return;
+        }
+        try {
+            await appeal.mutateAsync(trimmed);
+            toast.success("Appeal submitted — our team will review it.");
+            setOpen(false);
+            setReason("");
+        } catch (e) {
+            toast.error(buildError(e as unknown as AppError));
+        }
+    };
+
+    return (
+        <div className="px-5 py-4">
+            <div className="rounded-md border border-rose-200 bg-rose-50 p-3.5">
+                <div className="flex items-start gap-2.5">
+                    <div className="w-7 h-7 rounded-md bg-rose-100 text-rose-600 flex items-center justify-center shrink-0">
+                        <BanIcon className="w-4 h-4" />
+                    </div>
+                    <div className="min-w-0 flex-1">
+                        <div className="flex items-center gap-2">
+                            <span className="text-[12.5px] font-semibold text-rose-900">Blocked from warmup</span>
+                            <span className="h-5 px-2 rounded-full border border-rose-200 bg-white/60 text-rose-700 text-[10px] font-semibold uppercase tracking-wide inline-flex items-center capitalize">
+                                {data.health_state}
+                            </span>
+                        </div>
+                        <p className="mt-1 text-[11.5px] text-rose-800/90 leading-relaxed">
+                            {data.reason || "This mailbox was removed from the warmup pool to protect shared sender reputation."}
+                        </p>
+                        {(data.blocked_at || data.blocked_until) && (
+                            <div className="mt-2 flex flex-wrap items-center gap-x-4 gap-y-1 text-[10.5px] text-rose-700/80">
+                                {data.blocked_at && (
+                                    <span className="inline-flex items-center gap-1">
+                                        <ClockIcon className="w-3 h-3" /> Blocked {new Date(data.blocked_at).toLocaleDateString()}
+                                    </span>
+                                )}
+                                {data.blocked_until && (
+                                    <span className="inline-flex items-center gap-1">
+                                        <CalendarIcon className="w-3 h-3" /> Until {new Date(data.blocked_until).toLocaleDateString()}
+                                    </span>
+                                )}
+                            </div>
+                        )}
+
+                        {/* Appeal affordance */}
+                        {data.pending_appeal ? (
+                            <div className="mt-3 inline-flex items-center gap-1.5 rounded-md border border-amber-200 bg-amber-50 px-2.5 py-1.5 text-[11.5px] font-medium text-amber-800">
+                                <HourglassIcon className="w-3.5 h-3.5" /> Appeal submitted — under review
+                            </div>
+                        ) : data.can_appeal ? (
+                            open ? (
+                                <div className="mt-3 space-y-2">
+                                    <label className="block text-[10px] uppercase tracking-[0.14em] text-rose-700/80 font-medium">
+                                        Appeal reason
+                                    </label>
+                                    <textarea
+                                        value={reason}
+                                        onChange={(e) => setReason(e.target.value)}
+                                        rows={3}
+                                        autoFocus
+                                        placeholder="Tell us what changed or why this block is a mistake…"
+                                        className="w-full px-2.5 py-2 rounded-md border border-rose-200 bg-white text-[12px] text-slate-900 placeholder:text-slate-400 outline-none focus:border-sky-400 focus:ring-2 focus:ring-sky-100 resize-none transition-colors"
+                                    />
+                                    <div className="flex items-center gap-2">
+                                        <button
+                                            onClick={submit}
+                                            disabled={appeal.isPending || !reason.trim()}
+                                            className="h-8 px-3.5 rounded-md bg-sky-600 hover:bg-sky-700 text-white text-[12px] font-medium inline-flex items-center gap-1.5 transition-colors disabled:opacity-60"
+                                        >
+                                            {appeal.isPending && <Loading className="!w-3.5 h-3.5 text-white" />}
+                                            Submit appeal
+                                        </button>
+                                        <button
+                                            onClick={() => { setOpen(false); setReason(""); }}
+                                            disabled={appeal.isPending}
+                                            className="h-8 px-3 rounded-md border border-rose-200 hover:border-rose-300 text-[12px] text-rose-700 hover:text-rose-900 transition-colors disabled:opacity-60"
+                                        >
+                                            Cancel
+                                        </button>
+                                    </div>
+                                </div>
+                            ) : (
+                                <button
+                                    onClick={() => setOpen(true)}
+                                    className="mt-3 h-8 px-3 rounded-md bg-rose-600 hover:bg-rose-700 text-white text-[12px] font-medium inline-flex items-center gap-1.5 transition-colors"
+                                >
+                                    <ShieldAlertIcon className="w-3.5 h-3.5" /> Appeal this block
+                                </button>
+                            )
+                        ) : null}
+                    </div>
+                </div>
+            </div>
+        </div>
+    );
+}
+
+/* ── Domain authentication (SPF / DKIM / DMARC live check) ─────────────────────── */
+
+// One row per auth record. Green check when present/aligned, red cross when
+// missing. Optional detail (selectors, the SPF record, the DMARC policy) is
+// shown muted underneath.
+function AuthRecordRow({ label, ok, detail }: { label: string; ok: boolean; detail?: React.ReactNode }) {
+    return (
+        <div className="flex items-start justify-between gap-3 py-2 border-b border-slate-200/60 last:border-b-0">
+            <div className="min-w-0">
+                <div className="text-[12.5px] font-medium text-slate-900">{label}</div>
+                {detail && <div className="mt-0.5 text-[10.5px] text-slate-500 font-mono break-all leading-relaxed">{detail}</div>}
+            </div>
+            <span className={cn("inline-flex items-center gap-1 shrink-0 text-[11px] font-medium", ok ? "text-emerald-600" : "text-rose-600")}>
+                {ok ? <CheckCircle2Icon className="w-3.5 h-3.5" /> : <XCircleIcon className="w-3.5 h-3.5" />}
+                {ok ? "Found" : "Missing"}
+            </span>
+        </div>
+    );
+}
+
+function AuthCheckPanel({ emailId }: { emailId: string }) {
+    const [open, setOpen] = useState(false);
+    const check = useAuthCheck(emailId, open);
+    const data = check.data;
+
+    return (
+        <div className="px-5 py-4">
+            <div className="flex items-center justify-between gap-3">
+                <div className="min-w-0">
+                    <Eyebrow>Domain authentication</Eyebrow>
+                    <p className="mt-1 text-[11px] text-slate-400 leading-relaxed">Live SPF, DKIM &amp; DMARC check on the sending domain.</p>
+                </div>
+                <button
+                    onClick={() => {
+                        setOpen(true);
+                        if (open) check.refetch();
+                    }}
+                    disabled={check.isFetching}
+                    className="h-8 px-3 rounded-md border border-slate-200 hover:border-slate-300 text-[12px] font-medium text-slate-700 hover:text-slate-900 inline-flex items-center gap-1.5 transition-colors disabled:opacity-60 shrink-0"
+                >
+                    {check.isFetching ? <Loading className="!w-3.5 h-3.5" /> : <RefreshCwIcon className="w-3.5 h-3.5" />}
+                    {open ? "Re-check" : "Check"}
+                </button>
+            </div>
+
+            {open && (
+                <div className="mt-3">
+                    {check.isError ? (
+                        <div className="rounded-md border border-rose-200 bg-rose-50 px-3 py-2.5 text-[11.5px] text-rose-700 leading-relaxed">
+                            {buildError(check.error as unknown as AppError)}
+                        </div>
+                    ) : check.isFetching && !data ? (
+                        <div className="rounded-md border border-slate-200 bg-slate-50/70 px-3 py-3 flex items-center gap-2 text-[12px] text-slate-500">
+                            <Loading className="!w-3.5 h-3.5" /> Looking up DNS records…
+                        </div>
+                    ) : data ? (
+                        <div className="rounded-md border border-slate-200 bg-white">
+                            <div className={cn("flex items-start gap-2 px-3 py-2.5 border-b border-slate-200/60", data.all_aligned ? "text-emerald-700" : "text-amber-700")}>
+                                {data.all_aligned ? <ShieldCheckIcon className="w-4 h-4 shrink-0 mt-0.5" /> : <ShieldAlertIcon className="w-4 h-4 shrink-0 mt-0.5" />}
+                                <div className="min-w-0">
+                                    <div className="text-[12px] font-medium">{data.all_aligned ? "Authentication aligned" : "Authentication needs attention"}</div>
+                                    {data.summary && <div className="mt-0.5 text-[11px] text-slate-500 leading-relaxed">{data.summary}</div>}
+                                </div>
+                            </div>
+                            <div className="px-3">
+                                <AuthRecordRow label="SPF" ok={data.spf_found} detail={data.spf_record} />
+                                <AuthRecordRow
+                                    label="DKIM"
+                                    ok={data.dkim_found}
+                                    detail={data.dkim_selectors && data.dkim_selectors.length > 0 ? `selectors: ${data.dkim_selectors.join(", ")}` : undefined}
+                                />
+                                <AuthRecordRow
+                                    label="DMARC"
+                                    ok={data.dmarc_found}
+                                    detail={data.dmarc_found && data.dmarc_policy ? `policy: ${data.dmarc_policy}` : undefined}
+                                />
+                            </div>
+                            <div className="px-3 py-2 text-[10.5px] text-slate-400 font-mono truncate border-t border-slate-200/60">{data.domain}</div>
+                        </div>
+                    ) : null}
+                </div>
+            )}
+        </div>
+    );
+}
+
 function WarmupTab({ form, update, status, mailbox, canWarmup = true }: { form: Inbox; update: (p: Partial<Inbox>) => void; status?: AccountStatusModel; mailbox: Inbox; canWarmup?: boolean }) {
     const ws = status?.warmup_status;
     const wh = status?.warmup_health;
@@ -469,6 +679,9 @@ function WarmupTab({ form, update, status, mailbox, canWarmup = true }: { form:
 
     return (
         <div className="divide-y divide-slate-200/60">
+            {/* Ban banner + appeal — only when the mailbox is blocked from the pool */}
+            <WarmupBanBanner emailId={mailbox.id} />
+
             {/* Lifecycle control */}
             <div className="px-5 py-4 flex items-center justify-between gap-3">
                 <div className="flex items-center gap-2.5 min-w-0">
@@ -562,6 +775,9 @@ function WarmupTab({ form, update, status, mailbox, canWarmup = true }: { form:
                 </div>
             )}
 
+            {/* Domain authentication (live SPF/DKIM/DMARC check) */}
+            <AuthCheckPanel emailId={mailbox.id} />
+
             {/* In-campaign health-check explainer */}
             {inCampaign && (
                 <div className="px-5 py-4">
@@ -594,6 +810,14 @@ function WarmupTab({ form, update, status, mailbox, canWarmup = true }: { form:
                 <FieldShell label="Reply rate" hint="Share of warmup mail that gets a reply, to mimic real conversation.">
                     <NumField value={form.warmup_reply_rate} onChange={(v) => update({ warmup_reply_rate: v })} suffix="%" />
                 </FieldShell>
+                <FieldShell label="Content segment" hint="Targets segment-specific warmup content (e.g. saas, agency). Leave empty for generic content.">
+                    <TextInput
+                        value={form.warmup_tag ?? ""}
+                        placeholder="e.g. saas, agency"
+                        onChange={(v) => update({ warmup_tag: v.toLowerCase().replace(/[^a-z0-9-]/g, "") })}
+                        className="w-full h-9"
+                    />
+                </FieldShell>
             </div>
 
             {/* Schedule */}
diff --git a/web/src/lib/api/client/app/campaigns/scoreTemplate.ts b/web/src/lib/api/client/app/campaigns/scoreTemplate.ts
new file mode 100644
index 00000000..2b3b1c80
--- /dev/null
+++ b/web/src/lib/api/client/app/campaigns/scoreTemplate.ts
@@ -0,0 +1,16 @@
+import type TemplateScore from "@/lib/api/models/app/campaigns/TemplateScore";
+import type { ScoreTemplateRequest } from "@/lib/api/models/app/campaigns/TemplateScore";
+import Request from "../../Request";
+
+// Advisory content score for a campaign template. Never blocks — returns a
+// 0-100 score (higher = safer) plus a list of non-blocking issues.
+export default async function scoreTemplate(
+    body: ScoreTemplateRequest,
+): Promise<TemplateScore> {
+    return await Request<TemplateScore>({
+        method: "POST",
+        url: "/templates/score",
+        data: body,
+        authorization: true,
+    });
+}
diff --git a/web/src/lib/api/client/app/emails/appealWarmupBan.ts b/web/src/lib/api/client/app/emails/appealWarmupBan.ts
new file mode 100644
index 00000000..6233b980
--- /dev/null
+++ b/web/src/lib/api/client/app/emails/appealWarmupBan.ts
@@ -0,0 +1,14 @@
+import type { WarmupAppealResult } from "@/lib/api/models/app/emails/WarmupBanStatus";
+import Request from "../../Request";
+
+// Submits an appeal against a warmup-pool ban for a mailbox. The backend
+// returns 400 if the mailbox isn't blocked, an appeal is already pending, or
+// the reason is empty.
+export default async function appealWarmupBan(id: string, reason: string): Promise<WarmupAppealResult> {
+    return await Request<WarmupAppealResult>({
+        method: "POST",
+        url: `/emails/${id}/warmup/appeal`,
+        data: { reason },
+        authorization: true,
+    });
+}
diff --git a/web/src/lib/api/client/app/emails/getAuthCheck.ts b/web/src/lib/api/client/app/emails/getAuthCheck.ts
new file mode 100644
index 00000000..034c8115
--- /dev/null
+++ b/web/src/lib/api/client/app/emails/getAuthCheck.ts
@@ -0,0 +1,12 @@
+import type AuthCheck from "@/lib/api/models/app/emails/AuthCheck";
+import Request from "../../Request";
+
+// Runs a live SPF/DKIM/DMARC validation of the mailbox's sending domain.
+// Drives the auth-check panel in the mailbox detail drawer.
+export default async function getAuthCheck(id: string): Promise<AuthCheck> {
+    return await Request<AuthCheck>({
+        method: "GET",
+        url: `/emails/${id}/auth-check`,
+        authorization: true,
+    });
+}
diff --git a/web/src/lib/api/client/app/emails/getWarmupBanStatus.ts b/web/src/lib/api/client/app/emails/getWarmupBanStatus.ts
new file mode 100644
index 00000000..df5185fc
--- /dev/null
+++ b/web/src/lib/api/client/app/emails/getWarmupBanStatus.ts
@@ -0,0 +1,13 @@
+import type WarmupBanStatus from "@/lib/api/models/app/emails/WarmupBanStatus";
+import Request from "../../Request";
+
+// Reads whether a mailbox has been blocked from the warmup pool, why, and
+// whether the owner can still appeal. Drives the ban banner + appeal form in
+// the mailbox detail drawer's Warmup tab.
+export default async function getWarmupBanStatus(id: string): Promise<WarmupBanStatus> {
+    return await Request<WarmupBanStatus>({
+        method: "GET",
+        url: `/emails/${id}/warmup/ban-status`,
+        authorization: true,
+    });
+}
diff --git a/web/src/lib/api/hooks/app/campaigns/useScoreTemplate.ts b/web/src/lib/api/hooks/app/campaigns/useScoreTemplate.ts
new file mode 100644
index 00000000..c889cb97
--- /dev/null
+++ b/web/src/lib/api/hooks/app/campaigns/useScoreTemplate.ts
@@ -0,0 +1,12 @@
+import { useMutation } from "@tanstack/react-query";
+import scoreTemplate from "@/lib/api/client/app/campaigns/scoreTemplate";
+import type { ScoreTemplateRequest } from "@/lib/api/models/app/campaigns/TemplateScore";
+
+// On-demand advisory content score for a campaign template. A mutation rather
+// than a query because it's run explicitly via a "Check content" button, not
+// on every keystroke.
+export default function useScoreTemplate() {
+    return useMutation({
+        mutationFn: (body: ScoreTemplateRequest) => scoreTemplate(body),
+    });
+}
diff --git a/web/src/lib/api/hooks/app/emails/useAppealWarmupBan.ts b/web/src/lib/api/hooks/app/emails/useAppealWarmupBan.ts
new file mode 100644
index 00000000..6149ce82
--- /dev/null
+++ b/web/src/lib/api/hooks/app/emails/useAppealWarmupBan.ts
@@ -0,0 +1,15 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import appealWarmupBan from "@/lib/api/client/app/emails/appealWarmupBan";
+
+// Submits a warmup-ban appeal for a mailbox, then refreshes the ban-status
+// query so the banner flips to "under review" (pending_appeal) right away.
+export default function useAppealWarmupBan(id: string) {
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: (reason: string) => appealWarmupBan(id, reason),
+        onSuccess: () => {
+            void queryClient.invalidateQueries({ queryKey: ["analytics", "accounts", id, "warmup-ban"] });
+        },
+    });
+}
diff --git a/web/src/lib/api/hooks/app/emails/useAuthCheck.ts b/web/src/lib/api/hooks/app/emails/useAuthCheck.ts
new file mode 100644
index 00000000..992ec997
--- /dev/null
+++ b/web/src/lib/api/hooks/app/emails/useAuthCheck.ts
@@ -0,0 +1,14 @@
+import { useQuery } from "@tanstack/react-query";
+import getAuthCheck from "@/lib/api/client/app/emails/getAuthCheck";
+
+// Live SPF/DKIM/DMARC auth check for a mailbox's sending domain. Off by
+// default (enabled=false) so it only fires when the panel is opened — DNS
+// lookups are comparatively slow and shouldn't run on every drawer mount.
+export default function useAuthCheck(id: string, enabled = false) {
+    return useQuery({
+        queryKey: ["analytics", "accounts", id, "auth-check"],
+        queryFn: () => getAuthCheck(id),
+        enabled: !!id && enabled,
+        staleTime: 60_000,
+    });
+}
diff --git a/web/src/lib/api/hooks/app/emails/useWarmupBanStatus.ts b/web/src/lib/api/hooks/app/emails/useWarmupBanStatus.ts
new file mode 100644
index 00000000..0a50f2fc
--- /dev/null
+++ b/web/src/lib/api/hooks/app/emails/useWarmupBanStatus.ts
@@ -0,0 +1,14 @@
+import { useQuery } from "@tanstack/react-query";
+import getWarmupBanStatus from "@/lib/api/client/app/emails/getWarmupBanStatus";
+
+// Live warmup-ban status for a mailbox. Keyed under the
+// ["analytics", "accounts", id] prefix so the existing WARMUP/ACCOUNT realtime
+// branch in useRealtimeEvents (which invalidates ["analytics", "accounts"])
+// also refreshes this without any extra wiring.
+export default function useWarmupBanStatus(id: string, enabled = true) {
+    return useQuery({
+        queryKey: ["analytics", "accounts", id, "warmup-ban"],
+        queryFn: () => getWarmupBanStatus(id),
+        enabled: !!id && enabled,
+    });
+}
diff --git a/web/src/lib/api/models/app/campaigns/TemplateScore.ts b/web/src/lib/api/models/app/campaigns/TemplateScore.ts
new file mode 100644
index 00000000..027a172f
--- /dev/null
+++ b/web/src/lib/api/models/app/campaigns/TemplateScore.ts
@@ -0,0 +1,20 @@
+// Result of POST /templates/score — an advisory content-quality score for a
+// campaign template. Higher score = safer; issues are non-blocking hints to
+// improve deliverability (the score never prevents saving or sending).
+export interface TemplateScoreIssue {
+    severity: "warn" | "high";
+    code: string;
+    message: string;
+}
+
+export default interface TemplateScore {
+    score: number;
+    issues: TemplateScoreIssue[];
+}
+
+// Body for POST /templates/score.
+export interface ScoreTemplateRequest {
+    subject: string;
+    body_html: string;
+    body_plain: string;
+}
diff --git a/web/src/lib/api/models/app/emails/AuthCheck.ts b/web/src/lib/api/models/app/emails/AuthCheck.ts
new file mode 100644
index 00000000..59fd24f1
--- /dev/null
+++ b/web/src/lib/api/models/app/emails/AuthCheck.ts
@@ -0,0 +1,14 @@
+// Result of GET /emails/:id/auth-check — a live SPF/DKIM/DMARC validation of
+// the mailbox's sending domain. Surfaced in the mailbox detail drawer so an
+// owner can confirm their authentication is aligned before sending cold mail.
+export default interface AuthCheck {
+    domain: string;
+    spf_found: boolean;
+    dkim_found: boolean;
+    dmarc_found: boolean;
+    dmarc_policy: string;
+    all_aligned: boolean;
+    summary: string;
+    dkim_selectors?: string[];
+    spf_record?: string;
+}
diff --git a/web/src/lib/api/models/app/emails/Inbox.ts b/web/src/lib/api/models/app/emails/Inbox.ts
index fda0ca98..c8a8e4ed 100644
--- a/web/src/lib/api/models/app/emails/Inbox.ts
+++ b/web/src/lib/api/models/app/emails/Inbox.ts
@@ -24,6 +24,7 @@ export default interface Inbox {
     warmup_increase: number;
     warmup_reply_rate: number;
     warmup_pool_type?: string;
+    warmup_tag?: string;
     warmup_start_time?: string;
     warmup_end_time?: string;
     warmup_days?: number;
diff --git a/web/src/lib/api/models/app/emails/WarmupBanStatus.ts b/web/src/lib/api/models/app/emails/WarmupBanStatus.ts
new file mode 100644
index 00000000..4a470a50
--- /dev/null
+++ b/web/src/lib/api/models/app/emails/WarmupBanStatus.ts
@@ -0,0 +1,19 @@
+// Per-mailbox warmup ban status from GET /emails/:id/warmup/ban-status.
+// Surfaced in the mailbox detail drawer so an owner can see why warmup was
+// blocked (e.g. deleting or spam-marking warmup mail) and, when allowed,
+// submit an appeal for review.
+export default interface WarmupBanStatus {
+    email_account_id: string;
+    blocked: boolean;
+    health_state: string;
+    reason: string;
+    blocked_at: string | null;
+    blocked_until: string | null;
+    can_appeal: boolean;
+    pending_appeal: boolean;
+}
+
+// Result of POST /emails/:id/warmup/appeal.
+export interface WarmupAppealResult {
+    appeal_id: string;
+}