`eb06be2`

Add local event edit flow

Authored by

espadonne 2 weeks ago

SHA: eb06be2af61f0259f5e0500416c894984ba75182
Parents: e19fcf6
Tree: 71327ba

4 changed files

Status	File	+	-
M	`src/agenda.rs`	125	0
M	`src/app.rs`	446	6
M	`src/cli.rs`	22	8
M	`src/tui.rs`	116	4

src/agenda.rsmodified

          self.timing.is_timed()
+     }
++    pub fn is_local(&self) -> bool {
++        self.source.source_id == "local"
++    }
++
      pub fn intersects_range(&self, range: DateRange) -> bool {
          match self.timing {
              EventTiming::AllDay { date } => range.contains_date(date),
          Ok(event)
+     }
++    pub fn update_event(
++        &mut self,
++        id: &str,
++        draft: CreateEventDraft,
++    ) -> 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 event =
++            draft
++                .into_event(id.to_string())
++                .map_err(|err| LocalEventStoreError::Encode {
++                    path: self.events_file.clone(),
++                    reason: err.to_string(),
++                })?;
++        events[index] = event.clone();
++
++        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)
          path: PathBuf,
          version: u8,
      },
++    EventNotFound {
++        id: String,
++    },
++    EventNotEditable {
++        id: String,
++    },
      Encode {
          path: Option<PathBuf>,
          reason: String,
                  "unsupported local events file version {version} in {}",
                  path.display()
              ),
++            Self::EventNotFound { id } => write!(f, "local event '{id}' was not found"),
++            Self::EventNotEditable { id } => write!(f, "event '{id}' is not editable locally"),
              Self::Encode { path, reason } => {
                  if let Some(path) = path {
                      write!(f, "failed to encode {}: {reason}", path.display())
          );
+     }
++    #[test]
++    fn local_event_store_updates_existing_event_id_and_persists() {
++        let path = temp_events_path("update");
++        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(),
++            })
++            .expect("event saves");
++
++        let updated = source
++            .update_event(
++                &event.id,
++                CreateEventDraft {
++                    title: "Updated planning".to_string(),
++                    timing: CreateEventTiming::AllDay { date: day },
++                    location: Some("Room 2".to_string()),
++                    notes: Some("Moved".to_string()),
++                    reminders: vec![Reminder::minutes_before(5)],
++                },
++            )
++            .expect("event updates");
++
++        assert_eq!(updated.id, event.id);
++        assert!(updated.is_local());
++
++        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!(agenda.timed_events.is_empty());
++        assert_eq!(agenda.all_day_events.len(), 1);
++        assert_eq!(agenda.all_day_events[0].id, event.id);
++        assert_eq!(agenda.all_day_events[0].title, "Updated planning");
++        assert_eq!(agenda.all_day_events[0].location.as_deref(), Some("Room 2"));
++    }
++
++    #[test]
++    fn local_event_store_rejects_missing_and_non_local_updates() {
++        let day = date(23);
++        let mut source = ConfiguredAgendaSource::new(
++            InMemoryAgendaSource::with_events_and_holidays(
++                vec![timed("fixture", "Fixture", at(day, 8, 0), at(day, 9, 0))],
++                Vec::new(),
++            ),
++            HolidayProvider::off(),
++        );
++        let draft = CreateEventDraft {
++            title: "Updated".to_string(),
++            timing: CreateEventTiming::Timed {
++                start: at(day, 10, 0),
++                end: at(day, 11, 0),
++            },
++            location: None,
++            notes: None,
++            reminders: Vec::new(),
++        };
++
++        assert!(matches!(
++            source
++                .update_event("missing", draft.clone())
++                .expect_err("missing event fails"),
++            LocalEventStoreError::EventNotFound { .. }
++        ));
++        assert!(matches!(
++            source
++                .update_event("fixture", draft)
++                .expect_err("fixture event fails"),
++            LocalEventStoreError::EventNotEditable { .. }
++        ));
++    }
++
      #[test]
      fn local_event_store_rejects_malformed_json() {
          let path = temp_events_path("malformed");

src/app.rsmodified

  use crate::{
      agenda::{
--        AgendaSource, CreateEventDraft, CreateEventTiming, DayAgenda, EventDateTime, Reminder,
++        AgendaSource, CreateEventDraft, CreateEventTiming, DayAgenda, Event, EventDateTime,
++        EventTiming, Reminder,
      },
      calendar::{CalendarDate, CalendarMonth, DAYS_PER_WEEK},
  };
      today: CalendarDate,
      view_mode: ViewMode,
      create_form: Option<CreateEventForm>,
++    selected_day_event_id: Option<String>,
      should_quit: bool,
+ }
              today,
              view_mode: ViewMode::Month,
              create_form: None,
++            selected_day_event_id: None,
              should_quit: false,
+         }
+     }
          self.create_form.as_ref()
+     }
++    pub fn selected_day_event_id(&self) -> Option<&str> {
++        self.selected_day_event_id.as_deref()
++    }
++
      pub const fn is_creating_event(&self) -> bool {
          self.create_form.is_some()
+     }
          DayAgenda::from_source(self.selected_date, source)
+     }
++    pub fn reconcile_day_event_selection(&mut self, source: &dyn AgendaSource) {
++        if self.view_mode != ViewMode::Day {
++            self.selected_day_event_id = None;
++            return;
++        }
++
++        let events = selectable_day_events(self.selected_date, source);
++        if let Some(selected_id) = &self.selected_day_event_id
++            && events.iter().any(|event| &event.id == selected_id)
++        {
++            return;
++        }
++
++        self.selected_day_event_id = events.first().map(|event| event.id.clone());
++    }
++
      pub fn apply(&mut self, action: AppAction) {
++        self.apply_resolved(action, None);
++    }
++
++    pub fn apply_with_agenda_source(&mut self, action: AppAction, source: &dyn AgendaSource) {
++        self.apply_resolved(action, Some(source));
++    }
++
++    fn apply_resolved(&mut self, action: AppAction, source: Option<&dyn AgendaSource>) {
          match action {
              AppAction::Noop => {}
              AppAction::Quit => self.should_quit = true,
--            AppAction::OpenDay => self.view_mode = ViewMode::Day,
++            AppAction::OpenDay if self.view_mode == ViewMode::Day => {
--            AppAction::CloseDay => self.view_mode = ViewMode::Month,
++                if let Some(source) = source {
++                    self.open_selected_event_for_edit(source);
++                }
++            }
++            AppAction::OpenDay => {
++                self.view_mode = ViewMode::Day;
++                if let Some(source) = source {
++                    self.reconcile_day_event_selection(source);
++                }
++            }
++            AppAction::CloseDay => {
++                self.view_mode = ViewMode::Month;
++                self.selected_day_event_id = None;
++            }
              AppAction::OpenCreate => {
                  if self.create_form.is_none() {
                      let context = match self.view_mode {
                  if self.view_mode == ViewMode::Day && matches!(days, -1 | 1) =>
+             {
                  self.selected_date = self.selected_date.add_days(days);
++                if let Some(source) = source {
++                    self.reconcile_day_event_selection(source);
++                } else {
++                    self.selected_day_event_id = None;
++                }
++            }
++            AppAction::MoveDays(-7) if self.view_mode == ViewMode::Day => {
++                if let Some(source) = source {
++                    self.move_day_event_selection(source, -1);
++                }
++            }
++            AppAction::MoveDays(7) if self.view_mode == ViewMode::Day => {
++                if let Some(source) = source {
++                    self.move_day_event_selection(source, 1);
++                }
+             }
              AppAction::SelectDate(date) if self.view_mode == ViewMode::Month => {
                  self.selected_date = date;
+         }
+     }
++    fn move_day_event_selection(&mut self, source: &dyn AgendaSource, delta: i32) {
++        let events = selectable_day_events(self.selected_date, source);
++        if events.is_empty() {
++            self.selected_day_event_id = None;
++            return;
++        }
++
++        let current_index = self
++            .selected_day_event_id
++            .as_ref()
++            .and_then(|id| events.iter().position(|event| &event.id == id))
++            .unwrap_or(0);
++        let len = events.len();
++        let next_index = if delta < 0 {
++            (current_index + len - 1) % len
++        } else {
++            (current_index + 1) % len
++        };
++        self.selected_day_event_id = Some(events[next_index].id.clone());
++    }
++
++    fn open_selected_event_for_edit(&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.create_form = Some(CreateEventForm::edit(&event));
++        }
++    }
++
      fn weekday_in_selected_week(&self, weekday: Weekday) -> Option<CalendarDate> {
          let month = self.calendar_month();
          let selected = month.selected_cell()?;
      FixedDate,
+ }
++#[derive(Debug, Clone, PartialEq, Eq)]
++pub enum EventFormMode {
++    Create,
++    Edit { event_id: String },
++}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct CreateEventForm {
++    mode: EventFormMode,
      context: CreateEventContext,
      selected_date: CalendarDate,
      title: String,
  impl CreateEventForm {
      pub fn new(selected_date: CalendarDate, context: CreateEventContext) -> Self {
          Self {
++            mode: EventFormMode::Create,
              context,
              selected_date,
              title: String::new(),
+         }
+     }
++    pub fn edit(event: &Event) -> Self {
++        let (all_day, start_date, start_time, end_date, end_time, selected_date) =
++            match event.timing {
++                EventTiming::AllDay { date } => (
++                    true,
++                    date.to_string(),
++                    "09:00".to_string(),
++                    date.to_string(),
++                    "10:00".to_string(),
++                    date,
++                ),
++                EventTiming::Timed { start, end } => (
++                    false,
++                    start.date.to_string(),
++                    format_time_field(start.time),
++                    end.date.to_string(),
++                    format_time_field(end.time),
++                    start.date,
++                ),
++            };
++        let mut reminders = [false; REMINDER_PRESETS.len()];
++        for reminder in &event.reminders {
++            if let Some(index) = REMINDER_PRESETS
++                .iter()
++                .position(|preset| preset.minutes == reminder.minutes_before)
++            {
++                reminders[index] = true;
++            }
++        }
++
++        Self {
++            mode: EventFormMode::Edit {
++                event_id: event.id.clone(),
++            },
++            context: CreateEventContext::EditableDate,
++            selected_date,
++            title: event.title.clone(),
++            all_day,
++            start_date,
++            start_time,
++            end_date,
++            end_time,
++            location: event.location.clone().unwrap_or_default(),
++            notes: event.notes.clone().unwrap_or_default(),
++            reminders,
++            focused: 0,
++            error: None,
++        }
++    }
++
++    pub fn mode(&self) -> &EventFormMode {
++        &self.mode
++    }
++
++    pub fn heading(&self) -> &'static str {
++        match &self.mode {
++            EventFormMode::Create => "Create",
++            EventFormMode::Edit { .. } => "Edit",
++        }
++    }
++
      pub const fn context(&self) -> CreateEventContext {
          self.context
+     }
          if ctrl_s(key) {
              return match self.submit() {
--                Ok(draft) => CreateEventInputResult::Submit(draft),
++                Ok(draft) => CreateEventInputResult::Submit(EventFormSubmission {
++                    mode: self.mode.clone(),
++                    draft,
++                }),
                  Err(err) => {
                      self.error = Some(err.to_string());
                      CreateEventInputResult::Continue
      Toggle,
+ }
++#[derive(Debug, Clone, PartialEq, Eq)]
++pub struct EventFormSubmission {
++    pub mode: EventFormMode,
++    pub draft: CreateEventDraft,
++}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum CreateEventInputResult {
      Continue,
      Cancel,
--    Submit(CreateEventDraft),
++    Submit(EventFormSubmission),
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
      })
+ }
++fn format_time_field(time: Time) -> String {
++    format!("{:02}:{:02}", time.hour(), time.minute())
++}
++
++fn selectable_day_events(date: CalendarDate, source: &dyn AgendaSource) -> Vec<Event> {
++    let agenda = DayAgenda::from_source(date, source);
++    agenda
++        .all_day_events
++        .into_iter()
++        .chain(
++            agenda
++                .timed_events
++                .into_iter()
++                .map(|agenda_event| agenda_event.event),
++        )
++        .filter(Event::is_local)
++        .collect()
++}
++
  #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
  pub struct KeyboardInput {
      pending: PendingKey,
  mod tests {
      use super::*;
      use crossterm::event::{KeyModifiers, MouseButton, MouseEventKind};
--    use time::Month;
++    use time::{Month, Time};
      use crate::agenda::{Holiday, InMemoryAgendaSource, SourceMetadata};
          CalendarDate::from_ymd(year, month, day).expect("valid test date")
+     }
++    fn at(date: CalendarDate, hour: u8, minute: u8) -> EventDateTime {
++        EventDateTime::new(
++            date,
++            Time::from_hms(hour, minute, 0).expect("valid test time"),
++        )
++    }
++
++    fn local_timed_event(id: &str, title: &str, start: EventDateTime, end: EventDateTime) -> Event {
++        Event::timed(id, title, start, end, SourceMetadata::local())
++            .expect("valid local timed event")
++    }
++
++    fn local_all_day_event(id: &str, title: &str, date: CalendarDate) -> Event {
++        Event::all_day(id, title, date, SourceMetadata::local())
++    }
++
++    fn fixture_timed_event(
++        id: &str,
++        title: &str,
++        start: EventDateTime,
++        end: EventDateTime,
++    ) -> Event {
++        Event::timed(id, title, start, end, SourceMetadata::fixture())
++            .expect("valid fixture timed event")
++    }
++
      fn key(code: KeyCode) -> KeyEvent {
          KeyEvent::new(code, KeyModifiers::empty())
+     }
+         }
+     }
++    fn apply_keys_with_source(
++        app: &mut AppState,
++        input: &mut KeyboardInput,
++        source: &dyn AgendaSource,
++        keys: impl IntoIterator<Item = KeyEvent>,
++    ) {
++        for key in keys {
++            let action = input.translate(key);
++            app.apply_with_agenda_source(action, source);
++        }
++    }
++
      #[test]
      fn arrow_keys_move_within_month() {
          let mut app = AppState::new(date(2026, Month::April, 23));
          assert_eq!(app.selected_date(), date(2026, Month::April, 23));
+     }
++    #[test]
++    fn day_view_selects_first_local_event_and_skips_non_local_items() {
++        let day = date(2026, Month::April, 23);
++        let source = InMemoryAgendaSource::with_events_and_holidays(
++            vec![
++                Event::all_day("fixture-all", "A Fixture", day, SourceMetadata::fixture()),
++                local_all_day_event("local-all", "Release", day),
++                fixture_timed_event("fixture-time", "Fixture", at(day, 8, 0), at(day, 9, 0)),
++                local_timed_event("local-time", "Standup", at(day, 9, 0), at(day, 9, 30)),
++            ],
++            vec![Holiday::new(
++                "holiday",
++                "Holiday",
++                day,
++                SourceMetadata::fixture(),
++            )],
++        );
++        let mut app = AppState::new(day);
++        let mut input = KeyboardInput::default();
++
++        apply_keys_with_source(&mut app, &mut input, &source, [key(KeyCode::Enter)]);
++
++        assert_eq!(app.view_mode(), ViewMode::Day);
++        assert_eq!(app.selected_day_event_id(), Some("local-all"));
++    }
++
++    #[test]
++    fn day_view_up_and_down_cycle_local_event_selection() {
++        let day = date(2026, Month::April, 23);
++        let source = InMemoryAgendaSource::with_events_and_holidays(
++            vec![
++                local_all_day_event("local-all", "Release", day),
++                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), key(KeyCode::Down)],
++        );
++
++        assert_eq!(app.selected_date(), day);
++        assert_eq!(app.selected_day_event_id(), Some("local-time"));
++
++        apply_keys_with_source(&mut app, &mut input, &source, [key(KeyCode::Down)]);
++        assert_eq!(app.selected_day_event_id(), Some("local-all"));
++
++        apply_keys_with_source(&mut app, &mut input, &source, [key(KeyCode::Up)]);
++        assert_eq!(app.selected_day_event_id(), Some("local-time"));
++    }
++
++    #[test]
++    fn day_view_enter_opens_edit_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), key(KeyCode::Enter)],
++        );
++
++        let form = app.create_form().expect("edit form opens");
++        assert_eq!(
++            form.mode(),
++            &EventFormMode::Edit {
++                event_id: "local-time".to_string()
++            }
++        );
++        assert_eq!(form.rows()[0].value, "Standup");
++    }
++
++    #[test]
++    fn day_view_reconciles_selection_when_event_leaves_day() {
++        let day = date(2026, Month::April, 23);
++        let next_day = date(2026, Month::April, 24);
++        let source = InMemoryAgendaSource::with_events_and_holidays(
++            vec![
++                local_timed_event("move", "Move", at(day, 8, 0), at(day, 9, 0)),
++                local_timed_event("stay", "Stay", at(day, 10, 0), at(day, 11, 0)),
++            ],
++            Vec::new(),
++        );
++        let moved_source = InMemoryAgendaSource::with_events_and_holidays(
++            vec![
++                local_timed_event("move", "Move", at(next_day, 8, 0), at(next_day, 9, 0)),
++                local_timed_event("stay", "Stay", at(day, 10, 0), at(day, 11, 0)),
++            ],
++            Vec::new(),
++        );
++        let mut app = AppState::new(day);
++        app.apply_with_agenda_source(AppAction::OpenDay, &source);
++
++        assert_eq!(app.selected_day_event_id(), Some("move"));
++
++        app.reconcile_day_event_selection(&moved_source);
++
++        assert_eq!(app.selected_date(), day);
++        assert_eq!(app.selected_day_event_id(), Some("stay"));
++    }
++
++    #[test]
++    fn edit_form_up_and_down_keep_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), key(KeyCode::Enter)],
++        );
++
++        assert_eq!(
++            app.handle_create_key(key(KeyCode::Down)),
++            CreateEventInputResult::Continue
++        );
++        assert_eq!(app.selected_day_event_id(), Some("local-time"));
++        assert!(app.create_form().expect("form stays open").rows()[1].focused);
++    }
++
      #[test]
      fn quit_action_marks_app_done() {
          let mut app = AppState::new(date(2026, Month::April, 23));
          assert_eq!(form.error(), Some("title is required"));
+     }
++    #[test]
++    fn edit_form_preloads_timed_event_fields() {
++        let day = date(2026, Month::April, 23);
++        let event = local_timed_event("local-time", "Standup", at(day, 9, 0), at(day, 9, 30))
++            .with_location("Room 1")
++            .with_notes("Bring notes")
++            .with_reminders(vec![
++                Reminder::minutes_before(10),
++                Reminder::minutes_before(60),
++            ]);
++
++        let form = CreateEventForm::edit(&event);
++
++        assert_eq!(
++            form.mode(),
++            &EventFormMode::Edit {
++                event_id: "local-time".to_string()
++            }
++        );
++        assert_eq!(form.title, "Standup");
++        assert!(!form.all_day);
++        assert_eq!(form.start_date, "2026-04-23");
++        assert_eq!(form.start_time, "09:00");
++        assert_eq!(form.end_date, "2026-04-23");
++        assert_eq!(form.end_time, "09:30");
++        assert_eq!(form.location, "Room 1");
++        assert_eq!(form.notes, "Bring notes");
++        assert!(form.reminders[1]);
++        assert!(form.reminders[4]);
++    }
++
++    #[test]
++    fn edit_form_preloads_all_day_event_and_can_switch_to_timed() {
++        let day = date(2026, Month::April, 23);
++        let event = local_all_day_event("local-all", "Release", day);
++        let mut form = CreateEventForm::edit(&event);
++
++        assert!(form.all_day);
++        assert_eq!(form.start_date, "2026-04-23");
++        assert_eq!(form.start_time, "09:00");
++        assert_eq!(form.end_time, "10:00");
++
++        form.all_day = false;
++        let draft = form.submit().expect("all-day edit can become timed");
++
++        assert_eq!(
++            draft.timing,
++            CreateEventTiming::Timed {
++                start: EventDateTime::new(day, Time::from_hms(9, 0, 0).expect("valid time")),
++                end: EventDateTime::new(day, Time::from_hms(10, 0, 0).expect("valid time")),
++            }
++        );
++    }
++
++    #[test]
++    fn edit_form_can_switch_timed_event_to_all_day() {
++        let day = date(2026, Month::April, 23);
++        let event = local_timed_event("local-time", "Standup", at(day, 9, 0), at(day, 9, 30));
++        let mut form = CreateEventForm::edit(&event);
++
++        form.all_day = true;
++        let draft = form.submit().expect("timed edit can become all day");
++
++        assert_eq!(draft.timing, CreateEventTiming::AllDay { date: day });
++    }
++
      #[test]
      fn create_form_submits_day_view_cross_midnight_event() {
          let day = date(2026, Month::April, 23);

src/cli.rsmodified

  use crate::{
      agenda::{ConfiguredAgendaSource, HolidayProvider, LocalEventStoreError, default_events_file},
--    app::{AppState, CreateEventInputResult, KeyboardInput, MouseInput},
++    app::{AppState, CreateEventInputResult, EventFormMode, KeyboardInput, MouseInput},
      calendar::CalendarDate,
      tui::{
          AppView, DEFAULT_RENDER_HEIGHT, DEFAULT_RENDER_WIDTH, hit_test_app_date,
                      match app.handle_create_key(key) {
                          CreateEventInputResult::Continue => {}
                          CreateEventInputResult::Cancel => app.close_create_form(),
--                        CreateEventInputResult::Submit(draft) => {
++                        CreateEventInputResult::Submit(submission) => match submission.mode {
--                            match agenda_source.create_event(draft) {
++                            EventFormMode::Create => {
--                                Ok(_) => app.close_create_form(),
++                                match agenda_source.create_event(submission.draft) {
--                                Err(err) => app.set_create_form_error(err.to_string()),
++                                    Ok(_) => {
++                                        app.close_create_form();
++                                        app.reconcile_day_event_selection(&agenda_source);
++                                    }
++                                    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);
++                                    }
++                                    Err(err) => app.set_create_form_error(err.to_string()),
++                                }
++                            }
++                        },
+                     }
                  } else {
                      let action = keyboard.translate(key);
--                    app.apply(action);
++                    app.apply_with_agenda_source(action, &agenda_source);
+                 }
+             }
              Event::Mouse(mouse_event) => {
                  let target_date =
                      hit_test_app_date(&app, area, mouse_event.column, mouse_event.row);
                  let action = mouse.translate(mouse_event, target_date, app.selected_date());
--                app.apply(action);
++                app.apply_with_agenda_source(action, &agenda_source);
+             }
              Event::Resize(_, _) => {
                  keyboard.clear();

src/tui.rsmodified

      timeline_event: Style,
      holiday: Style,
      event: Style,
++    selected_event: Style,
+ }
  impl DayViewStyles {
              timeline_event: Style::new().fg(Color::White).bg(Color::Blue),
              holiday: Style::new().fg(Color::Yellow),
              event: Style::new().fg(Color::White),
++            selected_event: Style::new()
++                .fg(Color::White)
++                .bg(Color::Blue)
++                .add_modifier(Modifier::BOLD),
+         }
+     }
+ }
      match layout.mode {
          DayViewLayoutMode::Split | DayViewLayoutMode::Stacked => {
              if let Some(agenda_area) = layout.agenda_area {
--                render_agenda_panel(&agenda, agenda_area, buf, styles);
++                render_agenda_panel(
++                    &agenda,
++                    app.selected_day_event_id(),
++                    agenda_area,
++                    buf,
++                    styles,
++                );
+             }
              if let Some(timeline_area) = layout.timeline_area {
          content.y,
          content.x,
          content.width,
--        "Create",
++        form.heading(),
          styles.title,
      );
      let label_width = 12.min(content.width.saturating_sub(1));
+     }
+ }
--fn render_agenda_panel(agenda: &DayAgenda, area: Rect, buf: &mut Buffer, styles: DayViewStyles) {
++fn render_agenda_panel(
++    agenda: &DayAgenda,
++    selected_event_id: Option<&str>,
++    area: Rect,
++    buf: &mut Buffer,
++    styles: DayViewStyles,
++) {
      render_panel(area, "Agenda", buf, styles);
      let content = inset_rect(area);
              y = render_event_detail_lines(
                  event,
                  &format!("- {}", event.title),
++                selected_event_id == Some(event.id.as_str()),
                  content,
                  y,
                  buf,
                  y = render_event_detail_lines(
                      &agenda_event.event,
                      &agenda_event_line(agenda_event),
++                    selected_event_id == Some(agenda_event.event.id.as_str()),
                      content,
                      y,
                      buf,
  fn render_event_detail_lines(
      event: &Event,
      first_line: &str,
++    selected: bool,
      content: Rect,
      mut y: u16,
      buf: &mut Buffer,
      styles: DayViewStyles,
  ) -> u16 {
--    write_left(buf, y, content.x, content.width, first_line, styles.event);
++    let first_line = if selected {
++        format!("> {first_line}")
++    } else {
++        format!("  {first_line}")
++    };
++    let style = if selected {
++        styles.selected_event
++    } else {
++        styles.event
++    };
++    write_left(buf, y, content.x, content.width, &first_line, style);
      y += 1;
      if let Some(location) = &event.location {
          buffer
+     }
++    fn render_app_buffer_with_agenda_source<S>(
++        app: &AppState,
++        width: u16,
++        height: u16,
++        agenda_source: &S,
++    ) -> Buffer
++    where
++        S: AgendaSource,
++    {
++        let area = Rect::new(0, 0, width, height);
++        let mut buffer = Buffer::empty(area);
++        AppView::with_agenda_source(app, agenda_source).render(area, &mut buffer);
++        buffer
++    }
++
      fn buffer_lines(buffer: &Buffer) -> Vec<String> {
          buffer_to_string(buffer)
              .lines()
          SourceMetadata::fixture()
+     }
++    fn local_source_metadata() -> SourceMetadata {
++        SourceMetadata::local()
++    }
++
      fn at(date: CalendarDate, hour: u8, minute: u8) -> EventDateTime {
          EventDateTime::new(
              date,
          Event::timed(id, title, start, end, source_metadata()).expect("valid test event")
+     }
++    fn local_timed_event(id: &str, title: &str, start: EventDateTime, end: EventDateTime) -> Event {
++        Event::timed(id, title, start, end, local_source_metadata())
++            .expect("valid local timed event")
++    }
++
      fn agenda_source(events: Vec<Event>, holidays: Vec<Holiday>) -> InMemoryAgendaSource {
          InMemoryAgendaSource::with_events_and_holidays(events, holidays)
+     }
          assert!(rendered.contains("Ctrl-S save"));
+     }
++    #[test]
++    fn edit_modal_uses_edit_title() {
++        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::OpenDay, &source);
++
++        let rendered = render_app_to_string_with_agenda_source(&app, 84, 26, &source);
++
++        assert!(rendered.contains("Edit"));
++        assert!(rendered.contains("Planning"));
++    }
++
      #[test]
      fn create_modal_clears_background_content() {
          let selected = date(2026, Month::April, 23);
          assert!(rendered.contains("Bring notes"));
+     }
++    #[test]
++    fn day_view_highlights_selected_local_event() {
++        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);
++
++        let buffer = render_app_buffer_with_agenda_source(&app, 84, 18, &source);
++        let rendered = buffer_to_string(&buffer);
++        let selected_position = rendered
++            .lines()
++            .enumerate()
++            .find_map(|(row, line)| {
++                line.find("> 09:00-10:00 Planning")
++                    .map(|column| (column, row))
++            })
++            .expect("selected event is rendered");
++        let selected_cell = buffer
++            .cell((
++                u16::try_from(selected_position.0).expect("column fits"),
++                u16::try_from(selected_position.1).expect("row fits"),
++            ))
++            .expect("selected cell exists");
++
++        assert_eq!(selected_cell.bg, Color::Blue);
++        assert!(selected_cell.modifier.contains(Modifier::BOLD));
++    }
++
      #[test]
      fn overlapping_timeline_events_keep_distinct_labels() {
          let day = date(2026, Month::April, 23);