mail list redesign, folder actions, empty-folder, unread badges & empty-state art

Frontend:
- Redesign the mail list rows (avatar + sender + subject/snippet + right rail),
  even-spaced attachment/pin/archive/trash icons, hover-reveal actions, pink
  always-on pin, monocolor paperclip, row gaps, wider sender-subject gap.
- Sidebar folder badges: Inbox unread + Drafts counts (live via WS + mutations).
- Trash/Spam/Archive: hover Restore icon (replaces Archive), permanent delete in
  Trash; "Empty trash" / "Empty spam" buttons on the sort bar.
- Reading pane empty state: email illustration above an enlarged
  "Select a conversation".
- Search field clear (X) button; mark-read after a 4s dwell instead of instantly.

Backend:
- GET /api/mailboxes/counts (inbox unread + drafts) for the sidebar badges.
- POST /api/folders/{special}/empty + empty_folder_job to permanently clear a
  Trash/Spam/Archive folder (server EXPUNGE + DB rows + thread cleanup).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01U72FZiF1W1pb8XxyWBTREA

backend/app/sync/actions.py

@@ -13,7 +13,7 @@ import uuid
 from collections.abc import Iterable
 from typing import Any
 
-from sqlalchemy import select, update
+from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db import session_scope
@@ -358,3 +358,83 @@ async def delete_thread_job(ctx: dict[str, Any], thread_id: str) -> None:
     await get_event_bus().publish(
         "thread.updated", {"user_id": str(user_id), "thread_id": str(tid)}
     )
+
+
+async def empty_folder_job(ctx: dict[str, Any], user_id: str, special_use: str) -> None:
+    """Permanently delete every message in the user's folder of this special-use.
+
+    Backs the Trash/Spam/Archive "Empty" action: EXPUNGE on the server, drop the DB
+    rows, and re-denormalize (or delete) affected threads.
+    """
+    uid = uuid.UUID(user_id)
+    async with session_scope() as session:
+        mailboxes = list(
+            await session.scalars(
+                select(Mailbox).where(
+                    Mailbox.user_id == uid, Mailbox.special_use == special_use
+                )
+            )
+        )
+        if not mailboxes:
+            return
+        mb_ids = [mb.id for mb in mailboxes]
+        path_by_id = {mb.id: mb.path for mb in mailboxes}
+        messages = list(
+            await session.scalars(
+                select(Message).where(Message.user_id == uid, Message.mailbox_id.in_(mb_ids))
+            )
+        )
+        if not messages:
+            return
+        account_ids = list({m.account_id for m in messages})
+        accounts = {
+            a.id: a
+            for a in await session.scalars(select(Account).where(Account.id.in_(account_ids)))
+        }
+        thread_ids = list({m.thread_id for m in messages if m.thread_id is not None})
+        by_box: dict[tuple[uuid.UUID, str], list[int]] = {}
+        for m in messages:
+            by_box.setdefault((m.account_id, path_by_id[m.mailbox_id]), []).append(m.uid)
+
+    for account_id in account_ids:
+        provider = build_provider(accounts[account_id])
+        try:
+            for (acct, path), uids in by_box.items():
+                if acct != account_id:
+                    continue
+                try:
+                    await provider.delete_messages(path, uids)
+                except Exception:
+                    logger.exception("empty folder: expunge failed for %s in %s", uids, path)
+        finally:
+            await provider.close()
+
+    async with session_scope() as session:
+        msgs = list(
+            await session.scalars(
+                select(Message).where(Message.user_id == uid, Message.mailbox_id.in_(mb_ids))
+            )
+        )
+        msg_ids = [m.id for m in msgs]
+        if msg_ids:
+            await session.execute(
+                update(Draft)
+                .where(Draft.reply_to_message_id.in_(msg_ids))
+                .values(reply_to_message_id=None)
+            )
+        for m in msgs:
+            await session.delete(m)
+        await session.flush()
+        # Threads with no messages left get dropped (drafts un-linked first); the
+        # rest are re-denormalized so their counts/snippet reflect the removal.
+        for tid in thread_ids:
+            remaining = await session.scalar(
+                select(func.count()).select_from(Message).where(Message.thread_id == tid)
+            )
+            if not remaining:
+                await session.execute(
+                    update(Draft).where(Draft.thread_id == tid).values(thread_id=None)
+                )
+            await denormalize_thread(session, tid)
+
+    await get_event_bus().publish("message.deleted", {"user_id": str(uid)})