`027ce51`

Add calendar target selector

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 weeks ago

SHA: 027ce5189ab5349784cd617150f71dd3c7ece796
Parents: 816267c
Tree: 3abe913

6 changed files

Status	File	+	-
M	`README.md`	6	3
M	`src/agenda.rs`	143	2
M	`src/app.rs`	312	10
M	`src/cli.rs`	9	2
M	`src/providers.rs`	199	8
M	`src/tui.rs`	41	23

README.mdmodified

  - Left click selects a visible date; double-click a visible date to open day
    view.
 -Created events are stored locally as JSON and are shown immediately in month,
 -week, and day views. The create/edit modal supports timed events, single-day
 -all-day events, recurrence, location, notes, and multiple reminder offsets.
 +The create/edit modal supports timed events, single-day all-day events,
 +recurrence, location, notes, and multiple reminder offsets. Its `Calendar`
 +field controls where the event is saved; use Left/Right on that field to cycle
 +between local storage and configured editable provider calendars. Local events
 +are stored as JSON, while Microsoft events are written through Graph and then
 +shown immediately from the provider cache.
  Reminder notifications are delivered by a user-level background service. Use
  `rcal reminders install` to install it, `rcal reminders status` to inspect it,
  and `rcal reminders test` to send a test notification. On macOS, notification

src/agenda.rsmodified

+     }
+ }
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct EventWriteTarget {
 +    pub id: EventWriteTargetId,
 +    pub label: String,
 +}
++
 +impl EventWriteTarget {
 +    pub fn local() -> Self {
 +        Self {
 +            id: EventWriteTargetId::Local,
 +            label: "Local".to_string(),
 +        }
 +    }
++
 +    pub fn microsoft(
 +        account_id: impl Into<String>,
 +        calendar_id: impl Into<String>,
 +        label: impl Into<String>,
 +    ) -> Self {
 +        Self {
 +            id: EventWriteTargetId::Microsoft {
 +                account_id: account_id.into(),
 +                calendar_id: calendar_id.into(),
 +            },
 +            label: label.into(),
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum EventWriteTargetId {
 +    Local,
 +    Microsoft {
 +        account_id: String,
 +        calendar_id: String,
 +    },
 +}
++
 +impl EventWriteTargetId {
 +    pub const fn is_local(&self) -> bool {
 +        matches!(self, Self::Local)
 +    }
++
 +    pub fn from_event(event: &Event) -> Option<Self> {
 +        if event.is_local() {
 +            return Some(Self::Local);
 +        }
 +        let mut parts = event.source.source_id.splitn(3, ':');
 +        match (parts.next(), parts.next(), parts.next()) {
 +            (Some("microsoft"), Some(account_id), Some(calendar_id)) => Some(Self::Microsoft {
 +                account_id: account_id.to_string(),
 +                calendar_id: calendar_id.to_string(),
 +            }),
 +            _ => None,
 +        }
 +    }
 +}
++
  #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
  pub struct Reminder {
      pub minutes_before: u16,
      fn holidays_in(&self, range: DateRange) -> Vec<Holiday>;
 +    fn event_write_targets(&self) -> Vec<EventWriteTarget> {
 +        vec![EventWriteTarget::local()]
 +    }
++
 +    fn default_event_write_target(&self) -> EventWriteTargetId {
 +        EventWriteTargetId::Local
 +    }
++
      fn local_event_by_id(&self, _id: &str) -> Option<Event> {
          None
+     }
+     }
      pub fn create_event(&mut self, draft: CreateEventDraft) -> Result<Event, LocalEventStoreError> {
 -        if self.create_target == ProviderCreateTarget::Microsoft
 +        let target = self.default_event_write_target();
 +        self.create_event_with_target(draft, &target)
 +    }
++
 +    pub fn create_event_with_target(
 +        &mut self,
 +        draft: CreateEventDraft,
 +        target: &EventWriteTargetId,
 +    ) -> Result<Event, LocalEventStoreError> {
 +        if let EventWriteTargetId::Microsoft { .. } = target
              && let Some(microsoft) = &mut self.microsoft
+         {
              let http = ReqwestMicrosoftHttpClient;
              let token_store = KeyringMicrosoftTokenStore;
              return microsoft
 -                .create_event(draft, &http, &token_store)
 +                .create_event_in_target(draft, target, &http, &token_store)
                  .map_err(provider_error);
+         }
 +        if matches!(target, EventWriteTargetId::Microsoft { .. }) {
 +            return Err(LocalEventStoreError::Provider {
 +                reason: "Microsoft provider is not configured".to_string(),
 +            });
 +        }
 +        self.create_local_event(draft)
 +    }
++
 +    fn create_local_event(
 +        &mut self,
 +        draft: CreateEventDraft,
 +    ) -> Result<Event, LocalEventStoreError> {
          let id = self.next_local_event_id(&draft.title);
          let event = draft
              .into_event(id)
          id: &str,
          draft: CreateEventDraft,
      ) -> Result<Event, LocalEventStoreError> {
 +        let target = self
 +            .event_target_for_id(id)
 +            .unwrap_or(EventWriteTargetId::Local);
 +        self.update_event_with_target(id, draft, &target)
 +    }
++
 +    pub fn update_event_with_target(
 +        &mut self,
 +        id: &str,
 +        draft: CreateEventDraft,
 +        target: &EventWriteTargetId,
 +    ) -> Result<Event, LocalEventStoreError> {
 +        let current_target = self.event_target_for_id(id);
 +        if current_target
 +            .as_ref()
 +            .is_some_and(|current| current != target)
 +        {
 +            let created = self.create_event_with_target(draft, target)?;
 +            self.delete_event(id)?;
 +            return Ok(created);
 +        }
++
          if self.events.local_event_by_id(id).is_none()
              && id.starts_with("microsoft:")
              && let Some(microsoft) = &mut self.microsoft
          Ok(event)
+     }
 +    fn event_target_for_id(&self, id: &str) -> Option<EventWriteTargetId> {
 +        self.events
 +            .local_event_by_id(id)
 +            .as_ref()
 +            .and_then(EventWriteTargetId::from_event)
 +            .or_else(|| {
 +                let microsoft = self.microsoft.as_ref()?;
 +                let event = microsoft.agenda_source().editable_event_by_id(id)?;
 +                EventWriteTargetId::from_event(&event)
 +            })
 +    }
++
      fn next_local_event_id(&self, title: &str) -> String {
          let now = SystemTime::now()
              .duration_since(UNIX_EPOCH)
          self.holidays.holidays_in(range)
+     }
 +    fn event_write_targets(&self) -> Vec<EventWriteTarget> {
 +        let mut targets = vec![EventWriteTarget::local()];
 +        if let Some(microsoft) = &self.microsoft {
 +            targets.extend(microsoft.write_targets());
 +        }
 +        targets
 +    }
++
 +    fn default_event_write_target(&self) -> EventWriteTargetId {
 +        if self.create_target == ProviderCreateTarget::Microsoft
 +            && let Some(target) = self
 +                .microsoft
 +                .as_ref()
 +                .and_then(MicrosoftProviderRuntime::default_write_target)
 +        {
 +            return target;
 +        }
 +        EventWriteTargetId::Local
 +    }
++
      fn local_event_by_id(&self, id: &str) -> Option<Event> {
          self.events.local_event_by_id(id)
+     }

src/app.rsmodified

  use crate::{
      agenda::{
          AgendaSource, CreateEventDraft, CreateEventTiming, DayAgenda, Event, EventDateTime,
 -        EventTiming, OccurrenceAnchor, RecurrenceEnd, RecurrenceFrequency, RecurrenceMonthlyRule,
 -        RecurrenceRule, RecurrenceYearlyRule, Reminder, recurrence_ordinal_for_date,
 +        EventTiming, EventWriteTarget, EventWriteTargetId, OccurrenceAnchor, RecurrenceEnd,
 +        RecurrenceFrequency, RecurrenceMonthlyRule, RecurrenceRule, RecurrenceYearlyRule, Reminder,
 +        recurrence_ordinal_for_date,
      },
      calendar::{CalendarDate, CalendarMonth, DAYS_PER_WEEK},
  };
                                  .unwrap_or(false)
                          })
+                     {
 -                        self.create_form = Some(CreateEventForm::edit_occurrence(&event));
 +                        self.create_form = Some(CreateEventForm::edit_occurrence_with_targets(
 +                            &event,
 +                            source.event_write_targets(),
 +                        ));
+                     }
                      RecurrenceChoiceInputResult::Continue
+                 }
                      let series_id = choice.series_id.clone();
                      self.recurrence_choice = None;
                      if let Some(event) = source.editable_event_by_id(&series_id) {
 -                        self.create_form = Some(CreateEventForm::edit(&event));
 +                        self.create_form = Some(CreateEventForm::edit_with_targets(
 +                            &event,
 +                            source.event_write_targets(),
 +                        ));
+                     }
                      RecurrenceChoiceInputResult::Continue
+                 }
                          ViewMode::Month => CreateEventContext::EditableDate,
                          ViewMode::Day => CreateEventContext::FixedDate,
                      };
 -                    self.create_form = Some(CreateEventForm::new(self.selected_date, context));
 +                    let targets = source
 +                        .map(AgendaSource::event_write_targets)
 +                        .unwrap_or_else(|| vec![EventWriteTarget::local()]);
 +                    let selected_target = source
 +                        .map(AgendaSource::default_event_write_target)
 +                        .unwrap_or(EventWriteTargetId::Local);
 +                    self.create_form = Some(CreateEventForm::new_with_targets(
 +                        self.selected_date,
 +                        context,
 +                        targets,
 +                        selected_target,
 +                    ));
+                 }
+             }
              AppAction::OpenDelete if self.view_mode == ViewMode::Day => {
                      occurrence.anchor,
                  ));
              } else {
 -                self.create_form = Some(CreateEventForm::edit(&event));
 +                self.create_form = Some(CreateEventForm::edit_with_targets(
 +                    &event,
 +                    source.event_write_targets(),
 +                ));
+             }
+         }
+     }
  pub struct CreateEventForm {
      mode: EventFormMode,
      context: CreateEventContext,
 +    targets: Vec<EventWriteTarget>,
 +    selected_target: usize,
      selected_date: CalendarDate,
      title: String,
      all_day: bool,
      error: Option<String>,
+ }
 +fn normalize_write_targets(
 +    targets: Vec<EventWriteTarget>,
 +    current: Option<EventWriteTarget>,
 +) -> Vec<EventWriteTarget> {
 +    let mut normalized = Vec::new();
 +    for target in targets.into_iter().chain(current) {
 +        if !normalized
 +            .iter()
 +            .any(|existing: &EventWriteTarget| existing.id == target.id)
 +        {
 +            normalized.push(target);
 +        }
 +    }
 +    if normalized.is_empty() {
 +        normalized.push(EventWriteTarget::local());
 +    }
 +    normalized
 +}
++
 +fn selected_target_index(targets: &[EventWriteTarget], selected: &EventWriteTargetId) -> usize {
 +    targets
 +        .iter()
 +        .position(|target| &target.id == selected)
 +        .unwrap_or_default()
 +}
++
  impl CreateEventForm {
      pub fn new(selected_date: CalendarDate, context: CreateEventContext) -> Self {
 +        Self::new_with_targets(
 +            selected_date,
 +            context,
 +            vec![EventWriteTarget::local()],
 +            EventWriteTargetId::Local,
 +        )
 +    }
++
 +    pub fn new_with_targets(
 +        selected_date: CalendarDate,
 +        context: CreateEventContext,
 +        targets: Vec<EventWriteTarget>,
 +        selected_target: EventWriteTargetId,
 +    ) -> Self {
 +        let targets = normalize_write_targets(targets, None);
 +        let selected_target = selected_target_index(&targets, &selected_target);
          Self {
              mode: EventFormMode::Create,
              context,
 +            targets,
 +            selected_target,
              selected_date,
              title: String::new(),
              all_day: false,
+     }
      pub fn edit(event: &Event) -> Self {
 +        Self::edit_with_targets(event, vec![EventWriteTarget::local()])
 +    }
++
 +    pub fn edit_with_targets(event: &Event, targets: Vec<EventWriteTarget>) -> Self {
          let (all_day, start_date, start_time, end_date, end_time, selected_date) =
              match event.timing {
                  EventTiming::AllDay { date } => (
                  reminders[index] = true;
+             }
+         }
 +        let current_target = EventWriteTargetId::from_event(event);
 +        let targets = normalize_write_targets(
 +            targets,
 +            current_target.as_ref().map(|target| EventWriteTarget {
 +                id: target.clone(),
 +                label: event.source.source_name.clone(),
 +            }),
 +        );
 +        let selected_target = current_target
 +            .as_ref()
 +            .map(|target| selected_target_index(&targets, target))
 +            .unwrap_or_default();
          let mut form = Self {
              mode: EventFormMode::Edit {
                  event_id: event.id.clone(),
              },
              context: CreateEventContext::EditableDate,
 +            targets,
 +            selected_target,
              selected_date,
              title: event.title.clone(),
              all_day,
+     }
      pub fn edit_occurrence(event: &Event) -> Self {
 +        Self::edit_occurrence_with_targets(event, vec![EventWriteTarget::local()])
 +    }
++
 +    pub fn edit_occurrence_with_targets(event: &Event, targets: Vec<EventWriteTarget>) -> Self {
          let Some(occurrence) = event.occurrence() else {
 -            return Self::edit(event);
 +            return Self::edit_with_targets(event, targets);
          };
 -        let mut form = Self::edit(event);
 +        let mut form = Self::edit_with_targets(event, targets);
          form.mode = EventFormMode::EditOccurrence {
              series_id: occurrence.series_id.clone(),
              anchor: occurrence.anchor,
                  Ok(draft) => CreateEventInputResult::Submit(Box::new(EventFormSubmission {
                      mode: self.mode.clone(),
                      draft,
 +                    target: self.selected_target_id(),
                  })),
                  Err(err) => {
                      self.error = Some(err.to_string());
                  self.focus_next();
                  CreateEventInputResult::Continue
+             }
 +            KeyCode::Left => {
 +                self.cycle_focused_field(-1);
 +                CreateEventInputResult::Continue
 +            }
 +            KeyCode::Right => {
 +                self.cycle_focused_field(1);
 +                CreateEventInputResult::Continue
 +            }
              KeyCode::Backspace => {
                  self.edit_text_field(|value| {
                      value.pop();
+     }
      fn visible_fields(&self) -> Vec<CreateEventField> {
 -        let mut fields = vec![CreateEventField::Title, CreateEventField::AllDay];
 +        let mut fields = vec![CreateEventField::Title];
 +        if !matches!(self.mode, EventFormMode::EditOccurrence { .. }) {
 +            fields.push(CreateEventField::Calendar);
 +        }
 +        fields.push(CreateEventField::AllDay);
          if self.context == CreateEventContext::EditableDate {
              fields.push(CreateEventField::StartDate);
+         }
      fn field_value(&self, field: CreateEventField) -> String {
          match field {
              CreateEventField::Title => self.title.clone(),
 +            CreateEventField::Calendar => self.targets[self.selected_target].label.clone(),
              CreateEventField::AllDay => checkbox(self.all_day).to_string(),
              CreateEventField::StartDate => self.start_date.clone(),
              CreateEventField::StartTime => self.start_time.clone(),
      fn activate_focused_field(&mut self) {
          match self.focused_field() {
              CreateEventField::AllDay => self.all_day = !self.all_day,
 +            CreateEventField::Calendar => self.cycle_target(1),
              CreateEventField::Reminder(index) => self.reminders[index] = !self.reminders[index],
              CreateEventField::Notes => self.notes.push('\n'),
              CreateEventField::Repeat => self.repeat = self.repeat.next(),
          self.error = None;
+     }
 +    fn cycle_focused_field(&mut self, delta: i32) {
 +        match self.focused_field() {
 +            CreateEventField::Calendar => self.cycle_target(delta),
 +            CreateEventField::Repeat => {
 +                self.repeat = if delta < 0 {
 +                    self.repeat.previous()
 +                } else {
 +                    self.repeat.next()
 +                };
 +            }
 +            CreateEventField::MonthlyMode => {
 +                self.monthly_mode = if delta < 0 {
 +                    self.monthly_mode.previous()
 +                } else {
 +                    self.monthly_mode.next()
 +                };
 +            }
 +            CreateEventField::YearlyMode => {
 +                self.yearly_mode = if delta < 0 {
 +                    self.yearly_mode.previous()
 +                } else {
 +                    self.yearly_mode.next()
 +                };
 +            }
 +            CreateEventField::RecurrenceEnd => {
 +                self.recurrence_end = if delta < 0 {
 +                    self.recurrence_end.previous()
 +                } else {
 +                    self.recurrence_end.next()
 +                };
 +            }
 +            _ => {}
 +        }
 +        self.error = None;
 +    }
++
 +    fn cycle_target(&mut self, delta: i32) {
 +        let len = self.targets.len();
 +        if len <= 1 {
 +            return;
 +        }
 +        self.selected_target = if delta < 0 {
 +            (self.selected_target + len - 1) % len
 +        } else {
 +            (self.selected_target + 1) % len
 +        };
 +    }
++
 +    fn selected_target_id(&self) -> EventWriteTargetId {
 +        self.targets
 +            .get(self.selected_target)
 +            .map(|target| target.id.clone())
 +            .unwrap_or(EventWriteTargetId::Local)
 +    }
++
      fn edit_text_field(&mut self, edit: impl FnOnce(&mut String)) {
          let field = self.focused_field();
          let target = match field {
              CreateEventField::UntilDate => Some(&mut self.recurrence_until_date),
              CreateEventField::OccurrenceCount => Some(&mut self.recurrence_count),
              CreateEventField::AllDay
 +            | CreateEventField::Calendar
              | CreateEventField::Reminder(_)
              | CreateEventField::Repeat
              | CreateEventField::WeeklyDay(_)
      Text,
      Multiline,
      Toggle,
 +    Selector,
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub struct EventFormSubmission {
      pub mode: EventFormMode,
      pub draft: CreateEventDraft,
 +    pub target: EventWriteTargetId,
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
+         }
+     }
 +    const fn previous(self) -> Self {
 +        match self {
 +            Self::None => Self::Yearly,
 +            Self::Daily => Self::None,
 +            Self::Weekly => Self::Daily,
 +            Self::Monthly => Self::Weekly,
 +            Self::Yearly => Self::Monthly,
 +        }
 +    }
++
      const fn frequency(self) -> Option<RecurrenceFrequency> {
          match self {
              Self::None => None,
              Self::WeekdayOrdinal => Self::DayOfMonth,
+         }
+     }
++
 +    const fn previous(self) -> Self {
 +        self.next()
 +    }
+ }
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
              Self::WeekdayOrdinal => Self::Date,
+         }
+     }
++
 +    const fn previous(self) -> Self {
 +        self.next()
 +    }
+ }
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
              Self::Count => Self::Never,
+         }
+     }
++
 +    const fn previous(self) -> Self {
 +        match self {
 +            Self::Never => Self::Count,
 +            Self::Until => Self::Never,
 +            Self::Count => Self::Until,
 +        }
 +    }
+ }
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  enum CreateEventField {
      Title,
 +    Calendar,
      AllDay,
      StartDate,
      StartTime,
      const fn label(self) -> &'static str {
          match self {
              Self::Title => "Title",
 +            Self::Calendar => "Calendar",
              Self::AllDay => "All day",
              Self::StartDate => "Start date",
              Self::StartTime => "Start time",
          match self {
              Self::Notes => CreateEventFormRowKind::Multiline,
              Self::AllDay | Self::Reminder(_) | Self::WeeklyDay(_) => CreateEventFormRowKind::Toggle,
 +            Self::Calendar
 +            | Self::Repeat
 +            | Self::MonthlyMode
 +            | Self::YearlyMode
 +            | Self::RecurrenceEnd => CreateEventFormRowKind::Selector,
              _ => CreateEventFormRowKind::Text,
+         }
+     }
      use crossterm::event::{KeyModifiers, MouseButton, MouseEventKind};
      use time::{Month, Time};
 -    use crate::agenda::{Holiday, InMemoryAgendaSource, RecurrenceOrdinal, SourceMetadata};
 +    use crate::agenda::{
 +        DateRange, Holiday, InMemoryAgendaSource, RecurrenceOrdinal, SourceMetadata,
 +    };
      fn date(year: i32, month: Month, day: u8) -> CalendarDate {
          CalendarDate::from_ymd(year, month, day).expect("valid test date")
+         }
+     }
 +    struct WriteTargetSource {
 +        targets: Vec<EventWriteTarget>,
 +        default: EventWriteTargetId,
 +    }
++
 +    impl AgendaSource for WriteTargetSource {
 +        fn events_intersecting(&self, _range: DateRange) -> Vec<Event> {
 +            Vec::new()
 +        }
++
 +        fn holidays_in(&self, _range: DateRange) -> Vec<Holiday> {
 +            Vec::new()
 +        }
++
 +        fn event_write_targets(&self) -> Vec<EventWriteTarget> {
 +            self.targets.clone()
 +        }
++
 +        fn default_event_write_target(&self) -> EventWriteTargetId {
 +            self.default.clone()
 +        }
 +    }
++
 +    fn form_value(form: &CreateEventForm, label: &str) -> String {
 +        form.rows()
 +            .into_iter()
 +            .find(|row| row.label == label)
 +            .map(|row| row.value)
 +            .expect("form row exists")
 +    }
++
      #[test]
      fn configured_keybindings_replace_default_normal_mode_commands() {
          let bindings = KeyBindings::with_overrides(KeyBindingOverrides {
          );
+     }
 +    #[test]
 +    fn plus_opens_create_form_with_agenda_source_default_calendar_target() {
 +        let day = date(2026, Month::April, 23);
 +        let target = EventWriteTarget::microsoft("work", "cal", "Microsoft work: Calendar");
 +        let source = WriteTargetSource {
 +            targets: vec![EventWriteTarget::local(), target.clone()],
 +            default: target.id.clone(),
 +        };
 +        let mut app = AppState::new(day);
 +        let mut input = KeyboardInput::default();
++
 +        app.apply_with_agenda_source(input.translate(char_key('+')), &source);
++
 +        let form = app.create_form().expect("form opens");
 +        assert_eq!(form.context(), CreateEventContext::EditableDate);
 +        assert_eq!(form_value(form, "Calendar"), "Microsoft work: Calendar");
 +    }
++
      #[test]
      fn question_mark_opens_help_and_esc_closes_it() {
          let day = date(2026, Month::April, 23);
          assert_eq!(app.selected_date(), day);
+     }
 +    #[test]
 +    fn create_form_calendar_selector_cycles_and_submits_target() {
 +        let day = date(2026, Month::April, 23);
 +        let calendar = EventWriteTarget::microsoft("work", "cal", "Microsoft work: Calendar");
 +        let personal = EventWriteTarget::microsoft("work", "personal", "Microsoft work: Personal");
 +        let mut form = CreateEventForm::new_with_targets(
 +            day,
 +            CreateEventContext::EditableDate,
 +            vec![
 +                EventWriteTarget::local(),
 +                calendar.clone(),
 +                personal.clone(),
 +            ],
 +            calendar.id.clone(),
 +        );
++
 +        form.title = "Planning".to_string();
 +        let _ = form.handle_key(key(KeyCode::Tab));
 +        assert_eq!(form_value(&form, "Calendar"), "Microsoft work: Calendar");
++
 +        let _ = form.handle_key(key(KeyCode::Right));
 +        assert_eq!(form_value(&form, "Calendar"), "Microsoft work: Personal");
 +        let _ = form.handle_key(key(KeyCode::Left));
 +        assert_eq!(form_value(&form, "Calendar"), "Microsoft work: Calendar");
 +        let _ = form.handle_key(key(KeyCode::Left));
 +        assert_eq!(form_value(&form, "Calendar"), "Local");
 +        let _ = form.handle_key(key(KeyCode::Right));
 +        let _ = form.handle_key(key(KeyCode::Right));
++
 +        let result = form.handle_key(ctrl_char_key('s'));
++
 +        let CreateEventInputResult::Submit(submission) = result else {
 +            panic!("form should submit");
 +        };
 +        assert_eq!(submission.target, personal.id);
 +    }
++
      #[test]
      fn create_form_validates_required_title() {
          let mut form = CreateEventForm::new(
          assert!(form.reminders[4]);
+     }
 +    #[test]
 +    fn edit_form_preloads_provider_calendar_target() {
 +        let day = date(2026, Month::April, 23);
 +        let target = EventWriteTarget::microsoft("work", "cal", "Microsoft work: Calendar");
 +        let event = Event::timed(
 +            "microsoft:work:cal:remote-1",
 +            "Sync",
 +            at(day, 9, 0),
 +            at(day, 9, 30),
 +            SourceMetadata::new("microsoft:work:cal", "Microsoft work: Calendar"),
 +        )
 +        .expect("valid provider event");
++
 +        let form =
 +            CreateEventForm::edit_with_targets(&event, vec![EventWriteTarget::local(), target]);
++
 +        assert_eq!(form_value(&form, "Calendar"), "Microsoft work: Calendar");
 +    }
++
      #[test]
      fn edit_form_preloads_all_day_event_and_can_switch_to_timed() {
          let day = date(2026, Month::April, 23);

src/cli.rsmodified

                              let submission = *submission;
                              match submission.mode {
                                  EventFormMode::Create => {
 -                                    match agenda_source.create_event(submission.draft) {
 +                                    match agenda_source.create_event_with_target(
 +                                        submission.draft,
 +                                        &submission.target,
 +                                    ) {
                                          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) {
 +                                    match agenda_source.update_event_with_target(
 +                                        &event_id,
 +                                        submission.draft,
 +                                        &submission.target,
 +                                    ) {
                                          Ok(_) => {
                                              app.close_create_form();
                                              app.reconcile_day_event_selection(&agenda_source);

src/providers.rsmodified

  use crate::{
      agenda::{
          AgendaError, AgendaSource, CreateEventDraft, CreateEventTiming, DateRange, Event,
 -        EventDateTime, Holiday, InMemoryAgendaSource, OccurrenceAnchor, OccurrenceMetadata,
 -        RecurrenceEnd, RecurrenceFrequency, RecurrenceMonthlyRule, RecurrenceOrdinal,
 -        RecurrenceRule, RecurrenceYearlyRule, Reminder, SourceMetadata,
 +        EventDateTime, EventWriteTarget, EventWriteTargetId, Holiday, InMemoryAgendaSource,
 +        OccurrenceAnchor, OccurrenceMetadata, RecurrenceEnd, RecurrenceFrequency,
 +        RecurrenceMonthlyRule, RecurrenceOrdinal, RecurrenceRule, RecurrenceYearlyRule, Reminder,
 +        SourceMetadata,
      },
      calendar::CalendarDate,
  };
+         }
+     }
 +    pub fn write_targets(&self) -> Vec<EventWriteTarget> {
 +        self.config
 +            .accounts
 +            .iter()
 +            .flat_map(|account| {
 +                account.calendars.iter().filter_map(|calendar_id| {
 +                    let record = self.cache.calendar_record(&account.id, calendar_id);
 +                    if record.as_ref().is_some_and(|calendar| !calendar.can_edit) {
 +                        return None;
 +                    }
 +                    let label = record
 +                        .as_ref()
 +                        .map(|calendar| calendar.name.as_str())
 +                        .filter(|name| !name.trim().is_empty())
 +                        .map(|name| format!("Microsoft {}: {name}", account.id))
 +                        .unwrap_or_else(|| {
 +                            format!(
 +                                "Microsoft {}: {}",
 +                                account.id,
 +                                short_calendar_label(calendar_id)
 +                            )
 +                        });
 +                    Some(EventWriteTarget::microsoft(
 +                        account.id.clone(),
 +                        calendar_id.clone(),
 +                        label,
 +                    ))
 +                })
 +            })
 +            .collect()
 +    }
++
 +    pub fn default_write_target(&self) -> Option<EventWriteTargetId> {
 +        let (account, calendar_id) = self.config.default_calendar()?;
 +        Some(EventWriteTargetId::Microsoft {
 +            account_id: account.id.clone(),
 +            calendar_id: calendar_id.to_string(),
 +        })
 +    }
++
      pub fn status(&self, token_store: &dyn MicrosoftTokenStore) -> MicrosoftProviderStatus {
          let accounts = self
              .config
          http: &dyn MicrosoftHttpClient,
          token_store: &dyn MicrosoftTokenStore,
      ) -> Result<Event, ProviderError> {
 -        let (account, calendar_id) = self.config.default_calendar().ok_or_else(|| {
 +        let target = self.default_write_target().ok_or_else(|| {
              ProviderError::Config("no Microsoft default calendar configured".to_string())
          })?;
 -        let account = account.clone();
 -        let calendar_id = calendar_id.to_string();
 +        self.create_event_in_target(draft, &target, http, token_store)
 +    }
++
 +    pub fn create_event_in_target(
 +        &mut self,
 +        draft: CreateEventDraft,
 +        target: &EventWriteTargetId,
 +        http: &dyn MicrosoftHttpClient,
 +        token_store: &dyn MicrosoftTokenStore,
 +    ) -> Result<Event, ProviderError> {
 +        let EventWriteTargetId::Microsoft {
 +            account_id,
 +            calendar_id,
 +        } = target
 +        else {
 +            return Err(ProviderError::Config(
 +                "Microsoft provider requires a Microsoft calendar target".to_string(),
 +            ));
 +        };
 +        let account = self
 +            .config
 +            .account(account_id)
 +            .ok_or_else(|| {
 +                ProviderError::Config(format!("account '{account_id}' is not configured"))
 +            })?
 +            .clone();
 +        if !account
 +            .calendars
 +            .iter()
 +            .any(|calendar| calendar == calendar_id)
 +        {
 +            return Err(ProviderError::Config(format!(
 +                "calendar '{calendar_id}' is not configured for account '{account_id}'"
 +            )));
 +        }
          let token = access_token(&account, http, token_store)?;
          let body = graph_event_payload(&draft, false)?;
          let response = graph_request(
              "POST",
              &format!(
                  "{GRAPH_BASE_URL}/me/calendars/{}/events",
 -                percent_encode(&calendar_id)
 +                percent_encode(calendar_id)
              ),
              &token,
              Some(body.to_string()),
          )?;
          let value = parse_graph_success_json(response)?;
          let calendar =
 -            fetch_calendar(http, &token, &calendar_id).unwrap_or(MicrosoftCalendarRecord {
 +            fetch_calendar(http, &token, calendar_id).unwrap_or(MicrosoftCalendarRecord {
                  id: calendar_id.clone(),
                  name: calendar_id.clone(),
                  can_edit: true,
      format!("microsoft:{account_id}:{calendar_id}:{graph_id}")
+ }
 +fn short_calendar_label(calendar_id: &str) -> String {
 +    const MAX: usize = 18;
 +    let label = calendar_id.chars().take(MAX).collect::<String>();
 +    if calendar_id.chars().count() > MAX {
 +        format!("{label}...")
 +    } else {
 +        label
 +    }
 +}
++
  fn anchor_label(anchor: OccurrenceAnchor) -> String {
      match anchor {
          OccurrenceAnchor::AllDay { date } => date.to_string(),
+         }
+     }
 +    fn calendar_record(id: &str, name: &str, can_edit: bool) -> MicrosoftCalendarRecord {
 +        MicrosoftCalendarRecord {
 +            id: id.to_string(),
 +            name: name.to_string(),
 +            can_edit,
 +            is_default: false,
 +        }
 +    }
++
      #[derive(Default)]
      struct MemoryTokenStore {
          tokens: RefCell<HashMap<String, MicrosoftToken>>,
          assert!(event.source.source_id.starts_with("microsoft:work:cal"));
+     }
 +    #[test]
 +    fn provider_write_targets_use_configured_editable_calendars() {
 +        let cache_file = temp_path("targets/microsoft-cache.json");
 +        let mut config = provider_config(cache_file);
 +        config.default_calendar = Some("team".to_string());
 +        config.accounts[0].calendars = vec![
 +            "cal".to_string(),
 +            "team".to_string(),
 +            "holidays".to_string(),
 +        ];
 +        let mut runtime = MicrosoftProviderRuntime::load(config).expect("load");
 +        runtime
 +            .cache
 +            .replace_calendar("work", calendar_record("cal", "Work", true), Vec::new(), 0);
 +        runtime.cache.replace_calendar(
 +            "work",
 +            calendar_record("holidays", "Holidays", false),
 +            Vec::new(),
 +            0,
 +        );
++
 +        let targets = runtime.write_targets();
++
 +        assert_eq!(targets.len(), 2);
 +        assert_eq!(targets[0].label, "Microsoft work: Work");
 +        assert_eq!(targets[1].label, "Microsoft work: team");
 +        assert_eq!(
 +            runtime.default_write_target(),
 +            Some(EventWriteTargetId::Microsoft {
 +                account_id: "work".to_string(),
 +                calendar_id: "team".to_string(),
 +            })
 +        );
 +    }
++
 +    #[test]
 +    fn create_event_uses_explicit_calendar_target() {
 +        let cache_file = temp_path("create-target/microsoft-cache.json");
 +        let mut config = provider_config(cache_file.clone());
 +        config.accounts[0].calendars = vec!["cal".to_string(), "personal".to_string()];
 +        let store = MemoryTokenStore::with_token("work");
 +        let http = RecordingHttpClient::new(vec![
 +            RecordingHttpClient::json(
 +                201,
 +                json!({
 +                    "id": "evt",
 +                    "subject": "Planning",
 +                    "type": "singleInstance",
 +                    "isAllDay": false,
 +                    "start": {"dateTime": "2026-04-23T09:00:00", "timeZone": "UTC"},
 +                    "end": {"dateTime": "2026-04-23T10:00:00", "timeZone": "UTC"}
 +                }),
 +            ),
 +            RecordingHttpClient::json(
 +                200,
 +                json!({
 +                    "id": "personal",
 +                    "name": "Personal",
 +                    "canEdit": true,
 +                    "isDefaultCalendar": false
 +                }),
 +            ),
 +        ]);
 +        let mut runtime = MicrosoftProviderRuntime::load(config).expect("load");
 +        let day = date(2026, Month::April, 23);
 +        let draft = 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,
 +        };
 +        let target = EventWriteTargetId::Microsoft {
 +            account_id: "work".to_string(),
 +            calendar_id: "personal".to_string(),
 +        };
++
 +        let event = runtime
 +            .create_event_in_target(draft, &target, &http, &store)
 +            .expect("create succeeds");
++
 +        let _ = fs::remove_dir_all(
 +            cache_file
 +                .parent()
 +                .and_then(Path::parent)
 +                .expect("test root"),
 +        );
 +        assert_eq!(event.id, "microsoft:work:personal:evt");
 +        assert_eq!(
 +            http.requests.borrow()[0].url,
 +            format!("{GRAPH_BASE_URL}/me/calendars/personal/events")
 +        );
 +    }
++
      #[test]
      fn graph_all_day_recurring_occurrence_maps_anchor() {
          let calendar = MicrosoftCalendarRecord {

src/tui.rsmodified

              if value_x < content.right() {
                  match row.kind {
 -                    CreateEventFormRowKind::Text | CreateEventFormRowKind::Multiline => {
 +                    CreateEventFormRowKind::Text
 +                    | CreateEventFormRowKind::Multiline
 +                    | CreateEventFormRowKind::Selector => {
                          write_padded_left(
                              buf,
                              line_y,
          footer_y,
          content.x,
          content.width,
 -        "Tab/Up/Down fields | Ctrl-S save | Esc cancel",
 +        create_modal_footer(content.width),
          styles.footer,
      );
+ }
                      keybindings.display_for(KeyCommand::MoveUp),
                      keybindings.display_for(KeyCommand::MoveDown)
                  ),
 -                "Select a local event",
 +                "Select an editable event",
              ),
+             (
                  keybindings.display_for(KeyCommand::OpenDayOrEdit),
 -                "Edit the selected local event",
 +                "Edit the selected event",
              ),
+             (
                  keybindings.display_for(KeyCommand::CopyEvent),
 -                "Copy the selected local event",
 +                "Copy the selected event",
              ),
+             (
                  keybindings.display_for(KeyCommand::DeleteEvent),
 -                "Delete the selected local event",
 +                "Delete the selected event",
              ),
+             (
                  keybindings.display_for(KeyCommand::CreateEvent),
      u16::try_from(create_modal_value_lines(kind, value, value_width).len()).unwrap_or(u16::MAX)
+ }
 +fn create_modal_footer(width: u16) -> &'static str {
 +    let full = "Tab/Up/Down fields | Left/Right change | Ctrl-S save | Esc cancel";
 +    let compact = "Left/Right | Ctrl-S save | Esc";
 +    if usize::from(width) >= full.chars().count() {
 +        full
 +    } else {
 +        compact
 +    }
 +}
++
  fn create_modal_value_lines(
      kind: CreateEventFormRowKind,
      value: &str,
  ) -> Vec<String> {
      match kind {
          CreateEventFormRowKind::Multiline => wrap_text_lines(value, value_width),
 -        CreateEventFormRowKind::Text | CreateEventFormRowKind::Toggle => {
 +        CreateEventFormRowKind::Text
 +        | CreateEventFormRowKind::Toggle
 +        | CreateEventFormRowKind::Selector => {
              vec![value.to_string()]
+         }
+     }
          let rendered = render_app_to_string(&app, 84, 26);
          assert!(rendered.contains("Day keys"));
 -        assert!(rendered.contains("Copy the selected local event"));
 -        assert!(rendered.contains("Delete the selected local event"));
 +        assert!(rendered.contains("Copy the selected event"));
 +        assert!(rendered.contains("Delete the selected event"));
          assert!(rendered.contains("Move to the previous or next day"));
+     }
          app.apply(AppAction::OpenCreate);
          let _ = app.handle_create_key(key(KeyCode::Char('A')));
          let _ = app.handle_create_key(key(KeyCode::Tab));
 +        let _ = app.handle_create_key(key(KeyCode::Tab));
          let _ = app.handle_create_key(key(KeyCode::Enter));
          let area = Rect::new(0, 0, 84, 26);
          let label_width = 12.min(content.width.saturating_sub(1));
          let value_x = label_x.saturating_add(label_width).saturating_add(1);
 -        assert_styled_text(&buffer, content.x, row_y + 1, ">", Color::White);
 +        assert_styled_text(&buffer, content.x, row_y + 2, ">", Color::White);
          assert_styled_text(&buffer, label_x, row_y, "Title", Color::White);
 -        assert_styled_text(&buffer, label_x, row_y + 1, "All day", Color::White);
 -        assert_styled_text(&buffer, label_x, row_y + 2, "Start date", Color::White);
 +        assert_styled_text(&buffer, label_x, row_y + 1, "Calendar", Color::White);
 +        assert_styled_text(&buffer, label_x, row_y + 2, "All day", Color::White);
 +        assert_styled_text(&buffer, label_x, row_y + 3, "Start date", Color::White);
          assert_styled_text(&buffer, value_x, row_y, "A", Color::Gray);
 -        assert_styled_text(&buffer, value_x, row_y + 2, "2026-04-23", Color::Gray);
 -        assert_styled_text(&buffer, value_x, row_y + 3, "09:00", Color::Gray);
 -        assert_styled_cell(&buffer, value_x, row_y + 1, "[", Color::Yellow);
 -        assert_styled_cell(&buffer, value_x + 1, row_y + 1, "x", Color::White);
 -        assert_styled_cell(&buffer, value_x + 2, row_y + 1, "]", Color::Yellow);
 -        assert_styled_cell(&buffer, value_x, row_y + 8, "[", Color::Yellow);
 -        assert_styled_cell(&buffer, value_x + 1, row_y + 8, " ", Color::White);
 -        assert_styled_cell(&buffer, value_x + 2, row_y + 8, "]", Color::Yellow);
 -        assert_styled_text(&buffer, value_x + 4, row_y + 8, "5m", Color::Gray);
 +        assert_styled_text(&buffer, value_x, row_y + 1, "Local", Color::Gray);
 +        assert_styled_text(&buffer, value_x, row_y + 3, "2026-04-23", Color::Gray);
 +        assert_styled_text(&buffer, value_x, row_y + 4, "09:00", Color::Gray);
 +        assert_styled_cell(&buffer, value_x, row_y + 2, "[", Color::Yellow);
 +        assert_styled_cell(&buffer, value_x + 1, row_y + 2, "x", Color::White);
 +        assert_styled_cell(&buffer, value_x + 2, row_y + 2, "]", Color::Yellow);
 +        assert_styled_cell(&buffer, value_x, row_y + 9, "[", Color::Yellow);
 +        assert_styled_cell(&buffer, value_x + 1, row_y + 9, " ", Color::White);
 +        assert_styled_cell(&buffer, value_x + 2, row_y + 9, "]", Color::Yellow);
 +        assert_styled_text(&buffer, value_x + 4, row_y + 9, "5m", Color::Gray);
+     }
      #[test]
          let selected = date(2026, Month::April, 23);
          let mut app = AppState::new(selected);
          app.apply(AppAction::OpenCreate);
 -        for _ in 0..7 {
 +        for _ in 0..8 {
              let _ = app.handle_create_key(key(KeyCode::Tab));
+         }
          let notes = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
          let modal = create_modal_area(area, app.create_form().expect("form stays open"));
          let content = inset_rect(modal);
          let row_y = content.y.saturating_add(2);
 -        let notes_y = row_y.saturating_add(7);
 +        let notes_y = row_y.saturating_add(8);
          let label_x = content.x.saturating_add(2);
          let label_width = 12.min(content.width.saturating_sub(1));
          let value_x = label_x.saturating_add(label_width).saturating_add(1);
          assert_eq!(lines.len(), 10);
          assert!(lines[1].contains("Create"));
          assert!(rendered.contains("Title"));
 +        assert!(rendered.contains("Left/Right"));
          assert!(rendered.contains("Ctrl-S save"));
+     }