`424b004`

Add local recurring events

Authored by

espadonne 2 weeks ago

SHA: 424b0042eb9202f4d2d34cd7f836a43c11a124c9
Parents: eb06be2
Tree: d774907

4 changed files

Status	File	+	-
M	`src/agenda.rs`	1475	31
M	`src/app.rs`	708	13
M	`src/cli.rs`	46	19
M	`src/tui.rs`	130	2

src/agenda.rsmodified

1742 lines changed — click to load

+     }
+ }
 -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
  pub struct EventDateTime {
      pub date: CalendarDate,
      pub time: Time,
+     }
+ }
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum RecurrenceFrequency {
 +    Daily,
 +    Weekly,
 +    Monthly,
 +    Yearly,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum RecurrenceEnd {
 +    Never,
 +    Until(CalendarDate),
 +    Count(u32),
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum RecurrenceOrdinal {
 +    Number(u8),
 +    Last,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum RecurrenceMonthlyRule {
 +    DayOfMonth(u8),
 +    WeekdayOrdinal {
 +        ordinal: RecurrenceOrdinal,
 +        weekday: Weekday,
 +    },
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum RecurrenceYearlyRule {
 +    Date {
 +        month: Month,
 +        day: u8,
 +    },
 +    WeekdayOrdinal {
 +        month: Month,
 +        ordinal: RecurrenceOrdinal,
 +        weekday: Weekday,
 +    },
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct RecurrenceRule {
 +    pub frequency: RecurrenceFrequency,
 +    pub interval: u16,
 +    pub end: RecurrenceEnd,
 +    pub weekdays: Vec<Weekday>,
 +    pub monthly: Option<RecurrenceMonthlyRule>,
 +    pub yearly: Option<RecurrenceYearlyRule>,
 +}
++
 +impl RecurrenceRule {
 +    pub fn new(frequency: RecurrenceFrequency) -> Self {
 +        Self {
 +            frequency,
 +            interval: 1,
 +            end: RecurrenceEnd::Never,
 +            weekdays: Vec::new(),
 +            monthly: None,
 +            yearly: None,
 +        }
 +    }
++
 +    pub fn with_interval(mut self, interval: u16) -> Self {
 +        self.interval = interval.max(1);
 +        self
 +    }
++
 +    pub fn interval(&self) -> u16 {
 +        self.interval.max(1)
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 +pub enum OccurrenceAnchor {
 +    AllDay { date: CalendarDate },
 +    Timed { start: EventDateTime },
 +}
++
 +impl OccurrenceAnchor {
 +    pub const fn date(self) -> CalendarDate {
 +        match self {
 +            Self::AllDay { date } => date,
 +            Self::Timed { start } => start.date,
 +        }
 +    }
++
 +    fn storage_key(self) -> String {
 +        match self {
 +            Self::AllDay { date } => format!("{date}"),
 +            Self::Timed { start } => {
 +                format!("{}T{}", start.date, format_time(start.time))
 +            }
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct OccurrenceMetadata {
 +    pub series_id: String,
 +    pub anchor: OccurrenceAnchor,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct OccurrenceOverride {
 +    pub anchor: OccurrenceAnchor,
 +    pub draft: CreateEventDraft,
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct Event {
      pub id: String,
      pub reminders: Vec<Reminder>,
      pub source: SourceMetadata,
      pub timing: EventTiming,
 +    pub recurrence: Option<RecurrenceRule>,
 +    pub occurrence: Option<OccurrenceMetadata>,
 +    pub occurrence_overrides: Vec<OccurrenceOverride>,
+ }
  impl Event {
              reminders: Vec::new(),
              source,
              timing: EventTiming::AllDay { date },
 +            recurrence: None,
 +            occurrence: None,
 +            occurrence_overrides: Vec::new(),
+         }
+     }
              reminders: Vec::new(),
              source,
              timing: EventTiming::Timed { start, end },
 +            recurrence: None,
 +            occurrence: None,
 +            occurrence_overrides: Vec::new(),
          })
+     }
          self
+     }
 +    pub fn with_recurrence(mut self, recurrence: RecurrenceRule) -> Self {
 +        self.recurrence = Some(recurrence);
 +        self
 +    }
++
      pub const fn is_all_day(&self) -> bool {
          self.timing.is_all_day()
+     }
          self.source.source_id == "local"
+     }
 +    pub const fn is_recurring_series(&self) -> bool {
 +        self.recurrence.is_some()
 +    }
++
 +    pub const fn occurrence(&self) -> Option<&OccurrenceMetadata> {
 +        self.occurrence.as_ref()
 +    }
++
      pub fn intersects_range(&self, range: DateRange) -> bool {
          match self.timing {
              EventTiming::AllDay { date } => range.contains_date(date),
      pub location: Option<String>,
      pub notes: Option<String>,
      pub reminders: Vec<Reminder>,
 +    pub recurrence: Option<RecurrenceRule>,
+ }
  impl CreateEventDraft {
          event.location = self.location;
          event.notes = self.notes;
          event.reminders = self.reminders;
 +        event.recurrence = self.recurrence;
          Ok(event)
+     }
++
 +    fn without_recurrence(mut self) -> Self {
 +        self.recurrence = None;
 +        self
 +    }
+ }
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
      fn events_intersecting(&self, range: DateRange) -> Vec<Event>;
      fn holidays_in(&self, range: DateRange) -> Vec<Holiday>;
++
 +    fn local_event_by_id(&self, _id: &str) -> Option<Event> {
 +        None
 +    }
+ }
  #[derive(Debug)]
              return Err(LocalEventStoreError::EventNotEditable { id: id.to_string() });
+         }
 -        let event =
 +        let mut event =
              draft
                  .into_event(id.to_string())
                  .map_err(|err| LocalEventStoreError::Encode {
                      path: self.events_file.clone(),
                      reason: err.to_string(),
                  })?;
 +        let existing_overrides = std::mem::take(&mut events[index].occurrence_overrides);
 +        event.occurrence_overrides = existing_overrides
 +            .into_iter()
 +            .filter(|override_record| event_generates_anchor(&event, override_record.anchor))
 +            .collect();
          events[index] = event.clone();
          if let Some(path) = &self.events_file {
          Ok(event)
+     }
 +    pub fn update_occurrence(
 +        &mut self,
 +        series_id: &str,
 +        anchor: OccurrenceAnchor,
 +        draft: CreateEventDraft,
 +    ) -> Result<Event, LocalEventStoreError> {
 +        let mut events = self.events.events().to_vec();
 +        let Some(index) = events.iter().position(|event| event.id == series_id) else {
 +            return Err(LocalEventStoreError::EventNotFound {
 +                id: series_id.to_string(),
 +            });
 +        };
 +        if !events[index].is_local() || !events[index].is_recurring_series() {
 +            return Err(LocalEventStoreError::EventNotEditable {
 +                id: series_id.to_string(),
 +            });
 +        }
 +        if !event_generates_anchor(&events[index], anchor) {
 +            return Err(LocalEventStoreError::OccurrenceNotFound {
 +                id: series_id.to_string(),
 +                anchor: anchor.storage_key(),
 +            });
 +        }
++
 +        let override_record = OccurrenceOverride {
 +            anchor,
 +            draft: draft.without_recurrence(),
 +        };
 +        if let Some(existing) = events[index]
 +            .occurrence_overrides
 +            .iter_mut()
 +            .find(|existing| existing.anchor == anchor)
 +        {
 +            *existing = override_record;
 +        } else {
 +            events[index].occurrence_overrides.push(override_record);
 +        }
++
 +        let event = occurrence_override_event(&events[index], anchor).ok_or_else(|| {
 +            LocalEventStoreError::OccurrenceNotFound {
 +                id: series_id.to_string(),
 +                anchor: anchor.storage_key(),
 +            }
 +        })?;
++
 +        if let Some(path) = &self.events_file {
 +            write_events_file(path, &events)?;
 +        }
 +        self.events.events = events;
 +        Ok(event)
 +    }
++
      fn next_local_event_id(&self, title: &str) -> String {
          let now = SystemTime::now()
              .duration_since(UNIX_EPOCH)
      fn holidays_in(&self, range: DateRange) -> Vec<Holiday> {
          self.holidays.holidays_in(range)
+     }
++
 +    fn local_event_by_id(&self, id: &str) -> Option<Event> {
 +        self.events.local_event_by_id(id)
 +    }
+ }
  #[derive(Debug)]
  impl AgendaSource for InMemoryAgendaSource {
      fn events_intersecting(&self, range: DateRange) -> Vec<Event> {
 -        self.events
 +        let mut events = self
 +            .events
              .iter()
 -            .filter(|event| event.intersects_range(range))
 -            .cloned()
 -            .collect()
 +            .flat_map(|event| events_intersecting_range(event, range))
 +            .collect::<Vec<_>>();
 +        events.sort_by(|left, right| {
 +            event_sort_key(left)
 +                .cmp(&event_sort_key(right))
 +                .then(left.id.cmp(&right.id))
 +        });
 +        events
+     }
      fn holidays_in(&self, range: DateRange) -> Vec<Holiday> {
              .cloned()
              .collect()
+     }
++
 +    fn local_event_by_id(&self, id: &str) -> Option<Event> {
 +        self.events
 +            .iter()
 +            .find(|event| event.id == id && event.is_local())
 +            .cloned()
 +    }
 +}
++
 +fn events_intersecting_range(event: &Event, range: DateRange) -> Vec<Event> {
 +    if event.recurrence.is_none() {
 +        return event
 +            .intersects_range(range)
 +            .then(|| event.clone())
 +            .into_iter()
 +            .collect();
 +    }
++
 +    expand_recurring_event(event, range)
 +        .into_iter()
 +        .filter(|event| event.intersects_range(range))
 +        .collect()
 +}
++
 +fn expand_recurring_event(event: &Event, range: DateRange) -> Vec<Event> {
 +    let Some(recurrence) = &event.recurrence else {
 +        return Vec::new();
 +    };
 +    let Some(start_date) = event_start_date(event) else {
 +        return Vec::new();
 +    };
++
 +    let mut events = Vec::new();
 +    let final_date = range.end.add_days(-1);
 +    let mut date = start_date;
 +    let mut generated_count = 0_u32;
++
 +    while date <= final_date {
 +        if let RecurrenceEnd::Until(until) = recurrence.end
 +            && date > until
 +        {
 +            break;
 +        }
++
 +        if recurs_on_date(date, start_date, recurrence) {
 +            generated_count = generated_count.saturating_add(1);
 +            if let RecurrenceEnd::Count(max_count) = recurrence.end
 +                && generated_count > max_count
 +            {
 +                break;
 +            }
++
 +            let anchor = occurrence_anchor_for_date(event, date);
 +            let instance = occurrence_override_event(event, anchor)
 +                .unwrap_or_else(|| generated_occurrence_event(event, anchor));
 +            events.push(instance);
 +        }
++
 +        date = date.add_days(1);
 +    }
++
 +    events
 +}
++
 +fn event_generates_anchor(event: &Event, anchor: OccurrenceAnchor) -> bool {
 +    let Some(recurrence) = &event.recurrence else {
 +        return false;
 +    };
 +    let Some(start_date) = event_start_date(event) else {
 +        return false;
 +    };
 +    if anchor.date() < start_date || !recurs_on_date(anchor.date(), start_date, recurrence) {
 +        return false;
 +    }
 +    if !anchor_is_within_recurrence_end(anchor.date(), start_date, recurrence) {
 +        return false;
 +    }
 +    occurrence_anchor_for_date(event, anchor.date()) == anchor
 +}
++
 +fn anchor_is_within_recurrence_end(
 +    anchor_date: CalendarDate,
 +    start_date: CalendarDate,
 +    recurrence: &RecurrenceRule,
 +) -> bool {
 +    if let RecurrenceEnd::Until(until) = recurrence.end
 +        && anchor_date > until
 +    {
 +        return false;
 +    }
++
 +    if let RecurrenceEnd::Count(max_count) = recurrence.end {
 +        let mut count = 0_u32;
 +        let mut date = start_date;
 +        while date <= anchor_date {
 +            if recurs_on_date(date, start_date, recurrence) {
 +                count = count.saturating_add(1);
 +            }
 +            date = date.add_days(1);
 +        }
 +        return count <= max_count;
 +    }
++
 +    true
 +}
++
 +fn occurrence_override_event(series: &Event, anchor: OccurrenceAnchor) -> Option<Event> {
 +    let override_record = series
 +        .occurrence_overrides
 +        .iter()
 +        .find(|override_record| override_record.anchor == anchor)?;
 +    occurrence_event_from_draft(series, anchor, override_record.draft.clone()).ok()
 +}
++
 +fn generated_occurrence_event(series: &Event, anchor: OccurrenceAnchor) -> Event {
 +    let mut event = series.clone();
 +    event.id = occurrence_event_id(series, anchor);
 +    event.timing = occurrence_timing(series, anchor);
 +    event.occurrence = Some(OccurrenceMetadata {
 +        series_id: series.id.clone(),
 +        anchor,
 +    });
 +    event.recurrence = None;
 +    event.occurrence_overrides = Vec::new();
 +    event
 +}
++
 +fn occurrence_event_from_draft(
 +    series: &Event,
 +    anchor: OccurrenceAnchor,
 +    draft: CreateEventDraft,
 +) -> Result<Event, AgendaError> {
 +    let mut event = draft
 +        .without_recurrence()
 +        .into_event(occurrence_event_id(series, anchor))?;
 +    event.source = series.source.clone();
 +    event.occurrence = Some(OccurrenceMetadata {
 +        series_id: series.id.clone(),
 +        anchor,
 +    });
 +    Ok(event)
 +}
++
 +fn occurrence_event_id(series: &Event, anchor: OccurrenceAnchor) -> String {
 +    format!("{}#{}", series.id, anchor.storage_key())
 +}
++
 +fn occurrence_anchor_for_date(event: &Event, date: CalendarDate) -> OccurrenceAnchor {
 +    match event.timing {
 +        EventTiming::AllDay { .. } => OccurrenceAnchor::AllDay { date },
 +        EventTiming::Timed { start, .. } => OccurrenceAnchor::Timed {
 +            start: EventDateTime::new(date, start.time),
 +        },
 +    }
 +}
++
 +fn occurrence_timing(event: &Event, anchor: OccurrenceAnchor) -> EventTiming {
 +    match (event.timing, anchor) {
 +        (EventTiming::AllDay { .. }, OccurrenceAnchor::AllDay { date }) => {
 +            EventTiming::AllDay { date }
 +        }
 +        (
 +            EventTiming::Timed { start, end },
 +            OccurrenceAnchor::Timed {
 +                start: anchor_start,
 +            },
 +        ) => {
 +            let duration_minutes = datetime_distance_minutes(start, end);
 +            EventTiming::Timed {
 +                start: anchor_start,
 +                end: add_minutes(anchor_start, duration_minutes),
 +            }
 +        }
 +        _ => event.timing,
 +    }
 +}
++
 +fn event_start_date(event: &Event) -> Option<CalendarDate> {
 +    match event.timing {
 +        EventTiming::AllDay { date } => Some(date),
 +        EventTiming::Timed { start, .. } => Some(start.date),
 +    }
 +}
++
 +fn recurs_on_date(date: CalendarDate, start_date: CalendarDate, rule: &RecurrenceRule) -> bool {
 +    if date < start_date {
 +        return false;
 +    }
++
 +    match rule.frequency {
 +        RecurrenceFrequency::Daily => {
 +            days_between(start_date, date) % i32::from(rule.interval()) == 0
 +        }
 +        RecurrenceFrequency::Weekly => {
 +            let days = days_between(start_date, date);
 +            let week_index = days / 7;
 +            let weekdays = recurrence_weekdays(rule, start_date);
 +            week_index % i32::from(rule.interval()) == 0 && weekdays.contains(&date.weekday())
 +        }
 +        RecurrenceFrequency::Monthly => {
 +            let months = months_between(start_date, date);
 +            if months < 0 || months % i32::from(rule.interval()) != 0 {
 +                return false;
 +            }
 +            let monthly = rule
 +                .monthly
 +                .unwrap_or(RecurrenceMonthlyRule::DayOfMonth(start_date.day()));
 +            match monthly {
 +                RecurrenceMonthlyRule::DayOfMonth(day) => {
 +                    CalendarDate::from_ymd(date.year(), date.month(), day).ok() == Some(date)
 +                }
 +                RecurrenceMonthlyRule::WeekdayOrdinal { ordinal, weekday } => {
 +                    weekday_ordinal_date(date.year(), date.month(), ordinal, weekday) == Some(date)
 +                }
 +            }
 +        }
 +        RecurrenceFrequency::Yearly => {
 +            let years = date.year() - start_date.year();
 +            if years < 0 || years % i32::from(rule.interval()) != 0 {
 +                return false;
 +            }
 +            let yearly = rule.yearly.unwrap_or(RecurrenceYearlyRule::Date {
 +                month: start_date.month(),
 +                day: start_date.day(),
 +            });
 +            match yearly {
 +                RecurrenceYearlyRule::Date { month, day } => {
 +                    CalendarDate::from_ymd(date.year(), month, day).ok() == Some(date)
 +                }
 +                RecurrenceYearlyRule::WeekdayOrdinal {
 +                    month,
 +                    ordinal,
 +                    weekday,
 +                } => {
 +                    date.month() == month
 +                        && weekday_ordinal_date(date.year(), month, ordinal, weekday) == Some(date)
 +                }
 +            }
 +        }
 +    }
 +}
++
 +fn recurrence_weekdays(rule: &RecurrenceRule, start_date: CalendarDate) -> Vec<Weekday> {
 +    if rule.weekdays.is_empty() {
 +        vec![start_date.weekday()]
 +    } else {
 +        rule.weekdays.clone()
 +    }
 +}
++
 +fn weekday_ordinal_date(
 +    year: i32,
 +    month: Month,
 +    ordinal: RecurrenceOrdinal,
 +    weekday: Weekday,
 +) -> Option<CalendarDate> {
 +    match ordinal {
 +        RecurrenceOrdinal::Number(number) if (1..=4).contains(&number) => {
 +            let first = CalendarDate::from_ymd(year, month, 1).ok()?;
 +            let first_weekday = first.weekday().number_days_from_sunday();
 +            let target_weekday = weekday.number_days_from_sunday();
 +            let offset = (target_weekday + 7 - first_weekday) % 7;
 +            let day = 1 + offset + (number - 1) * 7;
 +            CalendarDate::from_ymd(year, month, day).ok()
 +        }
 +        RecurrenceOrdinal::Last => {
 +            let mut date = CalendarDate::from_ymd(year, month, month.length(year)).ok()?;
 +            while date.weekday() != weekday {
 +                date = date.add_days(-1);
 +            }
 +            Some(date)
 +        }
 +        _ => None,
 +    }
 +}
++
 +pub fn recurrence_ordinal_for_date(date: CalendarDate) -> RecurrenceOrdinal {
 +    if date.day().saturating_add(7) > date.month().length(date.year()) {
 +        RecurrenceOrdinal::Last
 +    } else {
 +        RecurrenceOrdinal::Number(((date.day() - 1) / 7) + 1)
 +    }
 +}
++
 +fn days_between(start: CalendarDate, end: CalendarDate) -> i32 {
 +    end.inner().to_julian_day() - start.inner().to_julian_day()
 +}
++
 +fn months_between(start: CalendarDate, end: CalendarDate) -> i32 {
 +    (end.year() - start.year()) * 12 + i32::from(u8::from(end.month()))
 +        - i32::from(u8::from(start.month()))
 +}
++
 +fn datetime_distance_minutes(start: EventDateTime, end: EventDateTime) -> i32 {
 +    days_between(start.date, end.date) * 24 * 60 + time_minutes(end.time) - time_minutes(start.time)
 +}
++
 +fn add_minutes(start: EventDateTime, duration_minutes: i32) -> EventDateTime {
 +    let absolute_minutes = time_minutes(start.time) + duration_minutes;
 +    let day_offset = absolute_minutes.div_euclid(24 * 60);
 +    let minute_of_day = absolute_minutes.rem_euclid(24 * 60);
 +    EventDateTime::new(
 +        start.date.add_days(day_offset),
 +        Time::from_hms(
 +            u8::try_from(minute_of_day / 60).expect("hour stays in range"),
 +            u8::try_from(minute_of_day % 60).expect("minute stays in range"),
 +            0,
 +        )
 +        .expect("computed time is valid"),
 +    )
 +}
++
 +fn time_minutes(time: Time) -> i32 {
 +    i32::from(time.hour()) * 60 + i32::from(time.minute())
 +}
++
 +fn event_sort_key(event: &Event) -> (CalendarDate, DayMinute, String) {
 +    match event.timing {
 +        EventTiming::AllDay { date } => (date, DayMinute::START, event.title.clone()),
 +        EventTiming::Timed { start, .. } => (
 +            start.date,
 +            DayMinute::from_time(start.time),
 +            event.title.clone(),
 +        ),
 +    }
+ }
  pub fn default_events_file() -> PathBuf {
      EventNotFound {
          id: String,
      },
 +    OccurrenceNotFound {
 +        id: String,
 +        anchor: String,
 +    },
      EventNotEditable {
          id: String,
      },
                  path.display()
              ),
              Self::EventNotFound { id } => write!(f, "local event '{id}' was not found"),
 +            Self::OccurrenceNotFound { id, anchor } => {
 +                write!(
 +                    f,
 +                    "recurring occurrence '{anchor}' was not found for local event '{id}'"
 +                )
 +            }
              Self::EventNotEditable { id } => write!(f, "event '{id}' is not editable locally"),
              Self::Encode { path, reason } => {
                  if let Some(path) = path {
+         }
      })?;
 -    if file.version != LOCAL_EVENTS_VERSION {
 +    if !matches!(file.version, 1 | LOCAL_EVENTS_VERSION) {
          return Err(LocalEventStoreError::UnsupportedVersion {
              path: path.to_path_buf(),
              version: file.version,
      })
+ }
 -const LOCAL_EVENTS_VERSION: u8 = 1;
 +const LOCAL_EVENTS_VERSION: u8 = 2;
  #[derive(Debug, Serialize, Deserialize)]
  struct LocalEventsFile {
          notes: Option<String>,
          #[serde(default, skip_serializing_if = "Vec::is_empty")]
          reminders_minutes_before: Vec<u16>,
 +        #[serde(default, skip_serializing_if = "Option::is_none")]
 +        recurrence: Option<LocalRecurrenceRecord>,
 +        #[serde(default, skip_serializing_if = "Vec::is_empty")]
 +        overrides: Vec<LocalOccurrenceOverrideRecord>,
      },
      AllDay {
          id: String,
          notes: Option<String>,
          #[serde(default, skip_serializing_if = "Vec::is_empty")]
          reminders_minutes_before: Vec<u16>,
 +        #[serde(default, skip_serializing_if = "Option::is_none")]
 +        recurrence: Option<LocalRecurrenceRecord>,
 +        #[serde(default, skip_serializing_if = "Vec::is_empty")]
 +        overrides: Vec<LocalOccurrenceOverrideRecord>,
      },
+ }
              .iter()
              .map(|reminder| reminder.minutes_before)
              .collect::<Vec<_>>();
 +        let recurrence = event
 +            .recurrence
 +            .as_ref()
 +            .map(LocalRecurrenceRecord::from_rule);
 +        let overrides = event
 +            .occurrence_overrides
 +            .iter()
 +            .map(LocalOccurrenceOverrideRecord::from_override)
 +            .collect::<Vec<_>>();
          match event.timing {
              EventTiming::AllDay { date } => Self::AllDay {
                  location: event.location.clone(),
                  notes: event.notes.clone(),
                  reminders_minutes_before,
 +                recurrence,
 +                overrides,
              },
              EventTiming::Timed { start, end } => Self::Timed {
                  id: event.id.clone(),
                  location: event.location.clone(),
                  notes: event.notes.clone(),
                  reminders_minutes_before,
 +                recurrence,
 +                overrides,
              },
+         }
+     }
                  location,
                  notes,
                  reminders_minutes_before,
 +                recurrence,
 +                overrides,
              } => {
                  let start = EventDateTime::new(
                      parse_local_date(&start_date, path)?,
                  event.location = empty_to_none(location);
                  event.notes = empty_to_none(notes);
                  event.reminders = reminders_from_minutes(reminders_minutes_before);
 +                event.recurrence = recurrence
 +                    .map(|recurrence| recurrence.into_rule(path))
 +                    .transpose()?;
 +                event.occurrence_overrides = overrides
 +                    .into_iter()
 +                    .map(|override_record| override_record.into_override(path))
 +                    .collect::<Result<Vec<_>, _>>()?;
                  Ok(event)
+             }
              Self::AllDay {
                  location,
                  notes,
                  reminders_minutes_before,
 +                recurrence,
 +                overrides,
              } => {
                  let mut event = Event::all_day(
                      id.clone(),
                  event.location = empty_to_none(location);
                  event.notes = empty_to_none(notes);
                  event.reminders = reminders_from_minutes(reminders_minutes_before);
 +                event.recurrence = recurrence
 +                    .map(|recurrence| recurrence.into_rule(path))
 +                    .transpose()?;
 +                event.occurrence_overrides = overrides
 +                    .into_iter()
 +                    .map(|override_record| override_record.into_override(path))
 +                    .collect::<Result<Vec<_>, _>>()?;
                  Ok(event)
+             }
+         }
+     }
+ }
 -fn reminders_from_minutes(minutes: Vec<u16>) -> Vec<Reminder> {
 -    let mut reminders = minutes
 -        .into_iter()
 -        .map(Reminder::minutes_before)
 -        .collect::<Vec<_>>();
 -    reminders.sort();
 -    reminders.dedup();
 -    reminders
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +struct LocalRecurrenceRecord {
 +    frequency: String,
 +    interval: u16,
 +    #[serde(default)]
 +    weekdays: Vec<String>,
 +    #[serde(default, skip_serializing_if = "Option::is_none")]
 +    monthly: Option<LocalRecurrenceMonthlyRecord>,
 +    #[serde(default, skip_serializing_if = "Option::is_none")]
 +    yearly: Option<LocalRecurrenceYearlyRecord>,
 +    end: LocalRecurrenceEndRecord,
+ }
 -fn empty_to_none(value: Option<String>) -> Option<String> {
 -    value.and_then(|value| {
 -        let trimmed = value.trim();
 -        if trimmed.is_empty() {
 -            None
 -        } else {
 -            Some(trimmed.to_string())
 +impl LocalRecurrenceRecord {
 +    fn from_rule(rule: &RecurrenceRule) -> Self {
 +        Self {
 +            frequency: match rule.frequency {
 +                RecurrenceFrequency::Daily => "daily",
 +                RecurrenceFrequency::Weekly => "weekly",
 +                RecurrenceFrequency::Monthly => "monthly",
 +                RecurrenceFrequency::Yearly => "yearly",
 +            }
 +            .to_string(),
 +            interval: rule.interval(),
 +            weekdays: rule
 +                .weekdays
 +                .iter()
 +                .map(|weekday| weekday_name(*weekday))
 +                .collect(),
 +            monthly: rule.monthly.map(LocalRecurrenceMonthlyRecord::from_rule),
 +            yearly: rule.yearly.map(LocalRecurrenceYearlyRecord::from_rule),
 +            end: LocalRecurrenceEndRecord::from_rule(rule.end),
+         }
 -    })
 +    }
++
 +    fn into_rule(self, path: &Path) -> Result<RecurrenceRule, LocalEventStoreError> {
 +        let frequency = match self.frequency.as_str() {
 +            "daily" => RecurrenceFrequency::Daily,
 +            "weekly" => RecurrenceFrequency::Weekly,
 +            "monthly" => RecurrenceFrequency::Monthly,
 +            "yearly" => RecurrenceFrequency::Yearly,
 +            value => {
 +                return Err(LocalEventStoreError::Parse {
 +                    path: path.to_path_buf(),
 +                    reason: format!("invalid recurrence frequency '{value}'"),
 +                });
 +            }
 +        };
 +        let weekdays = self
 +            .weekdays
 +            .into_iter()
 +            .map(|weekday| parse_weekday_record(&weekday, path))
 +            .collect::<Result<Vec<_>, _>>()?;
++
 +        Ok(RecurrenceRule {
 +            frequency,
 +            interval: self.interval.max(1),
 +            end: self.end.into_rule(path)?,
 +            weekdays,
 +            monthly: self
 +                .monthly
 +                .map(|monthly| monthly.into_rule(path))
 +                .transpose()?,
 +            yearly: self
 +                .yearly
 +                .map(|yearly| yearly.into_rule(path))
 +                .transpose()?,
 +        })
 +    }
+ }
 -fn parse_local_date(value: &str, path: &Path) -> Result<CalendarDate, LocalEventStoreError> {
 -    parse_iso_date(value).ok_or_else(|| LocalEventStoreError::Parse {
 -        path: path.to_path_buf(),
 -        reason: format!("invalid date '{value}'"),
 -    })
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "mode", rename_all = "snake_case")]
 +enum LocalRecurrenceEndRecord {
 +    Never,
 +    Until { date: String },
 +    Count { count: u32 },
+ }
 -fn parse_local_time(value: &str, path: &Path) -> Result<Time, LocalEventStoreError> {
 +impl LocalRecurrenceEndRecord {
 +    fn from_rule(end: RecurrenceEnd) -> Self {
 +        match end {
 +            RecurrenceEnd::Never => Self::Never,
 +            RecurrenceEnd::Until(date) => Self::Until {
 +                date: date.to_string(),
 +            },
 +            RecurrenceEnd::Count(count) => Self::Count { count },
 +        }
 +    }
++
 +    fn into_rule(self, path: &Path) -> Result<RecurrenceEnd, LocalEventStoreError> {
 +        match self {
 +            Self::Never => Ok(RecurrenceEnd::Never),
 +            Self::Until { date } => Ok(RecurrenceEnd::Until(parse_local_date(&date, path)?)),
 +            Self::Count { count } => Ok(RecurrenceEnd::Count(count.max(1))),
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 +#[serde(tag = "mode", rename_all = "snake_case")]
 +enum LocalRecurrenceMonthlyRecord {
 +    DayOfMonth {
 +        day: u8,
 +    },
 +    WeekdayOrdinal {
 +        ordinal: LocalRecurrenceOrdinalRecord,
 +        weekday: LocalWeekdayRecord,
 +    },
 +}
++
 +impl LocalRecurrenceMonthlyRecord {
 +    fn from_rule(rule: RecurrenceMonthlyRule) -> Self {
 +        match rule {
 +            RecurrenceMonthlyRule::DayOfMonth(day) => Self::DayOfMonth { day },
 +            RecurrenceMonthlyRule::WeekdayOrdinal { ordinal, weekday } => Self::WeekdayOrdinal {
 +                ordinal: LocalRecurrenceOrdinalRecord::from_rule(ordinal),
 +                weekday: LocalWeekdayRecord::from_weekday(weekday),
 +            },
 +        }
 +    }
++
 +    fn into_rule(self, _path: &Path) -> Result<RecurrenceMonthlyRule, LocalEventStoreError> {
 +        Ok(match self {
 +            Self::DayOfMonth { day } => RecurrenceMonthlyRule::DayOfMonth(day),
 +            Self::WeekdayOrdinal { ordinal, weekday } => RecurrenceMonthlyRule::WeekdayOrdinal {
 +                ordinal: ordinal.into_rule(),
 +                weekday: weekday.into_weekday(),
 +            },
 +        })
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 +#[serde(tag = "mode", rename_all = "snake_case")]
 +enum LocalRecurrenceYearlyRecord {
 +    Date {
 +        month: u8,
 +        day: u8,
 +    },
 +    WeekdayOrdinal {
 +        month: u8,
 +        ordinal: LocalRecurrenceOrdinalRecord,
 +        weekday: LocalWeekdayRecord,
 +    },
 +}
++
 +impl LocalRecurrenceYearlyRecord {
 +    fn from_rule(rule: RecurrenceYearlyRule) -> Self {
 +        match rule {
 +            RecurrenceYearlyRule::Date { month, day } => Self::Date {
 +                month: u8::from(month),
 +                day,
 +            },
 +            RecurrenceYearlyRule::WeekdayOrdinal {
 +                month,
 +                ordinal,
 +                weekday,
 +            } => Self::WeekdayOrdinal {
 +                month: u8::from(month),
 +                ordinal: LocalRecurrenceOrdinalRecord::from_rule(ordinal),
 +                weekday: LocalWeekdayRecord::from_weekday(weekday),
 +            },
 +        }
 +    }
++
 +    fn into_rule(self, path: &Path) -> Result<RecurrenceYearlyRule, LocalEventStoreError> {
 +        Ok(match self {
 +            Self::Date { month, day } => RecurrenceYearlyRule::Date {
 +                month: parse_month_record(month, path)?,
 +                day,
 +            },
 +            Self::WeekdayOrdinal {
 +                month,
 +                ordinal,
 +                weekday,
 +            } => RecurrenceYearlyRule::WeekdayOrdinal {
 +                month: parse_month_record(month, path)?,
 +                ordinal: ordinal.into_rule(),
 +                weekday: weekday.into_weekday(),
 +            },
 +        })
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 +#[serde(rename_all = "snake_case")]
 +enum LocalRecurrenceOrdinalRecord {
 +    First,
 +    Second,
 +    Third,
 +    Fourth,
 +    Last,
 +}
++
 +impl LocalRecurrenceOrdinalRecord {
 +    fn from_rule(ordinal: RecurrenceOrdinal) -> Self {
 +        match ordinal {
 +            RecurrenceOrdinal::Number(1) => Self::First,
 +            RecurrenceOrdinal::Number(2) => Self::Second,
 +            RecurrenceOrdinal::Number(3) => Self::Third,
 +            RecurrenceOrdinal::Number(4) => Self::Fourth,
 +            RecurrenceOrdinal::Last | RecurrenceOrdinal::Number(_) => Self::Last,
 +        }
 +    }
++
 +    const fn into_rule(self) -> RecurrenceOrdinal {
 +        match self {
 +            Self::First => RecurrenceOrdinal::Number(1),
 +            Self::Second => RecurrenceOrdinal::Number(2),
 +            Self::Third => RecurrenceOrdinal::Number(3),
 +            Self::Fourth => RecurrenceOrdinal::Number(4),
 +            Self::Last => RecurrenceOrdinal::Last,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 +#[serde(rename_all = "snake_case")]
 +enum LocalWeekdayRecord {
 +    Sunday,
 +    Monday,
 +    Tuesday,
 +    Wednesday,
 +    Thursday,
 +    Friday,
 +    Saturday,
 +}
++
 +impl LocalWeekdayRecord {
 +    const fn from_weekday(weekday: Weekday) -> Self {
 +        match weekday {
 +            Weekday::Sunday => Self::Sunday,
 +            Weekday::Monday => Self::Monday,
 +            Weekday::Tuesday => Self::Tuesday,
 +            Weekday::Wednesday => Self::Wednesday,
 +            Weekday::Thursday => Self::Thursday,
 +            Weekday::Friday => Self::Friday,
 +            Weekday::Saturday => Self::Saturday,
 +        }
 +    }
++
 +    const fn into_weekday(self) -> Weekday {
 +        match self {
 +            Self::Sunday => Weekday::Sunday,
 +            Self::Monday => Weekday::Monday,
 +            Self::Tuesday => Weekday::Tuesday,
 +            Self::Wednesday => Weekday::Wednesday,
 +            Self::Thursday => Weekday::Thursday,
 +            Self::Friday => Weekday::Friday,
 +            Self::Saturday => Weekday::Saturday,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +struct LocalOccurrenceOverrideRecord {
 +    anchor: LocalOccurrenceAnchorRecord,
 +    event: LocalEventDraftRecord,
 +}
++
 +impl LocalOccurrenceOverrideRecord {
 +    fn from_override(override_record: &OccurrenceOverride) -> Self {
 +        Self {
 +            anchor: LocalOccurrenceAnchorRecord::from_anchor(override_record.anchor),
 +            event: LocalEventDraftRecord::from_draft(&override_record.draft),
 +        }
 +    }
++
 +    fn into_override(self, path: &Path) -> Result<OccurrenceOverride, LocalEventStoreError> {
 +        Ok(OccurrenceOverride {
 +            anchor: self.anchor.into_anchor(path)?,
 +            draft: self.event.into_draft(path)?,
 +        })
 +    }
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "kind", rename_all = "snake_case")]
 +enum LocalOccurrenceAnchorRecord {
 +    AllDay { date: String },
 +    Timed { date: String, time: String },
 +}
++
 +impl LocalOccurrenceAnchorRecord {
 +    fn from_anchor(anchor: OccurrenceAnchor) -> Self {
 +        match anchor {
 +            OccurrenceAnchor::AllDay { date } => Self::AllDay {
 +                date: date.to_string(),
 +            },
 +            OccurrenceAnchor::Timed { start } => Self::Timed {
 +                date: start.date.to_string(),
 +                time: format_time(start.time),
 +            },
 +        }
 +    }
++
 +    fn into_anchor(self, path: &Path) -> Result<OccurrenceAnchor, LocalEventStoreError> {
 +        Ok(match self {
 +            Self::AllDay { date } => OccurrenceAnchor::AllDay {
 +                date: parse_local_date(&date, path)?,
 +            },
 +            Self::Timed { date, time } => OccurrenceAnchor::Timed {
 +                start: EventDateTime::new(
 +                    parse_local_date(&date, path)?,
 +                    parse_local_time(&time, path)?,
 +                ),
 +            },
 +        })
 +    }
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "timing", rename_all = "snake_case")]
 +enum LocalEventDraftRecord {
 +    Timed {
 +        title: String,
 +        start_date: String,
 +        start_time: String,
 +        end_date: String,
 +        end_time: String,
 +        #[serde(default, skip_serializing_if = "Option::is_none")]
 +        location: Option<String>,
 +        #[serde(default, skip_serializing_if = "Option::is_none")]
 +        notes: Option<String>,
 +        #[serde(default, skip_serializing_if = "Vec::is_empty")]
 +        reminders_minutes_before: Vec<u16>,
 +    },
 +    AllDay {
 +        title: String,
 +        date: String,
 +        #[serde(default, skip_serializing_if = "Option::is_none")]
 +        location: Option<String>,
 +        #[serde(default, skip_serializing_if = "Option::is_none")]
 +        notes: Option<String>,
 +        #[serde(default, skip_serializing_if = "Vec::is_empty")]
 +        reminders_minutes_before: Vec<u16>,
 +    },
 +}
++
 +impl LocalEventDraftRecord {
 +    fn from_draft(draft: &CreateEventDraft) -> Self {
 +        let reminders_minutes_before = draft
 +            .reminders
 +            .iter()
 +            .map(|reminder| reminder.minutes_before)
 +            .collect::<Vec<_>>();
 +        match draft.timing {
 +            CreateEventTiming::Timed { start, end } => Self::Timed {
 +                title: draft.title.clone(),
 +                start_date: start.date.to_string(),
 +                start_time: format_time(start.time),
 +                end_date: end.date.to_string(),
 +                end_time: format_time(end.time),
 +                location: draft.location.clone(),
 +                notes: draft.notes.clone(),
 +                reminders_minutes_before,
 +            },
 +            CreateEventTiming::AllDay { date } => Self::AllDay {
 +                title: draft.title.clone(),
 +                date: date.to_string(),
 +                location: draft.location.clone(),
 +                notes: draft.notes.clone(),
 +                reminders_minutes_before,
 +            },
 +        }
 +    }
++
 +    fn into_draft(self, path: &Path) -> Result<CreateEventDraft, LocalEventStoreError> {
 +        Ok(match self {
 +            Self::Timed {
 +                title,
 +                start_date,
 +                start_time,
 +                end_date,
 +                end_time,
 +                location,
 +                notes,
 +                reminders_minutes_before,
 +            } => {
 +                let start = EventDateTime::new(
 +                    parse_local_date(&start_date, path)?,
 +                    parse_local_time(&start_time, path)?,
 +                );
 +                let end = EventDateTime::new(
 +                    parse_local_date(&end_date, path)?,
 +                    parse_local_time(&end_time, path)?,
 +                );
 +                if start >= end {
 +                    return Err(LocalEventStoreError::Parse {
 +                        path: path.to_path_buf(),
 +                        reason: format!(
 +                            "invalid override range: start {start:?} must be before end {end:?}"
 +                        ),
 +                    });
 +                }
++
 +                CreateEventDraft {
 +                    title,
 +                    timing: CreateEventTiming::Timed { start, end },
 +                    location: empty_to_none(location),
 +                    notes: empty_to_none(notes),
 +                    reminders: reminders_from_minutes(reminders_minutes_before),
 +                    recurrence: None,
 +                }
 +            }
 +            Self::AllDay {
 +                title,
 +                date,
 +                location,
 +                notes,
 +                reminders_minutes_before,
 +            } => CreateEventDraft {
 +                title,
 +                timing: CreateEventTiming::AllDay {
 +                    date: parse_local_date(&date, path)?,
 +                },
 +                location: empty_to_none(location),
 +                notes: empty_to_none(notes),
 +                reminders: reminders_from_minutes(reminders_minutes_before),
 +                recurrence: None,
 +            },
 +        })
 +    }
 +}
++
 +fn reminders_from_minutes(minutes: Vec<u16>) -> Vec<Reminder> {
 +    let mut reminders = minutes
 +        .into_iter()
 +        .map(Reminder::minutes_before)
 +        .collect::<Vec<_>>();
 +    reminders.sort();
 +    reminders.dedup();
 +    reminders
 +}
++
 +fn empty_to_none(value: Option<String>) -> Option<String> {
 +    value.and_then(|value| {
 +        let trimmed = value.trim();
 +        if trimmed.is_empty() {
 +            None
 +        } else {
 +            Some(trimmed.to_string())
 +        }
 +    })
 +}
++
 +fn weekday_name(weekday: Weekday) -> String {
 +    match weekday {
 +        Weekday::Sunday => "sunday",
 +        Weekday::Monday => "monday",
 +        Weekday::Tuesday => "tuesday",
 +        Weekday::Wednesday => "wednesday",
 +        Weekday::Thursday => "thursday",
 +        Weekday::Friday => "friday",
 +        Weekday::Saturday => "saturday",
 +    }
 +    .to_string()
 +}
++
 +fn parse_weekday_record(value: &str, path: &Path) -> Result<Weekday, LocalEventStoreError> {
 +    match value {
 +        "sunday" => Ok(Weekday::Sunday),
 +        "monday" => Ok(Weekday::Monday),
 +        "tuesday" => Ok(Weekday::Tuesday),
 +        "wednesday" => Ok(Weekday::Wednesday),
 +        "thursday" => Ok(Weekday::Thursday),
 +        "friday" => Ok(Weekday::Friday),
 +        "saturday" => Ok(Weekday::Saturday),
 +        _ => Err(LocalEventStoreError::Parse {
 +            path: path.to_path_buf(),
 +            reason: format!("invalid weekday '{value}'"),
 +        }),
 +    }
 +}
++
 +fn parse_month_record(value: u8, path: &Path) -> Result<Month, LocalEventStoreError> {
 +    Month::try_from(value).map_err(|_| LocalEventStoreError::Parse {
 +        path: path.to_path_buf(),
 +        reason: format!("invalid month '{value}'"),
 +    })
 +}
++
 +fn parse_local_date(value: &str, path: &Path) -> Result<CalendarDate, LocalEventStoreError> {
 +    parse_iso_date(value).ok_or_else(|| LocalEventStoreError::Parse {
 +        path: path.to_path_buf(),
 +        reason: format!("invalid date '{value}'"),
 +    })
 +}
++
 +fn parse_local_time(value: &str, path: &Path) -> Result<Time, LocalEventStoreError> {
      parse_hhmm_time(value).ok_or_else(|| LocalEventStoreError::Parse {
          path: path.to_path_buf(),
          reason: format!("invalid time '{value}'"),
          assert!(!range.contains_date(day.add_days(1)));
+     }
 +    #[test]
 +    fn daily_recurrence_expands_with_interval_and_count() {
 +        let start = date_ymd(2026, Month::April, 1);
 +        let event = Event::all_day("daily", "Every other day", start, source()).with_recurrence(
 +            RecurrenceRule {
 +                frequency: RecurrenceFrequency::Daily,
 +                interval: 2,
 +                end: RecurrenceEnd::Count(3),
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: None,
 +            },
 +        );
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
 +        let range = DateRange::new(start, date_ymd(2026, Month::April, 10)).expect("valid range");
++
 +        let dates = source
 +            .events_intersecting(range)
 +            .into_iter()
 +            .filter_map(|event| event.timing.date())
 +            .collect::<Vec<_>>();
++
 +        assert_eq!(dates, [date_ymd(2026, Month::April, 1), date(3), date(5)]);
 +    }
++
 +    #[test]
 +    fn weekly_recurrence_supports_multiple_days_and_interval() {
 +        let start = date_ymd(2026, Month::April, 5);
 +        let event =
 +            Event::all_day("weekly", "Workout", start, source()).with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Weekly,
 +                interval: 2,
 +                end: RecurrenceEnd::Never,
 +                weekdays: vec![Weekday::Sunday, Weekday::Tuesday],
 +                monthly: None,
 +                yearly: None,
 +            });
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
 +        let range = DateRange::new(start, date_ymd(2026, Month::April, 23)).expect("valid range");
++
 +        let dates = source
 +            .events_intersecting(range)
 +            .into_iter()
 +            .filter_map(|event| event.timing.date())
 +            .collect::<Vec<_>>();
++
 +        assert_eq!(dates, [date(5), date(7), date(19), date(21)]);
 +    }
++
 +    #[test]
 +    fn monthly_recurrence_skips_invalid_day_of_month_dates() {
 +        let start = date_ymd(2026, Month::January, 31);
 +        let event = Event::all_day("month-day", "Month end", start, source()).with_recurrence(
 +            RecurrenceRule {
 +                frequency: RecurrenceFrequency::Monthly,
 +                interval: 1,
 +                end: RecurrenceEnd::Never,
 +                weekdays: Vec::new(),
 +                monthly: Some(RecurrenceMonthlyRule::DayOfMonth(31)),
 +                yearly: None,
 +            },
 +        );
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
 +        let range = DateRange::new(start, date_ymd(2026, Month::April, 1)).expect("valid range");
++
 +        let dates = source
 +            .events_intersecting(range)
 +            .into_iter()
 +            .filter_map(|event| event.timing.date())
 +            .collect::<Vec<_>>();
++
 +        assert_eq!(dates, [start, date_ymd(2026, Month::March, 31)]);
 +    }
++
 +    #[test]
 +    fn monthly_recurrence_supports_last_weekday_rules() {
 +        let start = date_ymd(2026, Month::April, 30);
 +        let event = Event::all_day("last-thursday", "Review", start, source()).with_recurrence(
 +            RecurrenceRule {
 +                frequency: RecurrenceFrequency::Monthly,
 +                interval: 1,
 +                end: RecurrenceEnd::Count(3),
 +                weekdays: Vec::new(),
 +                monthly: Some(RecurrenceMonthlyRule::WeekdayOrdinal {
 +                    ordinal: RecurrenceOrdinal::Last,
 +                    weekday: Weekday::Thursday,
 +                }),
 +                yearly: None,
 +            },
 +        );
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
 +        let range = DateRange::new(start, date_ymd(2026, Month::July, 1)).expect("valid range");
++
 +        let dates = source
 +            .events_intersecting(range)
 +            .into_iter()
 +            .filter_map(|event| event.timing.date())
 +            .collect::<Vec<_>>();
++
 +        assert_eq!(
 +            dates,
 +            [
 +                date_ymd(2026, Month::April, 30),
 +                date_ymd(2026, Month::May, 28),
 +                date_ymd(2026, Month::June, 25)
 +            ]
 +        );
 +    }
++
 +    #[test]
 +    fn yearly_recurrence_skips_invalid_dates_and_supports_weekday_ordinal() {
 +        let leap_day = date_ymd(2024, Month::February, 29);
 +        let leap =
 +            Event::all_day("leap", "Leap", leap_day, source()).with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Yearly,
 +                interval: 1,
 +                end: RecurrenceEnd::Never,
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: Some(RecurrenceYearlyRule::Date {
 +                    month: Month::February,
 +                    day: 29,
 +                }),
 +            });
 +        let thanksgiving = Event::all_day(
 +            "thanksgiving",
 +            "Thanksgiving",
 +            date_ymd(2026, Month::November, 26),
 +            source(),
 +        )
 +        .with_recurrence(RecurrenceRule {
 +            frequency: RecurrenceFrequency::Yearly,
 +            interval: 1,
 +            end: RecurrenceEnd::Count(2),
 +            weekdays: Vec::new(),
 +            monthly: None,
 +            yearly: Some(RecurrenceYearlyRule::WeekdayOrdinal {
 +                month: Month::November,
 +                ordinal: RecurrenceOrdinal::Number(4),
 +                weekday: Weekday::Thursday,
 +            }),
 +        });
 +        let source =
 +            InMemoryAgendaSource::with_events_and_holidays(vec![leap, thanksgiving], Vec::new());
 +        let range = DateRange::new(
 +            date_ymd(2024, Month::January, 1),
 +            date_ymd(2029, Month::January, 1),
 +        )
 +        .expect("valid range");
++
 +        let ids_and_dates = source
 +            .events_intersecting(range)
 +            .into_iter()
 +            .map(|event| (event.id, event.timing.date().expect("all-day date")))
 +            .collect::<Vec<_>>();
++
 +        assert!(ids_and_dates.contains(&("leap#2024-02-29".to_string(), leap_day)));
 +        assert!(ids_and_dates.contains(&(
 +            "leap#2028-02-29".to_string(),
 +            date_ymd(2028, Month::February, 29)
 +        )));
 +        assert!(
 +            !ids_and_dates
 +                .iter()
 +                .any(|(_, date)| *date == date_ymd(2025, Month::February, 28))
 +        );
 +        assert!(ids_and_dates.contains(&(
 +            "thanksgiving#2026-11-26".to_string(),
 +            date_ymd(2026, Month::November, 26)
 +        )));
 +        assert!(ids_and_dates.contains(&(
 +            "thanksgiving#2027-11-25".to_string(),
 +            date_ymd(2027, Month::November, 25)
 +        )));
 +    }
++
 +    #[test]
 +    fn recurring_cross_midnight_events_intersect_each_visible_day() {
 +        let start = date(23);
 +        let event = Event::timed(
 +            "late",
 +            "Late shift",
 +            at(start, 23, 0),
 +            at(start.add_days(1), 1, 0),
 +            source(),
 +        )
 +        .expect("valid recurring event")
 +        .with_recurrence(RecurrenceRule {
 +            frequency: RecurrenceFrequency::Daily,
 +            interval: 1,
 +            end: RecurrenceEnd::Count(2),
 +            weekdays: Vec::new(),
 +            monthly: None,
 +            yearly: None,
 +        });
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
++
 +        let agenda = DayAgenda::from_source(start.add_days(1), &source);
++
 +        assert_eq!(agenda.timed_events.len(), 2);
 +        assert!(agenda.timed_events[0].starts_before_day);
 +        assert_eq!(agenda.timed_events[0].visible_end.as_minutes(), 60);
 +        assert_eq!(agenda.timed_events[1].visible_start.as_minutes(), 23 * 60);
 +        assert!(agenda.timed_events[1].ends_after_day);
 +    }
++
      #[test]
      fn invalid_ranges_are_rejected() {
          let day = date(23);
                  location: Some("War room".to_string()),
                  notes: Some("Bring notes".to_string()),
                  reminders: vec![Reminder::minutes_before(10), Reminder::minutes_before(60)],
 +                recurrence: None,
              })
              .expect("timed event saves");
          source
                  location: None,
                  notes: None,
                  reminders: vec![Reminder::minutes_before(24 * 60)],
 +                recurrence: None,
              })
              .expect("all-day event saves");
          let body = std::fs::read_to_string(&path).expect("event file exists");
 -        assert!(body.contains(r#""version": 1"#));
 +        assert!(body.contains(r#""version": 2"#));
          assert!(body.contains(r#""reminders_minutes_before""#));
          let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
                  location: None,
                  notes: None,
                  reminders: Vec::new(),
 +                recurrence: None,
              })
              .expect("event saves");
                      location: Some("Room 2".to_string()),
                      notes: Some("Moved".to_string()),
                      reminders: vec![Reminder::minutes_before(5)],
 +                    recurrence: None,
                  },
+             )
              .expect("event updates");
          assert_eq!(agenda.all_day_events[0].location.as_deref(), Some("Room 2"));
+     }
 +    #[test]
 +    fn local_event_store_loads_version_one_and_rewrites_version_two_on_save() {
 +        let path = temp_events_path("version-one");
 +        let _ = std::fs::remove_dir_all(path.parent().expect("path has parent"));
 +        std::fs::create_dir_all(path.parent().expect("path has parent"))
 +            .expect("parent can be created");
 +        std::fs::write(
 +            &path,
 +            r#"{
 +  "version": 1,
 +  "events": [
 +    {
 +      "id": "old",
 +      "title": "Old file",
 +      "date": "2026-04-23"
 +    }
 +  ]
 +}"#,
 +        )
 +        .expect("file can be written");
 +        let mut source = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("version one file loads");
++
 +        source
 +            .update_event(
 +                "old",
 +                CreateEventDraft {
 +                    title: "Rewritten".to_string(),
 +                    timing: CreateEventTiming::AllDay { date: date(23) },
 +                    location: None,
 +                    notes: None,
 +                    reminders: Vec::new(),
 +                    recurrence: None,
 +                },
 +            )
 +            .expect("event update saves");
++
 +        let body = std::fs::read_to_string(&path).expect("event file exists");
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert!(body.contains(r#""version": 2"#));
 +        assert!(body.contains("Rewritten"));
 +    }
++
 +    #[test]
 +    fn local_event_store_saves_recurring_series_and_occurrence_overrides() {
 +        let path = temp_events_path("recurring-overrides");
 +        let _ = std::fs::remove_dir_all(path.parent().expect("path has parent"));
 +        let day = date(23);
 +        let mut source = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("missing event file is empty");
 +        let event = source
 +            .create_event(CreateEventDraft {
 +                title: "Standup".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(day, 9, 0),
 +                    end: at(day, 9, 30),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: Vec::new(),
 +                recurrence: Some(RecurrenceRule {
 +                    frequency: RecurrenceFrequency::Daily,
 +                    interval: 1,
 +                    end: RecurrenceEnd::Count(3),
 +                    weekdays: Vec::new(),
 +                    monthly: None,
 +                    yearly: None,
 +                }),
 +            })
 +            .expect("recurring event saves");
 +        let anchor = OccurrenceAnchor::Timed {
 +            start: at(day.add_days(1), 9, 0),
 +        };
++
 +        source
 +            .update_occurrence(
 +                &event.id,
 +                anchor,
 +                CreateEventDraft {
 +                    title: "Moved standup".to_string(),
 +                    timing: CreateEventTiming::Timed {
 +                        start: at(day.add_days(1), 10, 0),
 +                        end: at(day.add_days(1), 10, 30),
 +                    },
 +                    location: Some("Room 2".to_string()),
 +                    notes: None,
 +                    reminders: vec![Reminder::minutes_before(5)],
 +                    recurrence: None,
 +                },
 +            )
 +            .expect("occurrence override saves");
++
 +        let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("saved file reloads");
 +        let agenda = DayAgenda::from_source(day.add_days(1), &reloaded);
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert_eq!(agenda.timed_events.len(), 1);
 +        let overridden = &agenda.timed_events[0].event;
 +        assert_eq!(overridden.title, "Moved standup");
 +        assert_eq!(overridden.location.as_deref(), Some("Room 2"));
 +        assert_eq!(
 +            overridden.occurrence().map(|occurrence| occurrence.anchor),
 +            Some(anchor)
 +        );
 +    }
++
 +    #[test]
 +    fn series_edits_drop_overrides_whose_anchor_no_longer_generates() {
 +        let path = temp_events_path("series-edit-overrides");
 +        let _ = std::fs::remove_dir_all(path.parent().expect("path has parent"));
 +        let day = date(23);
 +        let mut source = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("missing event file is empty");
 +        let event = source
 +            .create_event(CreateEventDraft {
 +                title: "Standup".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(day, 9, 0),
 +                    end: at(day, 9, 30),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: Vec::new(),
 +                recurrence: Some(RecurrenceRule {
 +                    frequency: RecurrenceFrequency::Daily,
 +                    interval: 1,
 +                    end: RecurrenceEnd::Count(3),
 +                    weekdays: Vec::new(),
 +                    monthly: None,
 +                    yearly: None,
 +                }),
 +            })
 +            .expect("recurring event saves");
 +        let anchor = OccurrenceAnchor::Timed {
 +            start: at(day.add_days(1), 9, 0),
 +        };
 +        source
 +            .update_occurrence(
 +                &event.id,
 +                anchor,
 +                CreateEventDraft {
 +                    title: "Override".to_string(),
 +                    timing: CreateEventTiming::Timed {
 +                        start: at(day.add_days(1), 10, 0),
 +                        end: at(day.add_days(1), 10, 30),
 +                    },
 +                    location: None,
 +                    notes: None,
 +                    reminders: Vec::new(),
 +                    recurrence: None,
 +                },
 +            )
 +            .expect("override saves");
++
 +        let updated = source
 +            .update_event(
 +                &event.id,
 +                CreateEventDraft {
 +                    title: "Standup".to_string(),
 +                    timing: CreateEventTiming::Timed {
 +                        start: at(day, 9, 0),
 +                        end: at(day, 9, 30),
 +                    },
 +                    location: None,
 +                    notes: None,
 +                    reminders: Vec::new(),
 +                    recurrence: Some(RecurrenceRule {
 +                        frequency: RecurrenceFrequency::Weekly,
 +                        interval: 1,
 +                        end: RecurrenceEnd::Never,
 +                        weekdays: vec![day.weekday()],
 +                        monthly: None,
 +                        yearly: None,
 +                    }),
 +                },
 +            )
 +            .expect("series update saves");
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert!(updated.occurrence_overrides.is_empty());
 +    }
++
      #[test]
      fn local_event_store_rejects_missing_and_non_local_updates() {
          let day = date(23);
              location: None,
              notes: None,
              reminders: Vec::new(),
 +            recurrence: None,
          };
          assert!(matches!(

src/app.rsmodified

  use crate::{
      agenda::{
          AgendaSource, CreateEventDraft, CreateEventTiming, DayAgenda, Event, EventDateTime,
 -        EventTiming, Reminder,
 +        EventTiming, OccurrenceAnchor, RecurrenceEnd, RecurrenceFrequency, RecurrenceMonthlyRule,
 +        RecurrenceRule, RecurrenceYearlyRule, Reminder, recurrence_ordinal_for_date,
      },
      calendar::{CalendarDate, CalendarMonth, DAYS_PER_WEEK},
  };
      today: CalendarDate,
      view_mode: ViewMode,
      create_form: Option<CreateEventForm>,
 +    recurrence_choice: Option<RecurrenceEditChoice>,
      selected_day_event_id: Option<String>,
      should_quit: bool,
+ }
              today,
              view_mode: ViewMode::Month,
              create_form: None,
 +            recurrence_choice: None,
              selected_day_event_id: None,
              should_quit: false,
+         }
          self.create_form.as_ref()
+     }
 +    pub const fn recurrence_choice(&self) -> Option<&RecurrenceEditChoice> {
 +        self.recurrence_choice.as_ref()
 +    }
++
      pub fn selected_day_event_id(&self) -> Option<&str> {
          self.selected_day_event_id.as_deref()
+     }
          self.create_form.is_some()
+     }
 +    pub const fn is_choosing_recurring_edit(&self) -> bool {
 +        self.recurrence_choice.is_some()
 +    }
++
      pub fn close_create_form(&mut self) {
          self.create_form = None;
+     }
 +    pub fn close_recurrence_choice(&mut self) {
 +        self.recurrence_choice = None;
 +    }
++
      pub fn set_create_form_error(&mut self, message: impl Into<String>) {
          if let Some(form) = &mut self.create_form {
              form.error = Some(message.into());
          form.handle_key(key)
+     }
 +    pub fn handle_recurrence_choice_key(
 +        &mut self,
 +        key: KeyEvent,
 +        source: &dyn AgendaSource,
 +    ) -> RecurrenceChoiceInputResult {
 +        if key.kind == KeyEventKind::Release {
 +            return RecurrenceChoiceInputResult::Continue;
 +        }
++
 +        let Some(choice) = &mut self.recurrence_choice else {
 +            return RecurrenceChoiceInputResult::Continue;
 +        };
++
 +        match key.code {
 +            KeyCode::Esc => RecurrenceChoiceInputResult::Cancel,
 +            KeyCode::Up => {
 +                choice.select_previous();
 +                RecurrenceChoiceInputResult::Continue
 +            }
 +            KeyCode::Down => {
 +                choice.select_next();
 +                RecurrenceChoiceInputResult::Continue
 +            }
 +            KeyCode::Enter => match choice.selected_action() {
 +                RecurrenceEditChoiceAction::ThisOccurrence => {
 +                    let series_id = choice.series_id.clone();
 +                    let anchor = choice.anchor;
 +                    self.recurrence_choice = None;
 +                    if let Some(event) = selectable_day_events(self.selected_date, source)
 +                        .into_iter()
 +                        .find(|event| {
 +                            event
 +                                .occurrence()
 +                                .map(|occurrence| {
 +                                    occurrence.series_id == series_id && occurrence.anchor == anchor
 +                                })
 +                                .unwrap_or(false)
 +                        })
 +                    {
 +                        self.create_form = Some(CreateEventForm::edit_occurrence(&event));
 +                    }
 +                    RecurrenceChoiceInputResult::Continue
 +                }
 +                RecurrenceEditChoiceAction::Series => {
 +                    let series_id = choice.series_id.clone();
 +                    self.recurrence_choice = None;
 +                    if let Some(event) = source.local_event_by_id(&series_id) {
 +                        self.create_form = Some(CreateEventForm::edit(&event));
 +                    }
 +                    RecurrenceChoiceInputResult::Continue
 +                }
 +                RecurrenceEditChoiceAction::Cancel => RecurrenceChoiceInputResult::Cancel,
 +            },
 +            _ => RecurrenceChoiceInputResult::Continue,
 +        }
 +    }
++
      pub fn calendar_month(&self) -> CalendarMonth {
          CalendarMonth::from_dates(self.selected_date, self.today)
+     }
              AppAction::CloseDay => {
                  self.view_mode = ViewMode::Month;
                  self.selected_day_event_id = None;
 +                self.recurrence_choice = None;
+             }
              AppAction::OpenCreate => {
 -                if self.create_form.is_none() {
 +                if self.create_form.is_none() && self.recurrence_choice.is_none() {
                      let context = match self.view_mode {
                          ViewMode::Month => CreateEventContext::EditableDate,
                          ViewMode::Day => CreateEventContext::FixedDate,
              .into_iter()
              .find(|event| event.id == selected_id)
+         {
 -            self.create_form = Some(CreateEventForm::edit(&event));
 +            if let Some(occurrence) = event.occurrence() {
 +                self.recurrence_choice = Some(RecurrenceEditChoice::new(
 +                    occurrence.series_id.clone(),
 +                    occurrence.anchor,
 +                ));
 +            } else {
 +                self.create_form = Some(CreateEventForm::edit(&event));
 +            }
+         }
+     }
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum EventFormMode {
      Create,
 -    Edit { event_id: String },
 +    Edit {
 +        event_id: String,
 +    },
 +    EditOccurrence {
 +        series_id: String,
 +        anchor: OccurrenceAnchor,
 +    },
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct RecurrenceEditChoice {
 +    series_id: String,
 +    anchor: OccurrenceAnchor,
 +    selected: usize,
 +}
++
 +impl RecurrenceEditChoice {
 +    const OPTIONS: [RecurrenceEditChoiceAction; 3] = [
 +        RecurrenceEditChoiceAction::ThisOccurrence,
 +        RecurrenceEditChoiceAction::Series,
 +        RecurrenceEditChoiceAction::Cancel,
 +    ];
++
 +    fn new(series_id: String, anchor: OccurrenceAnchor) -> Self {
 +        Self {
 +            series_id,
 +            anchor,
 +            selected: 0,
 +        }
 +    }
++
 +    pub fn rows(&self) -> Vec<RecurrenceEditChoiceRow> {
 +        Self::OPTIONS
 +            .iter()
 +            .enumerate()
 +            .map(|(index, action)| RecurrenceEditChoiceRow {
 +                label: action.label(),
 +                selected: index == self.selected,
 +            })
 +            .collect()
 +    }
++
 +    fn selected_action(&self) -> RecurrenceEditChoiceAction {
 +        Self::OPTIONS[self.selected]
 +    }
++
 +    fn select_next(&mut self) {
 +        self.selected = (self.selected + 1) % Self::OPTIONS.len();
 +    }
++
 +    fn select_previous(&mut self) {
 +        self.selected = if self.selected == 0 {
 +            Self::OPTIONS.len() - 1
 +        } else {
 +            self.selected - 1
 +        };
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub struct RecurrenceEditChoiceRow {
 +    pub label: &'static str,
 +    pub selected: bool,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum RecurrenceEditChoiceAction {
 +    ThisOccurrence,
 +    Series,
 +    Cancel,
 +}
++
 +impl RecurrenceEditChoiceAction {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::ThisOccurrence => "Edit this occurrence",
 +            Self::Series => "Edit series",
 +            Self::Cancel => "Cancel",
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum RecurrenceChoiceInputResult {
 +    Continue,
 +    Cancel,
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
      location: String,
      notes: String,
      reminders: [bool; REMINDER_PRESETS.len()],
 +    repeat: RepeatFrequency,
 +    recurrence_interval: String,
 +    weekly_days: [bool; DAYS_PER_WEEK],
 +    monthly_mode: RecurrenceMonthlyFormMode,
 +    yearly_mode: RecurrenceYearlyFormMode,
 +    recurrence_end: RecurrenceEndFormMode,
 +    recurrence_until_date: String,
 +    recurrence_count: String,
      focused: usize,
      error: Option<String>,
+ }
              location: String::new(),
              notes: String::new(),
              reminders: [false; REMINDER_PRESETS.len()],
 +            repeat: RepeatFrequency::None,
 +            recurrence_interval: "1".to_string(),
 +            weekly_days: weekly_days_for(selected_date.weekday()),
 +            monthly_mode: RecurrenceMonthlyFormMode::DayOfMonth,
 +            yearly_mode: RecurrenceYearlyFormMode::Date,
 +            recurrence_end: RecurrenceEndFormMode::Never,
 +            recurrence_until_date: selected_date.to_string(),
 +            recurrence_count: "10".to_string(),
              focused: 0,
              error: None,
+         }
+             }
+         }
 -        Self {
 +        let mut form = Self {
              mode: EventFormMode::Edit {
                  event_id: event.id.clone(),
              },
              location: event.location.clone().unwrap_or_default(),
              notes: event.notes.clone().unwrap_or_default(),
              reminders,
 +            repeat: RepeatFrequency::None,
 +            recurrence_interval: "1".to_string(),
 +            weekly_days: weekly_days_for(selected_date.weekday()),
 +            monthly_mode: RecurrenceMonthlyFormMode::DayOfMonth,
 +            yearly_mode: RecurrenceYearlyFormMode::Date,
 +            recurrence_end: RecurrenceEndFormMode::Never,
 +            recurrence_until_date: selected_date.to_string(),
 +            recurrence_count: "10".to_string(),
              focused: 0,
              error: None,
 -        }
 +        };
 +        form.load_recurrence(event.recurrence.as_ref());
 +        form
 +    }
++
 +    pub fn edit_occurrence(event: &Event) -> Self {
 +        let Some(occurrence) = event.occurrence() else {
 +            return Self::edit(event);
 +        };
 +        let mut form = Self::edit(event);
 +        form.mode = EventFormMode::EditOccurrence {
 +            series_id: occurrence.series_id.clone(),
 +            anchor: occurrence.anchor,
 +        };
 +        form.repeat = RepeatFrequency::None;
 +        form
+     }
      pub fn mode(&self) -> &EventFormMode {
      pub fn heading(&self) -> &'static str {
          match &self.mode {
              EventFormMode::Create => "Create",
 -            EventFormMode::Edit { .. } => "Edit",
 +            EventFormMode::Edit { .. } | EventFormMode::EditOccurrence { .. } => "Edit",
+         }
+     }
          if ctrl_s(key) {
              return match self.submit() {
 -                Ok(draft) => CreateEventInputResult::Submit(EventFormSubmission {
 +                Ok(draft) => CreateEventInputResult::Submit(Box::new(EventFormSubmission {
                      mode: self.mode.clone(),
                      draft,
 -                }),
 +                })),
                  Err(err) => {
                      self.error = Some(err.to_string());
                      CreateEventInputResult::Continue
          if self.all_day {
              let date = self.start_date()?;
 +            let recurrence = self.recurrence_rule(date)?;
              return Ok(CreateEventDraft {
                  title,
                  timing: CreateEventTiming::AllDay { date },
                  location,
                  notes,
                  reminders,
 +                recurrence,
              });
+         }
          if start >= end {
              return Err(CreateEventFormError::InvalidRange);
+         }
 +        let recurrence = self.recurrence_rule(start_date)?;
          Ok(CreateEventDraft {
              title,
              location,
              notes,
              reminders,
 +            recurrence,
          })
+     }
          parse_date_field(&self.end_date, "end date")
+     }
 +    fn load_recurrence(&mut self, recurrence: Option<&RecurrenceRule>) {
 +        let Some(recurrence) = recurrence else {
 +            return;
 +        };
 +        self.repeat = RepeatFrequency::from_rule(recurrence.frequency);
 +        self.recurrence_interval = recurrence.interval().to_string();
 +        if !recurrence.weekdays.is_empty() {
 +            self.weekly_days = [false; DAYS_PER_WEEK];
 +            for weekday in &recurrence.weekdays {
 +                self.weekly_days[usize::from(weekday.number_days_from_sunday())] = true;
 +            }
 +        }
 +        self.recurrence_end = match recurrence.end {
 +            RecurrenceEnd::Never => RecurrenceEndFormMode::Never,
 +            RecurrenceEnd::Until(date) => {
 +                self.recurrence_until_date = date.to_string();
 +                RecurrenceEndFormMode::Until
 +            }
 +            RecurrenceEnd::Count(count) => {
 +                self.recurrence_count = count.to_string();
 +                RecurrenceEndFormMode::Count
 +            }
 +        };
 +        if let Some(monthly) = recurrence.monthly {
 +            self.monthly_mode = match monthly {
 +                RecurrenceMonthlyRule::DayOfMonth(_) => RecurrenceMonthlyFormMode::DayOfMonth,
 +                RecurrenceMonthlyRule::WeekdayOrdinal { .. } => {
 +                    RecurrenceMonthlyFormMode::WeekdayOrdinal
 +                }
 +            };
 +        }
 +        if let Some(yearly) = recurrence.yearly {
 +            self.yearly_mode = match yearly {
 +                RecurrenceYearlyRule::Date { .. } => RecurrenceYearlyFormMode::Date,
 +                RecurrenceYearlyRule::WeekdayOrdinal { .. } => {
 +                    RecurrenceYearlyFormMode::WeekdayOrdinal
 +                }
 +            };
 +        }
 +    }
++
 +    fn recurrence_rule(
 +        &self,
 +        start_date: CalendarDate,
 +    ) -> Result<Option<RecurrenceRule>, CreateEventFormError> {
 +        if matches!(self.mode, EventFormMode::EditOccurrence { .. })
 +            || self.repeat == RepeatFrequency::None
 +        {
 +            return Ok(None);
 +        }
++
 +        let interval = parse_positive_u16(&self.recurrence_interval, "interval")?;
 +        let end = match self.recurrence_end {
 +            RecurrenceEndFormMode::Never => RecurrenceEnd::Never,
 +            RecurrenceEndFormMode::Until => {
 +                RecurrenceEnd::Until(parse_date_field(&self.recurrence_until_date, "until date")?)
 +            }
 +            RecurrenceEndFormMode::Count => {
 +                RecurrenceEnd::Count(parse_positive_u32(&self.recurrence_count, "count")?)
 +            }
 +        };
 +        let frequency = self.repeat.frequency().expect("repeat is not none");
 +        let mut rule = RecurrenceRule::new(frequency).with_interval(interval);
 +        rule.end = end;
++
 +        match self.repeat {
 +            RepeatFrequency::Weekly => {
 +                rule.weekdays = self
 +                    .weekly_days
 +                    .iter()
 +                    .enumerate()
 +                    .filter_map(|(index, enabled)| enabled.then_some(weekday_at(index)))
 +                    .collect();
 +                if rule.weekdays.is_empty() {
 +                    rule.weekdays.push(start_date.weekday());
 +                }
 +            }
 +            RepeatFrequency::Monthly => {
 +                rule.monthly = Some(match self.monthly_mode {
 +                    RecurrenceMonthlyFormMode::DayOfMonth => {
 +                        RecurrenceMonthlyRule::DayOfMonth(start_date.day())
 +                    }
 +                    RecurrenceMonthlyFormMode::WeekdayOrdinal => {
 +                        RecurrenceMonthlyRule::WeekdayOrdinal {
 +                            ordinal: recurrence_ordinal_for_date(start_date),
 +                            weekday: start_date.weekday(),
 +                        }
 +                    }
 +                });
 +            }
 +            RepeatFrequency::Yearly => {
 +                rule.yearly = Some(match self.yearly_mode {
 +                    RecurrenceYearlyFormMode::Date => RecurrenceYearlyRule::Date {
 +                        month: start_date.month(),
 +                        day: start_date.day(),
 +                    },
 +                    RecurrenceYearlyFormMode::WeekdayOrdinal => {
 +                        RecurrenceYearlyRule::WeekdayOrdinal {
 +                            month: start_date.month(),
 +                            ordinal: recurrence_ordinal_for_date(start_date),
 +                            weekday: start_date.weekday(),
 +                        }
 +                    }
 +                });
 +            }
 +            RepeatFrequency::Daily | RepeatFrequency::None => {}
 +        }
++
 +        Ok(Some(rule))
 +    }
++
      fn visible_fields(&self) -> Vec<CreateEventField> {
          let mut fields = vec![CreateEventField::Title, CreateEventField::AllDay];
          if self.context == CreateEventContext::EditableDate {
              CreateEventField::Notes,
          ]);
          fields.extend((0..REMINDER_PRESETS.len()).map(CreateEventField::Reminder));
 +        if !matches!(self.mode, EventFormMode::EditOccurrence { .. }) {
 +            fields.push(CreateEventField::Repeat);
 +            if self.repeat != RepeatFrequency::None {
 +                fields.push(CreateEventField::RecurrenceInterval);
 +                match self.repeat {
 +                    RepeatFrequency::Weekly => {
 +                        fields.extend((0..DAYS_PER_WEEK).map(CreateEventField::WeeklyDay));
 +                    }
 +                    RepeatFrequency::Monthly => fields.push(CreateEventField::MonthlyMode),
 +                    RepeatFrequency::Yearly => fields.push(CreateEventField::YearlyMode),
 +                    RepeatFrequency::Daily | RepeatFrequency::None => {}
 +                }
 +                fields.push(CreateEventField::RecurrenceEnd);
 +                match self.recurrence_end {
 +                    RecurrenceEndFormMode::Until => fields.push(CreateEventField::UntilDate),
 +                    RecurrenceEndFormMode::Count => fields.push(CreateEventField::OccurrenceCount),
 +                    RecurrenceEndFormMode::Never => {}
 +                }
 +            }
 +        }
          fields
+     }
                  let preset = REMINDER_PRESETS[index];
                  format!("{} {}", checkbox(self.reminders[index]), preset.label)
+             }
 +            CreateEventField::Repeat => self.repeat.label().to_string(),
 +            CreateEventField::RecurrenceInterval => self.recurrence_interval.clone(),
 +            CreateEventField::WeeklyDay(index) => {
 +                format!(
 +                    "{} {}",
 +                    checkbox(self.weekly_days[index]),
 +                    weekday_short_label(weekday_at(index))
 +                )
 +            }
 +            CreateEventField::MonthlyMode => self.monthly_mode.label().to_string(),
 +            CreateEventField::YearlyMode => self.yearly_mode.label().to_string(),
 +            CreateEventField::RecurrenceEnd => self.recurrence_end.label().to_string(),
 +            CreateEventField::UntilDate => self.recurrence_until_date.clone(),
 +            CreateEventField::OccurrenceCount => self.recurrence_count.clone(),
+         }
+     }
              CreateEventField::AllDay => self.all_day = !self.all_day,
              CreateEventField::Reminder(index) => self.reminders[index] = !self.reminders[index],
              CreateEventField::Notes => self.notes.push('\n'),
 +            CreateEventField::Repeat => self.repeat = self.repeat.next(),
 +            CreateEventField::WeeklyDay(index) => {
 +                self.weekly_days[index] = !self.weekly_days[index]
 +            }
 +            CreateEventField::MonthlyMode => self.monthly_mode = self.monthly_mode.next(),
 +            CreateEventField::YearlyMode => self.yearly_mode = self.yearly_mode.next(),
 +            CreateEventField::RecurrenceEnd => self.recurrence_end = self.recurrence_end.next(),
              _ => {}
+         }
          self.error = None;
              CreateEventField::EndTime => Some(&mut self.end_time),
              CreateEventField::Location => Some(&mut self.location),
              CreateEventField::Notes => Some(&mut self.notes),
 -            CreateEventField::AllDay | CreateEventField::Reminder(_) => None,
 +            CreateEventField::RecurrenceInterval => Some(&mut self.recurrence_interval),
 +            CreateEventField::UntilDate => Some(&mut self.recurrence_until_date),
 +            CreateEventField::OccurrenceCount => Some(&mut self.recurrence_count),
 +            CreateEventField::AllDay
 +            | CreateEventField::Reminder(_)
 +            | CreateEventField::Repeat
 +            | CreateEventField::WeeklyDay(_)
 +            | CreateEventField::MonthlyMode
 +            | CreateEventField::YearlyMode
 +            | CreateEventField::RecurrenceEnd => None,
          };
          if let Some(target) = target {
  pub enum CreateEventInputResult {
      Continue,
      Cancel,
 -    Submit(EventFormSubmission),
 +    Submit(Box<EventFormSubmission>),
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
      RequiredField(&'static str),
      InvalidDate { field: &'static str, value: String },
      InvalidTime { field: &'static str, value: String },
 +    InvalidNumber { field: &'static str, value: String },
      InvalidRange,
+ }
              Self::RequiredField(field) => write!(f, "{field} is required"),
              Self::InvalidDate { field, value } => write!(f, "{field} '{value}' must be YYYY-MM-DD"),
              Self::InvalidTime { field, value } => write!(f, "{field} '{value}' must be HH:MM"),
 +            Self::InvalidNumber { field, value } => {
 +                write!(f, "{field} '{value}' must be a positive number")
 +            }
              Self::InvalidRange => write!(f, "end must be after start"),
+         }
+     }
      },
  ];
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum RepeatFrequency {
 +    None,
 +    Daily,
 +    Weekly,
 +    Monthly,
 +    Yearly,
 +}
++
 +impl RepeatFrequency {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::None => "None",
 +            Self::Daily => "Daily",
 +            Self::Weekly => "Weekly",
 +            Self::Monthly => "Monthly",
 +            Self::Yearly => "Yearly",
 +        }
 +    }
++
 +    const fn next(self) -> Self {
 +        match self {
 +            Self::None => Self::Daily,
 +            Self::Daily => Self::Weekly,
 +            Self::Weekly => Self::Monthly,
 +            Self::Monthly => Self::Yearly,
 +            Self::Yearly => Self::None,
 +        }
 +    }
++
 +    const fn frequency(self) -> Option<RecurrenceFrequency> {
 +        match self {
 +            Self::None => None,
 +            Self::Daily => Some(RecurrenceFrequency::Daily),
 +            Self::Weekly => Some(RecurrenceFrequency::Weekly),
 +            Self::Monthly => Some(RecurrenceFrequency::Monthly),
 +            Self::Yearly => Some(RecurrenceFrequency::Yearly),
 +        }
 +    }
++
 +    const fn from_rule(frequency: RecurrenceFrequency) -> Self {
 +        match frequency {
 +            RecurrenceFrequency::Daily => Self::Daily,
 +            RecurrenceFrequency::Weekly => Self::Weekly,
 +            RecurrenceFrequency::Monthly => Self::Monthly,
 +            RecurrenceFrequency::Yearly => Self::Yearly,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum RecurrenceMonthlyFormMode {
 +    DayOfMonth,
 +    WeekdayOrdinal,
 +}
++
 +impl RecurrenceMonthlyFormMode {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::DayOfMonth => "Day of month",
 +            Self::WeekdayOrdinal => "Nth weekday",
 +        }
 +    }
++
 +    const fn next(self) -> Self {
 +        match self {
 +            Self::DayOfMonth => Self::WeekdayOrdinal,
 +            Self::WeekdayOrdinal => Self::DayOfMonth,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum RecurrenceYearlyFormMode {
 +    Date,
 +    WeekdayOrdinal,
 +}
++
 +impl RecurrenceYearlyFormMode {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::Date => "Date",
 +            Self::WeekdayOrdinal => "Nth weekday",
 +        }
 +    }
++
 +    const fn next(self) -> Self {
 +        match self {
 +            Self::Date => Self::WeekdayOrdinal,
 +            Self::WeekdayOrdinal => Self::Date,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum RecurrenceEndFormMode {
 +    Never,
 +    Until,
 +    Count,
 +}
++
 +impl RecurrenceEndFormMode {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::Never => "Never",
 +            Self::Until => "Until date",
 +            Self::Count => "Count",
 +        }
 +    }
++
 +    const fn next(self) -> Self {
 +        match self {
 +            Self::Never => Self::Until,
 +            Self::Until => Self::Count,
 +            Self::Count => Self::Never,
 +        }
 +    }
 +}
++
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  enum CreateEventField {
      Title,
      Location,
      Notes,
      Reminder(usize),
 +    Repeat,
 +    RecurrenceInterval,
 +    WeeklyDay(usize),
 +    MonthlyMode,
 +    YearlyMode,
 +    RecurrenceEnd,
 +    UntilDate,
 +    OccurrenceCount,
+ }
  impl CreateEventField {
              Self::Location => "Location",
              Self::Notes => "Notes",
              Self::Reminder(_) => "Reminder",
 +            Self::Repeat => "Repeat",
 +            Self::RecurrenceInterval => "Interval",
 +            Self::WeeklyDay(_) => "Weekly",
 +            Self::MonthlyMode => "Monthly",
 +            Self::YearlyMode => "Yearly",
 +            Self::RecurrenceEnd => "Ends",
 +            Self::UntilDate => "Until",
 +            Self::OccurrenceCount => "Count",
+         }
+     }
      const fn kind(self) -> CreateEventFormRowKind {
          match self {
              Self::Notes => CreateEventFormRowKind::Multiline,
 -            Self::AllDay | Self::Reminder(_) => CreateEventFormRowKind::Toggle,
 +            Self::AllDay | Self::Reminder(_) | Self::WeeklyDay(_) => CreateEventFormRowKind::Toggle,
              _ => CreateEventFormRowKind::Text,
+         }
+     }
      if enabled { "[x]" } else { "[ ]" }
+ }
 +fn weekly_days_for(weekday: Weekday) -> [bool; DAYS_PER_WEEK] {
 +    let mut days = [false; DAYS_PER_WEEK];
 +    days[usize::from(weekday.number_days_from_sunday())] = true;
 +    days
 +}
++
 +fn weekday_at(index: usize) -> Weekday {
 +    match index {
 +        0 => Weekday::Sunday,
 +        1 => Weekday::Monday,
 +        2 => Weekday::Tuesday,
 +        3 => Weekday::Wednesday,
 +        4 => Weekday::Thursday,
 +        5 => Weekday::Friday,
 +        6 => Weekday::Saturday,
 +        _ => unreachable!("weekday index stays in range"),
 +    }
 +}
++
 +fn weekday_short_label(weekday: Weekday) -> &'static str {
 +    match weekday {
 +        Weekday::Sunday => "Sun",
 +        Weekday::Monday => "Mon",
 +        Weekday::Tuesday => "Tue",
 +        Weekday::Wednesday => "Wed",
 +        Weekday::Thursday => "Thu",
 +        Weekday::Friday => "Fri",
 +        Weekday::Saturday => "Sat",
 +    }
 +}
++
  fn normalize_required(value: &str, field: &'static str) -> Result<String, CreateEventFormError> {
      let trimmed = value.trim();
      if trimmed.is_empty() {
      (!trimmed.is_empty()).then(|| trimmed.to_string())
+ }
 +fn parse_positive_u16(value: &str, field: &'static str) -> Result<u16, CreateEventFormError> {
 +    let parsed = value.trim().parse::<u16>().ok().filter(|value| *value > 0);
 +    parsed.ok_or_else(|| CreateEventFormError::InvalidNumber {
 +        field,
 +        value: value.to_string(),
 +    })
 +}
++
 +fn parse_positive_u32(value: &str, field: &'static str) -> Result<u32, CreateEventFormError> {
 +    let parsed = value.trim().parse::<u32>().ok().filter(|value| *value > 0);
 +    parsed.ok_or_else(|| CreateEventFormError::InvalidNumber {
 +        field,
 +        value: value.to_string(),
 +    })
 +}
++
  fn parse_date_field(
      value: &str,
      field: &'static str,
      use crossterm::event::{KeyModifiers, MouseButton, MouseEventKind};
      use time::{Month, Time};
 -    use crate::agenda::{Holiday, InMemoryAgendaSource, SourceMetadata};
 +    use crate::agenda::{Holiday, InMemoryAgendaSource, RecurrenceOrdinal, SourceMetadata};
      fn date(year: i32, month: Month, day: u8) -> CalendarDate {
          CalendarDate::from_ymd(year, month, day).expect("valid test date")
          assert_eq!(form.rows()[0].value, "Standup");
+     }
 +    #[test]
 +    fn day_view_enter_on_recurring_event_opens_edit_choice() {
 +        let day = date(2026, Month::April, 23);
 +        let event = local_timed_event("series", "Standup", at(day, 9, 0), at(day, 9, 30))
 +            .with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Daily,
 +                interval: 1,
 +                end: RecurrenceEnd::Count(2),
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: None,
 +            });
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
 +        let mut app = AppState::new(day);
 +        let mut input = KeyboardInput::default();
++
 +        apply_keys_with_source(
 +            &mut app,
 +            &mut input,
 +            &source,
 +            [key(KeyCode::Enter), key(KeyCode::Enter)],
 +        );
++
 +        let choice = app.recurrence_choice().expect("choice modal opens");
 +        assert_eq!(choice.rows()[0].label, "Edit this occurrence");
 +        assert_eq!(app.selected_day_event_id(), Some("series#2026-04-23T09:00"));
 +    }
++
 +    #[test]
 +    fn recurring_edit_choice_can_open_occurrence_or_series_edit() {
 +        let day = date(2026, Month::April, 23);
 +        let event = local_timed_event("series", "Standup", at(day, 9, 0), at(day, 9, 30))
 +            .with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Daily,
 +                interval: 1,
 +                end: RecurrenceEnd::Count(2),
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: None,
 +            });
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
++
 +        let mut occurrence_app = AppState::new(day);
 +        occurrence_app.apply_with_agenda_source(AppAction::OpenDay, &source);
 +        occurrence_app.apply_with_agenda_source(AppAction::OpenDay, &source);
 +        assert_eq!(
 +            occurrence_app.handle_recurrence_choice_key(key(KeyCode::Enter), &source),
 +            RecurrenceChoiceInputResult::Continue
 +        );
 +        assert_eq!(
 +            occurrence_app.create_form().expect("form opens").mode(),
 +            &EventFormMode::EditOccurrence {
 +                series_id: "series".to_string(),
 +                anchor: OccurrenceAnchor::Timed {
 +                    start: at(day, 9, 0)
 +                },
 +            }
 +        );
++
 +        let mut series_app = AppState::new(day);
 +        series_app.apply_with_agenda_source(AppAction::OpenDay, &source);
 +        series_app.apply_with_agenda_source(AppAction::OpenDay, &source);
 +        assert_eq!(
 +            series_app.handle_recurrence_choice_key(key(KeyCode::Down), &source),
 +            RecurrenceChoiceInputResult::Continue
 +        );
 +        assert_eq!(
 +            series_app.handle_recurrence_choice_key(key(KeyCode::Enter), &source),
 +            RecurrenceChoiceInputResult::Continue
 +        );
 +        assert_eq!(
 +            series_app.create_form().expect("series form opens").mode(),
 +            &EventFormMode::Edit {
 +                event_id: "series".to_string()
 +            }
 +        );
 +    }
++
      #[test]
      fn day_view_reconciles_selection_when_event_leaves_day() {
          let day = date(2026, Month::April, 23);
          assert_eq!(draft.reminders[0].minutes_before, 24 * 60);
+     }
 +    #[test]
 +    fn create_form_submits_weekly_recurrence() {
 +        let day = date(2026, Month::April, 23);
 +        let mut form = CreateEventForm::new(day, CreateEventContext::EditableDate);
 +        form.title = "Practice".to_string();
 +        form.repeat = RepeatFrequency::Weekly;
 +        form.recurrence_interval = "2".to_string();
 +        form.weekly_days = [false; DAYS_PER_WEEK];
 +        form.weekly_days[usize::from(Weekday::Tuesday.number_days_from_sunday())] = true;
 +        form.weekly_days[usize::from(Weekday::Thursday.number_days_from_sunday())] = true;
 +        form.recurrence_end = RecurrenceEndFormMode::Count;
 +        form.recurrence_count = "4".to_string();
++
 +        let draft = form.submit().expect("form submits");
 +        let recurrence = draft.recurrence.expect("recurrence submitted");
++
 +        assert_eq!(recurrence.frequency, RecurrenceFrequency::Weekly);
 +        assert_eq!(recurrence.interval, 2);
 +        assert_eq!(recurrence.weekdays, [Weekday::Tuesday, Weekday::Thursday]);
 +        assert_eq!(recurrence.end, RecurrenceEnd::Count(4));
 +    }
++
 +    #[test]
 +    fn edit_series_form_preloads_recurrence_and_occurrence_form_hides_it() {
 +        let day = date(2026, Month::April, 23);
 +        let event = local_timed_event("series", "Standup", at(day, 9, 0), at(day, 9, 30))
 +            .with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Monthly,
 +                interval: 1,
 +                end: RecurrenceEnd::Until(day.add_days(60)),
 +                weekdays: Vec::new(),
 +                monthly: Some(RecurrenceMonthlyRule::WeekdayOrdinal {
 +                    ordinal: RecurrenceOrdinal::Last,
 +                    weekday: day.weekday(),
 +                }),
 +                yearly: None,
 +            });
++
 +        let form = CreateEventForm::edit(&event);
++
 +        assert_eq!(form.repeat, RepeatFrequency::Monthly);
 +        assert_eq!(form.monthly_mode, RecurrenceMonthlyFormMode::WeekdayOrdinal);
 +        assert_eq!(form.recurrence_end, RecurrenceEndFormMode::Until);
++
 +        let mut occurrence = event.clone();
 +        occurrence.id = "series#2026-04-23T09:00".to_string();
 +        occurrence.occurrence = Some(crate::agenda::OccurrenceMetadata {
 +            series_id: "series".to_string(),
 +            anchor: OccurrenceAnchor::Timed {
 +                start: at(day, 9, 0),
 +            },
 +        });
 +        let occurrence_form = CreateEventForm::edit_occurrence(&occurrence);
++
 +        assert!(
 +            !occurrence_form
 +                .rows()
 +                .iter()
 +                .any(|row| row.label == "Repeat")
 +        );
 +    }
++
      #[test]
      fn select_date_action_can_pick_adjacent_month_cells() {
          let mut app = AppState::new(date(2026, Month::April, 23));

src/cli.rsmodified

  use crate::{
      agenda::{ConfiguredAgendaSource, HolidayProvider, LocalEventStoreError, default_events_file},
 -    app::{AppState, CreateEventInputResult, EventFormMode, KeyboardInput, MouseInput},
 +    app::{
 +        AppState, CreateEventInputResult, EventFormMode, KeyboardInput, MouseInput,
 +        RecurrenceChoiceInputResult,
 +    },
      calendar::CalendarDate,
      tui::{
          AppView, DEFAULT_RENDER_HEIGHT, DEFAULT_RENDER_WIDTH, hit_test_app_date,
              return Ok(());
+         }
 -        let event = if !app.is_creating_event() && keyboard.is_waiting_for_digit() {
 +        let event = if !app.is_creating_event()
 +            && !app.is_choosing_recurring_edit()
 +            && keyboard.is_waiting_for_digit()
 +        {
              if event::poll(DIGIT_JUMP_TIMEOUT)? {
                  event::read()?
              } else {
          match event {
              Event::Key(key) => {
                  mouse.clear();
 -                if app.is_creating_event() {
 +                if app.is_choosing_recurring_edit() {
 +                    match app.handle_recurrence_choice_key(key, &agenda_source) {
 +                        RecurrenceChoiceInputResult::Continue => {}
 +                        RecurrenceChoiceInputResult::Cancel => app.close_recurrence_choice(),
 +                    }
 +                } else if app.is_creating_event() {
                      match app.handle_create_key(key) {
                          CreateEventInputResult::Continue => {}
                          CreateEventInputResult::Cancel => app.close_create_form(),
 -                        CreateEventInputResult::Submit(submission) => match submission.mode {
 -                            EventFormMode::Create => {
 -                                match agenda_source.create_event(submission.draft) {
 -                                    Ok(_) => {
 -                                        app.close_create_form();
 -                                        app.reconcile_day_event_selection(&agenda_source);
 +                        CreateEventInputResult::Submit(submission) => {
 +                            let submission = *submission;
 +                            match submission.mode {
 +                                EventFormMode::Create => {
 +                                    match agenda_source.create_event(submission.draft) {
 +                                        Ok(_) => {
 +                                            app.close_create_form();
 +                                            app.reconcile_day_event_selection(&agenda_source);
 +                                        }
 +                                        Err(err) => app.set_create_form_error(err.to_string()),
+                                     }
 -                                    Err(err) => app.set_create_form_error(err.to_string()),
+                                 }
 -                            }
 -                            EventFormMode::Edit { event_id } => {
 -                                match agenda_source.update_event(&event_id, submission.draft) {
 -                                    Ok(_) => {
 -                                        app.close_create_form();
 -                                        app.reconcile_day_event_selection(&agenda_source);
 +                                EventFormMode::Edit { event_id } => {
 +                                    match agenda_source.update_event(&event_id, submission.draft) {
 +                                        Ok(_) => {
 +                                            app.close_create_form();
 +                                            app.reconcile_day_event_selection(&agenda_source);
 +                                        }
 +                                        Err(err) => app.set_create_form_error(err.to_string()),
 +                                    }
 +                                }
 +                                EventFormMode::EditOccurrence { series_id, anchor } => {
 +                                    match agenda_source.update_occurrence(
 +                                        &series_id,
 +                                        anchor,
 +                                        submission.draft,
 +                                    ) {
 +                                        Ok(_) => {
 +                                            app.close_create_form();
 +                                            app.reconcile_day_event_selection(&agenda_source);
 +                                        }
 +                                        Err(err) => app.set_create_form_error(err.to_string()),
+                                     }
 -                                    Err(err) => app.set_create_form_error(err.to_string()),
+                                 }
+                             }
 -                        },
 +                        }
+                     }
                  } else {
                      let action = keyboard.translate(key);
+                 }
+             }
              Event::Mouse(mouse_event) => {
 -                if app.is_creating_event() {
 +                if app.is_creating_event() || app.is_choosing_recurring_edit() {
                      continue;
+                 }
                  keyboard.clear();

src/tui.rsmodified

      agenda::{
          AgendaSource, DayAgenda, DayMinute, EmptyAgendaSource, Event, EventTiming, TimedAgendaEvent,
      },
 -    app::{AppState, CreateEventForm, CreateEventFormRowKind, ViewMode},
 +    app::{AppState, CreateEventForm, CreateEventFormRowKind, RecurrenceEditChoice, ViewMode},
      calendar::{
          CalendarCell, CalendarDate, CalendarMonth, CalendarWeek, DAYS_PER_WEEK, MONTH_GRID_WEEKS,
      },
          if let Some(form) = self.app.create_form() {
              render_create_event_modal(form, area, buf, CreateModalStyles::new());
+         }
 +        if let Some(choice) = self.app.recurrence_choice() {
 +            render_recurrence_choice_modal(choice, area, buf, CreateModalStyles::new());
 +        }
+     }
+ }
      );
+ }
 +fn render_recurrence_choice_modal(
 +    choice: &RecurrenceEditChoice,
 +    area: Rect,
 +    buf: &mut Buffer,
 +    styles: CreateModalStyles,
 +) {
 +    if area.width == 0 || area.height == 0 {
 +        return;
 +    }
++
 +    let modal = recurrence_choice_modal_area(area);
 +    fill_rect(buf, modal, styles.panel);
 +    draw_border(buf, modal, styles.border, BorderCharacters::normal());
++
 +    let content = inset_rect(modal);
 +    if content.width == 0 || content.height == 0 {
 +        return;
 +    }
++
 +    write_centered(
 +        buf,
 +        content.y,
 +        content.x,
 +        content.width,
 +        "Edit",
 +        styles.title,
 +    );
++
 +    let mut y = content.y.saturating_add(2);
 +    for row in choice.rows() {
 +        if y >= content.bottom().saturating_sub(1) {
 +            break;
 +        }
 +        let marker = if row.selected { ">" } else { " " };
 +        write_padded_left(buf, y, content.x, 1, marker, styles.label);
 +        write_left(
 +            buf,
 +            y,
 +            content.x.saturating_add(2),
 +            content.width.saturating_sub(2),
 +            row.label,
 +            if row.selected {
 +                styles.title
 +            } else {
 +                styles.value
 +            },
 +        );
 +        y = y.saturating_add(1);
 +    }
++
 +    write_centered(
 +        buf,
 +        content.bottom().saturating_sub(1),
 +        content.x,
 +        content.width,
 +        "Enter select | Esc cancel",
 +        styles.footer,
 +    );
 +}
++
  fn create_modal_area(area: Rect, form: &CreateEventForm) -> Rect {
      if area.width < 52 || area.height < 16 {
          return area;
+     )
+ }
 +fn recurrence_choice_modal_area(area: Rect) -> Rect {
 +    if area.width < 36 || area.height < 9 {
 +        return area;
 +    }
++
 +    let width = area.width.saturating_sub(4).min(36);
 +    let height = 9.min(area.height.saturating_sub(4));
 +    Rect::new(
 +        area.x + area.width.saturating_sub(width) / 2,
 +        area.y + area.height.saturating_sub(height) / 2,
 +        width,
 +        height,
 +    )
 +}
++
  fn desired_create_modal_height(form: &CreateEventForm, modal_width: u16) -> u16 {
      let content_width = modal_width.saturating_sub(2);
      let value_width = create_modal_value_width(content_width);
      use time::{Month, Time};
      use crate::{
 -        agenda::{Event, EventDateTime, Holiday, InMemoryAgendaSource, Reminder, SourceMetadata},
 +        agenda::{
 +            Event, EventDateTime, Holiday, InMemoryAgendaSource, RecurrenceEnd,
 +            RecurrenceFrequency, RecurrenceRule, Reminder, SourceMetadata,
 +        },
          app::AppAction,
          calendar::CalendarDate,
      };
          assert!(rendered.contains("Planning"));
+     }
 +    #[test]
 +    fn recurring_edit_choice_modal_renders_over_day_view() {
 +        let day = date(2026, Month::April, 23);
 +        let recurring = local_timed_event("series", "Standup", at(day, 9, 0), at(day, 10, 0))
 +            .with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Daily,
 +                interval: 1,
 +                end: RecurrenceEnd::Count(2),
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: None,
 +            });
 +        let source = agenda_source(vec![recurring], Vec::new());
 +        let mut app = AppState::new(day);
 +        app.apply_with_agenda_source(AppAction::OpenDay, &source);
 +        app.apply_with_agenda_source(AppAction::OpenDay, &source);
++
 +        let rendered = render_app_to_string_with_agenda_source(&app, 84, 26, &source);
++
 +        assert!(rendered.contains("Edit this occurrence"));
 +        assert!(rendered.contains("Edit series"));
 +        assert!(rendered.contains("Enter select"));
 +    }
++
 +    #[test]
 +    fn recurring_instances_render_without_repeat_marker() {
 +        let day = date(2026, Month::April, 23);
 +        let recurring = local_timed_event("series", "Standup", at(day, 9, 0), at(day, 10, 0))
 +            .with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Daily,
 +                interval: 1,
 +                end: RecurrenceEnd::Count(2),
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: None,
 +            });
 +        let source = agenda_source(vec![recurring], Vec::new());
 +        let mut app = AppState::new(day.add_days(1));
 +        app.apply(AppAction::OpenDay);
++
 +        let rendered = render_app_to_string_with_agenda_source(&app, 84, 26, &source);
++
 +        assert!(rendered.contains("09:00-10:00 Standup"));
 +        assert!(!rendered.contains("repeat"));
 +        assert!(!rendered.contains("recurring"));
 +    }
++
      #[test]
      fn create_modal_clears_background_content() {
          let selected = date(2026, Month::April, 23);