`9cb416e`

Add local event deletion

Authored by

espadonne 2 weeks ago

SHA: 9cb416effa450c59abfbbede48aa1a7b3325653c
Parents: 24cd0c7
Tree: 61ef0a0

5 changed files

Status	File	+	-
M	`README.md`	4	4
M	`src/agenda.rs`	232	0
M	`src/app.rs`	358	2
M	`src/cli.rs`	36	5
M	`src/tui.rs`	104	1

README.mdmodified

  - Arrow keys move the selected date.
  - `+` opens the Create event modal.
 +- In day view, `d` opens the Delete confirmation for the selected local event.
  - `Enter` opens the focused day view.
  - `Esc` returns from day view to month view.
  - `q` exits.
    day view.
  Created events are stored locally as JSON and are shown immediately in month,
 -week, and day views. The create modal supports timed events, single-day all-day
 -events, location, notes, and multiple reminder offsets; reminder notifications
 -are not delivered yet.
 +week, and day views. The create/edit modal supports timed events, single-day
 +all-day events, recurrence, location, notes, and multiple reminder offsets.
 +Reminder notifications are not delivered yet.
  ## Layout
  - Real account integrations for Outlook, Google Calendar, Exchange, and similar
    providers are not implemented yet.
 -- Editing or deleting existing events is not implemented yet.
  - Reminder offsets are stored but do not trigger notifications yet.
  - Packaging is currently source-based through Cargo.

src/agenda.rsmodified

      pub recurrence: Option<RecurrenceRule>,
      pub occurrence: Option<OccurrenceMetadata>,
      pub occurrence_overrides: Vec<OccurrenceOverride>,
 +    pub deleted_occurrences: Vec<OccurrenceAnchor>,
+ }
  impl Event {
              recurrence: None,
              occurrence: None,
              occurrence_overrides: Vec::new(),
 +            deleted_occurrences: Vec::new(),
+         }
+     }
              recurrence: None,
              occurrence: None,
              occurrence_overrides: Vec::new(),
 +            deleted_occurrences: Vec::new(),
          })
+     }
              .into_iter()
              .filter(|override_record| event_generates_anchor(&event, override_record.anchor))
              .collect();
 +        let existing_deleted_occurrences = std::mem::take(&mut events[index].deleted_occurrences);
 +        event.deleted_occurrences = existing_deleted_occurrences
 +            .into_iter()
 +            .filter(|anchor| event_generates_anchor(&event, *anchor))
 +            .collect();
          events[index] = event.clone();
          if let Some(path) = &self.events_file {
          } else {
              events[index].occurrence_overrides.push(override_record);
+         }
 +        events[index]
 +            .deleted_occurrences
 +            .retain(|deleted_anchor| *deleted_anchor != anchor);
          let event = occurrence_override_event(&events[index], anchor).ok_or_else(|| {
              LocalEventStoreError::OccurrenceNotFound {
          Ok(event)
+     }
 +    pub fn delete_event(&mut self, id: &str) -> Result<Event, LocalEventStoreError> {
 +        let mut events = self.events.events().to_vec();
 +        let Some(index) = events.iter().position(|event| event.id == id) else {
 +            return Err(LocalEventStoreError::EventNotFound { id: id.to_string() });
 +        };
 +        if !events[index].is_local() {
 +            return Err(LocalEventStoreError::EventNotEditable { id: id.to_string() });
 +        }
++
 +        let deleted = events.remove(index);
 +        if let Some(path) = &self.events_file {
 +            write_events_file(path, &events)?;
 +        }
 +        self.events.events = events;
 +        Ok(deleted)
 +    }
++
 +    pub fn delete_occurrence(
 +        &mut self,
 +        series_id: &str,
 +        anchor: OccurrenceAnchor,
 +    ) -> Result<(), 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(),
 +            });
 +        }
++
 +        events[index]
 +            .occurrence_overrides
 +            .retain(|override_record| override_record.anchor != anchor);
 +        if !events[index].deleted_occurrences.contains(&anchor) {
 +            events[index].deleted_occurrences.push(anchor);
 +        }
++
 +        if let Some(path) = &self.events_file {
 +            write_events_file(path, &events)?;
 +        }
 +        self.events.events = events;
 +        Ok(())
 +    }
++
      fn next_local_event_id(&self, title: &str) -> String {
          let now = SystemTime::now()
              .duration_since(UNIX_EPOCH)
+             }
              let anchor = occurrence_anchor_for_date(event, date);
 +            if event.deleted_occurrences.contains(&anchor) {
 +                date = date.add_days(1);
 +                continue;
 +            }
              let instance = occurrence_override_event(event, anchor)
                  .unwrap_or_else(|| generated_occurrence_event(event, anchor));
              events.push(instance);
      });
      event.recurrence = None;
      event.occurrence_overrides = Vec::new();
 +    event.deleted_occurrences = Vec::new();
      event
+ }
          recurrence: Option<LocalRecurrenceRecord>,
          #[serde(default, skip_serializing_if = "Vec::is_empty")]
          overrides: Vec<LocalOccurrenceOverrideRecord>,
 +        #[serde(default, skip_serializing_if = "Vec::is_empty")]
 +        deleted_occurrences: Vec<LocalOccurrenceAnchorRecord>,
      },
      AllDay {
          id: String,
          recurrence: Option<LocalRecurrenceRecord>,
          #[serde(default, skip_serializing_if = "Vec::is_empty")]
          overrides: Vec<LocalOccurrenceOverrideRecord>,
 +        #[serde(default, skip_serializing_if = "Vec::is_empty")]
 +        deleted_occurrences: Vec<LocalOccurrenceAnchorRecord>,
      },
+ }
              .iter()
              .map(LocalOccurrenceOverrideRecord::from_override)
              .collect::<Vec<_>>();
 +        let deleted_occurrences = event
 +            .deleted_occurrences
 +            .iter()
 +            .copied()
 +            .map(LocalOccurrenceAnchorRecord::from_anchor)
 +            .collect::<Vec<_>>();
          match event.timing {
              EventTiming::AllDay { date } => Self::AllDay {
                  reminders_minutes_before,
                  recurrence,
                  overrides,
 +                deleted_occurrences,
              },
              EventTiming::Timed { start, end } => Self::Timed {
                  id: event.id.clone(),
                  reminders_minutes_before,
                  recurrence,
                  overrides,
 +                deleted_occurrences,
              },
+         }
+     }
                  reminders_minutes_before,
                  recurrence,
                  overrides,
 +                deleted_occurrences,
              } => {
                  let start = EventDateTime::new(
                      parse_local_date(&start_date, path)?,
                      .into_iter()
                      .map(|override_record| override_record.into_override(path))
                      .collect::<Result<Vec<_>, _>>()?;
 +                event.deleted_occurrences = deleted_occurrences
 +                    .into_iter()
 +                    .map(|anchor| anchor.into_anchor(path))
 +                    .collect::<Result<Vec<_>, _>>()?;
                  Ok(event)
+             }
              Self::AllDay {
                  reminders_minutes_before,
                  recurrence,
                  overrides,
 +                deleted_occurrences,
              } => {
                  let mut event = Event::all_day(
                      id.clone(),
                      .into_iter()
                      .map(|override_record| override_record.into_override(path))
                      .collect::<Result<Vec<_>, _>>()?;
 +                event.deleted_occurrences = deleted_occurrences
 +                    .into_iter()
 +                    .map(|anchor| anchor.into_anchor(path))
 +                    .collect::<Result<Vec<_>, _>>()?;
                  Ok(event)
+             }
+         }
          );
+     }
 +    #[test]
 +    fn local_event_store_deletes_single_event_and_persists() {
 +        let path = temp_events_path("delete-event");
 +        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: "Planning".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(day, 9, 0),
 +                    end: at(day, 10, 0),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: Vec::new(),
 +                recurrence: None,
 +            })
 +            .expect("event saves");
++
 +        let deleted = source.delete_event(&event.id).expect("event deletes");
 +        let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("saved file reloads");
 +        let agenda = DayAgenda::from_source(day, &reloaded);
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert_eq!(deleted.id, event.id);
 +        assert!(agenda.is_empty());
 +    }
++
 +    #[test]
 +    fn local_event_store_deletes_one_recurring_occurrence_and_persists() {
 +        let path = temp_events_path("delete-occurrence");
 +        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 deleted_anchor = OccurrenceAnchor::Timed {
 +            start: at(day.add_days(1), 9, 0),
 +        };
++
 +        source
 +            .update_occurrence(
 +                &event.id,
 +                deleted_anchor,
 +                CreateEventDraft {
 +                    title: "Moved".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 before delete");
 +        source
 +            .delete_occurrence(&event.id, deleted_anchor)
 +            .expect("occurrence deletes");
 +        let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("saved file reloads");
++
 +        let first = DayAgenda::from_source(day, &reloaded);
 +        let second = DayAgenda::from_source(day.add_days(1), &reloaded);
 +        let third = DayAgenda::from_source(day.add_days(2), &reloaded);
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert_eq!(first.timed_events.len(), 1);
 +        assert!(second.timed_events.is_empty());
 +        assert_eq!(third.timed_events.len(), 1);
 +        let stored = reloaded
 +            .local_event_by_id(&event.id)
 +            .expect("series exists");
 +        assert_eq!(stored.deleted_occurrences, vec![deleted_anchor]);
 +        assert!(stored.occurrence_overrides.is_empty());
 +    }
++
 +    #[test]
 +    fn local_event_store_delete_series_removes_all_occurrences() {
 +        let path = temp_events_path("delete-series");
 +        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");
++
 +        source.delete_event(&event.id).expect("series deletes");
 +        let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("saved file reloads");
 +        let range = DateRange::new(day, day.add_days(4)).expect("valid range");
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert!(reloaded.events_intersecting(range).is_empty());
 +    }
++
      #[test]
      fn series_edits_drop_overrides_whose_anchor_no_longer_generates() {
          let path = temp_events_path("series-edit-overrides");

src/app.rsmodified

      view_mode: ViewMode,
      create_form: Option<CreateEventForm>,
      recurrence_choice: Option<RecurrenceEditChoice>,
 +    delete_choice: Option<EventDeleteChoice>,
      selected_day_event_id: Option<String>,
      should_quit: bool,
+ }
              view_mode: ViewMode::Month,
              create_form: None,
              recurrence_choice: None,
 +            delete_choice: None,
              selected_day_event_id: None,
              should_quit: false,
+         }
          self.recurrence_choice.as_ref()
+     }
 +    pub const fn delete_choice(&self) -> Option<&EventDeleteChoice> {
 +        self.delete_choice.as_ref()
 +    }
++
      pub fn selected_day_event_id(&self) -> Option<&str> {
          self.selected_day_event_id.as_deref()
+     }
          self.recurrence_choice.is_some()
+     }
 +    pub const fn is_confirming_delete(&self) -> bool {
 +        self.delete_choice.is_some()
 +    }
++
      pub fn close_create_form(&mut self) {
          self.create_form = None;
+     }
          self.recurrence_choice = None;
+     }
 +    pub fn close_delete_choice(&mut self) {
 +        self.delete_choice = None;
 +    }
++
 +    pub fn set_delete_error(&mut self, message: impl Into<String>) {
 +        if let Some(choice) = &mut self.delete_choice {
 +            choice.error = Some(message.into());
 +        }
 +    }
++
      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());
+         }
+     }
 +    pub fn handle_delete_choice_key(&mut self, key: KeyEvent) -> EventDeleteInputResult {
 +        if key.kind == KeyEventKind::Release {
 +            return EventDeleteInputResult::Continue;
 +        }
++
 +        let Some(choice) = &mut self.delete_choice else {
 +            return EventDeleteInputResult::Continue;
 +        };
++
 +        match key.code {
 +            KeyCode::Esc => EventDeleteInputResult::Cancel,
 +            KeyCode::Up => {
 +                choice.select_previous();
 +                EventDeleteInputResult::Continue
 +            }
 +            KeyCode::Down => {
 +                choice.select_next();
 +                EventDeleteInputResult::Continue
 +            }
 +            KeyCode::Enter => match choice.selected_action() {
 +                EventDeleteChoiceAction::Cancel => EventDeleteInputResult::Cancel,
 +                EventDeleteChoiceAction::DeleteEvent => {
 +                    EventDeleteInputResult::Submit(EventDeleteSubmission::Event {
 +                        event_id: choice.event_id().to_string(),
 +                    })
 +                }
 +                EventDeleteChoiceAction::DeleteThisOccurrence => {
 +                    let EventDeleteTarget::Occurrence { series_id, anchor } = &choice.target else {
 +                        return EventDeleteInputResult::Continue;
 +                    };
 +                    EventDeleteInputResult::Submit(EventDeleteSubmission::Occurrence {
 +                        series_id: series_id.clone(),
 +                        anchor: *anchor,
 +                    })
 +                }
 +                EventDeleteChoiceAction::DeleteSeries => {
 +                    let EventDeleteTarget::Occurrence { series_id, .. } = &choice.target else {
 +                        return EventDeleteInputResult::Continue;
 +                    };
 +                    EventDeleteInputResult::Submit(EventDeleteSubmission::Series {
 +                        series_id: series_id.clone(),
 +                    })
 +                }
 +            },
 +            _ => EventDeleteInputResult::Continue,
 +        }
 +    }
++
      pub fn calendar_month(&self) -> CalendarMonth {
          CalendarMonth::from_dates(self.selected_date, self.today)
+     }
                  self.view_mode = ViewMode::Month;
                  self.selected_day_event_id = None;
                  self.recurrence_choice = None;
 +                self.delete_choice = None;
+             }
              AppAction::OpenCreate => {
 -                if self.create_form.is_none() && self.recurrence_choice.is_none() {
 +                if self.create_form.is_none()
 +                    && self.recurrence_choice.is_none()
 +                    && self.delete_choice.is_none()
 +                {
                      let context = match self.view_mode {
                          ViewMode::Month => CreateEventContext::EditableDate,
                          ViewMode::Day => CreateEventContext::FixedDate,
                      self.create_form = Some(CreateEventForm::new(self.selected_date, context));
+                 }
+             }
 +            AppAction::OpenDelete if self.view_mode == ViewMode::Day => {
 +                if self.create_form.is_none()
 +                    && self.recurrence_choice.is_none()
 +                    && self.delete_choice.is_none()
 +                    && let Some(source) = source
 +                {
 +                    self.open_selected_event_for_delete(source);
 +                }
 +            }
              AppAction::MoveDays(days) if self.view_mode == ViewMode::Month => {
                  self.selected_date = self.selected_date.add_days(days);
+             }
              AppAction::MoveDays(_)
              | AppAction::SelectDate(_)
              | AppAction::JumpToDay(_)
 -            | AppAction::JumpToWeekday(_) => {}
 +            | AppAction::JumpToWeekday(_)
 +            | AppAction::OpenDelete => {}
+         }
+     }
+         }
+     }
 +    fn open_selected_event_for_delete(&mut self, source: &dyn AgendaSource) {
 +        self.reconcile_day_event_selection(source);
 +        let Some(selected_id) = self.selected_day_event_id.as_deref() else {
 +            return;
 +        };
 +        if let Some(event) = selectable_day_events(self.selected_date, source)
 +            .into_iter()
 +            .find(|event| event.id == selected_id)
 +        {
 +            self.delete_choice = Some(EventDeleteChoice::for_event(&event));
 +        }
 +    }
++
      fn weekday_in_selected_week(&self, weekday: Weekday) -> Option<CalendarDate> {
          let month = self.calendar_month();
          let selected = month.selected_cell()?;
      OpenDay,
      CloseDay,
      OpenCreate,
 +    OpenDelete,
      Quit,
+ }
      Cancel,
+ }
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct EventDeleteChoice {
 +    target: EventDeleteTarget,
 +    selected: usize,
 +    error: Option<String>,
 +}
++
 +impl EventDeleteChoice {
 +    fn for_event(event: &Event) -> Self {
 +        let target = if let Some(occurrence) = event.occurrence() {
 +            EventDeleteTarget::Occurrence {
 +                series_id: occurrence.series_id.clone(),
 +                anchor: occurrence.anchor,
 +            }
 +        } else {
 +            EventDeleteTarget::Event {
 +                event_id: event.id.clone(),
 +            }
 +        };
++
 +        Self {
 +            target,
 +            selected: 0,
 +            error: None,
 +        }
 +    }
++
 +    pub fn heading(&self) -> &'static str {
 +        "Delete"
 +    }
++
 +    pub fn error(&self) -> Option<&str> {
 +        self.error.as_deref()
 +    }
++
 +    pub fn rows(&self) -> Vec<EventDeleteChoiceRow> {
 +        self.actions()
 +            .into_iter()
 +            .enumerate()
 +            .map(|(index, action)| EventDeleteChoiceRow {
 +                label: action.label(),
 +                selected: index == self.selected,
 +                dangerous: action.is_dangerous(),
 +            })
 +            .collect()
 +    }
++
 +    fn actions(&self) -> Vec<EventDeleteChoiceAction> {
 +        match self.target {
 +            EventDeleteTarget::Event { .. } => vec![
 +                EventDeleteChoiceAction::DeleteEvent,
 +                EventDeleteChoiceAction::Cancel,
 +            ],
 +            EventDeleteTarget::Occurrence { .. } => vec![
 +                EventDeleteChoiceAction::DeleteThisOccurrence,
 +                EventDeleteChoiceAction::DeleteSeries,
 +                EventDeleteChoiceAction::Cancel,
 +            ],
 +        }
 +    }
++
 +    fn selected_action(&self) -> EventDeleteChoiceAction {
 +        self.actions()[self.selected]
 +    }
++
 +    fn select_next(&mut self) {
 +        let len = self.actions().len();
 +        self.selected = (self.selected + 1) % len;
 +        self.error = None;
 +    }
++
 +    fn select_previous(&mut self) {
 +        let len = self.actions().len();
 +        self.selected = if self.selected == 0 {
 +            len - 1
 +        } else {
 +            self.selected - 1
 +        };
 +        self.error = None;
 +    }
++
 +    fn event_id(&self) -> &str {
 +        match &self.target {
 +            EventDeleteTarget::Event { event_id } => event_id,
 +            EventDeleteTarget::Occurrence { series_id, .. } => series_id,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +enum EventDeleteTarget {
 +    Event {
 +        event_id: String,
 +    },
 +    Occurrence {
 +        series_id: String,
 +        anchor: OccurrenceAnchor,
 +    },
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub struct EventDeleteChoiceRow {
 +    pub label: &'static str,
 +    pub selected: bool,
 +    pub dangerous: bool,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum EventDeleteChoiceAction {
 +    DeleteEvent,
 +    DeleteThisOccurrence,
 +    DeleteSeries,
 +    Cancel,
 +}
++
 +impl EventDeleteChoiceAction {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::DeleteEvent => "Delete event",
 +            Self::DeleteThisOccurrence => "Delete this occurrence",
 +            Self::DeleteSeries => "Delete series",
 +            Self::Cancel => "Cancel",
 +        }
 +    }
++
 +    const fn is_dangerous(self) -> bool {
 +        !matches!(self, Self::Cancel)
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum EventDeleteSubmission {
 +    Event {
 +        event_id: String,
 +    },
 +    Occurrence {
 +        series_id: String,
 +        anchor: OccurrenceAnchor,
 +    },
 +    Series {
 +        series_id: String,
 +    },
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum EventDeleteInputResult {
 +    Continue,
 +    Cancel,
 +    Submit(EventDeleteSubmission),
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct CreateEventForm {
      mode: EventFormMode,
              return AppAction::OpenCreate;
+         }
 +        if value.eq_ignore_ascii_case(&'d') {
 +            self.clear();
 +            return AppAction::OpenDelete;
 +        }
++
          if value.is_ascii_digit() {
              return self.translate_digit(value);
+         }
          );
+     }
 +    #[test]
 +    fn day_view_d_opens_delete_choice_for_selected_local_event() {
 +        let day = date(2026, Month::April, 23);
 +        let source = InMemoryAgendaSource::with_events_and_holidays(
 +            vec![local_timed_event(
 +                "local-time",
 +                "Standup",
 +                at(day, 9, 0),
 +                at(day, 9, 30),
 +            )],
 +            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), char_key('d')],
 +        );
++
 +        let choice = app.delete_choice().expect("delete modal opens");
 +        assert_eq!(choice.rows()[0].label, "Delete event");
 +        assert_eq!(
 +            app.handle_delete_choice_key(key(KeyCode::Enter)),
 +            EventDeleteInputResult::Submit(EventDeleteSubmission::Event {
 +                event_id: "local-time".to_string()
 +            })
 +        );
 +    }
++
 +    #[test]
 +    fn day_view_d_opens_recurring_delete_choices() {
 +        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), char_key('d')],
 +        );
++
 +        let choice = app.delete_choice().expect("delete modal opens");
 +        let rows = choice.rows();
 +        assert_eq!(rows[0].label, "Delete this occurrence");
 +        assert_eq!(rows[1].label, "Delete series");
 +        assert_eq!(
 +            app.handle_delete_choice_key(key(KeyCode::Enter)),
 +            EventDeleteInputResult::Submit(EventDeleteSubmission::Occurrence {
 +                series_id: "series".to_string(),
 +                anchor: OccurrenceAnchor::Timed {
 +                    start: at(day, 9, 0)
 +                },
 +            })
 +        );
 +    }
++
 +    #[test]
 +    fn delete_choice_up_and_down_do_not_change_day_event_selection() {
 +        let day = date(2026, Month::April, 23);
 +        let source = InMemoryAgendaSource::with_events_and_holidays(
 +            vec![local_timed_event(
 +                "local-time",
 +                "Standup",
 +                at(day, 9, 0),
 +                at(day, 9, 30),
 +            )],
 +            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), char_key('d')],
 +        );
++
 +        assert_eq!(
 +            app.handle_delete_choice_key(key(KeyCode::Down)),
 +            EventDeleteInputResult::Continue
 +        );
 +        assert_eq!(
 +            app.handle_delete_choice_key(key(KeyCode::Up)),
 +            EventDeleteInputResult::Continue
 +        );
++
 +        assert_eq!(app.selected_day_event_id(), Some("local-time"));
 +        assert!(app.delete_choice().expect("choice stays open").rows()[0].selected);
 +    }
++
      #[test]
      fn day_view_reconciles_selection_when_event_leaves_day() {
          let day = date(2026, Month::April, 23);

src/cli.rsmodified

  use crate::{
      agenda::{ConfiguredAgendaSource, HolidayProvider, LocalEventStoreError, default_events_file},
      app::{
 -        AppState, CreateEventInputResult, EventFormMode, KeyboardInput, MouseInput,
 -        RecurrenceChoiceInputResult,
 +        AppState, CreateEventInputResult, EventDeleteInputResult, EventDeleteSubmission,
 +        EventFormMode, KeyboardInput, MouseInput, RecurrenceChoiceInputResult,
      },
      calendar::CalendarDate,
      tui::{
      "Keys:\n",
      "  Arrow keys move selection; Enter opens day view; Esc returns to month; q exits.\n",
      "  + opens the Create event modal.\n",
 +    "  In day view, d opens the Delete confirmation for the selected local event.\n",
      "  In day view, Left/Right move to the previous or next day.\n",
      "  Digits jump immediately; a quick second digit refines the selected day.\n",
      "  Weekday initials jump within the selected week.\n\n",
      "Mouse:\n",
      "  Left click selects a visible date; left click the selected date again to open day view.\n\n",
      "Notes:\n",
 -    "  Real calendar-account integration, editing, deletion, and reminder notifications are not in this milestone.\n",
 +    "  Real calendar-account integration and reminder notifications are not in this milestone.\n",
  );
  const VERSION: &str = concat!(env!("CARGO_PKG_NAME"), " ", env!("CARGO_PKG_VERSION"), "\n");
          let event = if !app.is_creating_event()
              && !app.is_choosing_recurring_edit()
 +            && !app.is_confirming_delete()
              && keyboard.is_waiting_for_digit()
+         {
              if event::poll(DIGIT_JUMP_TIMEOUT)? {
          match event {
              Event::Key(key) => {
                  mouse.clear();
 -                if app.is_choosing_recurring_edit() {
 +                if app.is_confirming_delete() {
 +                    match app.handle_delete_choice_key(key) {
 +                        EventDeleteInputResult::Continue => {}
 +                        EventDeleteInputResult::Cancel => app.close_delete_choice(),
 +                        EventDeleteInputResult::Submit(submission) => match submission {
 +                            EventDeleteSubmission::Event { event_id }
 +                            | EventDeleteSubmission::Series {
 +                                series_id: event_id,
 +                            } => match agenda_source.delete_event(&event_id) {
 +                                Ok(_) => {
 +                                    app.close_delete_choice();
 +                                    app.reconcile_day_event_selection(&agenda_source);
 +                                }
 +                                Err(err) => app.set_delete_error(err.to_string()),
 +                            },
 +                            EventDeleteSubmission::Occurrence { series_id, anchor } => {
 +                                match agenda_source.delete_occurrence(&series_id, anchor) {
 +                                    Ok(()) => {
 +                                        app.close_delete_choice();
 +                                        app.reconcile_day_event_selection(&agenda_source);
 +                                    }
 +                                    Err(err) => app.set_delete_error(err.to_string()),
 +                                }
 +                            }
 +                        },
 +                    }
 +                } else if app.is_choosing_recurring_edit() {
                      match app.handle_recurrence_choice_key(key, &agenda_source) {
                          RecurrenceChoiceInputResult::Continue => {}
                          RecurrenceChoiceInputResult::Cancel => app.close_recurrence_choice(),
+                 }
+             }
              Event::Mouse(mouse_event) => {
 -                if app.is_creating_event() || app.is_choosing_recurring_edit() {
 +                if app.is_creating_event()
 +                    || app.is_choosing_recurring_edit()
 +                    || app.is_confirming_delete()
 +                {
                      continue;
+                 }
                  keyboard.clear();

src/tui.rsmodified

      agenda::{
          AgendaSource, DayAgenda, DayMinute, EmptyAgendaSource, Event, EventTiming, TimedAgendaEvent,
      },
 -    app::{AppState, CreateEventForm, CreateEventFormRowKind, RecurrenceEditChoice, ViewMode},
 +    app::{
 +        AppState, CreateEventForm, CreateEventFormRowKind, EventDeleteChoice, RecurrenceEditChoice,
 +        ViewMode,
 +    },
      calendar::{
          CalendarCell, CalendarDate, CalendarMonth, CalendarWeek, DAYS_PER_WEEK, MONTH_GRID_WEEKS,
      },
          if let Some(choice) = self.app.recurrence_choice() {
              render_recurrence_choice_modal(choice, area, buf, CreateModalStyles::new());
+         }
 +        if let Some(choice) = self.app.delete_choice() {
 +            render_delete_choice_modal(choice, area, buf, CreateModalStyles::new());
 +        }
+     }
+ }
      );
+ }
 +fn render_delete_choice_modal(
 +    choice: &EventDeleteChoice,
 +    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,
 +        choice.heading(),
 +        styles.error,
 +    );
++
 +    let mut y = content.y.saturating_add(2);
 +    for row in choice.rows() {
 +        if y >= content.bottom().saturating_sub(2) {
 +            break;
 +        }
 +        let marker = if row.selected { ">" } else { " " };
 +        let row_style = if row.selected && row.dangerous {
 +            styles.error
 +        } else if row.selected {
 +            styles.title
 +        } else {
 +            styles.value
 +        };
 +        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,
 +            row_style,
 +        );
 +        y = y.saturating_add(1);
 +    }
++
 +    if let Some(error) = choice.error() {
 +        write_left(
 +            buf,
 +            content.bottom().saturating_sub(2),
 +            content.x,
 +            content.width,
 +            error,
 +            styles.error,
 +        );
 +    }
++
 +    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;
          assert!(rendered.contains("Enter select"));
+     }
 +    #[test]
 +    fn delete_choice_modal_renders_over_day_view() {
 +        let day = date(2026, Month::April, 23);
 +        let source = agenda_source(
 +            vec![local_timed_event(
 +                "planning",
 +                "Planning",
 +                at(day, 9, 0),
 +                at(day, 10, 0),
 +            )],
 +            Vec::new(),
 +        );
 +        let mut app = AppState::new(day);
 +        app.apply_with_agenda_source(AppAction::OpenDay, &source);
 +        app.apply_with_agenda_source(AppAction::OpenDelete, &source);
++
 +        let rendered = render_app_to_string_with_agenda_source(&app, 84, 26, &source);
++
 +        assert!(rendered.contains("Delete"));
 +        assert!(rendered.contains("Delete event"));
 +        assert!(rendered.contains("Enter select"));
 +    }
++
      #[test]
      fn recurring_instances_render_without_repeat_marker() {
          let day = date(2026, Month::April, 23);