@agent-native/core 0.88.0 → 0.90.1

package/corpus/templates/calendar/app/pages/CalendarView.tsx

@@ -1,26 +1,8 @@
 import {
   AgentToggleButton,
   agentNativePath,
-  NotificationsBell,
   useT,
 } from "@agent-native/core/client";
-import { useIsMobile } from "@agent-native/toolkit/hooks/use-mobile";
-import { Button } from "@agent-native/toolkit/ui/button";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuLabel,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-} from "@agent-native/toolkit/ui/dropdown-menu";
-import { Spinner } from "@agent-native/toolkit/ui/spinner";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
-} from "@agent-native/toolkit/ui/tooltip";
 import type {
   CalendarEvent,
   CalendarEventDraft,
@@ -54,6 +36,7 @@ import { useState, useMemo, useEffect, useCallback, useRef } from "react";
 import { Link } from "react-router";
 import { toast } from "sonner";
 
+import type { QuickCreateEvent } from "@/components/calendar/CommandPalette";
 import { CommandPalette } from "@/components/calendar/CommandPalette";
 import { CreateEventPopover } from "@/components/calendar/CreateEventDialog";
 import { DayView } from "@/components/calendar/DayView";
@@ -69,16 +52,34 @@ import { PeopleSearchDialog } from "@/components/calendar/PeopleSearchDialog";
 import { WeekView } from "@/components/calendar/WeekView";
 import { useCalendarContext } from "@/components/layout/AppLayout";
 import type { ViewMode } from "@/components/layout/AppLayout";
+import { Button } from "@/components/ui/button";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Spinner } from "@/components/ui/spinner";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 import {
   useEvents,
   useCreateEvent,
   useUpdateEvent,
   useDeleteEvent,
+  useRsvpEvent,
   prefetchEvents,
   shouldShowEventsSkeleton,
 } from "@/hooks/use-events";
 import { useGoogleAuthStatus } from "@/hooks/use-google-auth";
 import { useMeetingStartNotifications } from "@/hooks/use-meeting-start-notifications";
+import { useIsMobile } from "@/hooks/use-mobile";
 import { useOverlayPeople } from "@/hooks/use-overlay-people";
 import { useSettings } from "@/hooks/use-settings";
 import { setUndoAction, runUndo } from "@/hooks/use-undo";
@@ -296,6 +297,7 @@ export default function CalendarView() {
     setViewMode,
     peopleSearchOpen,
     setPeopleSearchOpen,
+    addCalendarOpen,
     setAddCalendarOpen,
     setAddCalendarDefaultTab,
     eventDetailSidebar,
@@ -339,6 +341,7 @@ export default function CalendarView() {
   const createEvent = useCreateEvent();
   const updateEvent = useUpdateEvent();
   const deleteEvent = useDeleteEvent();
+  const rsvpEvent = useRsvpEvent();
   const { promptGuestNotification, guestNotificationDialog } =
     useGuestNotificationPrompt();
   const viewModeLabels: Record<ViewMode, string> = {
@@ -739,12 +742,15 @@ export default function CalendarView() {
     setSelectedDate(new Date());
   }
 
-  function handleDateSelect(date: Date) {
-    setSelectedDate(date);
-    if (viewMode === "month") {
-      setViewMode("day");
-    }
-  }
+  const handleDateSelect = useCallback(
+    (date: Date) => {
+      setSelectedDate(date);
+      if (viewMode === "month") {
+        setViewMode("day");
+      }
+    },
+    [viewMode, setSelectedDate, setViewMode],
+  );
 
   function handleGoToDate(date: Date) {
     setSelectedDate(date);
@@ -783,83 +789,116 @@ export default function CalendarView() {
     }
   }
 
-  async function handleDirectDelete(
-    ev: CalendarEvent,
-    notificationOptions?: {
-      sendUpdates: "all" | "none";
-      notificationMessage?: string;
-    },
-  ) {
-    const isOrganizer =
-      ev.organizer?.self ||
-      ev.attendees?.find((a) => a.self)?.organizer ||
-      !ev.attendees?.length;
-    const hasOtherAttendees =
-      ev.attendees && ev.attendees.filter((a) => !a.self).length > 0;
-    const removeOnly = !isOrganizer && !!hasOtherAttendees;
-    const shouldAskGuests = !removeOnly && shouldPromptGuests(ev);
-    const guestNotification =
-      notificationOptions ??
-      (shouldAskGuests
-        ? await promptGuestNotification({
-            event: ev,
-            action: "cancellation",
-          })
-        : { sendUpdates: "none" as const });
-    if (!guestNotification) return;
+  const handleDirectDelete = useCallback(
+    async (
+      ev: CalendarEvent,
+      notificationOptions?: {
+        sendUpdates: "all" | "none";
+        notificationMessage?: string;
+      },
+    ) => {
+      const isOrganizer =
+        ev.organizer?.self ||
+        ev.attendees?.find((a) => a.self)?.organizer ||
+        !ev.attendees?.length;
+      const hasOtherAttendees =
+        ev.attendees && ev.attendees.filter((a) => !a.self).length > 0;
+      const removeOnly = !isOrganizer && !!hasOtherAttendees;
+      const shouldAskGuests = !removeOnly && shouldPromptGuests(ev);
+      const guestNotification =
+        notificationOptions ??
+        (shouldAskGuests
+          ? await promptGuestNotification({
+              event: ev,
+              action: "cancellation",
+            })
+          : { sendUpdates: "none" as const });
+      if (!guestNotification) return;
 
-    // Snapshot for undo — preserve all event fields so undo recreates faithfully
-    const { id: _id, source: _source, ...snapshot } = ev;
-    const undo = () => {
-      createEvent.mutate(snapshot);
-    };
+      // Snapshot for undo — preserve all event fields so undo recreates faithfully
+      const { id: _id, source: _source, ...snapshot } = ev;
+      // removeOnly means the current user was only an attendee, not the
+      // organizer — the event still exists for everyone else. Undo must
+      // re-accept the existing event rather than fabricate a new one the
+      // user doesn't own.
+      const undo = removeOnly
+        ? () => {
+            rsvpEvent.mutate(
+              {
+                id: ev.id,
+                status: "accepted",
+                accountEmail: ev.accountEmail,
+                sendUpdates: "none",
+              },
+              {
+                onError: () =>
+                  toast.error(t("calendarView.failedRestoreAttendance")),
+              },
+            );
+          }
+        : () => {
+            createEvent.mutate(snapshot);
+          };
 
-    deleteEvent.mutate(
-      {
-        id: ev.id,
-        scope: "single",
-        ...guestNotification,
-        removeOnly,
-      },
-      {
-        onSuccess: () => {
-          if (sidebarEvent?.id === ev.id) setSidebarEvent(null);
-          setUndoAction(undo);
-          toast(
-            removeOnly
-              ? t("calendarView.eventRemoved")
-              : t("calendarView.eventDeleted"),
-            {
-              action: { label: t("calendarView.undo"), onClick: undo },
-            },
-          );
+      deleteEvent.mutate(
+        {
+          id: ev.id,
+          scope: "single",
+          ...guestNotification,
+          removeOnly,
         },
-        onError: () => toast.error(t("calendarView.failedDeleteEvent")),
-      },
-    );
-  }
+        {
+          onSuccess: () => {
+            if (sidebarEvent?.id === ev.id) setSidebarEvent(null);
+            setUndoAction(undo);
+            toast(
+              removeOnly
+                ? t("calendarView.eventRemoved")
+                : t("calendarView.eventDeleted"),
+              {
+                action: { label: t("calendarView.undo"), onClick: undo },
+              },
+            );
+          },
+          onError: () => toast.error(t("calendarView.failedDeleteEvent")),
+        },
+      );
+    },
+    [
+      createEvent,
+      deleteEvent,
+      promptGuestNotification,
+      rsvpEvent,
+      setSidebarEvent,
+      sidebarEvent,
+      t,
+    ],
+  );
 
-  function handleDeleteEvent(eventId: string) {
-    if (calendarDraftIdFromEventId(eventId)) {
-      discardDraftEvent(eventId);
-      return;
-    }
-    const ev = events.find((e) => e.id === eventId);
-    if (!ev) return;
-    const isRecurring = !!(ev.recurringEventId || ev.recurrence?.length);
-    const isOrganizer =
-      ev.organizer?.self ||
-      ev.attendees?.find((a) => a.self)?.organizer ||
-      !ev.attendees?.length;
-    const hasOtherAttendees =
-      ev.attendees && ev.attendees.filter((a) => !a.self).length > 0;
-    const removeOnly = !isOrganizer && !!hasOtherAttendees;
-    if (isRecurring || (!removeOnly && shouldPromptGuests(ev))) {
-      setDeleteDialogEvent(ev);
-    } else {
-      void handleDirectDelete(ev);
-    }
-  }
+  const handleDeleteEvent = useCallback(
+    (eventId: string) => {
+      if (calendarDraftIdFromEventId(eventId)) {
+        discardDraftEvent(eventId);
+        return;
+      }
+      const ev = events.find((e) => e.id === eventId);
+      if (!ev) return;
+      const isRecurring = !!(ev.recurringEventId || ev.recurrence?.length);
+      const isOrganizer =
+        ev.organizer?.self ||
+        ev.attendees?.find((a) => a.self)?.organizer ||
+        !ev.attendees?.length;
+      const hasOtherAttendees =
+        ev.attendees && ev.attendees.filter((a) => !a.self).length > 0;
+      const removeOnly = !isOrganizer && !!hasOtherAttendees;
+      if (isRecurring || (!removeOnly && shouldPromptGuests(ev))) {
+        setDeleteDialogEvent(ev);
+      } else {
+        void handleDirectDelete(ev);
+      }
+    },
+    [discardDraftEvent, events, handleDirectDelete],
+  );
 
   // Move event to a new date (drag-and-drop from MonthView)
   async function handleEventDrop(eventId: string, newDate: Date) {
@@ -906,6 +945,10 @@ export default function CalendarView() {
       newDate.getDate(),
     );
 
+    // Guard against a zero/negative duration reaching the server (e.g. a
+    // DST transition collapsing a short event's start/end onto each other).
+    if (newEnd.getTime() <= newStart.getTime()) return;
+
     const updates = {
       start: newStart.toISOString(),
       end: newEnd.toISOString(),
@@ -956,149 +999,252 @@ export default function CalendarView() {
   }
 
   // Move/resize event to new start/end times (drag from Week/Day views)
-  async function handleEventTimeChange(
-    eventId: string,
-    newStart: Date,
-    newEnd: Date,
-  ) {
-    // Skip no-op drags (dropped back in same spot)
-    const event = events.find((e) => e.id === eventId);
-    if (!event) return;
+  const handleEventTimeChange = useCallback(
+    async (eventId: string, newStart: Date, newEnd: Date) => {
+      // Skip no-op drags (dropped back in same spot)
+      const event = events.find((e) => e.id === eventId);
+      if (!event) return;
+
+      // Guard against a zero/negative duration reaching the server —
+      // gesture math should already prevent this, but never commit it.
+      if (newEnd.getTime() <= newStart.getTime()) return;
+
+      if (calendarDraftIdFromEventId(eventId)) {
+        const timezone = settings?.timezone || getLocalTimezone();
+        updateDraftEvent(eventId, {
+          start: newStart.toISOString(),
+          end: newEnd.toISOString(),
+          allDay: false,
+          startTimeZone: timezone,
+          endTimeZone: timezone,
+        });
+        return;
+      }
 
-    if (calendarDraftIdFromEventId(eventId)) {
-      const timezone = settings?.timezone || getLocalTimezone();
-      updateDraftEvent(eventId, {
+      const oldStart = parseISO(event.start).getTime();
+      const oldEnd = parseISO(event.end).getTime();
+      if (oldStart === newStart.getTime() && oldEnd === newEnd.getTime()) {
+        return;
+      }
+
+      const oldStartISO = event.start;
+      const oldEndISO = event.end;
+      const updates = {
         start: newStart.toISOString(),
         end: newEnd.toISOString(),
-        allDay: false,
-        startTimeZone: timezone,
-        endTimeZone: timezone,
+      };
+      const isRecurring = isRecurringCalendarEvent(event);
+      const guestNotification = await promptGuestNotification({
+        event,
+        action: "update",
+        updates,
+        recurrenceScope: isRecurring,
       });
-      return;
-    }
+      if (!guestNotification) return;
 
-    const oldStart = parseISO(event.start).getTime();
-    const oldEnd = parseISO(event.end).getTime();
-    if (oldStart === newStart.getTime() && oldEnd === newEnd.getTime()) {
-      return;
-    }
+      const undoScope = guestNotification.scope;
+      const undo = () => {
+        updateEvent.mutate({
+          id: eventId,
+          start: oldStartISO,
+          end: oldEndISO,
+          sendUpdates: "none",
+          ...updateScopePayload(undoScope),
+        });
+      };
+      const toastId = toast.loading(
+        isRecurring
+          ? t("calendarView.updatingRecurringEvent")
+          : t("calendarView.updatingEvent"),
+      );
 
-    const oldStartISO = event.start;
-    const oldEndISO = event.end;
-    const updates = {
-      start: newStart.toISOString(),
-      end: newEnd.toISOString(),
-    };
-    const isRecurring = isRecurringCalendarEvent(event);
-    const guestNotification = await promptGuestNotification({
-      event,
-      action: "update",
-      updates,
-      recurrenceScope: isRecurring,
-    });
-    if (!guestNotification) return;
+      updateEvent.mutate(
+        {
+          id: eventId,
+          ...updates,
+          ...guestNotification,
+        },
+        {
+          onSuccess: () => {
+            setUndoAction(undo);
+            toast.success(t("calendarView.eventUpdated"), {
+              id: toastId,
+              action: { label: t("calendarView.undo"), onClick: undo },
+            });
+          },
+          onError: () =>
+            toast.error(t("calendarView.failedUpdateEvent"), { id: toastId }),
+        },
+      );
+    },
+    [
+      events,
+      settings,
+      updateDraftEvent,
+      promptGuestNotification,
+      updateEvent,
+      t,
+    ],
+  );
 
-    const undoScope = guestNotification.scope;
-    const undo = () => {
-      updateEvent.mutate({
-        id: eventId,
-        start: oldStartISO,
-        end: oldEndISO,
-        sendUpdates: "none",
-        ...updateScopePayload(undoScope),
-      });
-    };
-    const toastId = toast.loading(
-      isRecurring
-        ? t("calendarView.updatingRecurringEvent")
-        : t("calendarView.updatingEvent"),
-    );
+  const handleClickTimeSlot = useCallback(
+    async (
+      clickedDate: Date,
+      startTime: string,
+      endTime: string,
+      options?: { explicitDuration?: boolean },
+    ) => {
+      let activeSettings = settings;
+      if (!activeSettings) {
+        const result = await settingsQuery.refetch();
+        activeSettings = result.data;
+      }
+      if (!activeSettings?.timezone) {
+        toast.error(t("calendarView.calendarSettingsLoading"));
+        return;
+      }
 
-    updateEvent.mutate(
-      {
-        id: eventId,
-        ...updates,
-        ...guestNotification,
-      },
-      {
-        onSuccess: () => {
-          setUndoAction(undo);
-          toast.success(t("calendarView.eventUpdated"), {
-            id: toastId,
-            action: { label: t("calendarView.undo"), onClick: undo },
-          });
-        },
-        onError: () =>
-          toast.error(t("calendarView.failedUpdateEvent"), { id: toastId }),
-      },
-    );
-  }
+      setSelectedDate(clickedDate);
+      const defaultDuration = Math.max(
+        5,
+        activeSettings.defaultEventDuration ?? 30,
+      );
+      const timezone = activeSettings.timezone;
+      setCreateDefaultStart(startTime);
+      setCreateDialogOpen(false);
+
+      const dateStr = format(clickedDate, "yyyy-MM-dd");
+      // A drag-to-create gesture already computed the exact dragged range;
+      // a plain click falls back to the user's configured default duration.
+      const end = options?.explicitDuration
+        ? { date: dateStr, time: endTime }
+        : addMinutesToDateTimeParts(dateStr, startTime, defaultDuration);
+      setCreateDefaultEnd(end.time);
+      const startISO = dateTimeInTimezoneToIso(dateStr, startTime, timezone);
+      const endISO = dateTimeInTimezoneToIso(end.date, end.time, timezone);
+      const now = new Date().toISOString();
+      const draftId = `slot-${Date.now()}`;
+      const draft: CalendarEventDraft = {
+        id: draftId,
+        title: "",
+        description: "",
+        location: "",
+        start: startISO,
+        end: endISO,
+        startTimeZone: timezone,
+        endTimeZone: timezone,
+        allDay: false,
+        eventType: "default",
+        createdAt: now,
+        updatedAt: now,
+      };
 
-  async function handleClickTimeSlot(
-    clickedDate: Date,
-    startTime: string,
-    _endTime: string,
-  ) {
-    let activeSettings = settings;
-    if (!activeSettings) {
-      const result = await settingsQuery.refetch();
-      activeSettings = result.data;
-    }
-    if (!activeSettings?.timezone) {
-      toast.error(t("calendarView.calendarSettingsLoading"));
-      return;
-    }
+      persistCalendarDraft(draft);
+      setEventDraft(draft);
+      setQuickEditEventId(calendarDraftEventId(draftId));
+    },
+    [settings, settingsQuery, t, setSelectedDate, setEventDraft],
+  );
 
-    setSelectedDate(clickedDate);
-    const defaultDuration = Math.max(
-      5,
-      activeSettings.defaultEventDuration ?? 30,
-    );
-    const timezone = activeSettings.timezone;
-    setCreateDefaultStart(startTime);
-    setCreateDialogOpen(false);
+  // Command palette natural-language quick create (e.g. "lunch with Sam
+  // tomorrow 12:30") — builds a prefilled draft and jumps to it, reusing the
+  // same draft/quick-edit flow as clicking a time slot.
+  const handleCreateEventFromText = useCallback(
+    async (quickCreate: QuickCreateEvent) => {
+      let activeSettings = settings;
+      if (!activeSettings) {
+        const result = await settingsQuery.refetch();
+        activeSettings = result.data;
+      }
+      if (!activeSettings?.timezone) {
+        toast.error(t("calendarView.calendarSettingsLoading"));
+        return;
+      }
 
-    const dateStr = format(clickedDate, "yyyy-MM-dd");
-    const end = addMinutesToDateTimeParts(dateStr, startTime, defaultDuration);
-    setCreateDefaultEnd(end.time);
-    const startISO = dateTimeInTimezoneToIso(dateStr, startTime, timezone);
-    const endISO = dateTimeInTimezoneToIso(end.date, end.time, timezone);
-    const now = new Date().toISOString();
-    const draftId = `slot-${Date.now()}`;
-    const draft: CalendarEventDraft = {
-      id: draftId,
-      title: "",
-      description: "",
-      location: "",
-      start: startISO,
-      end: endISO,
-      startTimeZone: timezone,
-      endTimeZone: timezone,
-      allDay: false,
-      eventType: "default",
-      createdAt: now,
-      updatedAt: now,
-    };
+      const timezone = activeSettings.timezone;
+      const defaultDuration = Math.max(
+        5,
+        activeSettings.defaultEventDuration ?? 30,
+      );
+      const startTime = quickCreate.hasExplicitTime
+        ? format(quickCreate.start, "HH:mm")
+        : "09:00";
+      const dateStr = format(quickCreate.start, "yyyy-MM-dd");
+      const end = addMinutesToDateTimeParts(
+        dateStr,
+        startTime,
+        defaultDuration,
+      );
+      const startISO = dateTimeInTimezoneToIso(dateStr, startTime, timezone);
+      const endISO = dateTimeInTimezoneToIso(end.date, end.time, timezone);
 
-    persistCalendarDraft(draft);
-    setEventDraft(draft);
-    setQuickEditEventId(calendarDraftEventId(draftId));
-  }
+      setSelectedDate(quickCreate.start);
+      setViewMode("day");
+      setCreateDefaultStart(startTime);
+      setCreateDefaultEnd(end.time);
+      setCreateDialogOpen(false);
+
+      const now = new Date().toISOString();
+      const draftId = `slot-${Date.now()}`;
+      const draft: CalendarEventDraft = {
+        id: draftId,
+        title: quickCreate.title,
+        description: "",
+        location: "",
+        start: startISO,
+        end: endISO,
+        startTimeZone: timezone,
+        endTimeZone: timezone,
+        allDay: false,
+        eventType: "default",
+        createdAt: now,
+        updatedAt: now,
+      };
 
-  async function handleQuickEditSave(eventId: string, title: string) {
-    setQuickEditEventId(null);
-    if (calendarDraftIdFromEventId(eventId)) {
-      updateDraftEvent(eventId, { title: title.trim() });
-      return;
-    }
-    setQuickEditTempIds((current) => {
-      if (!current[eventId]) return current;
-      const { [eventId]: _removed, ...next } = current;
-      return next;
-    });
-    if (title.trim() && title.trim() !== "(No title)") {
+      persistCalendarDraft(draft);
+      setEventDraft(draft);
+      setQuickEditEventId(calendarDraftEventId(draftId));
+    },
+    [settings, settingsQuery, t, setSelectedDate, setViewMode, setEventDraft],
+  );
+
+  const handleQuickEditSave = useCallback(
+    async (eventId: string, title: string) => {
+      setQuickEditEventId(null);
+      if (calendarDraftIdFromEventId(eventId)) {
+        updateDraftEvent(eventId, { title: title.trim() });
+        return;
+      }
+      setQuickEditTempIds((current) => {
+        if (!current[eventId]) return current;
+        const { [eventId]: _removed, ...next } = current;
+        return next;
+      });
+      if (title.trim() && title.trim() !== "(No title)") {
+        const event = events.find((e) => e.id === eventId);
+        const updates = { title: title.trim() };
+        const guestNotification = event
+          ? await promptGuestNotification({
+              event,
+              action: "update",
+              updates,
+            })
+          : { sendUpdates: "none" as const };
+        if (!guestNotification) return;
+        updateEvent.mutate({ id: eventId, ...updates, ...guestNotification });
+      }
+    },
+    [events, updateDraftEvent, promptGuestNotification, updateEvent],
+  );
+
+  const handleTitleSave = useCallback(
+    async (eventId: string, title: string) => {
+      if (calendarDraftIdFromEventId(eventId)) {
+        updateDraftEvent(eventId, { title });
+        return;
+      }
       const event = events.find((e) => e.id === eventId);
-      const updates = { title: title.trim() };
+      const updates = { title };
       const guestNotification = event
         ? await promptGuestNotification({
             event,
@@ -1108,44 +1254,34 @@ export default function CalendarView() {
         : { sendUpdates: "none" as const };
       if (!guestNotification) return;
       updateEvent.mutate({ id: eventId, ...updates, ...guestNotification });
-    }
-  }
-
-  async function handleTitleSave(eventId: string, title: string) {
-    if (calendarDraftIdFromEventId(eventId)) {
-      updateDraftEvent(eventId, { title });
-      return;
-    }
-    const event = events.find((e) => e.id === eventId);
-    const updates = { title };
-    const guestNotification = event
-      ? await promptGuestNotification({
-          event,
-          action: "update",
-          updates,
-        })
-      : { sendUpdates: "none" as const };
-    if (!guestNotification) return;
-    updateEvent.mutate({ id: eventId, ...updates, ...guestNotification });
-  }
+    },
+    [events, updateDraftEvent, promptGuestNotification, updateEvent],
+  );
 
-  function handleQuickEditCancel(eventId: string) {
-    setQuickEditEventId(null);
-    if (calendarDraftIdFromEventId(eventId)) {
-      discardDraftEvent(eventId);
-      return;
-    }
-    setQuickEditTempIds((current) => {
-      if (!current[eventId]) return current;
-      const { [eventId]: _removed, ...next } = current;
-      return next;
-    });
-    // Delete the event if title was never set
-    const ev = events.find((e) => e.id === eventId);
-    if (!ev || ev.title === "(No title)") {
-      deleteEvent.mutate({ id: eventId, scope: "single", sendUpdates: "none" });
-    }
-  }
+  const handleQuickEditCancel = useCallback(
+    (eventId: string) => {
+      setQuickEditEventId(null);
+      if (calendarDraftIdFromEventId(eventId)) {
+        discardDraftEvent(eventId);
+        return;
+      }
+      setQuickEditTempIds((current) => {
+        if (!current[eventId]) return current;
+        const { [eventId]: _removed, ...next } = current;
+        return next;
+      });
+      // Delete the event if title was never set
+      const ev = events.find((e) => e.id === eventId);
+      if (!ev || ev.title === "(No title)") {
+        deleteEvent.mutate({
+          id: eventId,
+          scope: "single",
+          sendUpdates: "none",
+        });
+      }
+    },
+    [discardDraftEvent, events, deleteEvent],
+  );
 
   // IconKeyboard shortcuts — don't fire when user is typing in an input
   const isTypingInInput = useCallback((e: KeyboardEvent) => {
@@ -1185,19 +1321,51 @@ export default function CalendarView() {
       // `?` / shift+/ opens the keyboard shortcuts help — that listener now
       // lives in AppLayout so it works on every tab. Don't double-handle here.
 
+      // Arrow keys navigate the calendar grid — never steal them from list
+      // navigation inside the command palette or other open dialogs.
+      const isArrowKey =
+        e.key === "ArrowLeft" ||
+        e.key === "ArrowRight" ||
+        e.key === "ArrowUp" ||
+        e.key === "ArrowDown";
+      if (
+        isArrowKey &&
+        (commandPaletteOpen || peopleSearchOpen || addCalendarOpen)
+      ) {
+        return;
+      }
+
       switch (e.key) {
         case "z":
           e.preventDefault();
           runUndo();
           break;
         case "j":
+        case "ArrowRight":
           e.preventDefault();
           handleNavigate("next");
           break;
         case "k":
+        case "ArrowLeft":
           e.preventDefault();
           handleNavigate("prev");
           break;
+        case "ArrowDown":
+          e.preventDefault();
+          setSelectedDate(
+            viewMode === "month"
+              ? addWeeks(selectedDate, 1)
+              : addDays(selectedDate, 1),
+          );
+          break;
+        case "ArrowUp":
+          e.preventDefault();
+          setSelectedDate(
+            viewMode === "month"
+              ? subWeeks(selectedDate, 1)
+              : subDays(selectedDate, 1),
+          );
+          break;
         case "p":
           e.preventDefault();
           setPeopleSearchOpen(true);
@@ -1239,6 +1407,9 @@ export default function CalendarView() {
     sidebarEvent,
     focusedEvent,
     events,
+    commandPaletteOpen,
+    peopleSearchOpen,
+    addCalendarOpen,
   ]);
 
   const headerLabel = (() => {
@@ -1421,14 +1592,6 @@ export default function CalendarView() {
                 </TooltipContent>
               </Tooltip>
 
-              {!isMobile && (
-                <NotificationsBell
-                  browserNotifications
-                  emptyDescription={t(
-                    "calendarView.notificationEmptyDescription",
-                  )}
-                />
-              )}
               <CreateEventPopover
                 open={createDialogOpen}
                 onOpenChange={(open) => {
@@ -1529,6 +1692,10 @@ export default function CalendarView() {
             setEventDraft(null);
             setCreateDialogOpen(true);
           }}
+          onCreateEventFromText={(quickCreate) => {
+            setCommandPaletteOpen(false);
+            void handleCreateEventFromText(quickCreate);
+          }}
           onViewChange={setViewMode}
           onToday={handleToday}
           selectedEvent={selectedEvent}