@agent-native/core 0.0.0-beta-20260819161541 → 0.0.0-beta-20260819172516

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8442
+- template files: 8457

package/corpus/templates/analytics/app/components/agents/FeatureFlagsFleetPanel.tsx

@@ -9,7 +9,7 @@ import {
 } from "@agent-native/core/client/hooks";
 import { useT } from "@agent-native/core/client/i18n";
 import { IconRefresh } from "@tabler/icons-react";
-import { useQueryClient } from "@tanstack/react-query";
+import { type QueryClient, useQueryClient } from "@tanstack/react-query";
 
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
@@ -40,6 +40,51 @@ export interface FlagDirectory {
   apps?: FlagApp[];
 }
 
+interface VerifiedFlagMutation {
+  contractVersion: 3;
+  status: "verified";
+  key: string;
+  rules: FeatureFlagMetadata["rules"];
+  enabledForCurrentUser: boolean;
+}
+
+export function reconcileVerifiedFleetMutation(
+  value: unknown,
+  targetAppId: string,
+  verified: VerifiedFlagMutation,
+): FlagDirectory {
+  const data = asDirectory(value);
+  return {
+    ...data,
+    apps: data.apps?.map((app) =>
+      appId(app) !== targetAppId
+        ? app
+        : {
+            ...app,
+            flags: app.flags?.map((flag) =>
+              flag.key === verified.key
+                ? {
+                    ...flag,
+                    rules: verified.rules,
+                    enabledForCurrentUser: verified.enabledForCurrentUser,
+                  }
+                : flag,
+            ),
+          },
+    ),
+  };
+}
+
+export function recoverFleetMutationFailure(
+  client: QueryClient,
+  context?: { previous: unknown; key: readonly unknown[] },
+) {
+  if (context) client.setQueryData(context.key, context.previous);
+  void client.invalidateQueries({
+    queryKey: ["action", "list-workspace-feature-flags"],
+  });
+}
+
 function asDirectory(value: unknown): FlagDirectory {
   return value && typeof value === "object" ? (value as FlagDirectory) : {};
 }
@@ -76,9 +121,10 @@ export function FeatureFlagsFleetPanel() {
     { retry: false },
   );
   const mutation = useActionMutation<
-    unknown,
+    VerifiedFlagMutation | unknown,
     { appId: string } & SetFeatureFlagInput
   >("set-workspace-feature-flag", {
+    skipActionQueryInvalidation: true,
     onMutate: async (input) => {
       await client.cancelQueries({
         queryKey: ["action", "list-workspace-feature-flags"],
@@ -119,13 +165,25 @@ export function FeatureFlagsFleetPanel() {
       });
       return { previous, key };
     },
-    onError: (_error, _input, context: any) => {
-      if (context) client.setQueryData(context.key, context.previous);
+    onError: (_error, _input, context: any) =>
+      recoverFleetMutationFailure(client, context),
+    onSuccess: (result, input, context: any) => {
+      if (
+        !result ||
+        typeof result !== "object" ||
+        (result as Partial<VerifiedFlagMutation>).contractVersion !== 3 ||
+        (result as Partial<VerifiedFlagMutation>).status !== "verified"
+      ) {
+        void client.invalidateQueries({
+          queryKey: ["action", "list-workspace-feature-flags"],
+        });
+        return;
+      }
+      const verified = result as VerifiedFlagMutation;
+      client.setQueryData(context.key, (old: unknown) =>
+        reconcileVerifiedFleetMutation(old, input.appId, verified),
+      );
     },
-    onSettled: () =>
-      void client.invalidateQueries({
-        queryKey: ["action", "list-workspace-feature-flags"],
-      }),
   });
   const directory = asDirectory(flags.data);
   const apps = directory.apps ?? [];
@@ -134,7 +192,11 @@ export function FeatureFlagsFleetPanel() {
     return (
       <StatusState
         title={t("agents.flagsUnavailable")}
-        detail={flags.error?.message || t("agents.flagsUnreachable")}
+        detail={
+          mutation.error?.message ||
+          flags.error?.message ||
+          t("agents.flagsUnreachable")
+        }
         onRetry={() => void flags.refetch()}
       />
     );
@@ -179,22 +241,19 @@ export function FeatureFlagsFleetPanel() {
           </div>
           {isReady(app) ? (
             <div className="p-4">
+              {mutation.variables?.appId === appId(app) && mutation.error ? (
+                <p className="mb-3 text-sm text-destructive">
+                  {mutation.error.message}
+                </p>
+              ) : null}
               <FeatureFlagsEditor
                 flags={(app.flags ?? []).filter(
                   (flag): flag is FeatureFlagMetadata =>
                     !!flag.rules && typeof flag.defaultValue === "boolean",
                 )}
                 isPending={mutation.isPending}
-                error={
-                  mutation.variables?.appId === appId(app)
-                    ? mutation.error
-                    : null
-                }
-                errorFlagKey={
-                  mutation.variables?.appId === appId(app)
-                    ? mutation.variables.key
-                    : null
-                }
+                error={null}
+                errorFlagKey={null}
                 showHeader={false}
                 onMutate={(input) =>
                   mutation.mutate(qualifyFleetMutation(appId(app), input))

package/corpus/templates/analytics/changelog/2026-08-18-verify-cross-app-feature-flag-changes.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-18
+---
+
+Feature flag changes now preserve actionable failures and verify the target app's persisted state.

package/corpus/templates/analytics/server/lib/workspace-feature-flags.ts

@@ -1,9 +1,11 @@
 import { randomUUID } from "node:crypto";
 
 import { signA2AToken } from "@agent-native/core/a2a";
+import { isFeatureFlagEnabled } from "@agent-native/core/feature-flags";
 import { fetchOrgApps, type OrgApp } from "@agent-native/core/mcp";
 import { getOrgDomain } from "@agent-native/core/org";
 
+import { VERIFIED_FLEET_FLAG_MUTATIONS } from "../../shared/feature-flags.js";
 import type { AnalyticsAdminContext } from "./db-admin-connections.js";
 
 const TARGET_TIMEOUT_MS = 3_000;
@@ -31,7 +33,16 @@ export interface WorkspaceFeatureFlagsResult {
   apps: FleetFlagApp[];
 }
 
-export interface WorkspaceFeatureFlagMutationResult {
+export interface VerifiedWorkspaceFeatureFlagMutationResult {
+  contractVersion: 3;
+  status: "verified";
+  key: string;
+  rules: Record<string, unknown>;
+  scope: { orgId: string | null; orgDomain: string | null };
+  enabledForCurrentUser: boolean;
+}
+
+interface TargetFeatureFlagMutationResult {
   contractVersion: 2;
   status: "ready";
   key: string;
@@ -39,6 +50,10 @@ export interface WorkspaceFeatureFlagMutationResult {
   scope: { orgId: string | null; orgDomain: string | null };
 }
 
+export type WorkspaceFeatureFlagMutationResult =
+  | TargetFeatureFlagMutationResult
+  | VerifiedWorkspaceFeatureFlagMutationResult;
+
 export interface WorkspaceFeatureFlagMutationInput {
   appId: string;
   key: string;
@@ -72,8 +87,8 @@ export function validateWorkspaceFeatureFlagMutation(
     rules?: Record<string, unknown>;
     enabledForEmail?: string;
   },
-): WorkspaceFeatureFlagMutationResult {
-  const payload = body as Partial<WorkspaceFeatureFlagMutationResult> | null;
+): TargetFeatureFlagMutationResult {
+  const payload = body as Partial<TargetFeatureFlagMutationResult> | null;
   const valid =
     payload?.contractVersion === 2 &&
     payload.status === "ready" &&
@@ -144,7 +159,7 @@ export function validateWorkspaceFeatureFlagMutation(
         "The target app did not enable the feature flag for the delegated operator.",
       );
   }
-  return payload as WorkspaceFeatureFlagMutationResult;
+  return payload as TargetFeatureFlagMutationResult;
 }
 
 function targetOrigin(app: OrgApp): string {
@@ -173,6 +188,39 @@ async function delegatedToken(
   }
 }
 
+export type WorkspaceFeatureFlagFailurePhase =
+  | "directory"
+  | "token-generation"
+  | "timeout"
+  | "network"
+  | "authorization"
+  | "unsupported-target"
+  | "target-action"
+  | "persistence"
+  | "verification";
+
+const FAILURE_MESSAGES: Record<WorkspaceFeatureFlagFailurePhase, string> = {
+  directory: "The organization app directory could not resolve this target.",
+  "token-generation":
+    "Analytics could not create delegated feature flag authority.",
+  timeout: "The target app timed out before the feature flag change completed.",
+  network: "Analytics could not reach the target app.",
+  authorization: "The target app denied this delegated flag operation.",
+  "unsupported-target":
+    "The target app does not support feature flag management.",
+  "target-action": "The target app could not complete the feature flag action.",
+  persistence:
+    "The target app did not persist the requested feature flag rules.",
+  verification: "Analytics could not verify the persisted feature flag change.",
+};
+
+export class WorkspaceFeatureFlagFailure extends Error {
+  constructor(readonly phase: WorkspaceFeatureFlagFailurePhase) {
+    super(`[${phase}] ${FAILURE_MESSAGES[phase]}`);
+    this.name = "WorkspaceFeatureFlagFailure";
+  }
+}
+
 type TargetFailureReason = "token-generation" | "timeout" | "network";
 
 class TargetCallFailure extends Error {
@@ -194,6 +242,30 @@ export function classifyWorkspaceFeatureFlagTargetFailure(
   return "network";
 }
 
+function targetFailure(error: unknown): WorkspaceFeatureFlagFailure {
+  const reason = classifyWorkspaceFeatureFlagTargetFailure(error);
+  return new WorkspaceFeatureFlagFailure(reason);
+}
+
+async function resolveTargetApp(
+  admin: AnalyticsAdminContext,
+  appId: string,
+): Promise<OrgApp> {
+  let apps: OrgApp[];
+  try {
+    apps = await fetchOrgApps({
+      selfId: "analytics",
+      includeDirectoryApp: true,
+      serviceOrgId: admin.orgId,
+    });
+  } catch {
+    throw new WorkspaceFeatureFlagFailure("directory");
+  }
+  const app = apps.find((candidate) => candidate.id === appId);
+  if (!app) throw new WorkspaceFeatureFlagFailure("directory");
+  return app;
+}
+
 async function callTarget(
   app: OrgApp,
   admin: AnalyticsAdminContext,
@@ -326,63 +398,139 @@ export async function setWorkspaceFeatureFlag(
   admin: AnalyticsAdminContext,
   input: WorkspaceFeatureFlagMutationInput,
 ): Promise<WorkspaceFeatureFlagMutationResult> {
-  const apps = await fetchOrgApps({
-    selfId: "analytics",
-    includeDirectoryApp: true,
-    serviceOrgId: admin.orgId,
-  });
-  const app = apps.find((candidate) => candidate.id === input.appId);
-  if (!app)
-    throw new Error(
-      "The requested app is not available in this organization directory.",
-    );
+  const app = await resolveTargetApp(admin, input.appId);
   const targetInput = workspaceFeatureFlagTargetInput(input);
   let orgDomain: string | undefined;
   try {
     orgDomain = (await getOrgDomain(admin.orgId))?.trim().toLowerCase();
   } catch {
-    throw new TargetCallFailure("token-generation");
+    throw new WorkspaceFeatureFlagFailure("token-generation");
+  }
+  if (!orgDomain) throw new WorkspaceFeatureFlagFailure("token-generation");
+  let result: Awaited<ReturnType<typeof callTarget>>;
+  try {
+    result = await callTarget(
+      app,
+      admin,
+      "set-feature-flag",
+      targetInput,
+      orgDomain,
+    );
+  } catch (error) {
+    throw targetFailure(error);
   }
-  if (!orgDomain) throw new TargetCallFailure("token-generation");
-  const result = await callTarget(
-    app,
-    admin,
-    "set-feature-flag",
-    targetInput,
-    orgDomain,
-  );
   if (result.status === 401 || result.status === 403)
-    throw new Error("The target app denied this delegated flag operation.");
+    throw new WorkspaceFeatureFlagFailure("authorization");
   if (result.status === 404 || result.status === 405)
-    throw new Error("The target app does not support feature flag management.");
+    throw new WorkspaceFeatureFlagFailure("unsupported-target");
   if (result.status < 200 || result.status >= 300)
-    throw new Error(
-      "The target app could not persist the feature flag change.",
-    );
-  return validateWorkspaceFeatureFlagMutation(result.body, {
-    key: input.key,
-    orgDomain,
-    allowExplicitNoOrgTarget: true,
-    ...(input.operation === "replace-rules" && input.rules
-      ? {
-          rules: {
-            mode: input.rules.mode,
-            emails: input.rules.emails ?? [],
-            orgIds: input.rules.orgIds ?? [],
-            percentage: input.rules.percentage ?? 0,
-          },
-        }
-      : input.operation === "off"
+    throw new WorkspaceFeatureFlagFailure("target-action");
+  let mutation: TargetFeatureFlagMutationResult;
+  try {
+    mutation = validateWorkspaceFeatureFlagMutation(result.body, {
+      key: input.key,
+      orgDomain,
+      allowExplicitNoOrgTarget: true,
+      ...(input.operation === "replace-rules" && input.rules
         ? {
             rules: {
-              mode: "off",
-              emails: [],
-              orgIds: [],
-              percentage: 0,
+              mode: input.rules.mode,
+              emails: input.rules.emails ?? [],
+              orgIds: input.rules.orgIds ?? [],
+              percentage: input.rules.percentage ?? 0,
             },
           }
-        : { enabledForEmail: admin.userEmail }),
-  });
+        : input.operation === "off"
+          ? {
+              rules: {
+                mode: "off",
+                emails: [],
+                orgIds: [],
+                percentage: 0,
+              },
+            }
+          : { enabledForEmail: admin.userEmail }),
+    });
+  } catch {
+    throw new WorkspaceFeatureFlagFailure("persistence");
+  }
+
+  if (
+    !(await isFeatureFlagEnabled(VERIFIED_FLEET_FLAG_MUTATIONS, {
+      userEmail: admin.userEmail,
+      userKey: admin.userEmail,
+      orgId: admin.orgId,
+    }))
+  ) {
+    return mutation;
+  }
+
+  let readBack: Awaited<ReturnType<typeof callTarget>>;
+  try {
+    readBack = await callTarget(
+      app,
+      admin,
+      "list-feature-flags",
+      {},
+      orgDomain,
+    );
+  } catch (error) {
+    throw targetFailure(error);
+  }
+  if (readBack.status === 401 || readBack.status === 403)
+    throw new WorkspaceFeatureFlagFailure("authorization");
+  if (readBack.status === 404 || readBack.status === 405)
+    throw new WorkspaceFeatureFlagFailure("unsupported-target");
+  if (readBack.status < 200 || readBack.status >= 300)
+    throw new WorkspaceFeatureFlagFailure("verification");
+  const verifiedApp = classifyWorkspaceFeatureFlagList(app, readBack);
+  if (verifiedApp.state === "forbidden")
+    throw new WorkspaceFeatureFlagFailure("authorization");
+  if (verifiedApp.state === "unsupported")
+    throw new WorkspaceFeatureFlagFailure("unsupported-target");
+  const verifiedFlag = verifiedApp.flags.find((flag) => flag.key === input.key);
+  const expectedEnabled =
+    input.operation === "enable-for-current-user"
+      ? true
+      : input.operation === "off"
+        ? false
+        : null;
+  if (
+    verifiedApp.state !== "ready" ||
+    !verifiedFlag ||
+    typeof verifiedFlag.enabledForCurrentUser !== "boolean" ||
+    (expectedEnabled !== null &&
+      verifiedFlag.enabledForCurrentUser !== expectedEnabled)
+  ) {
+    throw new WorkspaceFeatureFlagFailure("verification");
+  }
+  try {
+    validateWorkspaceFeatureFlagMutation(
+      {
+        contractVersion: 2,
+        status: "ready",
+        key: input.key,
+        rules: verifiedFlag.rules,
+        scope: mutation.scope,
+      },
+      {
+        key: input.key,
+        orgDomain,
+        allowExplicitNoOrgTarget: true,
+        rules: mutation.rules,
+      },
+    );
+  } catch {
+    throw new WorkspaceFeatureFlagFailure("verification");
+  }
+  return {
+    contractVersion: 3,
+    status: "verified",
+    key: mutation.key,
+    rules: verifiedFlag.rules as Record<string, unknown>,
+    scope: mutation.scope,
+    enabledForCurrentUser: verifiedFlag.enabledForCurrentUser,
+  };
 }
 
 export async function getWorkspaceFlagTarget(

package/corpus/templates/analytics/server/plugins/feature-flags.ts

@@ -0,0 +1,5 @@
+import { createFeatureFlagsPlugin } from "@agent-native/core/server";
+
+import { ANALYTICS_FEATURE_FLAGS } from "../../shared/feature-flags.js";
+
+export default createFeatureFlagsPlugin({ flags: ANALYTICS_FEATURE_FLAGS });

package/corpus/templates/analytics/shared/feature-flags.ts

@@ -0,0 +1,10 @@
+import { defineFeatureFlag } from "@agent-native/core/feature-flags/registry";
+
+export const VERIFIED_FLEET_FLAG_MUTATIONS = defineFeatureFlag({
+  key: "analytics.verified-fleet-flag-mutations",
+  displayName: "Verified fleet flag mutations",
+  description:
+    "Verify cross-app feature flag changes with an independent target read-back.",
+});
+
+export const ANALYTICS_FEATURE_FLAGS = [VERIFIED_FLEET_FLAG_MUTATIONS];

package/corpus/templates/calendar/app/components/calendar/CreateEventDialog.tsx

@@ -27,6 +27,7 @@ import {
   ReminderControls,
 } from "@/components/calendar/EventOptionControls";
 import { FindTimeTakeover } from "@/components/calendar/FindTimePanel";
+import { RepeatPicker } from "@/components/calendar/InlineEventPickers";
 import { TimezoneCombobox } from "@/components/TimezoneCombobox";
 import { Button } from "@/components/ui/button";
 import {
@@ -71,6 +72,7 @@ import { getGoogleEventColorHex } from "@/lib/event-colors";
 import { buildEventFormInitializationKey } from "@/lib/event-form-initialization";
 import {
   attachmentsToDrafts,
+  buildCustomRecurrenceRules,
   buildRecurrenceRules,
   buildReminderPayload,
   createAttachmentDraft,
@@ -78,9 +80,11 @@ import {
   dateTimeInTimezoneToIso,
   getEventEndValidationMessage,
   getRecurrencePreset,
+  parseCustomRecurrence,
   remindersToDraftState,
   resolveEventTimezone,
   type AttachmentDraft,
+  type CustomRecurrenceDraft,
   type RecurrencePreset,
   type ReminderDraft,
   type ReminderMode,
@@ -270,6 +274,10 @@ export function CreateEventPopover({
   const [visibility, setVisibility] = useState<Visibility>("default");
   const [recurrencePreset, setRecurrencePreset] =
     useState<RecurrencePreset>("none");
+  const [customRecurrence, setCustomRecurrence] =
+    useState<CustomRecurrenceDraft>(() =>
+      parseCustomRecurrence(undefined, defaultDateStr),
+    );
   const [timezone, setTimezone] = useState(defaultTimezone);
   const [colorId, setColorId] = useState<string | undefined>();
   const [reminderMode, setReminderMode] = useState<ReminderMode>("default");
@@ -377,6 +385,9 @@ export function CreateEventPopover({
       setAvailability(draft.transparency ?? "opaque");
       setVisibility(draft.visibility ?? "default");
       setRecurrencePreset(getRecurrencePreset(draft.recurrence));
+      setCustomRecurrence(
+        parseCustomRecurrence(draft.recurrence, draft.start || nextDate),
+      );
       setTimezone(draftTimezone);
       setColorId(draft.colorId);
       setReminderMode(reminderState.mode);
@@ -416,6 +427,7 @@ export function CreateEventPopover({
     setAvailability("opaque");
     setVisibility("default");
     setRecurrencePreset("none");
+    setCustomRecurrence(parseCustomRecurrence(undefined, nextDate));
     setTimezone(defaultTimezone);
     setColorId(undefined);
     setReminderMode("default");
@@ -478,11 +490,14 @@ export function CreateEventPopover({
         : dateTimeInTimezoneToIso(endDate, endTime, eventTimezone);
     const attachmentResult = validateAttachmentDrafts(attachments);
     const reminderPatch = buildReminderPayload(reminderMode, reminders);
-    const recurrence = buildRecurrenceRules(
-      recurrencePreset,
-      effectiveAllDay ? date : startValue,
-      eventTimezone,
-    );
+    const recurrence =
+      recurrencePreset === "custom"
+        ? buildCustomRecurrenceRules(customRecurrence)
+        : buildRecurrenceRules(
+            recurrencePreset,
+            effectiveAllDay ? date : startValue,
+            eventTimezone,
+          );
     const nextDraft: CalendarEventDraft = {
       id: draftId,
       createdAt: draft?.createdAt,
@@ -569,6 +584,7 @@ export function CreateEventPopover({
     availability,
     visibility,
     recurrencePreset,
+    customRecurrence,
     eventTimezone,
     colorId,
     reminderMode,
@@ -767,11 +783,14 @@ export function CreateEventPopover({
       ...trailingAttendees,
     ]);
     const reminderPatch = buildReminderPayload(reminderMode, reminders);
-    const recurrence = buildRecurrenceRules(
-      recurrencePreset,
-      effectiveAllDay ? date : startValue,
-      eventTimezone,
-    );
+    const recurrence =
+      recurrencePreset === "custom"
+        ? buildCustomRecurrenceRules(customRecurrence)
+        : buildRecurrenceRules(
+            recurrencePreset,
+            effectiveAllDay ? date : startValue,
+            eventTimezone,
+          );
     const statusPatch =
       eventType === "default"
         ? {}
@@ -1435,44 +1454,14 @@ export function CreateEventPopover({
                   <Label htmlFor="event-recurrence" className="text-xs">
                     {t("eventForm.repeats")}
                   </Label>
-                  <Select
-                    value={recurrencePreset}
-                    onValueChange={(value) =>
-                      setRecurrencePreset(value as RecurrencePreset)
+                  <RepeatPicker
+                    preset={recurrencePreset}
+                    referenceDate={
+                      effectiveAllDay ? date : currentStartISO || date
                     }
-                  >
-                    <SelectTrigger
-                      id="event-recurrence"
-                      className="h-8 text-sm"
-                    >
-                      <SelectValue />
-                    </SelectTrigger>
-                    <SelectContent>
-                      <SelectItem value="none">
-                        {t("eventForm.doesNotRepeat")}
-                      </SelectItem>
-                      <SelectItem value="daily">
-                        {t("eventForm.daily")}
-                      </SelectItem>
-                      <SelectItem value="weekdays">
-                        {t("eventForm.everyWeekday")}
-                      </SelectItem>
-                      <SelectItem value="weekly">
-                        {t("eventForm.weekly")}
-                      </SelectItem>
-                      <SelectItem value="monthly">
-                        {t("eventForm.monthly")}
-                      </SelectItem>
-                      <SelectItem value="yearly">
-                        {t("eventForm.yearly")}
-                      </SelectItem>
-                      {recurrencePreset === "custom" && (
-                        <SelectItem value="custom" disabled>
-                          {t("eventForm.customSchedule")}
-                        </SelectItem>
-                      )}
-                    </SelectContent>
-                  </Select>
+                    onChange={setRecurrencePreset}
+                    onCustomChange={setCustomRecurrence}
+                  />
                 </div>
 
                 {(!allDay || isOutOfOffice) && (

package/corpus/templates/calendar/app/components/calendar/DayView.tsx

@@ -441,6 +441,7 @@ const DayEventCard = memo(function DayEventCard({
       onDelete={onDeleteEvent}
       isDraft={isDraft}
       defaultOpen={defaultOpen}
+      popoverSide="bottom"
       onTitleSave={onQuickEditSave}
       onDismissNew={onQuickEditCancel}
       onDraftUpdate={onDraftUpdate}
@@ -810,6 +811,7 @@ export const DayView = memo(function DayView({
                       onDelete={onDeleteEvent}
                       isDraft={draftEventIds.includes(event.id)}
                       defaultOpen={quickEditEventId === event.id}
+                      popoverSide="bottom"
                       onTitleSave={onQuickEditSave}
                       onDismissNew={onQuickEditCancel}
                       onDraftUpdate={onDraftUpdate}
@@ -887,6 +889,7 @@ export const DayView = memo(function DayView({
                       onDelete={onDeleteEvent}
                       isDraft={draftEventIds.includes(event.id)}
                       defaultOpen={quickEditEventId === event.id}
+                      popoverSide="bottom"
                       onTitleSave={onQuickEditSave}
                       onDismissNew={onQuickEditCancel}
                       onDraftUpdate={onDraftUpdate}