`630db76`

Add user config and keybindings

Authored by

espadonne 2 weeks ago

SHA: 630db761903b54b7a705e756bc65089d7b3d4cb0
Parents: 4367c8f
Tree: f174768

10 changed files

Status	File	+	-
M	`Cargo.lock`	41	1
M	`Cargo.toml`	1	0
M	`README.md`	15	3
M	`src/app.rs`	667	95
M	`src/cli.rs`	566	29
A	`src/config.rs`	496	0
M	`src/lib.rs`	1	0
M	`src/services.rs`	2	2
M	`src/tui.rs`	240	47
M	`tests/cli_smoke.rs`	1	1

Cargo.lockmodified

   "serde",
   "serde_json",
   "time",
 + "toml",
+ ]
  [[package]]
   "syn 2.0.117",
+ ]
 +[[package]]
 +name = "serde_spanned"
 +version = "1.1.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
 +dependencies = [
 + "serde_core",
 +]
++
  [[package]]
  name = "serde_urlencoded"
  version = "0.7.1"
   "tokio",
+ ]
 +[[package]]
 +name = "toml"
 +version = "0.9.12+spec-1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
 +dependencies = [
 + "indexmap",
 + "serde_core",
 + "serde_spanned",
 + "toml_datetime 0.7.5+spec-1.1.0",
 + "toml_parser",
 + "toml_writer",
 + "winnow 0.7.15",
 +]
++
 +[[package]]
 +name = "toml_datetime"
 +version = "0.7.5+spec-1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
 +dependencies = [
 + "serde_core",
 +]
++
  [[package]]
  name = "toml_datetime"
  version = "1.1.1+spec-1.1.0"
  checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
  dependencies = [
   "indexmap",
 - "toml_datetime",
 + "toml_datetime 1.1.1+spec-1.1.0",
   "toml_parser",
   "winnow 1.0.2",
+ ]
   "winnow 1.0.2",
+ ]
 +[[package]]
 +name = "toml_writer"
 +version = "1.1.1+spec-1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
++
  [[package]]
  name = "tower"
  version = "0.5.3"

Cargo.tomlmodified

  serde = { version = "1.0.228", features = ["derive"] }
  serde_json = "1.0.145"
  time = { version = "0.3.47", features = ["local-offset", "parsing"] }
 +toml = "0.9.8"

README.mdmodified

  ## Usage
  ```sh
 -rcal [--date YYYY-MM-DD] [--events-file PATH] [--holiday-source off|us-federal|nager] [--holiday-country CC]
 +rcal [--config PATH|--no-config] [--date YYYY-MM-DD] [--events-file PATH] [--holiday-source off|us-federal|nager] [--holiday-country CC]
 +rcal config init [--path PATH] [--force]
  rcal reminders run [--events-file PATH] [--state-file PATH] [--once]
 -rcal reminders install [--events-file PATH]
 +rcal reminders install [--events-file PATH] [--state-file PATH]
  rcal reminders uninstall
  rcal reminders status
  rcal reminders test [--verbose]
  Options:
 +- `--config PATH`: load a specific TOML config file.
 +- `--no-config`: ignore any discovered config file.
  - `--date YYYY-MM-DD`: open with a deterministic selected date.
  - `--events-file PATH`: read and write local user-created events at `PATH`.
    By default, rcal uses `$XDG_DATA_HOME/rcal/events.json`,
  - `--help`: show CLI help.
  - `--version`: show the installed version.
 +Config is discovered at `$XDG_CONFIG_HOME/rcal/config.toml`, else
 +`~/.config/rcal/config.toml`. It is never created automatically; run
 +`rcal config init` to write a commented starter file. Omitted settings keep
 +built-in defaults, and CLI flags override config values. Config can set the
 +events file, holiday source and country, reminder state file, and normal-mode
 +keybindings. Modal/form keys stay fixed for now.
++
  Nager.Date is cache-first and opt-in. Default startup does not need network
  access.
  `rcal reminders install` to install it, `rcal reminders status` to inspect it,
  and `rcal reminders test` to send a test notification. On macOS, notification
  delivery uses `osascript` because it is more reliable for CLI-launched
 -notifications than the generic notification backend.
 +notifications than the generic notification backend. Reminder install snapshots
 +the resolved events and state file paths, so reinstall the service after config
 +changes that affect reminders.
  ## Layout

src/app.rsmodified

 -use std::time::{Duration, Instant};
 +use std::{
 +    collections::HashMap,
 +    fmt,
 +    time::{Duration, Instant},
 +};
  use crossterm::event::{
      KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent, MouseEventKind,
          .collect()
+ }
 -#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
 +#[derive(Debug, Clone, PartialEq, Eq)]
  pub struct KeyboardInput {
      pending: PendingKey,
 +    bindings: KeyBindings,
+ }
  impl KeyboardInput {
 +    pub fn new(bindings: KeyBindings) -> Self {
 +        Self {
 +            pending: PendingKey::None,
 +            bindings,
 +        }
 +    }
++
      pub fn translate(&mut self, key: KeyEvent) -> AppAction {
          if key.kind == KeyEventKind::Release {
              return AppAction::Noop;
+         }
 -        match key.code {
 -            KeyCode::Left => {
 -                self.clear();
 -                AppAction::MoveDays(-1)
 -            }
 -            KeyCode::Right => {
 -                self.clear();
 -                AppAction::MoveDays(1)
 -            }
 -            KeyCode::Up => {
 -                self.clear();
 -                AppAction::MoveDays(-7)
 -            }
 -            KeyCode::Down => {
 -                self.clear();
 -                AppAction::MoveDays(7)
 -            }
 -            KeyCode::Enter => {
 -                self.clear();
 -                AppAction::OpenDay
 -            }
 -            KeyCode::Esc => {
 -                self.clear();
 -                AppAction::CloseDay
 -            }
 -            KeyCode::Char(value) if ctrl_c(value, key.modifiers) => {
 -                self.clear();
 -                AppAction::Quit
 -            }
 -            KeyCode::Char(_) if key.modifiers.intersects(KeyModifiers::ALT) => {
 -                self.clear();
 -                AppAction::Noop
 -            }
 -            KeyCode::Char(value) => self.translate_char(value),
 -            _ => {
 -                self.clear();
 -                AppAction::Noop
 -            }
 +        if let Some(value) = digit_from_key(key) {
 +            return self.translate_digit(value);
+         }
++
 +        let Some(gesture) = KeyGesture::from_key_event(key) else {
 +            self.clear();
 +            return AppAction::Noop;
 +        };
++
 +        self.translate_gesture(gesture)
+     }
      pub fn clear(&mut self) {
+         }
+     }
 -    fn translate_char(&mut self, value: char) -> AppAction {
 -        if value == '+' {
 -            self.clear();
 -            return AppAction::OpenCreate;
 -        }
+-
 -        if value == '?' {
 -            self.clear();
 -            return AppAction::OpenHelp;
 -        }
+-
 -        if value.eq_ignore_ascii_case(&'d') {
 -            self.clear();
 -            return AppAction::OpenDelete;
 -        }
+-
 -        if value.eq_ignore_ascii_case(&'c') {
 -            self.clear();
 -            return AppAction::OpenCopy;
 -        }
+-
 -        if value.is_ascii_digit() {
 -            return self.translate_digit(value);
 -        }
+-
 -        let value = value.to_ascii_lowercase();
+-
 +    fn translate_gesture(&mut self, gesture: KeyGesture) -> AppAction {
          match self.pending {
              PendingKey::Digit(_) => {
                  self.clear();
 -                self.translate_weekday_start(value)
 +                self.translate_gesture(gesture)
+             }
 -            PendingKey::T => {
 +            PendingKey::Sequence(first) => {
                  self.clear();
 -                match value {
 -                    'u' => AppAction::JumpToWeekday(Weekday::Tuesday),
 -                    'h' => AppAction::JumpToWeekday(Weekday::Thursday),
 -                    _ => self.translate_weekday_start(value),
 +                if let Some(command) = self
 +                    .bindings
 +                    .command_for_sequence(&KeySequence::two(first, gesture))
 +                {
 +                    return command.app_action();
+                 }
++
 +                self.translate_gesture(gesture)
+             }
 -            PendingKey::S => {
 -                self.clear();
 -                match value {
 -                    'a' => AppAction::JumpToWeekday(Weekday::Saturday),
 -                    'u' => AppAction::JumpToWeekday(Weekday::Sunday),
 -                    _ => self.translate_weekday_start(value),
 +            PendingKey::None => {
 +                let sequence = KeySequence::one(gesture);
 +                if self.bindings.is_prefix(&sequence) {
 +                    self.pending = PendingKey::Sequence(gesture);
 +                    AppAction::Noop
 +                } else if let Some(command) = self.bindings.command_for_sequence(&sequence) {
 +                    self.clear();
 +                    command.app_action()
 +                } else {
 +                    self.clear();
 +                    AppAction::Noop
+                 }
+             }
 -            PendingKey::None => self.translate_weekday_start(value),
+         }
+     }
+             }
+         }
+     }
 +}
 -    fn translate_weekday_start(&mut self, value: char) -> AppAction {
 -        match value {
 -            'm' => AppAction::JumpToWeekday(Weekday::Monday),
 -            'w' => AppAction::JumpToWeekday(Weekday::Wednesday),
 -            'f' => AppAction::JumpToWeekday(Weekday::Friday),
 -            't' => {
 -                self.pending = PendingKey::T;
 -                AppAction::Noop
 +impl Default for KeyboardInput {
 +    fn default() -> Self {
 +        Self::new(KeyBindings::default())
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct KeyBindings {
 +    entries: Vec<KeyBinding>,
 +}
++
 +impl KeyBindings {
 +    pub fn from_lists(lists: KeyBindingLists) -> Result<Self, KeyBindingError> {
 +        let entries = lists.into_entries()?;
 +        validate_key_bindings(&entries)?;
 +        Ok(Self { entries })
 +    }
++
 +    pub fn default_lists() -> KeyBindingLists {
 +        KeyBindingLists::default()
 +    }
++
 +    pub fn with_overrides(overrides: KeyBindingOverrides) -> Result<Self, KeyBindingError> {
 +        let mut lists = KeyBindingLists::default();
 +        overrides.apply_to(&mut lists);
 +        Self::from_lists(lists)
 +    }
++
 +    fn command_for_sequence(&self, sequence: &KeySequence) -> Option<KeyCommand> {
 +        self.entries
 +            .iter()
 +            .find_map(|entry| (entry.sequence == *sequence).then_some(entry.command))
 +    }
++
 +    fn is_prefix(&self, sequence: &KeySequence) -> bool {
 +        self.entries
 +            .iter()
 +            .any(|entry| entry.sequence.starts_with(sequence) && entry.sequence != *sequence)
 +    }
++
 +    pub fn display_for(&self, command: KeyCommand) -> String {
 +        let labels = self
 +            .entries
 +            .iter()
 +            .filter(|entry| entry.command == command)
 +            .map(|entry| entry.sequence.label())
 +            .collect::<Vec<_>>();
++
 +        if labels.is_empty() {
 +            command.default_label().to_string()
 +        } else {
 +            labels.join(" / ")
 +        }
 +    }
 +}
++
 +impl Default for KeyBindings {
 +    fn default() -> Self {
 +        Self::from_lists(KeyBindingLists::default()).expect("default keybindings are valid")
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct KeyBindingLists {
 +    pub move_left: Vec<String>,
 +    pub move_right: Vec<String>,
 +    pub move_up: Vec<String>,
 +    pub move_down: Vec<String>,
 +    pub open_day_or_edit: Vec<String>,
 +    pub close_day: Vec<String>,
 +    pub create_event: Vec<String>,
 +    pub delete_event: Vec<String>,
 +    pub copy_event: Vec<String>,
 +    pub help: Vec<String>,
 +    pub quit: Vec<String>,
 +    pub jump_monday: Vec<String>,
 +    pub jump_tuesday: Vec<String>,
 +    pub jump_wednesday: Vec<String>,
 +    pub jump_thursday: Vec<String>,
 +    pub jump_friday: Vec<String>,
 +    pub jump_saturday: Vec<String>,
 +    pub jump_sunday: Vec<String>,
 +}
++
 +impl Default for KeyBindingLists {
 +    fn default() -> Self {
 +        Self {
 +            move_left: vec!["left".to_string()],
 +            move_right: vec!["right".to_string()],
 +            move_up: vec!["up".to_string()],
 +            move_down: vec!["down".to_string()],
 +            open_day_or_edit: vec!["enter".to_string()],
 +            close_day: vec!["esc".to_string()],
 +            create_event: vec!["+".to_string()],
 +            delete_event: vec!["d".to_string()],
 +            copy_event: vec!["c".to_string()],
 +            help: vec!["?".to_string()],
 +            quit: vec!["q".to_string(), "ctrl-c".to_string()],
 +            jump_monday: vec!["m".to_string()],
 +            jump_tuesday: vec!["tu".to_string()],
 +            jump_wednesday: vec!["w".to_string()],
 +            jump_thursday: vec!["th".to_string()],
 +            jump_friday: vec!["f".to_string()],
 +            jump_saturday: vec!["sa".to_string()],
 +            jump_sunday: vec!["su".to_string()],
 +        }
 +    }
 +}
++
 +impl KeyBindingLists {
 +    fn into_entries(self) -> Result<Vec<KeyBinding>, KeyBindingError> {
 +        let mut entries = Vec::new();
 +        push_entries(&mut entries, KeyCommand::MoveLeft, self.move_left)?;
 +        push_entries(&mut entries, KeyCommand::MoveRight, self.move_right)?;
 +        push_entries(&mut entries, KeyCommand::MoveUp, self.move_up)?;
 +        push_entries(&mut entries, KeyCommand::MoveDown, self.move_down)?;
 +        push_entries(
 +            &mut entries,
 +            KeyCommand::OpenDayOrEdit,
 +            self.open_day_or_edit,
 +        )?;
 +        push_entries(&mut entries, KeyCommand::CloseDay, self.close_day)?;
 +        push_entries(&mut entries, KeyCommand::CreateEvent, self.create_event)?;
 +        push_entries(&mut entries, KeyCommand::DeleteEvent, self.delete_event)?;
 +        push_entries(&mut entries, KeyCommand::CopyEvent, self.copy_event)?;
 +        push_entries(&mut entries, KeyCommand::Help, self.help)?;
 +        push_entries(&mut entries, KeyCommand::Quit, self.quit)?;
 +        push_entries(&mut entries, KeyCommand::JumpMonday, self.jump_monday)?;
 +        push_entries(&mut entries, KeyCommand::JumpTuesday, self.jump_tuesday)?;
 +        push_entries(&mut entries, KeyCommand::JumpWednesday, self.jump_wednesday)?;
 +        push_entries(&mut entries, KeyCommand::JumpThursday, self.jump_thursday)?;
 +        push_entries(&mut entries, KeyCommand::JumpFriday, self.jump_friday)?;
 +        push_entries(&mut entries, KeyCommand::JumpSaturday, self.jump_saturday)?;
 +        push_entries(&mut entries, KeyCommand::JumpSunday, self.jump_sunday)?;
 +        Ok(entries)
 +    }
 +}
++
 +#[derive(Debug, Default, Clone, PartialEq, Eq)]
 +pub struct KeyBindingOverrides {
 +    pub move_left: Option<Vec<String>>,
 +    pub move_right: Option<Vec<String>>,
 +    pub move_up: Option<Vec<String>>,
 +    pub move_down: Option<Vec<String>>,
 +    pub open_day_or_edit: Option<Vec<String>>,
 +    pub close_day: Option<Vec<String>>,
 +    pub create_event: Option<Vec<String>>,
 +    pub delete_event: Option<Vec<String>>,
 +    pub copy_event: Option<Vec<String>>,
 +    pub help: Option<Vec<String>>,
 +    pub quit: Option<Vec<String>>,
 +    pub jump_monday: Option<Vec<String>>,
 +    pub jump_tuesday: Option<Vec<String>>,
 +    pub jump_wednesday: Option<Vec<String>>,
 +    pub jump_thursday: Option<Vec<String>>,
 +    pub jump_friday: Option<Vec<String>>,
 +    pub jump_saturday: Option<Vec<String>>,
 +    pub jump_sunday: Option<Vec<String>>,
 +}
++
 +impl KeyBindingOverrides {
 +    fn apply_to(self, lists: &mut KeyBindingLists) {
 +        if let Some(value) = self.move_left {
 +            lists.move_left = value;
 +        }
 +        if let Some(value) = self.move_right {
 +            lists.move_right = value;
 +        }
 +        if let Some(value) = self.move_up {
 +            lists.move_up = value;
 +        }
 +        if let Some(value) = self.move_down {
 +            lists.move_down = value;
 +        }
 +        if let Some(value) = self.open_day_or_edit {
 +            lists.open_day_or_edit = value;
 +        }
 +        if let Some(value) = self.close_day {
 +            lists.close_day = value;
 +        }
 +        if let Some(value) = self.create_event {
 +            lists.create_event = value;
 +        }
 +        if let Some(value) = self.delete_event {
 +            lists.delete_event = value;
 +        }
 +        if let Some(value) = self.copy_event {
 +            lists.copy_event = value;
 +        }
 +        if let Some(value) = self.help {
 +            lists.help = value;
 +        }
 +        if let Some(value) = self.quit {
 +            lists.quit = value;
 +        }
 +        if let Some(value) = self.jump_monday {
 +            lists.jump_monday = value;
 +        }
 +        if let Some(value) = self.jump_tuesday {
 +            lists.jump_tuesday = value;
 +        }
 +        if let Some(value) = self.jump_wednesday {
 +            lists.jump_wednesday = value;
 +        }
 +        if let Some(value) = self.jump_thursday {
 +            lists.jump_thursday = value;
 +        }
 +        if let Some(value) = self.jump_friday {
 +            lists.jump_friday = value;
 +        }
 +        if let Some(value) = self.jump_saturday {
 +            lists.jump_saturday = value;
 +        }
 +        if let Some(value) = self.jump_sunday {
 +            lists.jump_sunday = value;
 +        }
 +    }
 +}
++
 +fn push_entries(
 +    entries: &mut Vec<KeyBinding>,
 +    command: KeyCommand,
 +    keys: Vec<String>,
 +) -> Result<(), KeyBindingError> {
 +    if keys.is_empty() {
 +        return Err(KeyBindingError::new(format!(
 +            "{} must define at least one key",
 +            command.config_name()
 +        )));
 +    }
++
 +    for key in keys {
 +        entries.push(KeyBinding {
 +            command,
 +            sequence: KeySequence::parse(&key)?,
 +        });
 +    }
++
 +    Ok(())
 +}
++
 +fn validate_key_bindings(entries: &[KeyBinding]) -> Result<(), KeyBindingError> {
 +    let mut seen = HashMap::new();
 +    for entry in entries {
 +        if let Some(existing) = seen.insert(entry.sequence.clone(), entry.command) {
 +            return Err(KeyBindingError::new(format!(
 +                "key '{}' is bound to both {} and {}",
 +                entry.sequence.label(),
 +                existing.config_name(),
 +                entry.command.config_name()
 +            )));
 +        }
 +    }
++
 +    for left in entries {
 +        for right in entries {
 +            if left.sequence != right.sequence && right.sequence.starts_with(&left.sequence) {
 +                return Err(KeyBindingError::new(format!(
 +                    "key '{}' conflicts with longer key '{}'",
 +                    left.sequence.label(),
 +                    right.sequence.label()
 +                )));
+             }
 -            's' => {
 -                self.pending = PendingKey::S;
 -                AppAction::Noop
 +        }
 +    }
++
 +    Ok(())
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct KeyBinding {
 +    command: KeyCommand,
 +    sequence: KeySequence,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 +struct KeySequence(Vec<KeyGesture>);
++
 +impl KeySequence {
 +    fn one(gesture: KeyGesture) -> Self {
 +        Self(vec![gesture])
 +    }
++
 +    fn two(first: KeyGesture, second: KeyGesture) -> Self {
 +        Self(vec![first, second])
 +    }
++
 +    fn parse(value: &str) -> Result<Self, KeyBindingError> {
 +        if value.is_empty() {
 +            return Err(KeyBindingError::new("key binding may not be empty"));
 +        }
++
 +        let normalized = value.to_ascii_lowercase();
 +        if let Some(gesture) = KeyGesture::parse_named(&normalized)? {
 +            return Ok(Self::one(gesture));
 +        }
++
 +        let chars = normalized.chars().collect::<Vec<_>>();
 +        match chars.as_slice() {
 +            [single] => Ok(Self::one(KeyGesture::parse_printable(*single)?)),
 +            [first, second] => Ok(Self::two(
 +                KeyGesture::parse_printable(*first)?,
 +                KeyGesture::parse_printable(*second)?,
 +            )),
 +            _ => Err(KeyBindingError::new(format!(
 +                "unsupported key binding '{value}'"
 +            ))),
 +        }
 +    }
++
 +    fn starts_with(&self, prefix: &Self) -> bool {
 +        self.0.starts_with(&prefix.0)
 +    }
++
 +    fn label(&self) -> String {
 +        if self.0.len() == 2
 +            && self
 +                .0
 +                .iter()
 +                .all(|gesture| matches!(gesture, KeyGesture::Char(_)))
 +        {
 +            self.0
 +                .iter()
 +                .map(|gesture| gesture.label())
 +                .collect::<String>()
 +        } else {
 +            self.0
 +                .iter()
 +                .map(|gesture| gesture.label())
 +                .collect::<Vec<_>>()
 +                .join(" ")
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 +enum KeyGesture {
 +    Named(NamedKey),
 +    Char(char),
 +    Ctrl(char),
 +}
++
 +impl KeyGesture {
 +    fn parse_named(value: &str) -> Result<Option<Self>, KeyBindingError> {
 +        let gesture = match value {
 +            "left" => Self::Named(NamedKey::Left),
 +            "right" => Self::Named(NamedKey::Right),
 +            "up" => Self::Named(NamedKey::Up),
 +            "down" => Self::Named(NamedKey::Down),
 +            "enter" => Self::Named(NamedKey::Enter),
 +            "esc" | "escape" => Self::Named(NamedKey::Esc),
 +            value if value.starts_with("ctrl-") => {
 +                let key = value.trim_start_matches("ctrl-");
 +                let mut chars = key.chars();
 +                let Some(value) = chars.next() else {
 +                    return Err(KeyBindingError::new("ctrl binding requires a key"));
 +                };
 +                if chars.next().is_some() || !value.is_ascii_alphabetic() {
 +                    return Err(KeyBindingError::new(format!(
 +                        "unsupported control binding 'ctrl-{key}'"
 +                    )));
 +                }
 +                Self::Ctrl(value.to_ascii_lowercase())
+             }
 -            'q' => AppAction::Quit,
 -            _ => AppAction::Noop,
 +            _ => return Ok(None),
 +        };
++
 +        Ok(Some(gesture))
 +    }
++
 +    fn parse_printable(value: char) -> Result<Self, KeyBindingError> {
 +        if value.is_ascii_digit() {
 +            return Err(KeyBindingError::new(format!(
 +                "digit key '{value}' is reserved for day jumps"
 +            )));
 +        }
 +        if value.is_control() {
 +            return Err(KeyBindingError::new("control characters are unsupported"));
 +        }
++
 +        Ok(Self::Char(value.to_ascii_lowercase()))
 +    }
++
 +    fn from_key_event(key: KeyEvent) -> Option<Self> {
 +        if key.modifiers.intersects(KeyModifiers::ALT) {
 +            return None;
 +        }
++
 +        match key.code {
 +            KeyCode::Left if key.modifiers.is_empty() => Some(Self::Named(NamedKey::Left)),
 +            KeyCode::Right if key.modifiers.is_empty() => Some(Self::Named(NamedKey::Right)),
 +            KeyCode::Up if key.modifiers.is_empty() => Some(Self::Named(NamedKey::Up)),
 +            KeyCode::Down if key.modifiers.is_empty() => Some(Self::Named(NamedKey::Down)),
 +            KeyCode::Enter if key.modifiers.is_empty() => Some(Self::Named(NamedKey::Enter)),
 +            KeyCode::Esc if key.modifiers.is_empty() => Some(Self::Named(NamedKey::Esc)),
 +            KeyCode::Char(value) if key.modifiers.contains(KeyModifiers::CONTROL) => {
 +                Some(Self::Ctrl(value.to_ascii_lowercase()))
 +            }
 +            KeyCode::Char(value)
 +                if key.modifiers.is_empty() || key.modifiers == KeyModifiers::SHIFT =>
 +            {
 +                Some(Self::Char(value.to_ascii_lowercase()))
 +            }
 +            _ => None,
 +        }
 +    }
++
 +    fn label(self) -> String {
 +        match self {
 +            Self::Named(named) => named.label().to_string(),
 +            Self::Char(value) => value.to_string(),
 +            Self::Ctrl(value) => format!("Ctrl-{}", value.to_ascii_uppercase()),
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 +enum NamedKey {
 +    Left,
 +    Right,
 +    Up,
 +    Down,
 +    Enter,
 +    Esc,
 +}
++
 +impl NamedKey {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::Left => "Left",
 +            Self::Right => "Right",
 +            Self::Up => "Up",
 +            Self::Down => "Down",
 +            Self::Enter => "Enter",
 +            Self::Esc => "Esc",
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 +pub enum KeyCommand {
 +    MoveLeft,
 +    MoveRight,
 +    MoveUp,
 +    MoveDown,
 +    OpenDayOrEdit,
 +    CloseDay,
 +    CreateEvent,
 +    DeleteEvent,
 +    CopyEvent,
 +    Help,
 +    Quit,
 +    JumpMonday,
 +    JumpTuesday,
 +    JumpWednesday,
 +    JumpThursday,
 +    JumpFriday,
 +    JumpSaturday,
 +    JumpSunday,
 +}
++
 +impl KeyCommand {
 +    const fn app_action(self) -> AppAction {
 +        match self {
 +            Self::MoveLeft => AppAction::MoveDays(-1),
 +            Self::MoveRight => AppAction::MoveDays(1),
 +            Self::MoveUp => AppAction::MoveDays(-7),
 +            Self::MoveDown => AppAction::MoveDays(7),
 +            Self::OpenDayOrEdit => AppAction::OpenDay,
 +            Self::CloseDay => AppAction::CloseDay,
 +            Self::CreateEvent => AppAction::OpenCreate,
 +            Self::DeleteEvent => AppAction::OpenDelete,
 +            Self::CopyEvent => AppAction::OpenCopy,
 +            Self::Help => AppAction::OpenHelp,
 +            Self::Quit => AppAction::Quit,
 +            Self::JumpMonday => AppAction::JumpToWeekday(Weekday::Monday),
 +            Self::JumpTuesday => AppAction::JumpToWeekday(Weekday::Tuesday),
 +            Self::JumpWednesday => AppAction::JumpToWeekday(Weekday::Wednesday),
 +            Self::JumpThursday => AppAction::JumpToWeekday(Weekday::Thursday),
 +            Self::JumpFriday => AppAction::JumpToWeekday(Weekday::Friday),
 +            Self::JumpSaturday => AppAction::JumpToWeekday(Weekday::Saturday),
 +            Self::JumpSunday => AppAction::JumpToWeekday(Weekday::Sunday),
 +        }
 +    }
++
 +    const fn config_name(self) -> &'static str {
 +        match self {
 +            Self::MoveLeft => "move_left",
 +            Self::MoveRight => "move_right",
 +            Self::MoveUp => "move_up",
 +            Self::MoveDown => "move_down",
 +            Self::OpenDayOrEdit => "open_day_or_edit",
 +            Self::CloseDay => "close_day",
 +            Self::CreateEvent => "create_event",
 +            Self::DeleteEvent => "delete_event",
 +            Self::CopyEvent => "copy_event",
 +            Self::Help => "help",
 +            Self::Quit => "quit",
 +            Self::JumpMonday => "jump_monday",
 +            Self::JumpTuesday => "jump_tuesday",
 +            Self::JumpWednesday => "jump_wednesday",
 +            Self::JumpThursday => "jump_thursday",
 +            Self::JumpFriday => "jump_friday",
 +            Self::JumpSaturday => "jump_saturday",
 +            Self::JumpSunday => "jump_sunday",
 +        }
 +    }
++
 +    const fn default_label(self) -> &'static str {
 +        match self {
 +            Self::MoveLeft => "Left",
 +            Self::MoveRight => "Right",
 +            Self::MoveUp => "Up",
 +            Self::MoveDown => "Down",
 +            Self::OpenDayOrEdit => "Enter",
 +            Self::CloseDay => "Esc",
 +            Self::CreateEvent => "+",
 +            Self::DeleteEvent => "d",
 +            Self::CopyEvent => "c",
 +            Self::Help => "?",
 +            Self::Quit => "q / Ctrl-C",
 +            Self::JumpMonday => "m",
 +            Self::JumpTuesday => "tu",
 +            Self::JumpWednesday => "w",
 +            Self::JumpThursday => "th",
 +            Self::JumpFriday => "f",
 +            Self::JumpSaturday => "sa",
 +            Self::JumpSunday => "su",
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct KeyBindingError {
 +    reason: String,
 +}
++
 +impl KeyBindingError {
 +    fn new(reason: impl Into<String>) -> Self {
 +        Self {
 +            reason: reason.into(),
 +        }
 +    }
 +}
++
 +impl fmt::Display for KeyBindingError {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        write!(f, "{}", self.reason)
 +    }
 +}
++
 +impl std::error::Error for KeyBindingError {}
++
 +fn digit_from_key(key: KeyEvent) -> Option<char> {
 +    match key.code {
 +        KeyCode::Char(value)
 +            if value.is_ascii_digit()
 +                && !key
 +                    .modifiers
 +                    .intersects(KeyModifiers::CONTROL | KeyModifiers::ALT) =>
 +        {
 +            Some(value)
+         }
 +        _ => None,
+     }
+ }
      #[default]
      None,
      Digit(u8),
 -    T,
 -    S,
 +    Sequence(KeyGesture),
+ }
  fn ctrl_c(value: char, modifiers: KeyModifiers) -> bool {
+         }
+     }
 +    #[test]
 +    fn configured_keybindings_replace_default_normal_mode_commands() {
 +        let bindings = KeyBindings::with_overrides(KeyBindingOverrides {
 +            create_event: Some(vec!["n".to_string()]),
 +            help: Some(vec!["h".to_string()]),
 +            quit: Some(vec!["x".to_string()]),
 +            ..KeyBindingOverrides::default()
 +        })
 +        .expect("custom bindings are valid");
 +        let mut input = KeyboardInput::new(bindings);
++
 +        assert_eq!(input.translate(char_key('+')), AppAction::Noop);
 +        assert_eq!(input.translate(char_key('n')), AppAction::OpenCreate);
 +        assert_eq!(input.translate(char_key('?')), AppAction::Noop);
 +        assert_eq!(input.translate(char_key('h')), AppAction::OpenHelp);
 +        assert_eq!(input.translate(char_key('q')), AppAction::Noop);
 +        assert_eq!(input.translate(char_key('x')), AppAction::Quit);
 +    }
++
 +    #[test]
 +    fn configured_two_key_weekday_sequence_waits_for_second_key() {
 +        let bindings = KeyBindings::with_overrides(KeyBindingOverrides {
 +            jump_tuesday: Some(vec!["xy".to_string()]),
 +            ..KeyBindingOverrides::default()
 +        })
 +        .expect("custom bindings are valid");
 +        let mut input = KeyboardInput::new(bindings);
++
 +        assert_eq!(input.translate(char_key('x')), AppAction::Noop);
 +        assert_eq!(
 +            input.translate(char_key('y')),
 +            AppAction::JumpToWeekday(Weekday::Tuesday)
 +        );
 +    }
++
 +    #[test]
 +    fn keybinding_validation_rejects_digits_duplicates_and_prefixes() {
 +        let digit_err = KeyBindings::with_overrides(KeyBindingOverrides {
 +            create_event: Some(vec!["1".to_string()]),
 +            ..KeyBindingOverrides::default()
 +        })
 +        .expect_err("digits are reserved");
 +        assert!(digit_err.to_string().contains("reserved for day jumps"));
++
 +        let duplicate_err = KeyBindings::with_overrides(KeyBindingOverrides {
 +            create_event: Some(vec!["x".to_string()]),
 +            quit: Some(vec!["x".to_string()]),
 +            ..KeyBindingOverrides::default()
 +        })
 +        .expect_err("duplicate binding fails");
 +        assert!(duplicate_err.to_string().contains("bound to both"));
++
 +        let prefix_err = KeyBindings::with_overrides(KeyBindingOverrides {
 +            create_event: Some(vec!["t".to_string()]),
 +            ..KeyBindingOverrides::default()
 +        })
 +        .expect_err("prefix binding fails");
 +        assert!(prefix_err.to_string().contains("conflicts with longer key"));
 +    }
++
      #[test]
      fn arrow_keys_move_within_month() {
          let mut app = AppState::new(date(2026, Month::April, 23));

src/cli.rsmodified

      agenda::{ConfiguredAgendaSource, HolidayProvider, LocalEventStoreError, default_events_file},
      app::{
          AppState, CreateEventInputResult, EventCopyInputResult, EventCopySubmission,
 -        EventDeleteInputResult, EventDeleteSubmission, EventFormMode, HelpInputResult,
 +        EventDeleteInputResult, EventDeleteSubmission, EventFormMode, HelpInputResult, KeyBindings,
          KeyboardInput, MouseInput, RecurrenceChoiceInputResult,
      },
      calendar::CalendarDate,
 +    config::{
 +        ConfigError, ConfigHolidaySource, UserConfig, init_config_file, load_discovered_config,
 +        load_explicit_config,
 +    },
      reminders::{
          ReminderDaemonConfig, ReminderError, SystemNotifier, default_state_file,
          notification_backend_name, run_daemon, run_once, test_notification,
      },
      tui::{
          AppView, DEFAULT_RENDER_HEIGHT, DEFAULT_RENDER_WIDTH, hit_test_app_date,
 -        render_app_to_string_with_agenda_source,
 +        render_app_to_string_with_agenda_source_and_keybindings,
      },
  };
      env!("CARGO_PKG_VERSION"),
      "\n\n",
      "Usage:\n",
 -    "  rcal [--date YYYY-MM-DD] [--events-file PATH] [--holiday-source off|us-federal|nager] [--holiday-country CC]\n\n",
 +    "  rcal [--config PATH|--no-config] [--date YYYY-MM-DD] [--events-file PATH] [--holiday-source off|us-federal|nager] [--holiday-country CC]\n",
 +    "  rcal config init [--path PATH] [--force]\n\n",
      "  rcal reminders run [--events-file PATH] [--state-file PATH] [--once]\n",
 -    "  rcal reminders install [--events-file PATH]\n",
 +    "  rcal reminders install [--events-file PATH] [--state-file PATH]\n",
      "  rcal reminders uninstall\n",
      "  rcal reminders status\n",
      "  rcal reminders test [--verbose]\n\n",
      "Options:\n",
 +    "  --config PATH                       Load a specific config file.\n",
 +    "  --no-config                         Ignore any discovered config file.\n",
      "  --date YYYY-MM-DD                   Open with the given date selected.\n",
      "  --events-file PATH                  Read and write local user events at PATH.\n",
      "  --holiday-source off|us-federal|nager\n",
      "  --holiday-country CC                Country code for --holiday-source nager. Default: US.\n",
      "  -h, --help                          Show this help.\n",
      "  -V, --version                       Show version.\n\n",
 +    "Config:\n",
 +    "  rcal config init                     Write a commented starter TOML config.\n",
 +    "  Config is discovered at $XDG_CONFIG_HOME/rcal/config.toml, else ~/.config/rcal/config.toml.\n",
 +    "  CLI flags override config values. Reminder services snapshot resolved paths at install time.\n\n",
      "Keys:\n",
      "  Arrow keys move selection; Enter opens day view; Esc returns to month; q exits.\n",
      "  ? opens contextual help.\n",
      pub events_file: PathBuf,
      pub holiday_source: HolidaySourceConfig,
      pub holiday_country: String,
 +    pub keybindings: KeyBindings,
+ }
  impl AppConfig {
              events_file: default_events_file(),
              holiday_source: HolidaySourceConfig::UsFederal,
              holiday_country: "US".to_string(),
 +            keybindings: KeyBindings::default(),
+         }
+     }
+ }
  pub enum CliAction {
      Run(AppConfig),
      Reminders(ReminderCliAction),
 +    Config(ConfigCliAction),
      Help,
      Version,
+ }
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum ConfigCliAction {
 +    Init { path: Option<PathBuf>, force: bool },
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum ReminderCliAction {
      Run(ReminderRunConfig),
 -    Install { events_file: PathBuf },
 +    Install {
 +        events_file: PathBuf,
 +        state_file: PathBuf,
 +    },
      Uninstall,
      Status,
 -    Test { verbose: bool },
 +    Test {
 +        verbose: bool,
 +    },
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
      MissingHolidayCountryValue,
      InvalidHolidayCountry(String),
      HolidayCountryRequiresNager,
 +    DuplicateConfig,
 +    MissingConfigValue,
 +    ConfigAndNoConfig,
 +    MissingConfigCommand,
 +    UnknownConfigCommand(String),
 +    DuplicateConfigInitPath,
 +    MissingConfigInitPathValue,
 +    Config(ConfigError),
      MissingReminderCommand,
      UnknownReminderCommand(String),
      DuplicateStateFile,
                      "--holiday-country may only be used with --holiday-source nager"
+                 )
+             }
 +            Self::DuplicateConfig => write!(f, "--config may only be provided once"),
 +            Self::MissingConfigValue => write!(f, "--config requires a path"),
 +            Self::ConfigAndNoConfig => write!(f, "--config and --no-config cannot be combined"),
 +            Self::MissingConfigCommand => write!(f, "config requires a command: init"),
 +            Self::UnknownConfigCommand(command) => write!(f, "unknown config command: {command}"),
 +            Self::DuplicateConfigInitPath => {
 +                write!(f, "config init --path may only be provided once")
 +            }
 +            Self::MissingConfigInitPathValue => write!(f, "config init --path requires a path"),
 +            Self::Config(err) => write!(f, "{err}"),
              Self::MissingReminderCommand => write!(
                  f,
                  "reminders requires one of: run, install, uninstall, status, test"
  impl std::error::Error for CliError {}
 +impl From<ConfigError> for CliError {
 +    fn from(err: ConfigError) -> Self {
 +        Self::Config(err)
 +    }
 +}
++
  pub fn run_terminal<I>(args: I) -> std::process::ExitCode
  where
      I: IntoIterator<Item = OsString>,
      W: Write,
      E: Write,
+ {
 -    match parse_args(args, default_start_date()) {
 +    match parse_runtime_args(args, default_start_date()) {
          Ok(CliAction::Run(config)) => {
              let app = AppState::new(config.start_date);
              let agenda_source = match agenda_source(&config) {
                  Err(err) => return local_event_error_exit(&mut stderr, err),
              };
              let (width, height) = terminal_size();
 -            let rendered =
 -                render_app_to_string_with_agenda_source(&app, width, height, &agenda_source);
 +            let rendered = render_app_to_string_with_agenda_source_and_keybindings(
 +                &app,
 +                width,
 +                height,
 +                &agenda_source,
 +                &config.keybindings,
 +            );
              match write!(stdout, "{rendered}") {
                  Ok(()) => std::process::ExitCode::SUCCESS,
                  Err(err) => io_error_exit(&mut stderr, err),
+             }
+         }
          Ok(CliAction::Reminders(action)) => run_reminder_action(action, &mut stdout, &mut stderr),
 +        Ok(CliAction::Config(action)) => run_config_action(action, &mut stdout, &mut stderr),
          Ok(CliAction::Help) => match write!(stdout, "{HELP}") {
              Ok(()) => std::process::ExitCode::SUCCESS,
              Err(err) => io_error_exit(&mut stderr, err),
      W: Write,
      E: Write,
+ {
 -    match parse_args(args, default_start_date()) {
 +    match parse_runtime_args(args, default_start_date()) {
          Ok(CliAction::Run(config)) => {
              let app = AppState::new(config.start_date);
              let agenda_source = match agenda_source(&config) {
                  Ok(source) => source,
                  Err(err) => return local_event_error_exit(&mut stderr, err),
              };
 -            match run_interactive_terminal(stdout, app, agenda_source) {
 +            match run_interactive_terminal(stdout, app, agenda_source, config.keybindings) {
                  Ok(()) => std::process::ExitCode::SUCCESS,
                  Err(err) => io_error_exit(&mut stderr, err),
+             }
+         }
          Ok(CliAction::Reminders(action)) => run_reminder_action(action, &mut stdout, &mut stderr),
 +        Ok(CliAction::Config(action)) => run_config_action(action, &mut stdout, &mut stderr),
          Ok(CliAction::Help) => match write!(stdout, "{HELP}") {
              Ok(()) => std::process::ExitCode::SUCCESS,
              Err(err) => io_error_exit(&mut stderr, err),
+ }
  pub fn parse_args<I>(args: I, today: Date) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    parse_args_with_config(args, today, UserConfig::empty(), None)
 +}
++
 +fn parse_runtime_args<I>(args: I, today: Date) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let args = args.into_iter().collect::<Vec<_>>();
 +    let (args, config_selection) = strip_config_flags(args)?;
++
 +    if let Some(action) = early_static_action(&args) {
 +        return Ok(action);
 +    }
++
 +    if let Some(first) = args.first()
 +        && first == "config"
 +    {
 +        return parse_config_args(args.into_iter().skip(1), config_selection.path);
 +    }
++
 +    let config = match &config_selection {
 +        ConfigSelection {
 +            no_config: true, ..
 +        } => UserConfig::empty(),
 +        ConfigSelection {
 +            path: Some(path), ..
 +        } => load_explicit_config(path.clone())?,
 +        ConfigSelection { .. } => load_discovered_config()?,
 +    };
++
 +    parse_args_with_config(args, today, config, config_selection.path)
 +}
++
 +fn parse_args_with_config<I>(
 +    args: I,
 +    today: Date,
 +    user_config: UserConfig,
 +    explicit_config_path: Option<PathBuf>,
 +) -> Result<CliAction, CliError>
  where
      I: IntoIterator<Item = OsString>,
+ {
      let args = args.into_iter().collect::<Vec<_>>();
 +    if let Some(first) = args.first()
 +        && first == "config"
 +    {
 +        return parse_config_args(args.into_iter().skip(1), explicit_config_path);
 +    }
++
      if let Some(first) = args.first()
          && first == "reminders"
+     {
 -        return parse_reminder_args(args.into_iter().skip(1));
 +        return parse_reminder_args(args.into_iter().skip(1), &user_config);
 +    }
++
 +    parse_calendar_args(args, today, user_config)
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct ConfigSelection {
 +    path: Option<PathBuf>,
 +    no_config: bool,
 +}
++
 +fn strip_config_flags(args: Vec<OsString>) -> Result<(Vec<OsString>, ConfigSelection), CliError> {
 +    let mut stripped = Vec::new();
 +    let mut config_path = None;
 +    let mut no_config = false;
 +    let mut args = args.into_iter();
++
 +    while let Some(arg) = args.next() {
 +        if arg == "--config" {
 +            if config_path.is_some() {
 +                return Err(CliError::DuplicateConfig);
 +            }
 +            config_path = Some(PathBuf::from(
 +                args.next().ok_or(CliError::MissingConfigValue)?,
 +            ));
 +            continue;
 +        }
++
 +        if let Some(value) = arg
 +            .to_str()
 +            .and_then(|value| value.strip_prefix("--config="))
 +        {
 +            if config_path.is_some() {
 +                return Err(CliError::DuplicateConfig);
 +            }
 +            config_path = Some(PathBuf::from(value));
 +            continue;
 +        }
++
 +        if arg == "--no-config" {
 +            no_config = true;
 +            continue;
 +        }
++
 +        stripped.push(arg);
 +    }
++
 +    if config_path.is_some() && no_config {
 +        return Err(CliError::ConfigAndNoConfig);
 +    }
++
 +    Ok((
 +        stripped,
 +        ConfigSelection {
 +            path: config_path,
 +            no_config,
 +        },
 +    ))
 +}
++
 +fn early_static_action(args: &[OsString]) -> Option<CliAction> {
 +    let first = args.first()?;
 +    if first == "--help" || first == "-h" {
 +        return Some(CliAction::Help);
 +    }
 +    if first == "--version" || first == "-V" {
 +        return Some(CliAction::Version);
 +    }
 +    if first == "reminders"
 +        && let Some(second) = args.get(1)
 +        && (second == "--help" || second == "-h")
 +    {
 +        return Some(CliAction::Help);
 +    }
 +    if first == "config"
 +        && let Some(second) = args.get(1)
 +        && (second == "--help" || second == "-h")
 +    {
 +        return Some(CliAction::Help);
+     }
 -    parse_calendar_args(args, today)
 +    None
+ }
 -fn parse_calendar_args<I>(args: I, today: Date) -> Result<CliAction, CliError>
 +fn parse_calendar_args<I>(
 +    args: I,
 +    today: Date,
 +    user_config: UserConfig,
 +) -> Result<CliAction, CliError>
  where
      I: IntoIterator<Item = OsString>,
+ {
          return Err(CliError::UnknownArgument(display_arg(&arg)));
+     }
 -    let holiday_country_was_provided = holiday_country.is_some();
 +    let cli_holiday_country_was_provided = holiday_country.is_some();
      let mut config = AppConfig::new(CalendarDate::from(start_date.unwrap_or(today)));
 +    if let Some(events_file) = user_config.events_file {
 +        config.events_file = events_file;
 +    }
 +    if let Some(holiday_source) = user_config.holiday_source {
 +        config.holiday_source = holiday_source.into();
 +    }
 +    if let Some(holiday_country) = user_config.holiday_country {
 +        config.holiday_country = holiday_country;
 +    }
 +    config.keybindings = user_config.keybindings;
++
      if let Some(events_file) = events_file {
          config.events_file = events_file;
+     }
      if let Some(holiday_country) = holiday_country {
          config.holiday_country = holiday_country;
+     }
 -    if holiday_country_was_provided && config.holiday_source != HolidaySourceConfig::Nager {
 +    if cli_holiday_country_was_provided && config.holiday_source != HolidaySourceConfig::Nager {
          return Err(CliError::HolidayCountryRequiresNager);
+     }
      Ok(CliAction::Run(config))
+ }
 -fn parse_reminder_args<I>(args: I) -> Result<CliAction, CliError>
 +impl From<ConfigHolidaySource> for HolidaySourceConfig {
 +    fn from(value: ConfigHolidaySource) -> Self {
 +        match value {
 +            ConfigHolidaySource::Off => Self::Off,
 +            ConfigHolidaySource::UsFederal => Self::UsFederal,
 +            ConfigHolidaySource::Nager => Self::Nager,
 +        }
 +    }
 +}
++
 +fn parse_config_args<I>(
 +    args: I,
 +    explicit_config_path: Option<PathBuf>,
 +) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let mut args = args.into_iter();
 +    let command = args.next().ok_or(CliError::MissingConfigCommand)?;
 +    let Some(command) = command.to_str() else {
 +        return Err(CliError::UnknownConfigCommand(display_arg(&command)));
 +    };
++
 +    match command {
 +        "init" => parse_config_init_args(args, explicit_config_path),
 +        "--help" | "-h" => Ok(CliAction::Help),
 +        _ => Err(CliError::UnknownConfigCommand(command.to_string())),
 +    }
 +}
++
 +fn parse_config_init_args<I>(
 +    args: I,
 +    explicit_config_path: Option<PathBuf>,
 +) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let mut path = explicit_config_path;
 +    let mut force = false;
 +    let mut args = args.into_iter();
++
 +    while let Some(arg) = args.next() {
 +        if arg == "--path" {
 +            if path.is_some() {
 +                return Err(CliError::DuplicateConfigInitPath);
 +            }
 +            path = Some(PathBuf::from(
 +                args.next().ok_or(CliError::MissingConfigInitPathValue)?,
 +            ));
 +            continue;
 +        }
++
 +        if let Some(value) = arg.to_str().and_then(|value| value.strip_prefix("--path=")) {
 +            if path.is_some() {
 +                return Err(CliError::DuplicateConfigInitPath);
 +            }
 +            path = Some(PathBuf::from(value));
 +            continue;
 +        }
++
 +        if arg == "--force" {
 +            force = true;
 +            continue;
 +        }
++
 +        return Err(CliError::UnknownArgument(display_arg(&arg)));
 +    }
++
 +    Ok(CliAction::Config(ConfigCliAction::Init { path, force }))
 +}
++
 +fn parse_reminder_args<I>(args: I, user_config: &UserConfig) -> Result<CliAction, CliError>
  where
      I: IntoIterator<Item = OsString>,
+ {
      };
      match command {
 -        "run" => parse_reminder_run_args(args),
 -        "install" => parse_reminder_install_args(args),
 +        "run" => parse_reminder_run_args(args, user_config),
 +        "install" => parse_reminder_install_args(args, user_config),
          "uninstall" => no_extra_reminder_args(args, ReminderCliAction::Uninstall),
          "status" => no_extra_reminder_args(args, ReminderCliAction::Status),
          "test" => parse_reminder_test_args(args),
+     }
+ }
 -fn parse_reminder_run_args<I>(args: I) -> Result<CliAction, CliError>
 +fn parse_reminder_run_args<I>(args: I, user_config: &UserConfig) -> Result<CliAction, CliError>
  where
      I: IntoIterator<Item = OsString>,
+ {
      Ok(CliAction::Reminders(ReminderCliAction::Run(
          ReminderRunConfig {
 -            events_file: events_file.unwrap_or_else(default_events_file),
 -            state_file: state_file.unwrap_or_else(default_state_file),
 +            events_file: events_file.unwrap_or_else(|| {
 +                user_config
 +                    .events_file
 +                    .clone()
 +                    .unwrap_or_else(default_events_file)
 +            }),
 +            state_file: state_file.unwrap_or_else(|| {
 +                user_config
 +                    .reminder_state_file
 +                    .clone()
 +                    .unwrap_or_else(default_state_file)
 +            }),
              once,
          },
      )))
+ }
 -fn parse_reminder_install_args<I>(args: I) -> Result<CliAction, CliError>
 +fn parse_reminder_install_args<I>(args: I, user_config: &UserConfig) -> Result<CliAction, CliError>
  where
      I: IntoIterator<Item = OsString>,
+ {
      let mut events_file = None;
 +    let mut state_file = None;
      let mut args = args.into_iter();
      while let Some(arg) = args.next() {
              events_file = Some(PathBuf::from(value));
              continue;
+         }
 +        if arg == "--state-file" {
 +            if state_file.is_some() {
 +                return Err(CliError::DuplicateStateFile);
 +            }
 +            state_file = Some(PathBuf::from(
 +                args.next().ok_or(CliError::MissingStateFileValue)?,
 +            ));
 +            continue;
 +        }
 +        if let Some(value) = arg
 +            .to_str()
 +            .and_then(|value| value.strip_prefix("--state-file="))
 +        {
 +            if state_file.is_some() {
 +                return Err(CliError::DuplicateStateFile);
 +            }
 +            state_file = Some(PathBuf::from(value));
 +            continue;
 +        }
          return Err(CliError::UnknownArgument(display_arg(&arg)));
+     }
      Ok(CliAction::Reminders(ReminderCliAction::Install {
 -        events_file: events_file.unwrap_or_else(default_events_file),
 +        events_file: events_file.unwrap_or_else(|| {
 +            user_config
 +                .events_file
 +                .clone()
 +                .unwrap_or_else(default_events_file)
 +        }),
 +        state_file: state_file.unwrap_or_else(|| {
 +            user_config
 +                .reminder_state_file
 +                .clone()
 +                .unwrap_or_else(default_state_file)
 +        }),
      }))
+ }
      ConfiguredAgendaSource::from_events_file(config.events_file.clone(), holidays)
+ }
 +fn run_config_action(
 +    action: ConfigCliAction,
 +    stdout: &mut impl Write,
 +    stderr: &mut impl Write,
 +) -> std::process::ExitCode {
 +    match action {
 +        ConfigCliAction::Init { path, force } => match init_config_file(path, force) {
 +            Ok(path) => {
 +                let _ = writeln!(stdout, "wrote config {}", path.display());
 +                std::process::ExitCode::SUCCESS
 +            }
 +            Err(err) => config_error_exit(stderr, err),
 +        },
 +    }
 +}
++
  fn run_reminder_action(
      action: ReminderCliAction,
      stdout: &mut impl Write,
+                 }
+             }
+         }
 -        ReminderCliAction::Install { events_file } => {
 -            let config = match ServiceConfig::new(events_file) {
 +        ReminderCliAction::Install {
 +            events_file,
 +            state_file,
 +        } => {
 +            let config = match ServiceConfig::new(events_file, state_file) {
                  Ok(config) => config,
                  Err(err) => return service_error_exit(stderr, err),
              };
      stdout: W,
      app: AppState,
      agenda_source: ConfiguredAgendaSource,
 +    keybindings: KeyBindings,
  ) -> io::Result<()>
  where
      W: Write,
          return Err(err);
+     }
 -    let result = run_event_loop(&mut terminal, app, agenda_source);
 +    let result = run_event_loop(&mut terminal, app, agenda_source, keybindings);
      let cleanup_result = restore_terminal(&mut terminal);
      result.and(cleanup_result)
      terminal: &mut Terminal<CrosstermBackend<W>>,
      mut app: AppState,
      mut agenda_source: ConfiguredAgendaSource,
 +    keybindings: KeyBindings,
  ) -> io::Result<()>
  where
      W: Write,
+ {
 -    let mut keyboard = KeyboardInput::default();
 +    let mut keyboard = KeyboardInput::new(keybindings.clone());
      let mut mouse = MouseInput::default();
      loop {
          terminal.draw(|frame| {
              frame.render_widget(
 -                AppView::with_agenda_source(&app, &agenda_source),
 +                AppView::with_agenda_source_and_keybindings(&app, &agenda_source, &keybindings),
                  frame.area(),
              );
          })?;
      std::process::ExitCode::FAILURE
+ }
 +fn config_error_exit(stderr: &mut impl Write, err: ConfigError) -> std::process::ExitCode {
 +    let _ = writeln!(stderr, "error: {err}");
 +    std::process::ExitCode::from(2)
 +}
++
  fn service_error_exit(stderr: &mut impl Write, err: ServiceError) -> std::process::ExitCode {
      let _ = writeln!(stderr, "error: {err}");
      std::process::ExitCode::FAILURE
  #[cfg(test)]
  mod tests {
      use super::*;
 +    use std::{env, fs};
++
 +    use crate::app::{KeyBindingOverrides, KeyCommand};
      use crate::calendar::CalendarMonth;
      use time::Month;
          OsString::from(value)
+     }
 +    fn temp_path(name: &str) -> PathBuf {
 +        env::temp_dir()
 +            .join(format!("rcal-cli-test-{}", std::process::id()))
 +            .join(name)
 +    }
++
 +    fn config_with_paths_and_keys() -> UserConfig {
 +        UserConfig {
 +            path: Some(PathBuf::from("/tmp/rcal/config.toml")),
 +            events_file: Some(PathBuf::from("/tmp/config-events.json")),
 +            holiday_source: Some(ConfigHolidaySource::Nager),
 +            holiday_country: Some("GB".to_string()),
 +            reminder_state_file: Some(PathBuf::from("/tmp/config-state.json")),
 +            keybindings: KeyBindings::with_overrides(KeyBindingOverrides {
 +                create_event: Some(vec!["n".to_string()]),
 +                help: Some(vec!["h".to_string()]),
 +                ..KeyBindingOverrides::default()
 +            })
 +            .expect("test bindings are valid"),
 +        }
 +    }
++
      #[test]
      fn no_args_uses_provided_today() {
          let today = date(2026, Month::April, 23);
          );
+     }
 +    #[test]
 +    fn config_values_merge_under_cli_overrides() {
 +        let today = date(2026, Month::April, 23);
++
 +        let action = parse_args_with_config(
 +            [
 +                arg("--events-file"),
 +                arg("/tmp/cli-events.json"),
 +                arg("--holiday-country"),
 +                arg("ca"),
 +            ],
 +            today.into(),
 +            config_with_paths_and_keys(),
 +            None,
 +        )
 +        .expect("parse succeeds");
++
 +        let CliAction::Run(config) = action else {
 +            panic!("calendar args should run the app");
 +        };
++
 +        assert_eq!(config.events_file, PathBuf::from("/tmp/cli-events.json"));
 +        assert_eq!(config.holiday_source, HolidaySourceConfig::Nager);
 +        assert_eq!(config.holiday_country, "CA");
 +        assert_eq!(config.keybindings.display_for(KeyCommand::CreateEvent), "n");
 +    }
++
 +    #[test]
 +    fn explicit_runtime_config_file_is_loaded() {
 +        let today = date(2026, Month::April, 23);
 +        let path = temp_path("explicit/config.toml");
 +        let root = path
 +            .parent()
 +            .expect("config dir")
 +            .parent()
 +            .expect("test root")
 +            .to_path_buf();
 +        let _ = fs::remove_dir_all(&root);
 +        fs::create_dir_all(path.parent().expect("config dir")).expect("dir creates");
 +        fs::write(
 +            &path,
 +            r#"
 +[paths]
 +events_file = "events.json"
++
 +[keybindings]
 +create_event = ["n"]
 +"#,
 +        )
 +        .expect("config writes");
++
 +        let action = parse_runtime_args(
 +            [
 +                arg("--config"),
 +                path.as_os_str().to_os_string(),
 +                arg("--date"),
 +                arg("2026-04-23"),
 +            ],
 +            today.into(),
 +        )
 +        .expect("runtime parse succeeds");
++
 +        let _ = fs::remove_dir_all(&root);
 +        let CliAction::Run(config) = action else {
 +            panic!("calendar args should run the app");
 +        };
 +        assert_eq!(
 +            config.events_file,
 +            path.parent().expect("config dir").join("events.json")
 +        );
 +        assert_eq!(config.keybindings.display_for(KeyCommand::CreateEvent), "n");
 +    }
++
 +    #[test]
 +    fn global_config_flags_reject_conflicts() {
 +        let today = date(2026, Month::April, 23);
++
 +        assert_eq!(
 +            parse_runtime_args(
 +                [arg("--config"), arg("/tmp/config.toml"), arg("--no-config")],
 +                today.into(),
 +            )
 +            .expect_err("conflicting config flags fail"),
 +            CliError::ConfigAndNoConfig
 +        );
 +    }
++
 +    #[test]
 +    fn config_init_args_parse_path_and_force() {
 +        let today = date(2026, Month::April, 23);
++
 +        let action = parse_args(
 +            [
 +                arg("config"),
 +                arg("init"),
 +                arg("--path=/tmp/rcal/config.toml"),
 +                arg("--force"),
 +            ],
 +            today.into(),
 +        )
 +        .expect("parse succeeds");
++
 +        assert_eq!(
 +            action,
 +            CliAction::Config(ConfigCliAction::Init {
 +                path: Some(PathBuf::from("/tmp/rcal/config.toml")),
 +                force: true,
 +            })
 +        );
 +    }
++
 +    #[test]
 +    fn config_init_can_use_global_config_path_without_loading_it() {
 +        let today = date(2026, Month::April, 23);
++
 +        let action = parse_runtime_args(
 +            [
 +                arg("--config"),
 +                arg("/tmp/nonexistent-rcal-config.toml"),
 +                arg("config"),
 +                arg("init"),
 +                arg("--force"),
 +            ],
 +            today.into(),
 +        )
 +        .expect("config init parses without loading missing config");
++
 +        assert_eq!(
 +            action,
 +            CliAction::Config(ConfigCliAction::Init {
 +                path: Some(PathBuf::from("/tmp/nonexistent-rcal-config.toml")),
 +                force: true,
 +            })
 +        );
 +    }
++
      #[test]
      fn reminder_run_args_set_events_and_state_paths() {
          let today = date(2026, Month::April, 23);
          );
+     }
 +    #[test]
 +    fn reminder_commands_use_config_default_paths() {
 +        let today = date(2026, Month::April, 23);
++
 +        let run_action = parse_args_with_config(
 +            [arg("reminders"), arg("run"), arg("--once")],
 +            today.into(),
 +            config_with_paths_and_keys(),
 +            None,
 +        )
 +        .expect("run parses");
 +        assert_eq!(
 +            run_action,
 +            CliAction::Reminders(ReminderCliAction::Run(ReminderRunConfig {
 +                events_file: PathBuf::from("/tmp/config-events.json"),
 +                state_file: PathBuf::from("/tmp/config-state.json"),
 +                once: true,
 +            }))
 +        );
++
 +        let install_action = parse_args_with_config(
 +            [
 +                arg("reminders"),
 +                arg("install"),
 +                arg("--state-file=/tmp/override-state.json"),
 +            ],
 +            today.into(),
 +            config_with_paths_and_keys(),
 +            None,
 +        )
 +        .expect("install parses");
 +        assert_eq!(
 +            install_action,
 +            CliAction::Reminders(ReminderCliAction::Install {
 +                events_file: PathBuf::from("/tmp/config-events.json"),
 +                state_file: PathBuf::from("/tmp/override-state.json"),
 +            })
 +        );
 +    }
++
      #[test]
      fn reminder_install_args_set_events_path() {
          let today = date(2026, Month::April, 23);
              action,
              CliAction::Reminders(ReminderCliAction::Install {
                  events_file: PathBuf::from("/tmp/events.json"),
 +                state_file: default_state_file(),
              })
          );
+     }

src/config.rsadded

 +use std::{
 +    env,
 +    error::Error,
 +    fmt, fs,
 +    path::{Path, PathBuf},
 +};
++
 +use serde::Deserialize;
++
 +use crate::app::{KeyBindingError, KeyBindingOverrides, KeyBindings};
++
 +pub const DEFAULT_CONFIG_TOML: &str = r#"# rcal configuration
 +# Generate this file with `rcal config init`.
++
 +[paths]
 +# Local user-created events.
 +events_file = "~/.local/share/rcal/events.json"
++
 +[holidays]
 +# One of: "off", "us-federal", "nager".
 +source = "us-federal"
 +# Two-letter country code. Only used by the Nager.Date holiday source.
 +country = "US"
++
 +[reminders]
 +# Delivered/skipped reminder state. Services snapshot this path at install time.
 +state_file = "~/.local/state/rcal/reminders-state.json"
++
 +[keybindings]
 +# Normal month/day app commands. Modal/form editing keys are fixed for now.
 +move_left = ["left"]
 +move_right = ["right"]
 +move_up = ["up"]
 +move_down = ["down"]
 +open_day_or_edit = ["enter"]
 +close_day = ["esc"]
 +create_event = ["+"]
 +delete_event = ["d"]
 +copy_event = ["c"]
 +help = ["?"]
 +quit = ["q", "ctrl-c"]
++
 +jump_monday = ["m"]
 +jump_tuesday = ["tu"]
 +jump_wednesday = ["w"]
 +jump_thursday = ["th"]
 +jump_friday = ["f"]
 +jump_saturday = ["sa"]
 +jump_sunday = ["su"]
 +"#;
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct UserConfig {
 +    pub path: Option<PathBuf>,
 +    pub events_file: Option<PathBuf>,
 +    pub holiday_source: Option<ConfigHolidaySource>,
 +    pub holiday_country: Option<String>,
 +    pub reminder_state_file: Option<PathBuf>,
 +    pub keybindings: KeyBindings,
 +}
++
 +impl UserConfig {
 +    pub fn empty() -> Self {
 +        Self {
 +            path: None,
 +            events_file: None,
 +            holiday_source: None,
 +            holiday_country: None,
 +            reminder_state_file: None,
 +            keybindings: KeyBindings::default(),
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ConfigHolidaySource {
 +    Off,
 +    UsFederal,
 +    Nager,
 +}
++
 +pub fn default_config_file() -> PathBuf {
 +    default_config_file_for(env::var_os("XDG_CONFIG_HOME"), env::var_os("HOME"))
 +}
++
 +fn default_config_file_for(
 +    xdg_config_home: Option<impl Into<PathBuf>>,
 +    home: Option<impl Into<PathBuf>>,
 +) -> PathBuf {
 +    if let Some(xdg_config_home) = xdg_config_home {
 +        return xdg_config_home.into().join("rcal").join("config.toml");
 +    }
++
 +    if let Some(home) = home {
 +        return home.into().join(".config").join("rcal").join("config.toml");
 +    }
++
 +    env::temp_dir().join("rcal").join("config.toml")
 +}
++
 +pub fn load_discovered_config() -> Result<UserConfig, ConfigError> {
 +    let path = default_config_file();
 +    if !path.exists() {
 +        return Ok(UserConfig::empty());
 +    }
++
 +    load_config_file(&path)
 +}
++
 +pub fn load_explicit_config(path: impl Into<PathBuf>) -> Result<UserConfig, ConfigError> {
 +    let path = expand_user_path(path.into())?;
 +    if !path.exists() {
 +        return Err(ConfigError::Missing { path });
 +    }
++
 +    load_config_file(&path)
 +}
++
 +pub fn load_config_file(path: &Path) -> Result<UserConfig, ConfigError> {
 +    let body = fs::read_to_string(path).map_err(|err| ConfigError::Read {
 +        path: path.to_path_buf(),
 +        reason: err.to_string(),
 +    })?;
 +    let parsed = toml::from_str::<RawConfig>(&body).map_err(|err| ConfigError::Parse {
 +        path: path.to_path_buf(),
 +        reason: err.to_string(),
 +    })?;
 +    raw_config_to_user_config(parsed, path)
 +}
++
 +pub fn init_config_file(path: Option<PathBuf>, force: bool) -> Result<PathBuf, ConfigError> {
 +    let path = match path {
 +        Some(path) => expand_user_path(path)?,
 +        None => default_config_file(),
 +    };
++
 +    if path.exists() && !force {
 +        return Err(ConfigError::AlreadyExists { path });
 +    }
++
 +    if let Some(parent) = path.parent() {
 +        fs::create_dir_all(parent).map_err(|err| ConfigError::Write {
 +            path: parent.to_path_buf(),
 +            reason: err.to_string(),
 +        })?;
 +    }
++
 +    fs::write(&path, DEFAULT_CONFIG_TOML).map_err(|err| ConfigError::Write {
 +        path: path.clone(),
 +        reason: err.to_string(),
 +    })?;
++
 +    Ok(path)
 +}
++
 +fn raw_config_to_user_config(raw: RawConfig, path: &Path) -> Result<UserConfig, ConfigError> {
 +    let base_dir = path.parent().unwrap_or_else(|| Path::new("."));
 +    let events_file = raw
 +        .paths
 +        .and_then(|paths| paths.events_file)
 +        .map(|path| resolve_config_path(&path, base_dir))
 +        .transpose()?;
 +    let reminder_state_file = raw
 +        .reminders
 +        .and_then(|reminders| reminders.state_file)
 +        .map(|path| resolve_config_path(&path, base_dir))
 +        .transpose()?;
++
 +    let (holiday_source, holiday_country) = if let Some(holidays) = raw.holidays {
 +        (
 +            holidays
 +                .source
 +                .map(|value| parse_holiday_source(&value, path))
 +                .transpose()?,
 +            holidays
 +                .country
 +                .map(|value| parse_holiday_country(&value, path))
 +                .transpose()?,
 +        )
 +    } else {
 +        (None, None)
 +    };
++
 +    let keybindings = if let Some(keybindings) = raw.keybindings {
 +        KeyBindings::with_overrides(keybindings.into_overrides()).map_err(|err| {
 +            ConfigError::Invalid {
 +                path: path.to_path_buf(),
 +                reason: format!("invalid keybindings: {err}"),
 +            }
 +        })?
 +    } else {
 +        KeyBindings::default()
 +    };
++
 +    Ok(UserConfig {
 +        path: Some(path.to_path_buf()),
 +        events_file,
 +        holiday_source,
 +        holiday_country,
 +        reminder_state_file,
 +        keybindings,
 +    })
 +}
++
 +fn parse_holiday_source(value: &str, path: &Path) -> Result<ConfigHolidaySource, ConfigError> {
 +    match value {
 +        "off" => Ok(ConfigHolidaySource::Off),
 +        "us-federal" => Ok(ConfigHolidaySource::UsFederal),
 +        "nager" => Ok(ConfigHolidaySource::Nager),
 +        _ => Err(ConfigError::Invalid {
 +            path: path.to_path_buf(),
 +            reason: format!(
 +                "invalid holidays.source '{value}'; expected off, us-federal, or nager"
 +            ),
 +        }),
 +    }
 +}
++
 +fn parse_holiday_country(value: &str, path: &Path) -> Result<String, ConfigError> {
 +    if value.len() == 2 && value.bytes().all(|value| value.is_ascii_alphabetic()) {
 +        Ok(value.to_ascii_uppercase())
 +    } else {
 +        Err(ConfigError::Invalid {
 +            path: path.to_path_buf(),
 +            reason: format!("invalid holidays.country '{value}'; expected two ASCII letters"),
 +        })
 +    }
 +}
++
 +fn resolve_config_path(value: &str, base_dir: &Path) -> Result<PathBuf, ConfigError> {
 +    let expanded = expand_user_path(PathBuf::from(value))?;
 +    if expanded.is_absolute() {
 +        Ok(expanded)
 +    } else {
 +        Ok(base_dir.join(expanded))
 +    }
 +}
++
 +pub fn expand_user_path(path: PathBuf) -> Result<PathBuf, ConfigError> {
 +    let Some(value) = path.to_str() else {
 +        return Ok(path);
 +    };
++
 +    if value == "~" {
 +        return Ok(home_dir()?.to_path_buf());
 +    }
++
 +    if let Some(rest) = value.strip_prefix("~/") {
 +        return Ok(home_dir()?.join(rest));
 +    }
++
 +    Ok(path)
 +}
++
 +fn home_dir() -> Result<PathBuf, ConfigError> {
 +    env::var_os("HOME")
 +        .map(PathBuf::from)
 +        .ok_or(ConfigError::MissingHome)
 +}
++
 +#[derive(Debug, Deserialize)]
 +#[serde(deny_unknown_fields)]
 +struct RawConfig {
 +    paths: Option<RawPathsConfig>,
 +    holidays: Option<RawHolidaysConfig>,
 +    reminders: Option<RawRemindersConfig>,
 +    keybindings: Option<RawKeyBindingsConfig>,
 +}
++
 +#[derive(Debug, Deserialize)]
 +#[serde(deny_unknown_fields)]
 +struct RawPathsConfig {
 +    events_file: Option<String>,
 +}
++
 +#[derive(Debug, Deserialize)]
 +#[serde(deny_unknown_fields)]
 +struct RawHolidaysConfig {
 +    source: Option<String>,
 +    country: Option<String>,
 +}
++
 +#[derive(Debug, Deserialize)]
 +#[serde(deny_unknown_fields)]
 +struct RawRemindersConfig {
 +    state_file: Option<String>,
 +}
++
 +#[derive(Debug, Default, Deserialize)]
 +#[serde(deny_unknown_fields)]
 +struct RawKeyBindingsConfig {
 +    move_left: Option<Vec<String>>,
 +    move_right: Option<Vec<String>>,
 +    move_up: Option<Vec<String>>,
 +    move_down: Option<Vec<String>>,
 +    open_day_or_edit: Option<Vec<String>>,
 +    close_day: Option<Vec<String>>,
 +    create_event: Option<Vec<String>>,
 +    delete_event: Option<Vec<String>>,
 +    copy_event: Option<Vec<String>>,
 +    help: Option<Vec<String>>,
 +    quit: Option<Vec<String>>,
 +    jump_monday: Option<Vec<String>>,
 +    jump_tuesday: Option<Vec<String>>,
 +    jump_wednesday: Option<Vec<String>>,
 +    jump_thursday: Option<Vec<String>>,
 +    jump_friday: Option<Vec<String>>,
 +    jump_saturday: Option<Vec<String>>,
 +    jump_sunday: Option<Vec<String>>,
 +}
++
 +impl RawKeyBindingsConfig {
 +    fn into_overrides(self) -> KeyBindingOverrides {
 +        KeyBindingOverrides {
 +            move_left: self.move_left,
 +            move_right: self.move_right,
 +            move_up: self.move_up,
 +            move_down: self.move_down,
 +            open_day_or_edit: self.open_day_or_edit,
 +            close_day: self.close_day,
 +            create_event: self.create_event,
 +            delete_event: self.delete_event,
 +            copy_event: self.copy_event,
 +            help: self.help,
 +            quit: self.quit,
 +            jump_monday: self.jump_monday,
 +            jump_tuesday: self.jump_tuesday,
 +            jump_wednesday: self.jump_wednesday,
 +            jump_thursday: self.jump_thursday,
 +            jump_friday: self.jump_friday,
 +            jump_saturday: self.jump_saturday,
 +            jump_sunday: self.jump_sunday,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum ConfigError {
 +    Missing { path: PathBuf },
 +    MissingHome,
 +    AlreadyExists { path: PathBuf },
 +    Read { path: PathBuf, reason: String },
 +    Write { path: PathBuf, reason: String },
 +    Parse { path: PathBuf, reason: String },
 +    Invalid { path: PathBuf, reason: String },
 +}
++
 +impl fmt::Display for ConfigError {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        match self {
 +            Self::Missing { path } => write!(f, "config file does not exist: {}", path.display()),
 +            Self::MissingHome => write!(f, "failed to locate a user home directory"),
 +            Self::AlreadyExists { path } => {
 +                write!(
 +                    f,
 +                    "config file already exists at {}; pass --force to overwrite",
 +                    path.display()
 +                )
 +            }
 +            Self::Read { path, reason } => {
 +                write!(f, "failed to read config {}: {reason}", path.display())
 +            }
 +            Self::Write { path, reason } => {
 +                write!(f, "failed to write config {}: {reason}", path.display())
 +            }
 +            Self::Parse { path, reason } => {
 +                write!(f, "failed to parse config {}: {reason}", path.display())
 +            }
 +            Self::Invalid { path, reason } => {
 +                write!(f, "invalid config {}: {reason}", path.display())
 +            }
 +        }
 +    }
 +}
++
 +impl Error for ConfigError {}
++
 +impl From<KeyBindingError> for ConfigError {
 +    fn from(err: KeyBindingError) -> Self {
 +        Self::Invalid {
 +            path: PathBuf::from("<config>"),
 +            reason: err.to_string(),
 +        }
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
 +    use std::sync::atomic::{AtomicUsize, Ordering};
++
 +    static TEMP_COUNTER: AtomicUsize = AtomicUsize::new(0);
++
 +    fn temp_config_path(name: &str) -> PathBuf {
 +        let counter = TEMP_COUNTER.fetch_add(1, Ordering::Relaxed);
 +        env::temp_dir()
 +            .join(format!("rcal-config-test-{}-{counter}", std::process::id()))
 +            .join(name)
 +    }
++
 +    #[test]
 +    fn default_config_path_prefers_xdg_then_home() {
 +        assert_eq!(
 +            default_config_file_for(Some("/tmp/xdg"), Some("/tmp/home")),
 +            PathBuf::from("/tmp/xdg/rcal/config.toml")
 +        );
 +        assert_eq!(
 +            default_config_file_for(None::<&str>, Some("/tmp/home")),
 +            PathBuf::from("/tmp/home/.config/rcal/config.toml")
 +        );
 +    }
++
 +    #[test]
 +    fn missing_discovered_config_is_empty() {
 +        let config = UserConfig::empty();
 +        assert!(config.events_file.is_none());
 +        assert!(config.reminder_state_file.is_none());
 +    }
++
 +    #[test]
 +    fn config_loads_paths_relative_to_file_and_expands_home() {
 +        let path = temp_config_path("relative/config.toml");
 +        let _ = fs::remove_dir_all(path.parent().and_then(Path::parent).expect("test root"));
 +        fs::create_dir_all(path.parent().expect("config dir")).expect("dir creates");
 +        fs::write(
 +            &path,
 +            r#"
 +[paths]
 +events_file = "events.json"
++
 +[reminders]
 +state_file = "~/state.json"
 +"#,
 +        )
 +        .expect("config writes");
++
 +        let config = load_config_file(&path).expect("config loads");
 +        let _ = fs::remove_dir_all(path.parent().and_then(Path::parent).expect("test root"));
++
 +        let expected_events_file = path.parent().expect("config dir").join("events.json");
 +        assert_eq!(
 +            config.events_file.as_deref(),
 +            Some(expected_events_file.as_path())
 +        );
 +        assert!(
 +            config
 +                .reminder_state_file
 +                .expect("state path")
 +                .ends_with("state.json")
 +        );
 +    }
++
 +    #[test]
 +    fn generated_config_parses_cleanly() {
 +        let parsed = toml::from_str::<RawConfig>(DEFAULT_CONFIG_TOML).expect("template parses");
 +        assert!(parsed.paths.expect("paths").events_file.is_some());
 +        assert!(parsed.keybindings.expect("keybindings").quit.is_some());
 +    }
++
 +    #[test]
 +    fn malformed_and_unknown_config_fail_clearly() {
 +        assert!(toml::from_str::<RawConfig>("not = [").is_err());
 +        assert!(toml::from_str::<RawConfig>("[unknown]\nvalue = true\n").is_err());
 +    }
++
 +    #[test]
 +    fn config_init_refuses_to_overwrite_without_force() {
 +        let path = temp_config_path("init/config.toml");
 +        let _ = fs::remove_dir_all(path.parent().and_then(Path::parent).expect("test root"));
 +        let created = init_config_file(Some(path.clone()), false).expect("config initializes");
 +        assert_eq!(created, path);
 +        let err = init_config_file(Some(path.clone()), false).expect_err("overwrite fails");
 +        init_config_file(Some(path.clone()), true).expect("force overwrites");
 +        let _ = fs::remove_dir_all(path.parent().and_then(Path::parent).expect("test root"));
 +        assert!(matches!(err, ConfigError::AlreadyExists { .. }));
 +    }
++
 +    #[test]
 +    fn invalid_keybindings_fail() {
 +        let path = temp_config_path("keys/config.toml");
 +        let _ = fs::remove_dir_all(path.parent().and_then(Path::parent).expect("test root"));
 +        fs::create_dir_all(path.parent().expect("config dir")).expect("dir creates");
 +        fs::write(
 +            &path,
 +            r#"
 +[keybindings]
 +create_event = ["1"]
 +"#,
 +        )
 +        .expect("config writes");
++
 +        let err = load_config_file(&path).expect_err("digit key fails");
 +        let _ = fs::remove_dir_all(path.parent().and_then(Path::parent).expect("test root"));
 +        assert!(err.to_string().contains("reserved for day jumps"));
 +    }
 +}

src/lib.rsmodified

  pub mod app;
  pub mod calendar;
  pub mod cli;
 +pub mod config;
  pub mod layout;
  pub mod reminders;
  pub mod services;

src/services.rsmodified

+ }
  impl ServiceConfig {
 -    pub fn new(events_file: PathBuf) -> Result<Self, ServiceError> {
 +    pub fn new(events_file: PathBuf, state_file: PathBuf) -> Result<Self, ServiceError> {
          let executable = std::env::current_exe().map_err(|err| ServiceError::CurrentExe {
              reason: err.to_string(),
          })?;
          Ok(Self {
              executable,
              events_file,
 -            state_file: default_state_file(),
 +            state_file,
              log_file: default_log_file(),
          })
+     }

src/tui.rsmodified

      },
      app::{
          AppState, CreateEventForm, CreateEventFormRowKind, EventCopyChoice, EventDeleteChoice,
 -        RecurrenceEditChoice, ViewMode,
 +        KeyBindings, KeyCommand, RecurrenceEditChoice, ViewMode,
      },
      calendar::{
          CalendarCell, CalendarDate, CalendarMonth, CalendarWeek, DAYS_PER_WEEK, MONTH_GRID_WEEKS,
  const HEADER_HEIGHT: u16 = 2;
  const VERTICAL_GRID_LINES: u16 = DAYS_PER_WEEK as u16 + 1;
  const HORIZONTAL_GRID_LINES: u16 = MONTH_GRID_WEEKS as u16 + 1;
 -const HELP_HINT: &str = "?: Help";
  static EMPTY_AGENDA_SOURCE: EmptyAgendaSource = EmptyAgendaSource;
  #[derive(Clone, Copy)]
  impl Widget for MonthGrid<'_> {
      fn render(self, area: Rect, buf: &mut Buffer) {
 -        render_month_grid(self.month, self.agenda_source, area, buf, self.styles);
 +        render_month_grid(
 +            self.month,
 +            self.agenda_source,
 +            area,
 +            buf,
 +            self.styles,
 +            &KeyBindings::default(),
 +        );
+     }
+ }
 -#[derive(Clone, Copy)]
 +#[derive(Clone)]
  pub struct AppView<'a> {
      app: &'a AppState,
      agenda_source: &'a dyn AgendaSource,
 +    keybindings: KeyBindings,
+ }
  impl<'a> AppView<'a> {
+     }
      pub fn with_agenda_source(app: &'a AppState, agenda_source: &'a dyn AgendaSource) -> Self {
 -        Self { app, agenda_source }
 +        Self::with_agenda_source_and_keybindings(app, agenda_source, &KeyBindings::default())
 +    }
++
 +    pub fn with_agenda_source_and_keybindings(
 +        app: &'a AppState,
 +        agenda_source: &'a dyn AgendaSource,
 +        keybindings: &KeyBindings,
 +    ) -> Self {
 +        Self {
 +            app,
 +            agenda_source,
 +            keybindings: keybindings.clone(),
 +        }
+     }
+ }
          match (self.app.view_mode(), ResponsiveLayout::for_area(area)) {
              (ViewMode::Month, layout) if layout.should_render_month_grid() => {
                  let month = self.app.calendar_month();
 -                MonthGrid::with_agenda_source(&month, self.agenda_source).render(area, buf);
 +                render_month_grid(
 +                    &month,
 +                    self.agenda_source,
 +                    area,
 +                    buf,
 +                    MonthGridStyles::new(),
 +                    &self.keybindings,
 +                );
+             }
              (ViewMode::Month, layout) if layout.should_render_week_view() => {
                  let month = self.app.calendar_month();
 -                WeekGrid::with_agenda_source(&month, self.agenda_source).render(area, buf);
 -            }
 -            (ViewMode::Month, _) => {
 -                DayView::responsive_fallback(self.app, self.agenda_source).render(area, buf)
 +                render_week_grid(
 +                    &month,
 +                    self.agenda_source,
 +                    area,
 +                    buf,
 +                    MonthGridStyles::new(),
 +                    &self.keybindings,
 +                );
+             }
 -            (ViewMode::Day, _) => DayView::focused(self.app, self.agenda_source).render(area, buf),
 +            (ViewMode::Month, _) => DayView::responsive_fallback_with_keybindings(
 +                self.app,
 +                self.agenda_source,
 +                self.keybindings.clone(),
 +            )
 +            .render(area, buf),
 +            (ViewMode::Day, _) => DayView::focused_with_keybindings(
 +                self.app,
 +                self.agenda_source,
 +                self.keybindings.clone(),
 +            )
 +            .render(area, buf),
+         }
          if let Some(form) = self.app.create_form() {
              render_copy_choice_modal(choice, area, buf, CreateModalStyles::new());
+         }
          if self.app.is_showing_help() {
 -            render_help_modal(self.app.view_mode(), area, buf, CreateModalStyles::new());
 +            render_help_modal(
 +                self.app.view_mode(),
 +                area,
 +                buf,
 +                CreateModalStyles::new(),
 +                &self.keybindings,
 +            );
+         }
+     }
+ }
 -#[derive(Clone, Copy)]
 +#[derive(Clone)]
  pub struct DayView<'a> {
      app: &'a AppState,
      agenda_source: &'a dyn AgendaSource,
      context: DayViewContext,
      styles: DayViewStyles,
 +    keybindings: KeyBindings,
+ }
  impl<'a> DayView<'a> {
              agenda_source,
              context: DayViewContext::Focused,
              styles: DayViewStyles::new(),
 +            keybindings: KeyBindings::default(),
+         }
+     }
              agenda_source,
              context: DayViewContext::ResponsiveFallback,
              styles: DayViewStyles::new(),
 +            keybindings: KeyBindings::default(),
 +        }
 +    }
++
 +    fn focused_with_keybindings(
 +        app: &'a AppState,
 +        agenda_source: &'a dyn AgendaSource,
 +        keybindings: KeyBindings,
 +    ) -> Self {
 +        Self {
 +            app,
 +            agenda_source,
 +            context: DayViewContext::Focused,
 +            styles: DayViewStyles::new(),
 +            keybindings,
 +        }
 +    }
++
 +    fn responsive_fallback_with_keybindings(
 +        app: &'a AppState,
 +        agenda_source: &'a dyn AgendaSource,
 +        keybindings: KeyBindings,
 +    ) -> Self {
 +        Self {
 +            app,
 +            agenda_source,
 +            context: DayViewContext::ResponsiveFallback,
 +            styles: DayViewStyles::new(),
 +            keybindings,
+         }
+     }
+ }
              area,
              buf,
              self.styles,
 +            &self.keybindings,
          );
+     }
+ }
  impl Widget for WeekGrid<'_> {
      fn render(self, area: Rect, buf: &mut Buffer) {
 -        render_week_grid(self.month, self.agenda_source, area, buf, self.styles);
 +        render_week_grid(
 +            self.month,
 +            self.agenda_source,
 +            area,
 +            buf,
 +            self.styles,
 +            &KeyBindings::default(),
 +        );
+     }
+ }
      height: u16,
      agenda_source: &S,
  ) -> String
 +where
 +    S: AgendaSource,
 +{
 +    render_app_to_string_with_agenda_source_and_keybindings(
 +        app,
 +        width,
 +        height,
 +        agenda_source,
 +        &KeyBindings::default(),
 +    )
 +}
++
 +pub fn render_app_to_string_with_agenda_source_and_keybindings<S>(
 +    app: &AppState,
 +    width: u16,
 +    height: u16,
 +    agenda_source: &S,
 +    keybindings: &KeyBindings,
 +) -> String
  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);
 +    AppView::with_agenda_source_and_keybindings(app, agenda_source, keybindings)
 +        .render(area, &mut buffer);
      buffer_to_string(&buffer)
+ }
      area: Rect,
      buf: &mut Buffer,
      styles: MonthGridStyles,
 +    keybindings: &KeyBindings,
  ) {
      let Some(layout) = MonthGridLayout::new(area) else {
          render_too_small_message(area, buf, styles);
      };
      buf.set_style(area, Style::default());
 -    render_title(month, &layout, buf, styles);
 +    render_title(month, &layout, buf, styles, keybindings);
      render_weekdays(&layout, buf, styles);
      for cell in month
      area: Rect,
      buf: &mut Buffer,
      styles: MonthGridStyles,
 +    keybindings: &KeyBindings,
  ) {
      let Some(layout) = WeekGridLayout::new(area) else {
          render_too_small_message(area, buf, styles);
      };
      buf.set_style(area, Style::default());
 -    render_week_title(selected_week, &layout, buf, styles);
 +    render_week_title(selected_week, &layout, buf, styles, keybindings);
      render_weekdays_for_week(&layout, buf, styles);
      for cell in selected_week
      area: Rect,
      buf: &mut Buffer,
      styles: DayViewStyles,
 +    keybindings: &KeyBindings,
  ) {
      if area.width == 0 || area.height == 0 {
          return;
      let layout = DayViewLayout::new(area);
      let agenda = app.day_agenda(agenda_source);
      buf.set_style(area, Style::default());
 -    render_day_header(&agenda, context, &layout, buf, styles);
 +    render_day_header(&agenda, context, &layout, buf, styles, keybindings);
      match layout.mode {
          DayViewLayoutMode::Split | DayViewLayoutMode::Stacked => {
      layout: &DayViewLayout,
      buf: &mut Buffer,
      styles: DayViewStyles,
 +    keybindings: &KeyBindings,
  ) {
      let title = day_title(agenda.date);
      write_centered(
          layout.area.width,
          &title,
          styles.help_hint,
 +        keybindings,
      );
      let Some(summary_y) = layout.summary_y else {
      };
      let summary = match context {
 -        DayViewContext::Focused => format!("{} | Esc returns to month", agenda_summary(agenda)),
 +        DayViewContext::Focused => format!(
 +            "{} | {} returns to month",
 +            agenda_summary(agenda),
 +            keybindings.display_for(KeyCommand::CloseDay)
 +        ),
          DayViewContext::ResponsiveFallback => agenda_summary(agenda),
      };
      write_centered(
      );
+ }
 -fn render_help_modal(view_mode: ViewMode, area: Rect, buf: &mut Buffer, styles: CreateModalStyles) {
 +fn render_help_modal(
 +    view_mode: ViewMode,
 +    area: Rect,
 +    buf: &mut Buffer,
 +    styles: CreateModalStyles,
 +    keybindings: &KeyBindings,
 +) {
      if area.width == 0 || area.height == 0 {
          return;
+     }
 -    let rows = help_rows(view_mode);
 +    let rows = help_rows(view_mode, keybindings);
      let modal = help_modal_area(area, rows.len());
      fill_rect(buf, modal, styles.panel);
      draw_border(buf, modal, styles.border, BorderCharacters::normal());
      let description_x = content.x.saturating_add(key_width).saturating_add(2);
      let description_width = content.right().saturating_sub(description_x);
      let mut y = content.y.saturating_add(2);
 -    for (key, description) in rows {
 +    for (key, description) in &rows {
          if y >= content.bottom().saturating_sub(2) {
              break;
+         }
          content.bottom().saturating_sub(1),
          content.x,
          content.width,
 -        "Esc / ? close",
 +        "Esc / Enter close",
          styles.footer,
      );
+ }
+     }
+ }
 -fn help_rows(view_mode: ViewMode) -> &'static [(&'static str, &'static str)] {
 +fn help_rows(view_mode: ViewMode, keybindings: &KeyBindings) -> Vec<(String, &'static str)> {
      match view_mode {
 -        ViewMode::Month => &[
 -            ("Arrows", "Move the selected date"),
 -            ("Digits", "Jump to a day, with quick two-digit refinement"),
 -            ("Weekdays", "Jump within the selected week"),
 -            ("Enter", "Open the focused day view"),
 -            ("+", "Create an event on the selected date"),
 -            ("Mouse", "Select a date; double-click to open"),
 -            ("?", "Close this help"),
 -            ("q", "Quit"),
 +        ViewMode::Month => vec![
 +            (
 +                format!(
 +                    "{} / {} / {} / {}",
 +                    keybindings.display_for(KeyCommand::MoveLeft),
 +                    keybindings.display_for(KeyCommand::MoveRight),
 +                    keybindings.display_for(KeyCommand::MoveUp),
 +                    keybindings.display_for(KeyCommand::MoveDown)
 +                ),
 +                "Move the selected date",
 +            ),
 +            (
 +                "Digits".to_string(),
 +                "Jump to a day, with quick two-digit refinement",
 +            ),
 +            (
 +                format!(
 +                    "{} {} {} {} {} {} {}",
 +                    keybindings.display_for(KeyCommand::JumpMonday),
 +                    keybindings.display_for(KeyCommand::JumpTuesday),
 +                    keybindings.display_for(KeyCommand::JumpWednesday),
 +                    keybindings.display_for(KeyCommand::JumpThursday),
 +                    keybindings.display_for(KeyCommand::JumpFriday),
 +                    keybindings.display_for(KeyCommand::JumpSaturday),
 +                    keybindings.display_for(KeyCommand::JumpSunday)
 +                ),
 +                "Jump within the selected week",
 +            ),
 +            (
 +                keybindings.display_for(KeyCommand::OpenDayOrEdit),
 +                "Open the focused day view",
 +            ),
 +            (
 +                keybindings.display_for(KeyCommand::CreateEvent),
 +                "Create an event on the selected date",
 +            ),
 +            ("Mouse".to_string(), "Select a date; double-click to open"),
 +            ("Esc / Enter".to_string(), "Close this help"),
 +            (keybindings.display_for(KeyCommand::Quit), "Quit"),
          ],
 -        ViewMode::Day => &[
 -            ("Left/Right", "Move to the previous or next day"),
 -            ("Up/Down", "Select a local event"),
 -            ("Enter", "Edit the selected local event"),
 -            ("c", "Copy the selected local event"),
 -            ("d", "Delete the selected local event"),
 -            ("+", "Create an event on this day"),
 -            ("Esc", "Return to month view"),
 -            ("?", "Close this help"),
 -            ("q", "Quit"),
 +        ViewMode::Day => vec![
 +            (
 +                format!(
 +                    "{} / {}",
 +                    keybindings.display_for(KeyCommand::MoveLeft),
 +                    keybindings.display_for(KeyCommand::MoveRight)
 +                ),
 +                "Move to the previous or next day",
 +            ),
 +            (
 +                format!(
 +                    "{} / {}",
 +                    keybindings.display_for(KeyCommand::MoveUp),
 +                    keybindings.display_for(KeyCommand::MoveDown)
 +                ),
 +                "Select a local event",
 +            ),
 +            (
 +                keybindings.display_for(KeyCommand::OpenDayOrEdit),
 +                "Edit the selected local event",
 +            ),
 +            (
 +                keybindings.display_for(KeyCommand::CopyEvent),
 +                "Copy the selected local event",
 +            ),
 +            (
 +                keybindings.display_for(KeyCommand::DeleteEvent),
 +                "Delete the selected local event",
 +            ),
 +            (
 +                keybindings.display_for(KeyCommand::CreateEvent),
 +                "Create an event on this day",
 +            ),
 +            (
 +                keybindings.display_for(KeyCommand::CloseDay),
 +                "Return to month view",
 +            ),
 +            ("Esc / Enter".to_string(), "Close this help"),
 +            (keybindings.display_for(KeyCommand::Quit), "Quit"),
          ],
+     }
+ }
      layout: &MonthGridLayout,
      buf: &mut Buffer,
      styles: MonthGridStyles,
 +    keybindings: &KeyBindings,
  ) {
      let title = format!("{} {}", month.current.month, month.current.year);
      write_centered(
          layout.area.width,
          &title,
          styles.help_hint,
 +        keybindings,
      );
+ }
      layout: &WeekGridLayout,
      buf: &mut Buffer,
      styles: MonthGridStyles,
 +    keybindings: &KeyBindings,
  ) {
      let title = week_title(week);
      write_centered(
          layout.area.width,
          &title,
          styles.help_hint,
 +        keybindings,
      );
+ }
      buf.set_stringn(start, y, text, usize::from(width), style);
+ }
 -fn render_title_hint(buf: &mut Buffer, y: u16, x: u16, width: u16, title: &str, style: Style) {
 -    let hint_width = u16::try_from(HELP_HINT.len()).unwrap_or(u16::MAX);
 +fn render_title_hint(
 +    buf: &mut Buffer,
 +    y: u16,
 +    x: u16,
 +    width: u16,
 +    title: &str,
 +    style: Style,
 +    keybindings: &KeyBindings,
 +) {
 +    let hint = format!("{}: Help", keybindings.display_for(KeyCommand::Help));
 +    let hint_width = u16::try_from(hint.len()).unwrap_or(u16::MAX);
      let title_width = u16::try_from(title.len()).unwrap_or(u16::MAX);
      if width <= hint_width.saturating_add(1) || title_width >= width {
          return;
          return;
+     }
 -    write_left(buf, y, hint_x, hint_width, HELP_HINT, style);
 +    write_left(buf, y, hint_x, hint_width, &hint, style);
+ }
  fn write_left(buf: &mut Buffer, y: u16, x: u16, width: u16, text: &str, style: Style) {
          assert!(rendered.contains("Month / Week keys"));
          assert!(rendered.contains("Open the focused day view"));
 -        assert!(rendered.contains("Esc / ? close"));
 +        assert!(rendered.contains("Esc / Enter close"));
          assert!(!rendered.contains("Delete the selected local event"));
+     }

tests/cli_smoke.rsmodified

      let stderr = String::from_utf8_lossy(&output.stderr);
      assert!(stderr.contains("invalid --date value '2026-02-30'"));
      assert!(stderr.contains("Usage:"));
 -    assert!(stderr.contains("rcal [--date YYYY-MM-DD]"));
 +    assert!(stderr.contains("rcal [--config PATH|--no-config]"));
+ }
  #[test]