diff --git a/src/app/(inbox)/calendar/page.tsx b/src/app/(inbox)/calendar/page.tsx
new file mode 100644
index 0000000..e6146dd
--- /dev/null
+++ b/src/app/(inbox)/calendar/page.tsx
@@ -0,0 +1,225 @@
+import Link from "next/link";
+import MobileBackButton from "@/components/MobileBackButton";
+import { CalendarEventData } from "@/components/CalendarEventCard";
+import { resolveCalendarEvent } from "@/lib/calendarDetect";
+import { addMonths, buildCalendarEntries, buildMonthDays, filterEventsForMonth, formatEventTime, groupEventsByDay, monthTitle, normalizeMonthKey } from "@/lib/calendarView";
+import { getAccountId, getMailboxes, getSession, listRecentCalendarCandidateEmails } from "@/lib/jmap";
+
+export const dynamic = "force-dynamic";
+
+const DAY_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
+
+interface Props {
+  searchParams: Promise<{ month?: string }>;
+}
+
+function eventClasses(event: CalendarEventData): string {
+  if (event.method === "CANCEL") {
+    return "border-red-200 bg-red-50/80 text-red-700 dark:border-red-900/60 dark:bg-red-950/30 dark:text-red-300";
+  }
+  switch (event.myCurrentPartstat) {
+    case "ACCEPTED":
+      return "border-green-200 bg-green-50/80 text-green-700 dark:border-green-900/60 dark:bg-green-950/30 dark:text-green-300";
+    case "TENTATIVE":
+      return "border-amber-200 bg-amber-50/80 text-amber-700 dark:border-amber-900/60 dark:bg-amber-950/30 dark:text-amber-300";
+    case "DECLINED":
+      return "border-stone-200 bg-stone-100/90 text-stone-500 dark:border-stone-700 dark:bg-stone-800/80 dark:text-stone-400";
+    default:
+      return "border-blue-200 bg-blue-50/80 text-blue-700 dark:border-blue-900/60 dark:bg-blue-950/30 dark:text-blue-300";
+  }
+}
+
+function statusLabel(event: CalendarEventData): string | null {
+  if (event.method === "CANCEL") return "Cancelled";
+  switch (event.myCurrentPartstat) {
+    case "ACCEPTED":
+      return "Accepted";
+    case "TENTATIVE":
+      return "Maybe";
+    case "DECLINED":
+      return "Declined";
+    default:
+      return null;
+  }
+}
+
+function EventLink({ event }: { event: CalendarEventData }) {
+  const status = statusLabel(event);
+  return (
+    <Link
+      href={`/email/${event.emailId}`}
+      className={[
+        "block rounded-md border px-2 py-1.5 transition-colors hover:border-stone-300 hover:bg-white dark:hover:border-stone-500 dark:hover:bg-stone-900/70",
+        eventClasses(event),
+      ].join(" ")}
+      title={`${formatEventTime(event)} — ${event.summary}`}
+    >
+      <div className="flex items-start justify-between gap-2">
+        <span className="text-[11px] font-medium tabular-nums">
+          {formatEventTime(event)}
+        </span>
+        {status && (
+          <span className="text-[10px] uppercase tracking-wide opacity-80">
+            {status}
+          </span>
+        )}
+      </div>
+      <p className={["mt-1 text-xs leading-snug", event.method === "CANCEL" ? "line-through" : ""].join(" ")}>
+        {event.summary || event.emailSubject || "(no title)"}
+      </p>
+      {event.location && (
+        <p className="mt-1 text-[11px] opacity-80 truncate">
+          {event.location}
+        </p>
+      )}
+    </Link>
+  );
+}
+
+export default async function CalendarPage({ searchParams }: Props) {
+  const { month } = await searchParams;
+  const monthKey = normalizeMonthKey(month);
+
+  const session = await getSession();
+  const accountId = getAccountId(session);
+  const mailboxes = await getMailboxes(session.apiUrl, accountId);
+
+  const excludedMailboxIds = new Set(
+    mailboxes
+      .filter((mailbox) => mailbox.role === "drafts" || mailbox.role === "sent" || mailbox.role === "trash")
+      .map((mailbox) => mailbox.id)
+  );
+
+  const recentEmails = await listRecentCalendarCandidateEmails(session.apiUrl, accountId);
+  const inviteEmails = recentEmails.filter((email) => {
+    const mailboxIds = Object.keys(email.mailboxIds ?? {});
+    if (mailboxIds.some((mailboxId) => excludedMailboxIds.has(mailboxId))) {
+      return false;
+    }
+
+    return (
+      email.textBody?.some((part) => part.type === "text/calendar") ||
+      email.attachments?.some((part) => part.type === "text/calendar")
+    );
+  });
+
+  const resolvedEvents = (await Promise.all(
+    inviteEmails.map((email) =>
+      resolveCalendarEvent(email, session.downloadUrl, accountId)
+    )
+  )).filter((event): event is CalendarEventData => event !== null);
+
+  const entries = buildCalendarEntries(resolvedEvents);
+  const monthEntries = filterEventsForMonth(entries, monthKey);
+  const monthDays = buildMonthDays(monthKey, monthEntries);
+  const groupedDays = groupEventsByDay(monthEntries);
+
+  return (
+    <div className="overflow-y-auto h-full bg-stone-50 dark:bg-stone-900">
+      <div className="max-w-6xl mx-auto px-4 sm:px-8 py-8">
+        <MobileBackButton label="Inbox" />
+
+        <div className="flex flex-col gap-4 md:flex-row md:items-start md:justify-between mb-6">
+          <div>
+            <h1 className="text-xl font-semibold text-stone-900 dark:text-stone-100">
+              Calendar
+            </h1>
+            <p className="mt-1 text-sm text-stone-500 dark:text-stone-400">
+              Meetings parsed from recent calendar invite emails.
+            </p>
+          </div>
+
+          <div className="flex items-center gap-2">
+            <Link
+              href={`/calendar?month=${addMonths(monthKey, -1)}`}
+              className="px-3 py-1.5 rounded-md border border-stone-200 dark:border-stone-700 text-xs text-stone-600 dark:text-stone-400 hover:bg-stone-100 dark:hover:bg-stone-800 hover:text-stone-900 dark:hover:text-stone-100 transition-colors"
+            >
+              Prev
+            </Link>
+            <div className="min-w-40 text-center text-sm font-medium text-stone-800 dark:text-stone-200">
+              {monthTitle(monthKey)}
+            </div>
+            <Link
+              href={`/calendar?month=${addMonths(monthKey, 1)}`}
+              className="px-3 py-1.5 rounded-md border border-stone-200 dark:border-stone-700 text-xs text-stone-600 dark:text-stone-400 hover:bg-stone-100 dark:hover:bg-stone-800 hover:text-stone-900 dark:hover:text-stone-100 transition-colors"
+            >
+              Next
+            </Link>
+          </div>
+        </div>
+
+        {monthEntries.length === 0 ? (
+          <div className="rounded-xl border border-dashed border-stone-300 dark:border-stone-700 px-6 py-10 text-center text-sm text-stone-500 dark:text-stone-400">
+            No meetings found for {monthTitle(monthKey)}.
+          </div>
+        ) : (
+          <>
+            <div className="md:hidden space-y-4">
+              {groupedDays.map(({ key, date, events }) => (
+                <section key={key} className="rounded-xl border border-stone-200 dark:border-stone-700 bg-white dark:bg-stone-800/50 overflow-hidden">
+                  <div className="px-4 py-3 border-b border-stone-100 dark:border-stone-700/60">
+                    <h2 className="text-sm font-semibold text-stone-900 dark:text-stone-100">
+                      {date.toLocaleDateString("en-US", {
+                        weekday: "long",
+                        month: "long",
+                        day: "numeric",
+                      })}
+                    </h2>
+                  </div>
+                  <div className="p-3 space-y-2">
+                    {events.map((event) => (
+                      <EventLink key={`${event.uid}-${event.emailId}`} event={event} />
+                    ))}
+                  </div>
+                </section>
+              ))}
+            </div>
+
+            <div className="hidden md:block rounded-xl overflow-hidden border border-stone-200 dark:border-stone-700 bg-stone-200 dark:bg-stone-700">
+              <div className="grid grid-cols-7">
+                {DAY_LABELS.map((label) => (
+                  <div
+                    key={label}
+                    className="bg-stone-100 dark:bg-stone-800 px-3 py-2 text-xs font-medium uppercase tracking-wide text-stone-500 dark:text-stone-400 border-b border-stone-200 dark:border-stone-700"
+                  >
+                    {label}
+                  </div>
+                ))}
+
+                {monthDays.map((day) => (
+                  <div
+                    key={day.key}
+                    className={[
+                      "min-h-40 bg-white dark:bg-stone-900/70 p-2 border-b border-r border-stone-200 dark:border-stone-700",
+                      day.inMonth ? "" : "bg-stone-50/70 dark:bg-stone-900/30",
+                    ].join(" ")}
+                  >
+                    <div className="mb-2 flex items-center justify-between">
+                      <span
+                        className={[
+                          "inline-flex h-7 w-7 items-center justify-center rounded-full text-xs font-medium",
+                          day.isToday
+                            ? "bg-blue-600 text-white"
+                            : day.inMonth
+                              ? "text-stone-700 dark:text-stone-200"
+                              : "text-stone-400 dark:text-stone-500",
+                        ].join(" ")}
+                      >
+                        {day.date.getDate()}
+                      </span>
+                    </div>
+                    <div className="space-y-1.5">
+                      {day.events.map((event) => (
+                        <EventLink key={`${event.uid}-${event.emailId}`} event={event} />
+                      ))}
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index 842029d..9e9bbf3 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -76,6 +76,12 @@ export default async function RootLayout({
                 >
                   [SENT]
                 </Link>
+                <Link
+                  href="/calendar"
+                  className="text-xs tracking-widest uppercase text-stone-500 dark:text-stone-300 hover:text-stone-900 dark:hover:text-stone-100 border border-stone-400 dark:border-stone-300 hover:border-stone-700 dark:hover:border-stone-100 px-2 py-1.5 transition-colors"
+                >
+                  [CALENDAR]
+                </Link>
               </div>
 
               <div className="mt-auto flex flex-col gap-1">
diff --git a/src/components/CalendarEventCard.tsx b/src/components/CalendarEventCard.tsx
index 3ad22a6..36575b5 100644
--- a/src/components/CalendarEventCard.tsx
+++ b/src/components/CalendarEventCard.tsx
@@ -4,7 +4,12 @@ import { useState } from "react";
 import { sendCalendarReplyAction } from "@/app/(inbox)/email/[id]/actions";
 
 export interface CalendarEventData {
+  uid: string;
   emailId: string;
+  threadId: string;
+  receivedAt: string;
+  emailSubject: string | null;
+  preview: string;
   icsText: string;
   method: string;
   summary: string;
diff --git a/src/components/InboxPanelLayout.tsx b/src/components/InboxPanelLayout.tsx
index c324c0d..b09b398 100644
--- a/src/components/InboxPanelLayout.tsx
+++ b/src/components/InboxPanelLayout.tsx
@@ -12,6 +12,7 @@ export default function InboxPanelLayout({ list, children }: Props) {
   const showDetail =
     pathname.startsWith("/email/") ||
     pathname.startsWith("/thread/") ||
+    pathname.startsWith("/calendar") ||
     pathname.startsWith("/attachment/") ||
     pathname.startsWith("/settings") ||
     pathname.startsWith("/sent");
diff --git a/src/components/MobileNav.tsx b/src/components/MobileNav.tsx
index de690c5..02077b3 100644
--- a/src/components/MobileNav.tsx
+++ b/src/components/MobileNav.tsx
@@ -42,6 +42,15 @@ function SentIcon() {
   );
 }
 
+function CalendarIcon() {
+  return (
+    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={1.75} className="w-5 h-5" aria-hidden="true">
+      <rect x="3" y="4" width="18" height="17" rx="2" />
+      <path d="M8 2v4M16 2v4M3 10h18" />
+    </svg>
+  );
+}
+
 function SettingsIcon() {
   return (
     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={1.75} className="w-5 h-5" aria-hidden="true">
@@ -85,6 +94,13 @@ export default function MobileNav({ draftTotal = 0 }: Props) {
       active: pathname.startsWith("/sent"),
       badge: 0,
     },
+    {
+      href: "/calendar",
+      label: "Calendar",
+      icon: <CalendarIcon />,
+      active: pathname.startsWith("/calendar"),
+      badge: 0,
+    },
     {
       href: "/compose",
       label: "Compose",
diff --git a/src/lib/__tests__/calendarView.test.ts b/src/lib/__tests__/calendarView.test.ts
new file mode 100644
index 0000000..8db33c1
--- /dev/null
+++ b/src/lib/__tests__/calendarView.test.ts
@@ -0,0 +1,94 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildCalendarEntries, buildMonthDays, filterEventsForMonth, addMonths, normalizeMonthKey, monthTitle, formatEventTime } from "../calendarView";
+import { CalendarEventData } from "@/components/CalendarEventCard";
+
+function makeEvent(overrides: Partial<CalendarEventData> = {}): CalendarEventData {
+  return {
+    uid: "uid-1",
+    emailId: "email-1",
+    threadId: "thread-1",
+    receivedAt: "2026-05-01T12:00:00.000Z",
+    emailSubject: "Invite",
+    preview: "",
+    icsText: "BEGIN:VCALENDAR",
+    method: "REQUEST",
+    summary: "Meeting",
+    dtStart: "2026-05-20T16:00:00.000Z",
+    dtEnd: "2026-05-20T17:00:00.000Z",
+    allDay: false,
+    location: null,
+    organizerName: null,
+    organizerEmail: null,
+    myCurrentPartstat: null,
+    inReplyToMessageId: undefined,
+    ...overrides,
+  };
+}
+
+describe("calendarView", () => {
+  it("normalizes invalid month keys to the current month", () => {
+    assert.equal(normalizeMonthKey(undefined, new Date(2026, 4, 20)), "2026-05");
+    assert.equal(normalizeMonthKey("bad-value", new Date(2026, 4, 20)), "2026-05");
+    assert.equal(normalizeMonthKey("2026-11", new Date(2026, 4, 20)), "2026-11");
+  });
+
+  it("adds months across year boundaries", () => {
+    assert.equal(addMonths("2026-12", 1), "2027-01");
+    assert.equal(addMonths("2026-01", -1), "2025-12");
+  });
+
+  it("formats month titles", () => {
+    assert.equal(monthTitle("2026-05"), "May 2026");
+  });
+
+  it("dedupes invites by uid using the latest received email", () => {
+    const older = makeEvent({
+      uid: "meeting-1",
+      emailId: "email-older",
+      receivedAt: "2026-05-01T10:00:00.000Z",
+      summary: "Older",
+    });
+    const newer = makeEvent({
+      uid: "meeting-1",
+      emailId: "email-newer",
+      receivedAt: "2026-05-02T10:00:00.000Z",
+      summary: "Newer",
+    });
+    const result = buildCalendarEntries([older, newer]);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].emailId, "email-newer");
+    assert.equal(result[0].summary, "Newer");
+  });
+
+  it("omits reply messages and events without a start time", () => {
+    const reply = makeEvent({ uid: "reply", method: "REPLY" });
+    const noStart = makeEvent({ uid: "nostart", dtStart: null });
+    const result = buildCalendarEntries([reply, noStart]);
+    assert.equal(result.length, 0);
+  });
+
+  it("filters events for the requested month", () => {
+    const mayEvent = makeEvent({ uid: "may", dtStart: "2026-05-20T16:00:00.000Z" });
+    const juneEvent = makeEvent({ uid: "june", dtStart: "2026-06-01T16:00:00.000Z" });
+    const result = filterEventsForMonth([mayEvent, juneEvent], "2026-05");
+    assert.deepEqual(result.map((event) => event.uid), ["may"]);
+  });
+
+  it("builds a 6-week month grid with events slotted into their day", () => {
+    const entry = makeEvent({ uid: "may", dtStart: "2026-05-20T16:00:00.000Z" });
+    const days = buildMonthDays("2026-05", [entry], new Date("2026-05-20T08:00:00.000Z"));
+    assert.equal(days.length, 42);
+    const matchingDay = days.find((day) => day.key === "2026-05-20");
+    assert.ok(matchingDay);
+    assert.equal(matchingDay?.isToday, true);
+    assert.deepEqual(matchingDay?.events.map((event) => event.uid), ["may"]);
+  });
+
+  it("formats event times for timed and all-day events", () => {
+    const timed = makeEvent({ dtStart: "2026-05-20T16:00:00.000Z", allDay: false });
+    const allDay = makeEvent({ dtStart: "2026-05-20T00:00:00.000Z", allDay: true });
+    assert.match(formatEventTime(timed), /[0-9]/);
+    assert.equal(formatEventTime(allDay), "All day");
+  });
+});
diff --git a/src/lib/calendarDetect.ts b/src/lib/calendarDetect.ts
index 7aca5ef..4436b0f 100644
--- a/src/lib/calendarDetect.ts
+++ b/src/lib/calendarDetect.ts
@@ -1,8 +1,17 @@
-import { Email } from "./types";
+import { Email, EmailBodyPart } from "./types";
 import { downloadBlobAsText } from "./jmap";
 import { parseIcs } from "./ics";
 import { CalendarEventData } from "@/components/CalendarEventCard";
 
+type CalendarSourceEmail = Pick<
+  Email,
+  "id" | "messageId" | "threadId" | "subject" | "preview" | "to" | "cc" | "receivedAt" | "keywords"
+> & {
+  textBody?: EmailBodyPart[];
+  attachments?: EmailBodyPart[];
+  bodyValues?: Email["bodyValues"];
+};
+
 /**
  * Given an email object (with bodyValues already fetched), detect and parse
  * any attached or inline calendar invite. Returns null if none found.
@@ -11,7 +20,7 @@ import { CalendarEventData } from "@/components/CalendarEventCard";
  * calendar events forwarded or CC'd still resolve the user's PARTSTAT.
  */
 export async function resolveCalendarEvent(
-  email: Email,
+  email: CalendarSourceEmail,
   downloadUrl: string,
   accountId: string
 ): Promise<CalendarEventData | null> {
@@ -60,7 +69,12 @@ export async function resolveCalendarEvent(
       null;
 
     return {
+      uid: event.uid || email.id,
       emailId: email.id,
+      threadId: email.threadId,
+      receivedAt: email.receivedAt,
+      emailSubject: email.subject,
+      preview: email.preview,
       icsText,
       method: event.method,
       summary: event.summary,
diff --git a/src/lib/calendarView.ts b/src/lib/calendarView.ts
new file mode 100644
index 0000000..2a5301a
--- /dev/null
+++ b/src/lib/calendarView.ts
@@ -0,0 +1,135 @@
+import { CalendarEventData } from "@/components/CalendarEventCard";
+
+export interface CalendarMonthDay {
+  date: Date;
+  key: string;
+  inMonth: boolean;
+  isToday: boolean;
+  events: CalendarEventData[];
+}
+
+function monthKeyFor(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
+}
+
+function dayKeyFor(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+export function normalizeMonthKey(raw: string | undefined, now = new Date()): string {
+  return /^\d{4}-\d{2}$/.test(raw ?? "") ? raw! : monthKeyFor(now);
+}
+
+export function addMonths(monthKey: string, delta: number): string {
+  const [year, month] = monthKey.split("-").map(Number);
+  const date = new Date(year, month - 1 + delta, 1);
+  return monthKeyFor(date);
+}
+
+export function monthTitle(monthKey: string): string {
+  const [year, month] = monthKey.split("-").map(Number);
+  return new Date(year, month - 1, 1).toLocaleDateString("en-US", {
+    month: "long",
+    year: "numeric",
+  });
+}
+
+export function formatEventTime(event: CalendarEventData): string {
+  if (!event.dtStart) return "Time unknown";
+  if (event.allDay) return "All day";
+  return new Date(event.dtStart).toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
+
+export function buildCalendarEntries(events: CalendarEventData[]): CalendarEventData[] {
+  const deduped = new Map<string, CalendarEventData>();
+
+  for (const event of events) {
+    if (!event.dtStart) continue;
+    if (event.method === "REPLY") continue;
+
+    const key = event.uid || event.emailId;
+    const existing = deduped.get(key);
+    if (!existing || event.receivedAt > existing.receivedAt) {
+      deduped.set(key, event);
+    }
+  }
+
+  return [...deduped.values()].sort((a, b) => {
+    const aStart = a.dtStart ?? "";
+    const bStart = b.dtStart ?? "";
+    if (aStart !== bStart) return aStart.localeCompare(bStart);
+    if (a.allDay !== b.allDay) return a.allDay ? -1 : 1;
+    return a.summary.localeCompare(b.summary);
+  });
+}
+
+export function filterEventsForMonth(
+  entries: CalendarEventData[],
+  monthKey: string
+): CalendarEventData[] {
+  return entries.filter((entry) => {
+    if (!entry.dtStart) return false;
+    return dayKeyFor(new Date(entry.dtStart)).startsWith(monthKey);
+  });
+}
+
+export function groupEventsByDay(
+  entries: CalendarEventData[]
+): Array<{ key: string; date: Date; events: CalendarEventData[] }> {
+  const groups = new Map<string, { date: Date; events: CalendarEventData[] }>();
+
+  for (const event of entries) {
+    if (!event.dtStart) continue;
+    const date = new Date(event.dtStart);
+    const key = dayKeyFor(date);
+    if (!groups.has(key)) groups.set(key, { date, events: [] });
+    groups.get(key)!.events.push(event);
+  }
+
+  return [...groups.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, value]) => ({ key, date: value.date, events: value.events }));
+}
+
+export function buildMonthDays(
+  monthKey: string,
+  entries: CalendarEventData[],
+  now = new Date()
+): CalendarMonthDay[] {
+  const [year, month] = monthKey.split("-").map(Number);
+  const monthStart = new Date(year, month - 1, 1);
+  const gridStart = new Date(monthStart);
+  gridStart.setDate(monthStart.getDate() - monthStart.getDay());
+
+  const todayKey = dayKeyFor(now);
+  const eventsByDay = new Map<string, CalendarEventData[]>();
+
+  for (const entry of entries) {
+    if (!entry.dtStart) continue;
+    const key = dayKeyFor(new Date(entry.dtStart));
+    const existing = eventsByDay.get(key) ?? [];
+    existing.push(entry);
+    eventsByDay.set(key, existing);
+  }
+
+  return Array.from({ length: 42 }, (_, index) => {
+    const date = new Date(gridStart);
+    date.setDate(gridStart.getDate() + index);
+    const key = dayKeyFor(date);
+    return {
+      date,
+      key,
+      inMonth: date.getMonth() === monthStart.getMonth(),
+      isToday: key === todayKey,
+      events: eventsByDay.get(key) ?? [],
+    };
+  });
+}
diff --git a/src/lib/jmap.ts b/src/lib/jmap.ts
index 87a4c7b..91bbf0d 100644
--- a/src/lib/jmap.ts
+++ b/src/lib/jmap.ts
@@ -95,6 +95,22 @@ const EMAIL_LIST_PROPERTIES = [
   "size",
 ];
 
+const CALENDAR_CANDIDATE_PROPERTIES = [
+  "id",
+  "messageId",
+  "threadId",
+  "mailboxIds",
+  "subject",
+  "from",
+  "to",
+  "cc",
+  "receivedAt",
+  "preview",
+  "keywords",
+  "textBody",
+  "attachments",
+];
+
 export async function listEmails(
   apiUrl: string,
   accountId: string,
@@ -514,6 +530,42 @@ export async function listSentEmails(
   return { emails, total };
 }
 
+export async function listRecentCalendarCandidateEmails(
+  apiUrl: string,
+  accountId: string,
+  limit = 500
+): Promise<Email[]> {
+  const t = Date.now();
+  const data = await jmapCall(apiUrl, [
+    [
+      "Email/query",
+      {
+        accountId,
+        sort: [{ property: "receivedAt", isAscending: false }],
+        limit,
+        position: 0,
+      },
+      "q",
+    ],
+    [
+      "Email/get",
+      {
+        accountId,
+        "#ids": { resultOf: "q", name: "Email/query", path: "/ids" },
+        properties: CALENDAR_CANDIDATE_PROPERTIES,
+      },
+      "g",
+    ],
+  ]);
+  const [, gResult] = data.methodResponses[1];
+  const emails = (gResult.list as Email[]) ?? [];
+  log.info(
+    { count: emails.length, limit, duration_ms: Date.now() - t },
+    "jmap.list_calendar_candidates"
+  );
+  return emails;
+}
+
 export async function saveDraft(
   apiUrl: string,
   accountId: string,