mail UX: restore-to-folder, draft/attachment fixes, printing, sidebar collapse

Backend:
- Restore returns each message to its original folder (e.g. Sent/Archive) instead
  of always the Inbox: new messages.restore_mailbox_id (migration 0010) +
  restore_thread_job.
- Drafts: expunge reconciliation for the Drafts poll (provider.list_uids /
  _reconcile_drafts) clears phantom "remote" drafts; send + discard drop the
  mirrored DB row; adopting a remote draft carries its real attachments into the
  compose flow.
- Thread detail/list are folder-aware: individually trashed/spam messages are
  hidden outside their folder, Trash/Spam show only their own messages, and the
  mail-list message count matches the view.

Frontend:
- Thread reading panel: fix newest-first card overlap/spacing (expand-all and
  single expand), hide Reply/Forward on trashed messages, close the Actions menu
  on message-body (iframe) clicks, scroll to the inline composer, and prompt
  Save draft / Discard on the X close.
- Composer: remount when switching drafts, dirty-tracking to stop duplicate IMAP
  mirrors, and close the From/More dropdowns on outside click.
- Sidebar: collapse/expand toggle (icons-only ~60px rail) and a log-out icon on
  Sign out.
- Mail-standard printing in a new window with reliable page margins (lib/print.ts).

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

backend/tests/api/test_api.py

@@ -254,6 +254,50 @@ async def test_thread_detail_messages_ascending(api: ApiCtx) -> None:
     assert dates == sorted(dates)  # ascending
 
 
+async def test_thread_detail_hides_trashed_message_unless_viewing_trash(api: ApiCtx) -> None:
+    assert api.session is not None
+    # Give the account a Trash folder and delete a single message of the 2-message
+    # kickoff thread (move it to Trash) — as the per-message Delete action does.
+    trash = Mailbox(
+        account_id=api.account_id, user_id=api.user_id, path="Trash", special_use="trash"
+    )
+    api.session.add(trash)
+    await api.session.flush()
+    resp = await api.client.get("/api/threads")
+    kickoff = next(t for t in resp.json()["threads"] if t["message_count"] == 2)
+    detail = (await api.client.get(f"/api/threads/{kickoff['id']}")).json()
+    victim = uuid.UUID(detail["messages"][-1]["id"])
+    msg = await api.session.get(Message, victim)
+    assert msg is not None
+    msg.mailbox_id = trash.id
+    await api.session.commit()
+
+    # Viewing the thread from the Inbox: the trashed message is gone.
+    inbox_view = await api.client.get(
+        f"/api/threads/{kickoff['id']}", params={"view": "folder:inbox"}
+    )
+    ids = [m["id"] for m in inbox_view.json()["messages"]]
+    assert str(victim) not in ids
+    assert len(ids) == 1
+
+    # Viewing from the Trash folder: only the trashed message is shown (Trash is
+    # message-scoped), not the rest of the conversation.
+    trash_view = await api.client.get(
+        f"/api/threads/{kickoff['id']}", params={"view": "folder:trash"}
+    )
+    ids_trash = [m["id"] for m in trash_view.json()["messages"]]
+    assert ids_trash == [str(victim)]
+
+    # The Inbox LIST count drops the trashed message (was 2, now 1); the Trash list
+    # counts only the one trashed message.
+    inbox_list = await api.client.get("/api/threads", params={"view": "folder:inbox"})
+    row = next(t for t in inbox_list.json()["threads"] if t["id"] == kickoff["id"])
+    assert row["message_count"] == 1
+    trash_list = await api.client.get("/api/threads", params={"view": "folder:trash"})
+    trow = next(t for t in trash_list.json()["threads"] if t["id"] == kickoff["id"])
+    assert trow["message_count"] == 1
+
+
 async def test_message_html_is_sanitized(api: ApiCtx) -> None:
     # the lunch message has HTML with a script
     resp = await api.client.get("/api/threads")

backend/tests/mail/test_actions.py

@@ -225,14 +225,20 @@ async def test_archive_unknown_thread_404(ctx: Ctx) -> None:
     assert ctx.enqueued == []
 
 
-async def test_restore_thread_enqueues_move_to_inbox(ctx: Ctx) -> None:
+async def test_restore_thread_enqueues_restore_job(ctx: Ctx) -> None:
     resp = await ctx.client.post(f"/api/threads/{ctx.thread_id}/restore", headers=_hdr())
     assert resp.status_code == 200
     assert ctx.enqueued == [
-        ("move_thread_to_folder_job", str(ctx.thread_id), "inbox"),
+        ("restore_thread_job", str(ctx.thread_id)),
     ]
 
 
+async def test_restore_unknown_thread_404(ctx: Ctx) -> None:
+    resp = await ctx.client.post(f"/api/threads/{uuid.uuid4()}/restore", headers=_hdr())
+    assert resp.status_code == 404
+    assert ctx.enqueued == []
+
+
 async def test_delete_thread_enqueues_permanent_delete(ctx: Ctx) -> None:
     resp = await ctx.client.post(f"/api/threads/{ctx.thread_id}/delete", headers=_hdr())
     assert resp.status_code == 200

backend/tests/outbox/test_outbox.py

@@ -274,6 +274,73 @@ async def test_remote_drafts_listed_and_adopted(ctx: Ctx) -> None:
     assert again.json()["id"] == draft["id"]
 
 
+async def test_adopt_remote_draft_carries_attachments(ctx: Ctx) -> None:
+    from datetime import UTC, datetime
+
+    from app.indexer import blobstore
+    from app.models import Attachment
+
+    drafts_mb = Mailbox(
+        account_id=ctx.account_id, user_id=ctx.user_id, path="DRAFTS", special_use="drafts"
+    )
+    ctx.session.add(drafts_mb)
+    await ctx.session.flush()
+    msg = Message(
+        user_id=ctx.user_id,
+        account_id=ctx.account_id,
+        mailbox_id=drafts_mb.id,
+        uid=95,
+        subject="Home draft with file",
+        to_addr=[{"name": "", "email": "bob@example.com"}],
+        cc_addr=[],
+        bcc_addr=[],
+        internal_date=datetime.now(UTC),
+        blob_sha256="y" * 64,
+        snippet="",
+        has_attachments=True,
+    )
+    ctx.session.add(msg)
+    await ctx.session.flush()
+    # A real (downloadable) attachment plus an inline cid image, which must NOT be carried.
+    sha = blobstore.store(ctx.user_id, b"file contents")
+    ctx.session.add(
+        Attachment(
+            message_id=msg.id,
+            user_id=ctx.user_id,
+            filename="report.pdf",
+            mime_type="application/pdf",
+            size_bytes=13,
+            content_id=None,
+            blob_sha256=sha,
+        )
+    )
+    ctx.session.add(
+        Attachment(
+            message_id=msg.id,
+            user_id=ctx.user_id,
+            filename="logo.png",
+            mime_type="image/png",
+            size_bytes=3,
+            content_id="logo@x",
+            blob_sha256=blobstore.store(ctx.user_id, b"img"),
+        )
+    )
+    await ctx.session.commit()
+
+    adopted = await ctx.client.post(f"/api/drafts/adopt/{msg.id}", headers=_hdr())
+    assert adopted.status_code == 200, adopted.text
+    ids = adopted.json()["payload"]["attachment_ids"]
+    assert len(ids) == 1  # only the real attachment, not the inline image
+
+    # The compose-attachment metadata resolves — this is what the editor renders and
+    # what load_attachments re-attaches on send.
+    meta = await ctx.client.get("/api/attachments", params={"ids": ",".join(ids)})
+    assert meta.status_code == 200
+    body = meta.json()
+    assert [a["filename"] for a in body] == ["report.pdf"]
+    assert body[0]["size_bytes"] == 13
+
+
 async def test_publish_draft_enqueues_imap_mirror(ctx: Ctx) -> None:
     did = (await ctx.client.post("/api/drafts", json=_draft_body(ctx), headers=_hdr())).json()["id"]
     ctx.enqueued.clear()

backend/tests/sync/test_secondary_poll.py

@@ -13,7 +13,7 @@ from sqlalchemy.pool import NullPool
 from app.config import get_settings
 from app.db import session_scope
 from app.identity.passwords import hash_password
-from app.models import Account, Mailbox, Message, User
+from app.models import Account, Draft, Mailbox, Message, User
 from app.providers.base import MailboxDelta, RemoteMessage
 from app.sync import engine as sync_engine
 
@@ -97,3 +97,73 @@ async def test_secondary_poll_syncs_special_folders_not_inbox(monkeypatch) -> No
             await cleanup.execute(delete(User).where(User.id == user.id))
         await session.close()
         await engine.dispose()
+
+
+async def test_drafts_poll_reconciles_expunged_rows(monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    """A Drafts poll drops DB rows whose server copy was expunged (phantoms) and
+    un-links a local draft whose mirrored copy vanished."""
+    engine = create_async_engine(get_settings().database_url, poolclass=NullPool)
+    sm = async_sessionmaker(engine, expire_on_commit=False)
+    session = sm()
+    user = User(handle=f"rec{uuid.uuid4().hex[:8]}@test.local", password_hash=hash_password("pw"))
+    session.add(user)
+    await session.flush()
+    account = Account(
+        user_id=user.id,
+        email="me@example.com",
+        imap_config={},
+        smtp_config={},
+        secret_ct=b"",
+        discovery_src="manual",
+    )
+    session.add(account)
+    await session.flush()
+    drafts = Mailbox(account_id=account.id, user_id=user.id, path="DRAFTS", special_use="drafts")
+    session.add(drafts)
+    await session.flush()
+
+    # uid 2 survives on the server; uids 1 and 3 were expunged (phantom DB rows).
+    for uid in (1, 2, 3):
+        session.add(
+            Message(
+                user_id=user.id,
+                account_id=account.id,
+                mailbox_id=drafts.id,
+                uid=uid,
+                internal_date=datetime.now(UTC),
+                blob_sha256="",
+            )
+        )
+    # A local draft still linking the vanished uid 3 must be un-linked (imap_uid -> NULL).
+    linked = Draft(user_id=user.id, account_id=account.id, kind="new", payload={}, imap_uid=3)
+    kept = Draft(user_id=user.id, account_id=account.id, kind="new", payload={}, imap_uid=2)
+    session.add_all([linked, kept])
+    await session.commit()
+
+    class FakeProvider:
+        async def poll(self, mailbox: str, *, last_seen_uid: int, highestmodseq: int | None):  # type: ignore[no-untyped-def]
+            return MailboxDelta([], [], [], None, None)
+
+        async def list_uids(self, mailbox: str) -> set[int]:
+            return {2}  # only uid 2 remains on the server
+
+        async def close(self) -> None:
+            return None
+
+    monkeypatch.setattr(sync_engine, "build_provider", lambda _a: FakeProvider())
+
+    try:
+        await sync_engine._poll_secondary_once(account.id)
+
+        session.expunge_all()
+        remaining = set(
+            await session.scalars(select(Message.uid).where(Message.mailbox_id == drafts.id))
+        )
+        assert remaining == {2}  # phantoms 1 and 3 removed
+        assert (await session.get(Draft, linked.id)).imap_uid is None  # un-linked
+        assert (await session.get(Draft, kept.id)).imap_uid == 2  # untouched
+    finally:
+        async with session_scope() as cleanup:
+            await cleanup.execute(delete(User).where(User.id == user.id))
+        await session.close()
+        await engine.dispose()