release: prepare v2.7.1 — privacy-respecting crash reporting

Bump committed versionCode/versionName to 2.7.1 (20701) and move the
crash-reporting entry under a 2.7.1 CHANGELOG heading. The tag remains the
source of truth; CI derives the published version from it.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitea/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Something doesn't work the way it should
+title: ""
+labels:
+  - bug
+---
+
+### What happened
+
+
+### What you expected
+
+
+### Steps to reproduce
+1.
+2.
+3.
+
+### Environment
+- Calendula version: <!-- Settings → bottom of the screen -->
+- Android version:
+- Device:

.gitea/ISSUE_TEMPLATE/crash_report.md

@@ -0,0 +1,26 @@
+---
+name: Crash report
+about: Report a crash. Calendula can capture this for you (Settings → Report a problem, or the prompt after a crash) — it copies the report to your clipboard and prefills this form.
+title: "Crash: "
+labels:
+  - bug
+  - crash
+---
+
+<!--
+Thanks for reporting a crash in Calendula!
+
+If the app prefilled this for you, the crash report is already below — just add
+what you were doing and submit. Otherwise, paste the report from your clipboard
+into the code block. The report contains only app/Android/device versions and the
+stack trace — no personal data or calendar content.
+-->
+
+### What happened
+
+
+### Crash report
+
+```
+(paste the crash report here)
+```

.gitea/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea or improvement
+title: ""
+labels:
+  - enhancement
+---
+
+### What would you like Calendula to do?
+
+
+### Why — what problem does it solve?
+
+
+### Anything else
+<!-- mockups, examples from other apps, alternatives you considered -->

.gitea/workflows/translations.yaml

@@ -0,0 +1,41 @@
+name: Translations
+
+# Fast, SDK-free parity check for translation resources, so Weblate PRs (which
+# only touch values-*/strings.xml) get quick feedback without the full Android
+# build. The deeper checks still run in CI via lintDebug (ExtraTranslation).
+on:
+  push:
+    branches:
+      - '**'
+    tags-ignore:
+      - '**'
+    paths:
+      - 'app/src/main/res/values*/strings.xml'
+      - 'app/src/main/res/xml/locales_config.xml'
+      - 'scripts/check_translations.py'
+      - '.gitea/workflows/translations.yaml'
+
+concurrency:
+  group: translations-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: docker
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Ensure python3
+        run: |
+          if ! command -v python3 >/dev/null 2>&1; then
+            if command -v apt-get >/dev/null 2>&1; then
+              apt-get update && apt-get install -y python3
+            elif command -v apk >/dev/null 2>&1; then
+              apk add --no-cache python3
+            fi
+          fi
+          python3 --version
+
+      - name: Check translation parity
+        run: python3 scripts/check_translations.py

.planning/ROADMAP.md

@@ -126,6 +126,23 @@ Deliberately deferred (add only if needed):
 - Shared `InlineTextField` extracted to `ui.common` (event form + calendar
   editor share one input style)
 
+## v2.3 — Material 3 grouped-list redesign (shipped 2026-06-16)
+
+A structural + visual pass adopting one shared blueprint (modelled on the ReFra
+gallery app) across Settings, the calendar manager and the navigation drawer.
+
+- Shared `ui/common/GroupedList.kt`: `CollapsingScaffold` (a `LargeTopAppBar`
+  whose title collapses on scroll) + `GroupedRow` (Position-based corner
+  grouping, press-animated corners, `selected` + `minHeight` knobs).
+- Settings: category hub with About card on top and sliding sub-pages
+  (Appearance / New event form / Notifications); theme/week-start/language
+  pickers moved from `DropdownMenu` to OptionCard dialogs; token-based icon
+  chips; `ic_gitea.xml` for the About "Source" button.
+- Calendar manager + drawer restyled to match; shared `CalendarColorChip`;
+  drawer scrolls as one with the active view highlighted.
+- Cards use `surfaceContainerHigh` for readable contrast.
+- Donate button on the About card deferred (target TBD).
+
 ---
 
 # Backlog (theme-based, post-v2.1)
@@ -146,13 +163,22 @@ unblock a later item. Order is a plan, not a contract — revisit after each lan
 **Tier 1 — finish the current arc (create/edit + calendars)**
 1. Tap-to-create in day/week *(shipped v2.2.0)* — prefilled create from an empty slot
 2. Local calendar management + "manage in source app" deep-links *(shipped v2.2.0)*
-3. **Settings redesign & restructure** *(next, high prio)* — see scope below
-4. Per-event color — reuses the calendar color picker/palette; closes the create/edit theme
-5. Duplicate event — detail action → prefilled create form; near-free on the tap-to-create prefill infra
+3. ~~Settings redesign & restructure~~ *(shipped v2.3.0 — grew into the full
+   grouped-list blueprint across Settings + calendars + drawer; see "v2.3"
+   above)*
+4. ~~Per-event color~~ *(shipped v2.4.0)* — palette calendars write
+   `EVENT_COLOR_KEY` (sync-safe); local/opted-in calendars write a raw
+   `EVENT_COLOR`; off-by-default setting for no-palette synced calendars
+Tier 1's create/edit + calendars arc is effectively closed. **Duplicate event**
+was deprioritised (2026-06-17) as low-importance and dropped to the bottom of
+the sequence; the next item is now **Jump-to-date** (formerly Tier 2).
 
 (Tier 2+ numbering below shifts accordingly; ranking unchanged.)
 
-### Settings redesign & restructure *(next, high prio)*
+### Settings redesign & restructure *(shipped v2.3.0)*
+
+The original scope below is kept as a record; the implementation expanded from a
+sub-screen restructure into the shared grouped-list blueprint (see "v2.3" above).
 
 The settings screen has grown into a flat vertical scroll of divider-separated
 sections (Appearance, Event form, Notifications, Calendars, Language, About) and
@@ -199,28 +225,49 @@ Out of scope (no new settings *features* here) — this is a structure + style
 pass on the existing controls; new toggles ride in with their own features.
 
 **Tier 2 — navigation & daily-driver completeness**
-5. Jump-to-date — drawer date picker (un-cut from V1); cheap, fills the nav gap
-6. Agenda view — the missing 4th view; serves daily-driver users *and* becomes the data source for the widget
+5. ~~Jump-to-date — drawer date picker (un-cut from V1); cheap, fills the nav gap~~ *(done, v2.5.0)*
+6. ~~Agenda view — the missing 4th view; serves daily-driver users *and* becomes the data source for the widget~~ *(done, v2.5.0)*
 
 **Tier 3 — platform reach (depends on Tier 2)**
-7. Home-screen widget — built on the agenda data source from #6
-8. App shortcuts (launcher long-press → New event); cheap, optional quick-settings tile
+7. ~~Home-screen widget — built on the agenda data source from #6~~ *(done, v2.5.0 — agenda + month widgets)*
+8. App shortcuts: ~~launcher long-press → New event~~ *(done, v2.5.0)*; optional quick-settings tile still open
 
-**Tier 4 — interop & bigger-ticket**
-9. Share event as .ics + receive/open .ics into a prefilled create form
-10. Default reminder applied to new events; then snooze/dismiss notification actions
-11. Drag & drop rescheduling in day/week — big-ticket, own slice (recurring drops reuse the scope dialog)
+**Tier 4 — reliability, data-safety & interop** *(re-ranked 2026-06-17)*
+9. **Reminders — defaults + delivery reliability** *(shipped v2.6.0)* — global
+   default reminder **+ per-calendar override**, bundled with battery-exemption
+   hardening. Full sketch in "Reminders — defaults & delivery reliability" below.
+10. **The `.ics` engine — export + import** *(in progress → v2.7)* — one
+    hand-rolled serializer/parser (zero deps, stays on `kotlinx-datetime`),
+    four surfaces: single-event share + whole-calendar backup (export),
+    open-`.ics`→form + whole-calendar restore (import). Closes the
+    device-local-calendar data-loss gap (#10/#11 merged here). Built as **two
+    sequential branches in one release**: `feat/ics-export` (write side +
+    UID-on-create precursor) then `feat/ics-import` (parser, restore, dedup).
+    Import is liberal-in/strict-out: skip-and-report foreign `VTIMEZONE` /
+    `RECURRENCE-ID` it can't model. Timezone rule: all-day `VALUE=DATE`,
+    non-recurring timed UTC `Z`, recurring timed `TZID`-labelled from the stored
+    `EVENT_TIMEZONE` (no `VTIMEZONE` blocks; resolved against the OS tz DB on
+    import). Plan: `docs/superpowers/plans/2026-06-18-05-ics-export.md`.
+11. **Snooze / dismiss notification actions** *(next, after v2.7)* — follows the
+    `.ics` work; inherits v2.6's deferred exact-alarm/WorkManager decision (snooze
+    must re-fire an alarm).
+12. Drag & drop rescheduling in day/week — big-ticket, own slice (recurring drops reuse the scope dialog)
 
 **Gated — explicit go/no-go before any work (mostly INTERNET-permission calls)**
 - Remote calendar create/edit (re-implements DAVx5; INTERNET + credential storage)
 - Locations & People — contact address picker (no-permission, one-shot) is the safe entry; OSM autocomplete needs INTERNET
 - Move event to another calendar — sync-adapter minefield (copy+delete model)
 
+**Bottom — deprioritised, not important**
+- Duplicate event (detail action → prefilled create form) — moved here
+  2026-06-17; cheap but low value, pick up only if asked
+
 **Unranked / fill-in** — pinch-to-zoom time scale, tablet/foldable layouts,
 full-text search, ICS file import. Pulled in opportunistically, not sequenced.
 
-Debatable calls worth a second look: widget (#7) vs .ics interop (#9) ordering;
-whether drag-drop (#11) jumps ahead given its daily-driver impact.
+Debatable calls worth a second look: whether **local-calendar backup (#10)**
+should lead Tier 4 outright (it's a silent data-loss risk, not a feature);
+whether drag-drop (#12) jumps ahead given its daily-driver impact.
 
 ## Navigation & views
 
@@ -230,9 +277,14 @@ whether drag-drop (#11) jumps ahead given its daily-driver impact.
 - Agenda view (fourth view: upcoming events grouped by day; also the
   natural data source for a future widget)
 - Jump to date — drawer date picker (un-cut from V1)
+- Current-time "now" line in day/week — standard in every calendar, cheap,
+  currently absent. Daily-driver polish.
+- Week numbers in the **month** grid — week view already shows the badge
+  (`WeekNumberBadge`, `WeekScreen.kt`); extend to month for ISO/European users.
 - Pinch-to-zoom time scale in day/week
 - Tablet / foldable layouts *(was v3.0)*
-- Full-text search *(was v3.0)*
+- Full-text search *(was v3.0)* — promote out of "fill-in": for a daily driver
+  with real event history, finding an event is core completeness, not optional.
 
 ## Event editing & creation
 
@@ -267,12 +319,103 @@ whether drag-drop (#11) jumps ahead given its daily-driver impact.
   go/no-go gate as the OSM/INTERNET item below.
 - Move event to another calendar (copy+delete model with a consequences
   warning — deferred from v2.0; `CALENDAR_ID` is sync-adapter-owned) *(was v3.0)*
+- **Local-calendar backup / export** *(Tier 4 #10)* — device-only
+  (`ACCOUNT_TYPE_LOCAL`) calendars are first-class in Calendula but have **no
+  sync and therefore no backup**: a lost/wiped phone destroys them permanently.
+  Whole-calendar `.ics` (VCALENDAR) export to a user-chosen file (SAF), plus
+  restore-on-import that recreates events into a chosen local calendar. Reuses
+  the .ics serializer from the single-event share work; the restore path reuses
+  the import parser. A data-integrity obligation, not a feature.
 
-## Reminders, round two
+## Reminders — defaults & delivery reliability *(implemented 2026-06-17, `feat/default-reminders` — pending on-device review)*
+
+Two themes bundled because both are "make reminders trustworthy" — the core of
+the "Calendula is your only calendar app" promise.
+
+**Built in this slice (A + the safe half of B):** global timed default reminder
++ a **separate all-day default** (day-scale lead times) + per-calendar override
+(timed events), applied on create with manual-edit / calendar-switch / all-day-
+toggle handling; three pickers + per-calendar override list in Settings →
+Notifications; battery-optimisation exemption row (status + system deep-link, no
+extra permission). `resolveDefaultReminder` + prefs round-trips unit-tested.
+Resolution model: all-day events use the all-day global default outright;
+per-calendar overrides govern timed events only. Reviewed (8-angle), fixes
+applied: form-reset state race, label-fn consolidation with the detail screen,
+inline wrapper + single combined flow read.
+
+**Deliberately deferred (documented decisions, not oversights):**
+- *Absolute time-of-day for all-day reminders* — the all-day default is still
+  minutes-before-midnight (day-scale presets), not "9am the day before" (open
+  decision #2's richer half). Per-calendar all-day overrides also deferred.
+- *Self-scheduled alarms* — kept the existing provider-broadcast architecture
+  (open decision #1). The battery exemption is the reliability lever; no
+  `AlarmManager`/`USE_EXACT_ALARM` subsystem was added.
+- *Test-reminder diagnostic* and *battery prompt inside onboarding* — the
+  exemption lives only in Settings for now (onboarding flow untouched to keep
+  the change reviewable).
+
+### A. Default reminders (global + per-calendar override)
+
+**No provider backing.** `CalendarContract` has no column that auto-applies a
+default reminder per calendar — Google's per-calendar defaults live server-side.
+So both the global default *and* the per-calendar override are **app-side
+preferences**, applied by us at event-insert time. We inherit nothing from the
+synced calendar.
+
+- **Storage (DataStore):**
+  - `defaultReminderMinutes: Int?` — global default; `null` = "no reminder".
+  - `defaultAllDayReminderMinutes: Int?` — separate all-day default (all-day
+    reminders are expressed as minutes before midnight / day-before-at-time, not
+    minutes before a start instant — they need their own value).
+  - `perCalendarReminderOverride: Map<Long, Int?>` — keyed by calendar id;
+    **absent key = inherit global**, explicit `null` = "no reminder for this
+    calendar". (Same for an all-day override map if we want per-calendar all-day.)
+- **Apply on create:** a fresh event prefills its reminders list from
+  override-or-global for the preselected calendar. Changing the calendar in the
+  form re-applies the *new* calendar's default **only if the user hasn't manually
+  edited the reminders** — track a dirty flag, mirroring the per-event-color
+  reset pattern (v2.4).
+- **Edit semantics:** defaults apply to **new events only**; never rewrite
+  reminders on existing events on open or on calendar-switch-during-edit.
+- **Settings UI (Notifications sub-page):**
+  - Global default via OptionCard (None / at time of event / 5 / 10 / 15 / 30 min
+    / 1 h / 1 day / custom), plus the separate all-day default.
+  - Per-calendar overrides: a row per writable calendar (in the Calendars screen
+    or a Notifications subsection), each opening the same OptionCard with a
+    leading **"Use global default"** option.
+
+### B. Delivery reliability (exact alarms + battery)
+
+The provider broadcasts `EVENT_REMINDER`, but on modern Android (Doze / OEM
+battery managers) delivery can be silently delayed or dropped. v1.4 deferred this;
+it directly undermines the feature's premise, so it rides in here.
+
+- **Exact alarm — decision first:** trust the provider broadcast, or
+  self-schedule via `AlarmManager.setExactAndAllowWhileIdle` for reliability?
+  If we self-schedule, declare `USE_EXACT_ALARM` (API 33+, auto-granted for
+  calendar/alarm-category apps, F-Droid-clean) with a `SCHEDULE_EXACT_ALARM`
+  fallback for API 31–32 (user-revocable → settings deep-link prompt).
+- **Battery-optimization exemption:** a *soft, optional* prompt via
+  `ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` (settings deep-link — never the
+  auto-grant intent), honest copy: "Android may delay reminders to save battery;
+  exempt Calendula for on-time delivery." Shown once after the existing
+  `POST_NOTIFICATIONS` onboarding step, reversible in Settings → Notifications.
+- **Diagnostics:** a "send a test reminder in 1 minute" button in Notifications
+  settings so users can verify delivery on their specific OEM (Samsung / Xiaomi
+  are notorious for suppressing it).
+
+### Open decisions (resolve before building)
+
+1. Self-schedule via `AlarmManager` vs trust the provider broadcast
+   (reliability vs simplicity + battery cost).
+2. All-day reminder representation (minutes-before vs absolute time-of-day).
+3. Where per-calendar overrides live in the UI (rows on the Calendars screen vs
+   a list inside the Notifications sub-page).
+
+### Later (round two)
 
 - Snooze + dismiss actions on the notification (snooze needs an
-  exact-alarm / WorkManager decision)
-- Settings default reminder applied to new events
+  exact-alarm / WorkManager decision) — Tier 4 #13.
 
 ## Sharing & interop
 
@@ -282,8 +425,18 @@ whether drag-drop (#11) jumps ahead given its daily-driver impact.
 
 ## Platform & launchers
 
-- Home-screen widget *(was v3.0)*
-- App shortcuts (launcher long-press → New event), maybe a quick-settings tile
+- ~~Home-screen widget~~ **shipped v2.5.0** — agenda + month widgets
+- ~~App shortcuts (launcher long-press → New event)~~ **shipped v2.5.0** —
+  optional quick-settings tile still open
+
+## Quality & reliability
+
+- **Accessibility pass** — TalkBack content descriptions across all screens,
+  dynamic-type / large-font reflow, touch-target audit. Quality bar for an
+  F-Droid app; nothing tracks it yet.
+- **Reminder delivery reliability** — exact alarms + battery-optimization
+  exemption; specced in the "Reminders — defaults & delivery reliability" slice
+  above (Tier 4 #9).
 
 ## Locations & People *(go/no-go, captured 2026-06-11)*
 

.planning/STATE.md

@@ -1,14 +1,17 @@
 # Calendula — Current State
 
-*Last updated: 2026-06-16*
+*Last updated: 2026-06-17*
 
 ## Status
 
 **Milestone:** 2 (write support) **complete** — v2.0.0 shipped 2026-06-11;
 v2.1.0 (month event grid, drawer view tabs, cursor fix) shipped 2026-06-15.
 **Phase:** post-2.1 backlog work. v2.2.0 (tap-to-create in day/week + local
-calendar management with per-calendar "manage in source app" deep-links)
-shipped 2026-06-16. The backlog is now organised by theme in `ROADMAP.md`.
+calendar management) and v2.3.0 (Material 3 grouped-list redesign of Settings,
+the calendar manager and the navigation drawer) both shipped 2026-06-16;
+v2.4.0 (per-event colors) and v2.5.0 (jump-to-date, Agenda view, home-screen
+agenda + month widgets, and a "New event" launcher shortcut) shipped
+2026-06-17. The backlog is now organised by theme in `ROADMAP.md`.
 
 ## Progress
 
@@ -86,18 +89,42 @@ shipped 2026-06-16. The backlog is now organised by theme in `ROADMAP.md`.
   deep-link (resolved from the account's authenticator: DAVx5/ICSx5/…) and
   an add-account shortcut. Shared `InlineTextField` extracted to `ui.common`
 
+- [x] v2.3 settings/calendars/drawer redesign (shipped 2026-06-16) — adopted a
+  shared Material 3 grouped-list blueprint, modelled on the ReFra gallery app
+  and extracted to `ui/common/GroupedList.kt` (`CollapsingScaffold` with a
+  `LargeTopAppBar` exit-until-collapsed title; `GroupedRow` with Position-based
+  corner grouping, press-animated corners, `selected` + `minHeight` knobs).
+    - Settings: category hub (About card on top → version mark at the foot) with
+      sliding sub-pages (Appearance / New event form / Notifications); token-
+      based icon chips; theme/week-start/language pickers migrated from
+      `DropdownMenu` to OptionCard dialogs. New `ic_gitea.xml` (Simple Icons,
+      verbatim path) for the About "Source" button; en+de strings.
+    - Calendar manager: same collapsing scaffold + grouped rows; shared
+      `CalendarColorChip` (neutral chip, pastelised calendar glyph).
+    - Navigation drawer: branded header, grouped View switcher (active view
+      highlighted via `secondaryContainer`), the filter list restyled to
+      grouped rows with a trailing checkbox; the whole drawer scrolls as one.
+    - Cards use `surfaceContainerHigh` for readable contrast against `surface`.
+    - Donate button on the About card deferred (target still TBD).
+
+- [x] v2.4 per-event color (shipped 2026-06-17) — an optional "Color" field in
+  the event form. Read/render already resolved `EVENT_COLOR` with a calendar
+  fallback; this adds the write side and the picker. Palette-backed calendars
+  (Google, some CalDAV) pick from the account's `Colors` (`TYPE_EVENT`) and
+  write `EVENT_COLOR_KEY` so the color round-trips through sync; local
+  calendars write a raw `EVENT_COLOR` from the shared `CALENDAR_COLOR_PALETTE`
+  (extracted with the swatch row to `ui/common/ColorSwatchRow.kt`). Switching
+  calendars resets the choice (a key is account-scoped). A settings toggle
+  ("Allow colors on unsupported calendars", off by default) extends the raw
+  path to synced calendars with no palette, with an honest "may not survive
+  sync" warning on the picker and in Settings. Color writes flow through
+  insert / dirty-checked update / occurrence-exception; mapper + form tests.
+
 ## Next
 
-1. Monitor the F-Droid build/publish for the v2.2.0 tag
+1. Monitor the F-Droid build/publish for the v2.4.0 tag
 2. Decide the "Locations & People" and "remote calendar create/edit"
    go/no-go calls (both hinge on the INTERNET permission) — see `ROADMAP.md`
-3. **Settings redesign & restructure** is the agreed high-prio next item
-   (2026-06-16) — group into M3 cards / sub-screens, and migrate the
-   theme/week-start/language `DropdownMenu` selectors to the OptionCard modal
-   default (current dropdowns violate `option-card-modal-style-default`).
-   Structure + style pass only, no new settings features.
-4. **Per-event color** follows — reuses the color picker + palette plumbing
-   from local calendar management; finishes the create/edit theme.
-5. Then agenda view (strategic, backs a future widget); jump-to-date and
-   duplicate event remain cheap follow-ups. Full ranked sequence in
+3. **Duplicate event** and **jump-to-date** are the cheap follow-ups; then
+   agenda view (strategic, backs a future widget). Full ranked sequence in
    `ROADMAP.md` → "Near-term sequence".

CHANGELOG.md

@@ -7,6 +7,108 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.7.1] — 2026-06-18
+
+### Added
+- Crash reporting you control. If Calendula closes unexpectedly, it now captures
+  a technical report and, on the next launch, offers to send it as an issue on
+  the project's tracker. Nothing is uploaded automatically — the report stays on
+  your device until you choose to share it, it contains no personal data or
+  calendar content (only the app, Android and device versions plus the stack
+  trace), and you see the full text before sending. There's also a "Report a
+  problem" entry in Settings, and if the app ever fails to start repeatedly, a
+  minimal recovery screen still lets you send the report.
+
+## [2.7.0] — 2026-06-18
+
+### Added
+- Share a single event as an `.ics` file from the event detail screen — hands a
+  standard calendar file to any app via the system share sheet.
+- Back up your local (device-only) calendars: Settings → Calendars → Export as
+  `.ics` file writes every event of your on-device calendars to a file you
+  choose. Local calendars aren't synced anywhere, so this is their only backup.
+- Open or share an `.ics` file into Calendula: a single event opens the create
+  form prefilled for review, while a file with many events (e.g. a backup) opens
+  a bulk import — pick a calendar and import them all. Re-importing a backup
+  won't create duplicates (events are matched by their unique identifier), and
+  anything Calendula can't represent (changed recurring occurrences, guest
+  lists) is reported rather than silently dropped.
+
+### Fixed
+- All-day events that cover a single day (e.g. a birthday) no longer show up on
+  the following day as well — in the day, week and month views or on the event
+  detail screen. The extra day came from interpreting the all-day date range in
+  the device's time zone instead of UTC.
+- Fixed the app crashing immediately on every launch in the optimized release
+  build: release code-shrinking (R8) was stripping a database class the
+  home-screen widget framework needs, so the app died at startup before showing
+  anything. Added the missing keep rule.
+
+## [2.6.0] — 2026-06-18
+
+### Added
+- App language can now be set from Android's system per-app language settings
+  (Android 13+), in addition to the in-app picker in Settings — and the app is
+  set up so further languages can be added by community translators
+
+### Fixed
+- Changing the app language in Settings now takes effect immediately; the
+  picker previously had no effect
+
+## [2.5.0] — 2026-06-17
+
+### Added
+- Home-screen widgets (two of them): an "Upcoming" agenda widget — a scrolling
+  list of the next month of events grouped under day headers, with refresh and
+  "New event" buttons — and a month-grid widget showing the full month with
+  today highlighted, connected multi-day event bars, and prev/next/today
+  navigation. Both reuse the in-app grouping and layout so they match the app
+  exactly, respect your hidden-calendar choices, and refresh automatically when
+  the calendar changes or the day rolls over. Tapping a day opens that day;
+  tapping an event opens its details
+- App shortcut: long-press the Calendula icon for a "New event" action that
+  jumps straight into the create-event form
+- Agenda view — a fourth top-level view alongside Month/Week/Day: a
+  forward-looking list of upcoming events grouped under "Today"/"Tomorrow"/date
+  headers, reachable from the view switcher
+- Jump to date — a "Jump to date" row in the navigation drawer opens a date
+  picker and moves the active view (Month/Week/Day/Agenda) to the chosen day
+
+## [2.4.0] — 2026-06-17
+
+### Added
+- Per-event colors: give a single event its own color, instead of always
+  inheriting its calendar's. Add the new "Color" field from "More fields" in
+  the event form. On calendars that publish their own color set — such as
+  Google — you pick from that calendar's palette, so the color is stored
+  with the event and shows correctly on every synced device. On local
+  calendars you pick from Calendula's palette. "Reset" returns an event to
+  its calendar's color
+- A new "Allow colors on unsupported calendars" setting (New event form,
+  off by default) extends per-event colors to calendars that publish no
+  color set of their own (some CalDAV). Such a color is kept on the device
+  and may be dropped or overwritten on that calendar's next sync — a
+  limitation of those calendars, called out plainly in the setting and on
+  the color picker
+
+## [2.3.0] — 2026-06-16
+
+### Changed
+- Redesigned Settings around the Material 3 grouped-list pattern: a large
+  title that collapses into the toolbar as you scroll, category cards on the
+  main screen, and dedicated sub-pages for Appearance, the new-event form, and
+  Notifications. The theme, week-start and language pickers now use the app's
+  standard option-card dialogs instead of dropdown menus
+- About moved to the top of Settings as a card — app icon, author, and quick
+  links to the source code and licence — with the version shown plainly at the
+  foot of the list
+- The Calendars screen now uses the same grouped-card layout and collapsing
+  title, and each calendar shows a soft pastel-tinted calendar glyph rather
+  than a plain colour swatch
+- Redesigned the navigation drawer to match: a branded header, the
+  Month / Week / Day switch and your calendars as grouped cards (with the
+  active view highlighted), and the whole drawer now scrolls as one
+
 ## [2.2.0] — 2026-06-16
 
 ### Added

app/build.gradle.kts

@@ -28,8 +28,8 @@ android {
         // the tag, with versionCode = MAJOR*10000 + MINOR*100 + PATCH
         // (e.g. v2.0.0 -> 20000). These committed values are the dev/local
         // default; keep them matching the latest released tag. See docs/RELEASING.md.
-        versionCode = 20200
-        versionName = "2.2.0"
+        versionCode = 20701
+        versionName = "2.7.1"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -78,6 +78,15 @@ android {
         }
     }
 
+    lint {
+        // Community translations are expected to be partial — a missing string
+        // falls back to the English base at runtime — so don't fail the build on
+        // it. Stale/extra keys (ExtraTranslation) stay fatal; scripts/
+        // check_translations.py guards the same invariants with clearer,
+        // translator-facing messages.
+        informational += "MissingTranslation"
+    }
+
     testOptions {
         unitTests {
             all { it.useJUnitPlatform() }
@@ -113,6 +122,9 @@ dependencies {
 
     implementation(libs.androidx.datastore.preferences)
 
+    implementation(libs.androidx.glance.appwidget)
+    implementation(libs.androidx.glance.material3)
+
     implementation(libs.kotlinx.datetime)
     implementation(libs.kotlinx.coroutines.core)
 

app/proguard-rules.pro

@@ -4,3 +4,14 @@
 
 # Compose Compiler may keep its own; defaults are fine
 -dontwarn org.jetbrains.annotations.**
+
+# Room database implementations (pulled in transitively via
+# androidx.glance:glance-appwidget → androidx.work → androidx.room).
+# The widgets rely on Glance, whose WorkManager backend stores state in a Room
+# database. Under R8 full mode (AGP 9 default) the generated *_Impl subclasses
+# of RoomDatabase lose their usable no-arg constructor / are marked abstract,
+# so Room's reflective instantiation throws InstantiationException and the app
+# crashes at startup with "Failed to create an instance of ...WorkDatabase".
+# Keep the generated Room database implementations fully intact.
+-keep class * extends androidx.room.RoomDatabase { *; }
+-dontwarn androidx.room.paging.**

app/src/main/AndroidManifest.xml

@@ -5,6 +5,13 @@
     <uses-permission android:name="android.permission.READ_CALENDAR" />
     <uses-permission android:name="android.permission.WRITE_CALENDAR" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <!--
+      Lets the "Reliable delivery" setting open the direct system dialog to
+      exempt Calendula from battery optimisation (so reminder broadcasts aren't
+      delayed by Doze). Used only to launch that dialog; falls back to the
+      battery-optimisation list if the OS declines the direct intent.
+    -->
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
 
     <!-- Package visibility (Android 11+): without this, getLaunchIntentForPackage
          returns null and the calendar manager's per-account "manage" button can't
@@ -25,6 +32,7 @@
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:localeConfig="@xml/locales_config"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.Calendula"
@@ -38,8 +46,37 @@
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+
+            <!-- Open a .ics file (file manager / email attachment / browser). -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="content" android:mimeType="text/calendar" />
+                <data android:scheme="file" android:mimeType="text/calendar" />
+            </intent-filter>
+            <!-- Receive a .ics shared from another app. -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/calendar" />
+            </intent-filter>
+
+            <!-- Launcher long-press shortcuts (e.g. "New event"). -->
+            <meta-data
+                android:name="android.app.shortcuts"
+                android:resource="@xml/shortcuts" />
         </activity>
 
+        <!-- Standalone surface for a captured crash report. MainActivity routes
+             here on a startup crash-loop, so it stays clear of the app's Hilt
+             graph and Compose content. Not exported: launched only by us. -->
+        <activity
+            android:name=".ui.crash.CrashReportActivity"
+            android:exported="false"
+            android:excludeFromRecents="true"
+            android:launchMode="singleTask" />
+
         <!-- The provider broadcasts EVENT_REMINDER at reminder time but posts
              no notification itself — a calendar app must (v1.4, Etar model).
              Exported: the broadcast arrives from the provider's process. -->
@@ -54,6 +91,64 @@
             </intent-filter>
         </receiver>
 
+        <!-- Home-screen widgets (Glance). Exported: the launcher/host binds them. -->
+        <receiver
+            android:name=".widget.agenda.AgendaWidgetReceiver"
+            android:label="@string/widget_agenda_label"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/appwidget_info_agenda" />
+        </receiver>
+
+        <receiver
+            android:name=".widget.month.MonthWidgetReceiver"
+            android:label="@string/widget_month_label"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/appwidget_info_month" />
+        </receiver>
+
+        <!-- Keeps both widgets fresh: the calendar provider broadcasts
+             PROVIDER_CHANGED on any data change (our writes and external sync),
+             and the system broadcasts the date/time ones at midnight / clock
+             changes so "today" highlighting rolls over. -->
+        <receiver
+            android:name=".widget.WidgetUpdateReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.PROVIDER_CHANGED" />
+                <data
+                    android:host="com.android.calendar"
+                    android:scheme="content" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.DATE_CHANGED" />
+                <action android:name="android.intent.action.TIME_SET" />
+                <action android:name="android.intent.action.TIMEZONE_CHANGED" />
+            </intent-filter>
+        </receiver>
+
+        <!-- Hands .ics files we stage in the cache to other apps via a content
+             Uri (single-event share). Authority tracks applicationId so the
+             debug suffix doesn't break getUriForFile. -->
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
         <!-- Persists the per-app language (M4) on API < 33, where the platform
              per-app-languages API is unavailable. On 33+ this is a no-op. -->
         <service

app/src/main/java/de/jeanlucmakiola/calendula/CalendulaApp.kt

@@ -2,10 +2,19 @@ package de.jeanlucmakiola.calendula
 
 import android.app.Application
 import dagger.hilt.android.HiltAndroidApp
+import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 
 /**
  * Application entry point. Registered as android:name=".CalendulaApp"
  * in AndroidManifest.xml. Hilt initializes its component graph here.
  */
 @HiltAndroidApp
-class CalendulaApp : Application()
+class CalendulaApp : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+        // Install first thing so startup crashes are captured too (privacy-
+        // respecting, on-device; the user submits the report by hand).
+        CrashReporter.install(this)
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt

@@ -2,37 +2,74 @@ package de.jeanlucmakiola.calendula
 
 import android.content.Context
 import android.content.Intent
+import android.net.Uri
 import android.os.Bundle
-import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import androidx.core.content.IntentCompat
 import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import dagger.hilt.android.AndroidEntryPoint
+import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.ui.RootScreen
+import de.jeanlucmakiola.calendula.ui.WidgetNavRequest
+import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
+import de.jeanlucmakiola.calendula.ui.crash.CrashReportDialog
+import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
 import de.jeanlucmakiola.calendula.ui.settings.SettingsViewModel
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
+import kotlinx.datetime.LocalDate
 
 @AndroidEntryPoint
-class MainActivity : ComponentActivity() {
+class MainActivity : AppCompatActivity() {
 
     // The occurrence a reminder notification was tapped for (eventId, begin,
     // end — the detail screen's key shape). singleTop + onNewIntent route a
     // tap into the running activity; CalendarHost consumes and clears it.
     private var requestedDetailKey by mutableStateOf<LongArray?>(null)
 
+    // A navigation a home-screen widget asked for (open a date / start a
+    // create). Consumed once by CalendarHost, same pattern as the detail key.
+    private var requestedNav by mutableStateOf<WidgetNavRequest?>(null)
+
+    // An .ics file opened/shared into the app (ACTION_VIEW/SEND). Consumed once
+    // by CalendarHost's import flow.
+    private var requestedImportUri by mutableStateOf<Uri?>(null)
+
+    // A captured crash report awaiting the user's decision, surfaced as a dialog
+    // over the calendar on the next launch (the single-crash path). A startup
+    // crash-loop is handled out of band, before setContent — see below.
+    private var pendingCrashReport by mutableStateOf<String?>(null)
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+
+        // If the app keeps crashing as it starts, the main UI can't be trusted
+        // to come up — route to the standalone report screen instead of
+        // re-entering the crashing graph.
+        if (CrashReporter.isCrashLoop(this)) {
+            startActivity(
+                Intent(this, CrashReportActivity::class.java)
+                    .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK),
+            )
+            finish()
+            return
+        }
+
         enableEdgeToEdge()
         requestedDetailKey = intent.detailKeyOrNull()
+        requestedNav = intent.navRequestOrNull()
+        requestedImportUri = intent.importUriOrNull()
+        if (CrashReporter.shouldPrompt(this)) pendingCrashReport = CrashReporter.pendingReport(this)
         setContent {
             // One activity-scoped SettingsViewModel drives both the theme here
             // and the Settings screen, so a theme change applies app-wide at once.
@@ -51,14 +88,67 @@ class MainActivity : ComponentActivity() {
                     modifier = Modifier.fillMaxSize(),
                     requestedDetailKey = requestedDetailKey,
                     onDetailKeyConsumed = { requestedDetailKey = null },
+                    widgetNavRequest = requestedNav,
+                    onWidgetNavConsumed = { requestedNav = null },
+                    requestedImportUri = requestedImportUri,
+                    onImportConsumed = { requestedImportUri = null },
+                )
+                pendingCrashReport?.let { report ->
+                    CrashReportDialog(
+                        report = report,
+                        onSend = {
+                            submitCrashReport(this@MainActivity, report)
+                            CrashReporter.clearReport(this@MainActivity)
+                            pendingCrashReport = null
+                        },
+                        onDismiss = {
+                            // Keep the report (Settings can still reach it); just
+                            // stop it popping on every launch.
+                            CrashReporter.dismissPrompt(this@MainActivity)
+                            pendingCrashReport = null
+                        },
                     )
                 }
             }
         }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        // Reaching a running UI means startup succeeded; reset the loop trail.
+        CrashReporter.markHealthy(this)
+    }
 
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         intent.detailKeyOrNull()?.let { requestedDetailKey = it }
+        intent.navRequestOrNull()?.let { requestedNav = it }
+        intent.importUriOrNull()?.let { requestedImportUri = it }
+    }
+
+    /**
+     * The `.ics` Uri an external app asked us to open (file manager `ACTION_VIEW`)
+     * or share into us (`ACTION_SEND`). Restricted to content/file schemes so the
+     * app's own `calendula://` deep-links never match.
+     */
+    private fun Intent.importUriOrNull(): Uri? {
+        val uri = when (action) {
+            Intent.ACTION_VIEW -> data
+            Intent.ACTION_SEND -> IntentCompat.getParcelableExtra(this, Intent.EXTRA_STREAM, Uri::class.java)
+            else -> null
+        } ?: return null
+        return uri.takeIf { it.scheme == "content" || it.scheme == "file" }
+    }
+
+    private fun Intent.navRequestOrNull(): WidgetNavRequest? = when {
+        // Launcher long-press "New event" shortcut. Static shortcut intents
+        // can't carry typed extras, so the action alone signals create-on-today.
+        action == ACTION_NEW_EVENT -> WidgetNavRequest.Create(null)
+        getBooleanExtra(EXTRA_CREATE, false) ->
+            WidgetNavRequest.Create(getStringExtra(EXTRA_DATE_ISO))
+        getStringExtra(EXTRA_DATE_ISO) != null ->
+            WidgetNavRequest.OpenDate(getStringExtra(EXTRA_DATE_ISO)!!)
+        else -> null
     }
 
     private fun Intent.detailKeyOrNull(): LongArray? {
@@ -75,6 +165,12 @@ class MainActivity : ComponentActivity() {
         private const val EXTRA_EVENT_ID = "de.jeanlucmakiola.calendula.extra.EVENT_ID"
         private const val EXTRA_BEGIN_MILLIS = "de.jeanlucmakiola.calendula.extra.BEGIN"
         private const val EXTRA_END_MILLIS = "de.jeanlucmakiola.calendula.extra.END"
+        private const val EXTRA_DATE_ISO = "de.jeanlucmakiola.calendula.extra.DATE_ISO"
+        private const val EXTRA_CREATE = "de.jeanlucmakiola.calendula.extra.CREATE"
+
+        // Fired by the launcher long-press "New event" shortcut (res/xml/
+        // shortcuts.xml hardcodes this string — keep the two in sync).
+        const val ACTION_NEW_EVENT = "de.jeanlucmakiola.calendula.action.NEW_EVENT"
 
         /**
          * Intent opening the detail screen of one occurrence (reminder
@@ -93,5 +189,22 @@ class MainActivity : ComponentActivity() {
             putExtra(EXTRA_END_MILLIS, endMillis)
             addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
         }
+
+        /** Open the day view anchored on [date] (home-screen widgets). */
+        fun openDateIntent(context: Context, date: LocalDate): Intent =
+            Intent(context, MainActivity::class.java).apply {
+                data = "calendula://date/$date".toUri()
+                putExtra(EXTRA_DATE_ISO, date.toString())
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+
+        /** Open the create-event form prefilled for [date] (home-screen widgets). */
+        fun openCreateIntent(context: Context, date: LocalDate): Intent =
+            Intent(context, MainActivity::class.java).apply {
+                data = "calendula://create/$date".toUri()
+                putExtra(EXTRA_CREATE, true)
+                putExtra(EXTRA_DATE_ISO, date.toString())
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/AllDayReminderEncoding.kt

@@ -0,0 +1,70 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import java.time.Instant
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.time.temporal.ChronoUnit
+
+/**
+ * Translates an all-day reminder between the **semantic** lead time the UI
+ * speaks (whole days before the event — "1 day before") and the **raw**
+ * `CalendarContract.Reminders.MINUTES` offset the provider stores.
+ *
+ * Calendula schedules no alarms itself: the provider fires a reminder at
+ * `DTSTART − MINUTES` (the Etar model). An all-day event's DTSTART is **UTC
+ * midnight** (see [EventWriteTimes]), so a raw `MINUTES = 1440` ("1 day") lands
+ * on UTC-midnight of the previous day — 02:00 local in CEST, not the morning.
+ *
+ * To fire at a chosen wall-clock time we encode that time *into* the offset:
+ * `MINUTES = UTC-midnight(startDate) − (localInstant of [timeOfDayMinutes] on the
+ * day [semanticMinutes] before)`. The single fixed offset can only be tuned for
+ * the event's own date, so a recurring all-day series or a post-creation
+ * timezone change drifts the fire time by the offset delta (±1h across DST) —
+ * an inherent limit of the provider model, shared by Etar.
+ */
+private const val MINUTES_PER_DAY = 1_440
+private const val MILLIS_PER_MINUTE = 60_000L
+
+/**
+ * Raw provider `MINUTES` for an all-day reminder set [semanticMinutes] before the
+ * event (a whole-day multiple; sub-day remainders are dropped), so it fires at
+ * [timeOfDayMinutes] (minutes from local midnight) in [zone]. The result may be
+ * **negative** — e.g. "at time of event" at 09:00 CEST encodes to −420, meaning
+ * the provider fires *after* DTSTART; this is valid and must not be clamped.
+ * A negative [semanticMinutes] is the "provider default" sentinel and passes
+ * through unchanged.
+ */
+internal fun toProviderAllDayMinutes(
+    semanticMinutes: Int,
+    startDate: LocalDate,
+    zone: ZoneId,
+    timeOfDayMinutes: Int,
+): Int {
+    if (semanticMinutes < 0) return semanticMinutes
+    val utcMidnight = startDate.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+    val fire = startDate.minusDays((semanticMinutes / MINUTES_PER_DAY).toLong())
+        .atTime(LocalTime.of(timeOfDayMinutes / 60, timeOfDayMinutes % 60))
+        .atZone(zone).toInstant().toEpochMilli()
+    return ((utcMidnight - fire) / MILLIS_PER_MINUTE).toInt()
+}
+
+/**
+ * Recover the semantic whole-day lead time from a raw all-day reminder
+ * [rawMinutes]. Keys off the **local date** of the encoded fire instant, so it
+ * returns the right day count regardless of which [timeOfDayMinutes] wrote the
+ * row — including pre-feature rows (raw multiples of 1440, fired at UTC midnight)
+ * and rows written under a different timezone. A negative [rawMinutes] (fire
+ * after DTSTART) folds to day 0.
+ */
+internal fun fromProviderAllDayMinutes(
+    rawMinutes: Int,
+    startDate: LocalDate,
+    zone: ZoneId,
+): Int {
+    val utcMidnight = startDate.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+    val fireLocalDate = Instant.ofEpochMilli(utcMidnight - rawMinutes * MILLIS_PER_MINUTE)
+        .atZone(zone).toLocalDate()
+    return ChronoUnit.DAYS.between(fireLocalDate, startDate).toInt() * MINUTES_PER_DAY
+}

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt

@@ -14,13 +14,19 @@ import android.util.Log
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.Attendee
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
+import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import de.jeanlucmakiola.calendula.domain.rruleTruncatedAt
+import kotlinx.datetime.toJavaLocalDate
 import java.time.ZoneId
 import java.time.ZoneOffset
+import java.util.UUID
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -37,6 +43,35 @@ interface CalendarDataSource {
     fun instances(beginMillis: Long, endMillis: Long): List<EventInstance>
     fun eventDetail(eventId: Long): EventDetail?
 
+    /**
+     * The event-colour palette the calendar's account publishes
+     * (`CalendarContract.Colors`, `TYPE_EVENT`), sorted by key. Empty when the
+     * account exposes no palette (most local calendars, some CalDAV) — the
+     * signal that a custom colour can only be written as a raw `EVENT_COLOR`,
+     * which a synced calendar may drop on its next sync.
+     */
+    fun eventColorPalette(calendarId: Long): List<EventColorOption>
+
+    /**
+     * Every master/one-off event of the writable local calendars, mapped for a
+     * whole-calendar `.ics` backup. Modified-occurrence and cancelled-exception
+     * rows are excluded (see [EventExportProjection]).
+     */
+    fun exportableEvents(): List<IcsEvent>
+
+    /**
+     * The non-empty `Events.UID_2445` values present in [calendarId] — used to
+     * dedup an `.ics` import so re-importing a backup doesn't double events.
+     */
+    fun existingUids(calendarId: Long): Set<String>
+
+    /**
+     * Insert a parsed `.ics` event into [calendarId], preserving its UID (or
+     * minting one when absent); returns the new `Events._ID`. Reminders are
+     * written as the file's raw lead minutes (METHOD_ALERT).
+     */
+    fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long
+
     /**
      * Create a new device-only (`ACCOUNT_TYPE_LOCAL`) calendar the app owns;
      * returns its `Calendars._ID`. Inserted through the sync-adapter URI so the
@@ -50,24 +85,40 @@ interface CalendarDataSource {
     /** Permanently delete a local calendar the app owns, with all its events. */
     fun deleteCalendar(id: Long)
 
-    /** Insert a new event; returns the new `Events._ID`. */
-    fun insertEvent(form: EventForm): Long
+    /**
+     * Insert a new event; returns the new `Events._ID`. [allDayReminderTimeMinutes]
+     * (minutes from local midnight) is the wall-clock time all-day reminders
+     * should fire at — encoded into each all-day reminder's provider offset
+     * (ignored for timed events).
+     */
+    fun insertEvent(form: EventForm, allDayReminderTimeMinutes: Int): Long
 
     /**
      * Update an existing event (for recurring events: the whole series) to
      * match [updated]. [original] is the form as it was prefilled from the
      * event, so only fields the user actually changed are written and the
      * reminder rows can be diffed instead of wiped.
+     * [allDayReminderTimeMinutes]: see [insertEvent].
      */
-    fun updateEvent(eventId: Long, original: EventForm, updated: EventForm)
+    fun updateEvent(
+        eventId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    )
 
     /**
      * Change a single occurrence of a recurring event by inserting a
      * modified-occurrence exception at [beginMillis] (the occurrence's
      * `Instances.BEGIN`) carrying [form]'s values; returns the exception
-     * row's `Events._ID`.
+     * row's `Events._ID`. [allDayReminderTimeMinutes]: see [insertEvent].
      */
-    fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long
+    fun updateOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        form: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long
 
     /**
      * Change a recurring event from the occurrence at [beginMillis] onwards
@@ -82,6 +133,7 @@ interface CalendarDataSource {
         beginMillis: Long,
         original: EventForm,
         updated: EventForm,
+        allDayReminderTimeMinutes: Int,
     ): Long
 
     /**
@@ -152,7 +204,8 @@ class AndroidCalendarDataSource @Inject constructor(
             putDescription(description)
         }
         val uri = resolver.insert(localCalendarsUri(), values)
-            ?: throw WriteFailedException("create local calendar '$name'")
+            // No calendar name in the message — it can reach a crash report.
+            ?: throw WriteFailedException("create local calendar")
         return ContentUris.parseId(uri)
     }
 
@@ -215,13 +268,190 @@ class AndroidCalendarDataSource @Inject constructor(
         }
     }
 
-    override fun insertEvent(form: EventForm): Long {
+    override fun eventColorPalette(calendarId: Long): List<EventColorOption> {
+        val account = calendarAccount(calendarId) ?: return emptyList()
+        return resolver.query(
+            CalendarContract.Colors.CONTENT_URI,
+            arrayOf(CalendarContract.Colors.COLOR_KEY, CalendarContract.Colors.COLOR),
+            CalendarContract.Colors.ACCOUNT_NAME + " = ? AND " +
+                CalendarContract.Colors.ACCOUNT_TYPE + " = ? AND " +
+                CalendarContract.Colors.COLOR_TYPE + " = ?",
+            arrayOf(
+                account.name,
+                account.type,
+                CalendarContract.Colors.TYPE_EVENT.toString(),
+            ),
+            null,
+        )?.use { c ->
+            c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
+        }
+            ?.filter { it.key.isNotEmpty() }
+            ?.sortedBy { it.key }
+            ?: emptyList()
+    }
+
+    override fun exportableEvents(): List<IcsEvent> {
+        // Only the local calendars the app owns and can write — synced calendars
+        // already have a backup (their server). Map id → display name for the
+        // X-CALENDULA-CALENDAR tag a restore uses to fan back out.
+        val names = calendars()
+            .filter { it.isLocal && it.canModifyContents }
+            .associate { it.id to it.displayName }
+        if (names.isEmpty()) return emptyList()
+
+        val idList = names.keys.joinToString(",")
+        return resolver.query(
+            CalendarContract.Events.CONTENT_URI,
+            EventExportProjection.COLUMNS,
+            // Skip soft-deleted rows and exception rows (modified occurrences /
+            // cancellations) — v1 exports masters + one-offs only.
+            "${CalendarContract.Events.CALENDAR_ID} IN ($idList) AND " +
+                "${CalendarContract.Events.DELETED} = 0 AND " +
+                "${CalendarContract.Events.ORIGINAL_ID} IS NULL",
+            null,
+            CalendarContract.Events.DTSTART + " ASC",
+        )?.use { c ->
+            c.mapAll {
+                val reader = CursorColumnReader(c)
+                val eventId = reader.getLong(EventExportProjection.IDX_ID)
+                val calendarId = reader.getLong(EventExportProjection.IDX_CALENDAR_ID)
+                reader.toIcsEvent(
+                    reminderMinutes = queryReminders(eventId).map { it.minutes },
+                    calendarName = names[calendarId],
+                )
+            }
+        } ?: emptyList()
+    }
+
+    override fun existingUids(calendarId: Long): Set<String> = resolver.query(
+        CalendarContract.Events.CONTENT_URI,
+        arrayOf(CalendarContract.Events.UID_2445),
+        "${CalendarContract.Events.CALENDAR_ID} = ? AND " +
+            "${CalendarContract.Events.UID_2445} IS NOT NULL",
+        arrayOf(calendarId.toString()),
+        null,
+    )?.use { c ->
+        buildSet { while (c.moveToNext()) c.getString(0)?.takeIf { it.isNotEmpty() }?.let(::add) }
+    } ?: emptySet()
+
+    override fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long {
+        val startMillis = event.start.toEpochMillis()
+        val endMillis = event.end.toEpochMillis()
+        val values = ContentValues().apply {
+            put(CalendarContract.Events.CALENDAR_ID, calendarId)
+            // Preserve the file's UID so a re-import dedups against it; mint one
+            // only when the source event carried none.
+            put(
+                CalendarContract.Events.UID_2445,
+                event.uid?.takeIf { it.isNotBlank() } ?: "${UUID.randomUUID()}@calendula",
+            )
+            put(CalendarContract.Events.TITLE, event.summary.trim())
+            put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0)
+            put(CalendarContract.Events.DTSTART, startMillis)
+            if (event.recurrenceRule == null) {
+                put(CalendarContract.Events.DTEND, endMillis)
+            } else {
+                put(CalendarContract.Events.RRULE, event.recurrenceRule)
+                put(
+                    CalendarContract.Events.DURATION,
+                    importDuration(startMillis, endMillis, event.isAllDay),
+                )
+            }
+            // All-day rows live at UTC midnights (the file already encodes them so);
+            // timed rows keep the event's own zone.
+            put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId)
+            put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue())
+            put(CalendarContract.Events.STATUS, event.status.toProviderStatus())
+            event.location?.trim()?.takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
+            event.description?.trim()?.takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
+        }
+        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values)
+            ?: throw WriteFailedException("import event into calendar id=$calendarId")
+        val eventId = ContentUris.parseId(uri)
+        // Raw lead minutes straight from the file's VALARMs (best-effort, like insertEvent).
+        event.reminderMinutes.distinct().filter { it >= 0 }.forEach { minutes ->
+            val reminder = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, eventId)
+                put(CalendarContract.Reminders.MINUTES, minutes)
+                put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
+            }
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
+                Log.w(TAG, "Failed to attach reminder ($minutes min) to imported event $eventId")
+            }
+        }
+        return eventId
+    }
+
+    /** Provider DURATION for an imported recurring row: whole days / seconds. */
+    private fun importDuration(startMillis: Long, endMillis: Long, isAllDay: Boolean): String {
+        val span = (endMillis - startMillis).coerceAtLeast(0)
+        return if (isAllDay) "P${span / 86_400_000L}D" else "P${span / 1_000L}S"
+    }
+
+    private fun EventStatus.toProviderStatus(): Int = when (this) {
+        EventStatus.Confirmed -> CalendarContract.Events.STATUS_CONFIRMED
+        EventStatus.Tentative -> CalendarContract.Events.STATUS_TENTATIVE
+        EventStatus.Cancelled -> CalendarContract.Events.STATUS_CANCELED
+    }
+
+    /** The account a calendar belongs to, for scoping a `Colors` lookup. */
+    private fun calendarAccount(calendarId: Long): CalendarAccount? = resolver.query(
+        ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId),
+        arrayOf(
+            CalendarContract.Calendars.ACCOUNT_NAME,
+            CalendarContract.Calendars.ACCOUNT_TYPE,
+        ),
+        null, null, null,
+    )?.use { c ->
+        if (c.moveToFirst()) {
+            CalendarAccount(name = c.getString(0).orEmpty(), type = c.getString(1).orEmpty())
+        } else {
+            null
+        }
+    }
+
+    private data class CalendarAccount(val name: String, val type: String)
+
+    /**
+     * The raw provider `MINUTES` to store for one of [form]'s reminders: an
+     * all-day reminder is shifted to fire at [allDayReminderTimeMinutes] local
+     * (see [toProviderAllDayMinutes]); a timed reminder is its lead time as-is.
+     */
+    private fun providerReminderMinutes(
+        form: EventForm,
+        minutes: Int,
+        allDayReminderTimeMinutes: Int,
+    ): Int = if (form.isAllDay) {
+        toProviderAllDayMinutes(
+            semanticMinutes = minutes,
+            startDate = form.start.date.toJavaLocalDate(),
+            zone = ZoneId.systemDefault(),
+            timeOfDayMinutes = allDayReminderTimeMinutes,
+        )
+    } else {
+        minutes
+    }
+
+    /** [form]'s reminders as the distinct raw provider offsets to store. */
+    private fun encodedReminders(form: EventForm, allDayReminderTimeMinutes: Int): List<Int> =
+        form.reminders
+            .map { providerReminderMinutes(form, it, allDayReminderTimeMinutes) }
+            .distinct()
+
+    override fun insertEvent(form: EventForm, allDayReminderTimeMinutes: Int): Long {
         val times = form.toWriteTimes(ZoneId.systemDefault())
         val values = ContentValues().apply {
             put(
                 CalendarContract.Events.CALENDAR_ID,
                 requireNotNull(form.calendarId) { "EventForm.calendarId is required" },
             )
+            // A globally-unique UID so a later .ics backup/restore can identify
+            // the event and not duplicate it on re-import (the provider leaves
+            // this null for events it didn't sync). Older rows without one fall
+            // back to a stable synthesised UID at export time (deriveIcsUid).
+            put(CalendarContract.Events.UID_2445, "${UUID.randomUUID()}@calendula")
             put(CalendarContract.Events.TITLE, form.title.trim())
             put(CalendarContract.Events.ALL_DAY, if (form.isAllDay) 1 else 0)
             put(CalendarContract.Events.DTSTART, times.dtStartMillis)
@@ -240,13 +470,21 @@ class AndroidCalendarDataSource @Inject constructor(
                 ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
             form.description.trim().takeIf { it.isNotEmpty() }
                 ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
+            // A null colour just leaves both columns unset (the event inherits
+            // its calendar's colour), so only the key/raw cases are written.
+            when {
+                form.colorKey != null ->
+                    put(CalendarContract.Events.EVENT_COLOR_KEY, form.colorKey)
+                form.color != null -> put(CalendarContract.Events.EVENT_COLOR, form.color)
+            }
         }
         val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values)
             ?: throw WriteFailedException("insert event into calendar id=${form.calendarId}")
         val eventId = ContentUris.parseId(uri)
         // Best effort (spec §8): the event exists at this point — a reminder
         // that fails to attach is logged, not surfaced as a failed create.
-        form.reminders.distinct().forEach { minutes ->
+        encodedReminders(form, allDayReminderTimeMinutes)
+            .forEach { minutes ->
                 val reminder = ContentValues().apply {
                     put(CalendarContract.Reminders.EVENT_ID, eventId)
                     put(CalendarContract.Reminders.MINUTES, minutes)
@@ -259,7 +497,12 @@ class AndroidCalendarDataSource @Inject constructor(
         return eventId
     }
 
-    override fun updateEvent(eventId: Long, original: EventForm, updated: EventForm) {
+    override fun updateEvent(
+        eventId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ) {
         val values = buildEventUpdateValues(
             original = original,
             updated = updated,
@@ -275,13 +518,19 @@ class AndroidCalendarDataSource @Inject constructor(
             if (rows == 0) throw WriteFailedException("update event id=$eventId")
         }
         // Untouched reminder sets are left alone so unrelated edits can't
-        // disturb provider rows the form never knew about.
+        // disturb provider rows the form never knew about. The diff is on the
+        // form's semantic minutes; reconcile works in encoded provider minutes.
         if (updated.reminders.toSet() != original.reminders.toSet()) {
-            reconcileReminders(eventId, updated.reminders)
+            reconcileReminders(eventId, encodedReminders(updated, allDayReminderTimeMinutes))
         }
     }
 
-    override fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long {
+    override fun updateOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        form: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long {
         // The provider clones the series row and applies these values on top.
         val values = buildOccurrenceExceptionValues(
             form = form,
@@ -295,7 +544,7 @@ class AndroidCalendarDataSource @Inject constructor(
         val exceptionId = ContentUris.parseId(uri)
         // Whether the provider copied the parent's reminder rows is its
         // business — reconciling against the actual rows handles both ways.
-        reconcileReminders(exceptionId, form.reminders)
+        reconcileReminders(exceptionId, encodedReminders(form, allDayReminderTimeMinutes))
         return exceptionId
     }
 
@@ -304,16 +553,17 @@ class AndroidCalendarDataSource @Inject constructor(
         beginMillis: Long,
         original: EventForm,
         updated: EventForm,
+        allDayReminderTimeMinutes: Int,
     ): Long {
         val row = querySeriesRow(eventId)
         // From the first occurrence on (or with no rule to split) this is
         // just a series update.
         if (row.rrule.isNullOrBlank() || beginMillis <= row.dtStartMillis) {
-            updateEvent(eventId, original, updated)
+            updateEvent(eventId, original, updated, allDayReminderTimeMinutes)
             return eventId
         }
         // Insert the new series first: if it fails, the original is untouched.
-        val newEventId = insertEvent(updated)
+        val newEventId = insertEvent(updated, allDayReminderTimeMinutes)
         truncateSeries(eventId, row, beginMillis)
         return newEventId
     }
@@ -399,9 +649,11 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     /**
-     * Make the event's reminder rows match [targetMinutes]: rows with other
-     * lead times are deleted, missing ones inserted as best-effort ALERTs
-     * (like insertEvent). Rows whose minutes survive keep their method.
+     * Make the event's reminder rows match [targetMinutes] — the raw provider
+     * offsets to store (already encoded via [encodedReminders], so all-day shifts
+     * are baked in and the diff matches the stored rows). Rows with other offsets
+     * are deleted, missing ones inserted as best-effort ALERTs (like insertEvent).
+     * Rows whose minutes survive keep their method.
      */
     private fun reconcileReminders(eventId: Long, targetMinutes: List<Int>) {
         val target = targetMinutes.toSet()
@@ -434,7 +686,8 @@ class AndroidCalendarDataSource @Inject constructor(
                     is String -> cv.put(column, value)
                     is Long -> cv.put(column, value)
                     is Int -> cv.put(column, value)
-                    else -> error("Unsupported value for $column: $value")
+                    // Only the type, never the value — a cell value can be event content.
+                    else -> error("Unsupported value type for column '$column': ${value::class.simpleName}")
                 }
             }
         }

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt

@@ -1,9 +1,13 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.flow.Flow
 import kotlin.time.Instant
 
@@ -12,6 +16,12 @@ interface CalendarRepository {
     fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>>
     suspend fun eventDetail(eventId: Long): EventDetail
 
+    /**
+     * The event-colour palette a calendar's account publishes; empty when it
+     * exposes none (see [CalendarDataSource.eventColorPalette]).
+     */
+    suspend fun eventColorPalette(calendarId: Long): List<EventColorOption>
+
     /** Create a device-only (LOCAL) calendar the app owns; returns its id. */
     suspend fun createLocalCalendar(displayName: String, color: Int, description: String?): Long
 
@@ -21,6 +31,19 @@ interface CalendarRepository {
     /** Permanently delete a local calendar the app owns, with all its events. */
     suspend fun deleteCalendar(id: Long)
 
+    /**
+     * Every event of the writable local calendars, ready to serialise into a
+     * whole-calendar `.ics` backup (see [CalendarDataSource.exportableEvents]).
+     */
+    suspend fun exportEvents(): List<IcsEvent>
+
+    /**
+     * Bulk-import parsed `.ics` [events] into [targetCalendarId]. Events whose
+     * UID already exists in the target are skipped (idempotent restore); the
+     * rest are inserted. See [CalendarDataSource.insertImportedEvent].
+     */
+    suspend fun importEvents(targetCalendarId: Long, events: List<ParsedIcsEvent>): IcsImportSummary
+
     /** Create a new event from a validated form; returns the new `Events._ID`. */
     suspend fun createEvent(form: EventForm): Long
 

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt

@@ -2,14 +2,19 @@ package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.onStart
@@ -27,9 +32,14 @@ import javax.inject.Singleton
 class CalendarRepositoryImpl @Inject constructor(
     private val dataSource: CalendarDataSource,
     private val prefs: CalendarPrefs,
+    private val settingsPrefs: SettingsPrefs,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : CalendarRepository {
 
+    /** The configured wall-clock fire time for all-day reminders, read per write. */
+    private suspend fun allDayReminderTimeMinutes(): Int =
+        settingsPrefs.allDayReminderTimeMinutes.first()
+
     private val ticks = MutableSharedFlow<Unit>(
         replay = 0,
         extraBufferCapacity = 1,
@@ -70,6 +80,9 @@ class CalendarRepositoryImpl @Inject constructor(
         dataSource.eventDetail(eventId) ?: throw NoSuchEventException(eventId)
     }
 
+    override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =
+        withContext(io) { dataSource.eventColorPalette(calendarId) }
+
     override suspend fun createLocalCalendar(
         displayName: String,
         color: Int,
@@ -88,8 +101,30 @@ class CalendarRepositoryImpl @Inject constructor(
     override suspend fun deleteCalendar(id: Long) =
         withContext(io) { dataSource.deleteCalendar(id) }
 
+    override suspend fun exportEvents() = withContext(io) { dataSource.exportableEvents() }
+
+    override suspend fun importEvents(
+        targetCalendarId: Long,
+        events: List<ParsedIcsEvent>,
+    ): IcsImportSummary = withContext(io) {
+        val existing = dataSource.existingUids(targetCalendarId)
+        var imported = 0
+        var skipped = 0
+        for (event in events) {
+            // A known UID means the event is already in this calendar — skip,
+            // keeping a restore idempotent (no overwrite this pass).
+            if (event.uid != null && event.uid in existing) {
+                skipped++
+            } else {
+                dataSource.insertImportedEvent(event, targetCalendarId)
+                imported++
+            }
+        }
+        IcsImportSummary(imported = imported, skippedDuplicate = skipped)
+    }
+
     override suspend fun createEvent(form: EventForm): Long = withContext(io) {
-        dataSource.insertEvent(form)
+        dataSource.insertEvent(form, allDayReminderTimeMinutes())
     }
 
     override suspend fun updateEvent(
@@ -97,7 +132,7 @@ class CalendarRepositoryImpl @Inject constructor(
         original: EventForm,
         updated: EventForm,
     ) = withContext(io) {
-        dataSource.updateEvent(eventId, original, updated)
+        dataSource.updateEvent(eventId, original, updated, allDayReminderTimeMinutes())
     }
 
     override suspend fun deleteEvent(eventId: Long) = withContext(io) {
@@ -109,7 +144,7 @@ class CalendarRepositoryImpl @Inject constructor(
         beginMillis: Long,
         form: EventForm,
     ): Long = withContext(io) {
-        dataSource.updateOccurrence(eventId, beginMillis, form)
+        dataSource.updateOccurrence(eventId, beginMillis, form, allDayReminderTimeMinutes())
     }
 
     override suspend fun updateEventFromOccurrence(
@@ -118,7 +153,9 @@ class CalendarRepositoryImpl @Inject constructor(
         original: EventForm,
         updated: EventForm,
     ): Long = withContext(io) {
-        dataSource.updateEventFromOccurrence(eventId, beginMillis, original, updated)
+        dataSource.updateEventFromOccurrence(
+            eventId, beginMillis, original, updated, allDayReminderTimeMinutes(),
+        )
     }
 
     override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = withContext(io) {

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventDetailMapper.kt

@@ -13,6 +13,9 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.ReminderMethod
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
 
 private const val TAG = "EventDetailMapper"
 
@@ -46,13 +49,19 @@ internal fun ColumnReader.toEventDetailCore(
     // localized placeholder, and the edit form must prefill the true value.
     val title = getString(EventDetailProjection.IDX_TITLE).orEmpty()
 
-    val color = if (isNull(EventDetailProjection.IDX_EVENT_COLOR)) {
-        getInt(EventDetailProjection.IDX_CALENDAR_COLOR)
+    // The event's own colour (null = inherits the calendar's) is kept apart
+    // from the resolved display colour: the edit form needs to tell the two
+    // cases apart, while the instance carries the calendar fallback for display.
+    val eventColor = if (isNull(EventDetailProjection.IDX_EVENT_COLOR)) {
+        null
     } else {
         getInt(EventDetailProjection.IDX_EVENT_COLOR)
     }
+    val eventColorKey = getString(EventDetailProjection.IDX_EVENT_COLOR_KEY)
+    val color = eventColor ?: getInt(EventDetailProjection.IDX_CALENDAR_COLOR)
 
     val eventId = getLong(EventDetailProjection.IDX_EVENT_ID)
+    val isAllDay = getInt(EventDetailProjection.IDX_ALL_DAY) != 0
     val instance = EventInstance(
         instanceId = eventId,
         eventId = eventId,
@@ -60,11 +69,23 @@ internal fun ColumnReader.toEventDetailCore(
         title = title,
         start = begin.toKotlinInstantFromEpochMillis(),
         end = end.toKotlinInstantFromEpochMillis(),
-        isAllDay = getInt(EventDetailProjection.IDX_ALL_DAY) != 0,
+        isAllDay = isAllDay,
         color = color,
         location = getString(EventDetailProjection.IDX_LOCATION),
     )
 
+    // All-day reminders are stored as a wall-clock-shifted offset (see
+    // AllDayReminderEncoding); decode back to the whole-day lead time the form
+    // and detail screen speak. DTSTART is UTC midnight for all-day events, so the
+    // event's date is its UTC date.
+    val displayReminders = if (isAllDay) {
+        val startDate = Instant.ofEpochMilli(begin).atZone(ZoneOffset.UTC).toLocalDate()
+        val zone = ZoneId.systemDefault()
+        reminders.map { it.copy(minutes = fromProviderAllDayMinutes(it.minutes, startDate, zone)) }
+    } else {
+        reminders
+    }
+
     // STATUS shares its 0 value with STATUS_TENTATIVE, so a missing column must
     // be distinguished from a present 0 — an absent status means "just confirmed".
     val status = if (isNull(EventDetailProjection.IDX_STATUS)) {
@@ -79,7 +100,7 @@ internal fun ColumnReader.toEventDetailCore(
         organizer = getString(EventDetailProjection.IDX_ORGANIZER),
         attendees = attendees,
         rrule = getString(EventDetailProjection.IDX_RRULE),
-        reminders = reminders,
+        reminders = displayReminders,
         status = status,
         // BUSY and DEFAULT are both 0, so a null column folds into the same
         // default these mappers already return — no isNull guard needed.
@@ -87,6 +108,8 @@ internal fun ColumnReader.toEventDetailCore(
         accessLevel = mapAccessLevel(getInt(EventDetailProjection.IDX_ACCESS_LEVEL)),
         eventTimezone = getString(EventDetailProjection.IDX_EVENT_TIMEZONE),
         selfStatus = mapAttendeeStatus(getInt(EventDetailProjection.IDX_SELF_ATTENDEE_STATUS)),
+        eventColor = eventColor,
+        eventColorKey = eventColorKey,
     )
 }
 

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt

@@ -85,6 +85,9 @@ internal fun buildEventUpdateValues(
     if (updated.accessLevel != original.accessLevel) {
         put(CalendarContract.Events.ACCESS_LEVEL, updated.accessLevel.toProviderValue())
     }
+    if (updated.colorKey != original.colorKey || updated.color != original.color) {
+        putAll(eventColorColumns(updated.colorKey, updated.color))
+    }
 
     val timesChanged = updated.start != original.start ||
         updated.end != original.end ||
@@ -134,6 +137,28 @@ internal fun buildOccurrenceExceptionValues(
     put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())
     put(CalendarContract.Events.EVENT_LOCATION, form.location.trim().ifEmpty { null })
     put(CalendarContract.Events.DESCRIPTION, form.description.trim().ifEmpty { null })
+    putAll(eventColorColumns(form.colorKey, form.color))
+}
+
+/**
+ * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
+ * [colorKey] writes the key alone (the provider derives `EVENT_COLOR` from the
+ * account's palette, so the colour round-trips through sync); a raw [color]
+ * writes `EVENT_COLOR` and clears any key; "no colour" clears both so the event
+ * falls back to its calendar's colour. The two are never written together —
+ * the provider rejects a raw colour on a calendar that publishes a palette,
+ * which is exactly why palette calendars only ever go through the key.
+ */
+internal fun eventColorColumns(colorKey: String?, color: Int?): Map<String, Any?> = when {
+    colorKey != null -> mapOf(CalendarContract.Events.EVENT_COLOR_KEY to colorKey)
+    color != null -> mapOf(
+        CalendarContract.Events.EVENT_COLOR_KEY to null,
+        CalendarContract.Events.EVENT_COLOR to color,
+    )
+    else -> mapOf(
+        CalendarContract.Events.EVENT_COLOR_KEY to null,
+        CalendarContract.Events.EVENT_COLOR to null,
+    )
 }
 
 /**

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapper.kt

@@ -0,0 +1,54 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
+
+/**
+ * Map one Events row (read through [EventExportProjection]) into an [IcsEvent]
+ * for backup. [reminderMinutes] are the row's raw provider reminder offsets and
+ * [calendarName] the display name of its calendar (emitted as
+ * `X-CALENDULA-CALENDAR`). Pure given a [ColumnReader] — JVM-tested with
+ * MapColumnReader.
+ */
+internal fun ColumnReader.toIcsEvent(
+    reminderMinutes: List<Int>,
+    calendarName: String?,
+): IcsEvent {
+    val eventId = getLong(EventExportProjection.IDX_ID)
+    val dtStart = getLong(EventExportProjection.IDX_DTSTART)
+    val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() }
+
+    // Recurring rows store DURATION instead of DTEND; reconstruct the end from it
+    // so the writer can render DTEND. A missing/blank both means a zero-length event.
+    val end = when {
+        !isNull(EventExportProjection.IDX_DTEND) -> getLong(EventExportProjection.IDX_DTEND)
+        else -> dtStart + parseRfc2445DurationMillis(getString(EventExportProjection.IDX_DURATION))
+    }
+
+    // STATUS shares value 0 with TENTATIVE, so an absent column must read as Confirmed.
+    val status = if (isNull(EventExportProjection.IDX_STATUS)) {
+        EventStatus.Confirmed
+    } else {
+        mapEventStatus(getInt(EventExportProjection.IDX_STATUS))
+    }
+
+    return IcsEvent(
+        uid = deriveIcsUid(getString(EventExportProjection.IDX_UID), eventId, dtStart),
+        summary = getString(EventExportProjection.IDX_TITLE).orEmpty(),
+        start = dtStart.toKotlinInstantFromEpochMillis(),
+        end = end.toKotlinInstantFromEpochMillis(),
+        isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0,
+        zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() }
+            ?: "UTC",
+        recurrenceRule = rrule,
+        location = getString(EventExportProjection.IDX_LOCATION),
+        description = getString(EventExportProjection.IDX_DESCRIPTION),
+        reminderMinutes = reminderMinutes,
+        status = status,
+        availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
+        calendarName = calendarName,
+    )
+}
+

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt

@@ -74,6 +74,7 @@ internal object EventDetailProjection {
         CalendarContract.Events.ACCESS_LEVEL,
         CalendarContract.Events.EVENT_TIMEZONE,
         CalendarContract.Events.SELF_ATTENDEE_STATUS,
+        CalendarContract.Events.EVENT_COLOR_KEY,
     )
 
     const val IDX_EVENT_ID = 0
@@ -93,6 +94,49 @@ internal object EventDetailProjection {
     const val IDX_ACCESS_LEVEL = 14
     const val IDX_EVENT_TIMEZONE = 15
     const val IDX_SELF_ATTENDEE_STATUS = 16
+    const val IDX_EVENT_COLOR_KEY = 17
+}
+
+/**
+ * Master/one-off Events rows for a whole-calendar backup. Unlike
+ * [EventDetailProjection] this reads `UID_2445` (to keep a row's identity across
+ * backups) and `DURATION` (recurring rows carry it instead of DTEND). Modified-
+ * occurrence and cancelled-exception rows are filtered out by the query
+ * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides and EXDATEs aren't
+ * exported yet — a documented v1 limit (import skips them too).
+ */
+internal object EventExportProjection {
+    val COLUMNS: Array<String> = arrayOf(
+        CalendarContract.Events._ID,
+        CalendarContract.Events.UID_2445,
+        CalendarContract.Events.TITLE,
+        CalendarContract.Events.DTSTART,
+        CalendarContract.Events.DTEND,
+        CalendarContract.Events.DURATION,
+        CalendarContract.Events.ALL_DAY,
+        CalendarContract.Events.EVENT_TIMEZONE,
+        CalendarContract.Events.RRULE,
+        CalendarContract.Events.EVENT_LOCATION,
+        CalendarContract.Events.DESCRIPTION,
+        CalendarContract.Events.STATUS,
+        CalendarContract.Events.AVAILABILITY,
+        CalendarContract.Events.CALENDAR_ID,
+    )
+
+    const val IDX_ID = 0
+    const val IDX_UID = 1
+    const val IDX_TITLE = 2
+    const val IDX_DTSTART = 3
+    const val IDX_DTEND = 4
+    const val IDX_DURATION = 5
+    const val IDX_ALL_DAY = 6
+    const val IDX_EVENT_TIMEZONE = 7
+    const val IDX_RRULE = 8
+    const val IDX_LOCATION = 9
+    const val IDX_DESCRIPTION = 10
+    const val IDX_STATUS = 11
+    const val IDX_AVAILABILITY = 12
+    const val IDX_CALENDAR_ID = 13
 }
 
 internal object AttendeeProjection {

app/src/main/java/de/jeanlucmakiola/calendula/data/crash/CrashReporter.kt

@@ -0,0 +1,188 @@
+package de.jeanlucmakiola.calendula.data.crash
+
+import android.content.Context
+import android.content.pm.PackageInfo
+import android.os.Build
+import androidx.core.content.pm.PackageInfoCompat
+import java.io.File
+import java.io.PrintWriter
+import java.io.StringWriter
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * Privacy-respecting crash capture (prod-readiness item 10). On an uncaught
+ * exception it writes a self-contained report to the app's private storage and
+ * then chains to the platform's default handler, so the process still dies
+ * normally (and the OS shows its own "stopped" dialog). Nothing is uploaded —
+ * the app holds no `INTERNET` permission. The user submits the report later,
+ * by hand, as a Gitea issue (see the ui/crash surfaces).
+ *
+ * The report is built from a fixed [CrashContext] allowlist — app/Android/device
+ * version, locale, time, and the stack trace — and **nothing else**: no device
+ * identifiers, no account names, no calendar/event content, no logcat. The user
+ * is always shown the full text before it leaves the device.
+ */
+object CrashReporter {
+
+    /**
+     * Install the handler. Called first thing in `CalendulaApp.onCreate()` so it
+     * also catches crashes during startup. The handler swallows nothing — it
+     * persists, then delegates to the previously-registered handler.
+     */
+    fun install(context: Context) {
+        val appContext = context.applicationContext
+        val previous = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            // Capturing must never mask the original crash, so guard every step.
+            runCatching {
+                val now = System.currentTimeMillis()
+                writeReport(appContext, buildCrashReport(CrashContext.from(appContext), throwable, now))
+                recordCrashTime(appContext, now)
+            }
+            previous?.uncaughtException(thread, throwable)
+        }
+    }
+
+    /** The persisted report from the last crash, or null if there is none. */
+    fun pendingReport(context: Context): String? {
+        val file = reportFile(context)
+        return if (file.exists()) runCatching { file.readText() }.getOrNull()?.takeIf { it.isNotBlank() } else null
+    }
+
+    /**
+     * Whether to surface the report unprompted (on the next launch): a report
+     * exists and the user hasn't already waved this one away. Settings reaches
+     * the report via [pendingReport] regardless, so "Not now" only stops the
+     * auto-prompt — it doesn't discard the report.
+     */
+    fun shouldPrompt(context: Context): Boolean =
+        reportFile(context).exists() && !dismissedFile(context).exists()
+
+    /** Stop auto-prompting for the current report without discarding it. */
+    fun dismissPrompt(context: Context) {
+        runCatching { dismissedFile(context).apply { parentFile?.mkdirs() }.writeText("") }
+    }
+
+    /** Drop the persisted report once the user has reported it (or from Settings). */
+    fun clearReport(context: Context) {
+        runCatching { reportFile(context).delete() }
+        runCatching { dismissedFile(context).delete() }
+    }
+
+    /**
+     * Whether the app appears to be in a startup crash-loop: at least
+     * [LOOP_THRESHOLD] crashes inside [LOOP_WINDOW_MS]. In that case the main UI
+     * can't be trusted to start, so the caller routes straight to the standalone
+     * report screen instead of re-entering the crashing graph.
+     */
+    fun isCrashLoop(context: Context): Boolean {
+        val times = readCrashTimes(context)
+        if (times.size < LOOP_THRESHOLD) return false
+        val recent = times.sortedDescending()
+        return recent[0] - recent[LOOP_THRESHOLD - 1] <= LOOP_WINDOW_MS
+    }
+
+    /**
+     * Mark the app as having started successfully, resetting the loop counter so
+     * an ordinary single crash much later never trips loop detection. The
+     * pending report itself is kept — only the timing trail is cleared.
+     */
+    fun markHealthy(context: Context) {
+        runCatching { timesFile(context).delete() }
+    }
+
+    // --- persistence -------------------------------------------------------
+
+    private fun writeReport(context: Context, report: String) {
+        val file = reportFile(context).apply { parentFile?.mkdirs() }
+        file.writeText(report.take(MAX_REPORT_CHARS))
+        // A fresh crash should prompt again, even if the previous one was waved away.
+        runCatching { dismissedFile(context).delete() }
+    }
+
+    private fun recordCrashTime(context: Context, nowMillis: Long) {
+        val kept = (readCrashTimes(context) + nowMillis).takeLast(MAX_TIMES)
+        timesFile(context).apply { parentFile?.mkdirs() }
+            .writeText(kept.joinToString("\n"))
+    }
+
+    private fun readCrashTimes(context: Context): List<Long> {
+        val file = timesFile(context)
+        if (!file.exists()) return emptyList()
+        return runCatching { file.readLines().mapNotNull { it.trim().toLongOrNull() } }.getOrDefault(emptyList())
+    }
+
+    private fun crashDir(context: Context) = File(context.filesDir, CRASH_DIR)
+    private fun reportFile(context: Context) = File(crashDir(context), REPORT_FILE)
+    private fun timesFile(context: Context) = File(crashDir(context), TIMES_FILE)
+    private fun dismissedFile(context: Context) = File(crashDir(context), DISMISSED_FILE)
+
+    private const val CRASH_DIR = "crash"
+    private const val REPORT_FILE = "last_crash.txt"
+    private const val TIMES_FILE = "crash_times.txt"
+    private const val DISMISSED_FILE = "dismissed"
+    private const val MAX_TIMES = 5
+    private const val MAX_REPORT_CHARS = 64 * 1024
+    private const val LOOP_THRESHOLD = 2
+    private const val LOOP_WINDOW_MS = 10_000L
+}
+
+/**
+ * The allowlist of non-personal facts that go into a crash report. Built from
+ * [Build] and the app's own [PackageInfo]; deliberately holds no identifiers.
+ */
+data class CrashContext(
+    val appVersionName: String,
+    val appVersionCode: Long,
+    val sdkInt: Int,
+    val androidRelease: String,
+    val manufacturer: String,
+    val model: String,
+    val locale: String,
+) {
+    companion object {
+        fun from(context: Context): CrashContext {
+            val pkg = runCatching {
+                context.packageManager.getPackageInfo(context.packageName, 0)
+            }.getOrNull()
+            return CrashContext(
+                appVersionName = pkg?.versionName ?: "?",
+                appVersionCode = pkg?.let { PackageInfoCompat.getLongVersionCode(it) } ?: 0L,
+                sdkInt = Build.VERSION.SDK_INT,
+                androidRelease = Build.VERSION.RELEASE ?: "?",
+                manufacturer = Build.MANUFACTURER ?: "?",
+                model = Build.MODEL ?: "?",
+                locale = Locale.getDefault().toLanguageTag(),
+            )
+        }
+    }
+}
+
+/**
+ * Render a crash report from the [ctx] allowlist, the [throwable]'s full stack
+ * trace, and the crash [nowMillis]. Pure (no Android, no I/O) so it is unit
+ * tested. The leading marker doubles as the file's sanity check in
+ * [CrashReporter.pendingReport].
+ */
+fun buildCrashReport(ctx: CrashContext, throwable: Throwable, nowMillis: Long): String {
+    val trace = StringWriter().also { throwable.printStackTrace(PrintWriter(it)) }.toString().trim()
+    val time = runCatching {
+        Instant.ofEpochMilli(nowMillis).atZone(ZoneId.systemDefault()).format(TIME_FORMAT)
+    }.getOrDefault(nowMillis.toString())
+    return buildString {
+        appendLine("Calendula crash report")
+        appendLine("App version: ${ctx.appVersionName} (${ctx.appVersionCode})")
+        appendLine("Android: ${ctx.androidRelease} (API ${ctx.sdkInt})")
+        appendLine("Device: ${ctx.manufacturer} ${ctx.model}")
+        appendLine("Locale: ${ctx.locale}")
+        appendLine("Time: $time")
+        appendLine()
+        appendLine("Stack trace:")
+        append(trace)
+    }
+}
+
+private val TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")

app/src/main/java/de/jeanlucmakiola/calendula/data/ics/IcsExporter.kt

@@ -0,0 +1,46 @@
+package de.jeanlucmakiola.calendula.data.ics
+
+import android.content.Context
+import android.net.Uri
+import androidx.core.content.FileProvider
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.io.File
+import java.io.IOException
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * The Android IO edge of `.ics` export: writes a serialised calendar to a
+ * SAF document (whole-calendar backup) or stages it in a cache file behind a
+ * `FileProvider` content Uri (single-event share). The serialisation itself is
+ * the pure `domain.ics.IcsWriter`; this class only moves bytes.
+ */
+@Singleton
+class IcsExporter @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+
+    /** Write [content] to the SAF document at [uri] as UTF-8. Throws on failure. */
+    fun writeDocument(uri: Uri, content: String) {
+        context.contentResolver.openOutputStream(uri)?.use { out ->
+            out.write(content.toByteArray(Charsets.UTF_8))
+            // Only the scheme — the full Uri can embed the user's chosen filename.
+        } ?: throw IOException("Could not open output stream for export (scheme=${uri.scheme})")
+    }
+
+    /**
+     * Stage [content] in a private cache file and return a shareable content
+     * Uri for an `ACTION_SEND`. [fileName] is the suggested `.ics` name shown to
+     * the receiving app. The authority mirrors the manifest's `FileProvider`.
+     */
+    fun stageShareFile(fileName: String, content: String): Uri {
+        val dir = File(context.cacheDir, SHARE_DIR).apply { mkdirs() }
+        val file = File(dir, fileName)
+        file.writeText(content, Charsets.UTF_8)
+        return FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
+    }
+
+    private companion object {
+        const val SHARE_DIR = "shared_ics"
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/data/ics/IcsImporter.kt

@@ -0,0 +1,21 @@
+package de.jeanlucmakiola.calendula.data.ics
+
+import android.content.Context
+import android.net.Uri
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Android IO edge of `.ics` import: reads the text of a received/opened
+ * document [Uri]. Parsing is the pure `domain.ics.IcsParser`; this class only
+ * pulls bytes off the ContentResolver. Returns null on any read failure.
+ */
+@Singleton
+class IcsImporter @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    fun readText(uri: Uri): String? = runCatching {
+        context.contentResolver.openInputStream(uri)?.use { it.readBytes().toString(Charsets.UTF_8) }
+    }.getOrNull()
+}

app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt

@@ -4,6 +4,7 @@ import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import kotlinx.coroutines.flow.Flow
@@ -99,6 +100,22 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[REMINDERS_ENABLED_KEY] = enabled }
     }
 
+    /**
+     * Whether to offer a custom event colour even on calendars that publish no
+     * colour palette (most local calendars handle it fine; synced calendars
+     * without a palette — some CalDAV — may drop or overwrite a raw colour on
+     * their next sync). Defaults to OFF: such calendars hide the colour picker
+     * until the user opts in, accepting the limitation. Local calendars and
+     * palette-backed calendars (Google, …) are unaffected by this flag.
+     */
+    val allowColorOnUnsupportedCalendars: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ALLOW_COLOR_UNSUPPORTED_KEY] ?: false
+    }
+
+    suspend fun setAllowColorOnUnsupportedCalendars(enabled: Boolean) {
+        store.edit { it[ALLOW_COLOR_UNSUPPORTED_KEY] = enabled }
+    }
+
     /**
      * Whether the one-time reminder onboarding step (after the calendar
      * grant) has been shown — also true for users who tapped "not now".
@@ -111,6 +128,97 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[REMINDER_ONBOARDING_KEY] = true }
     }
 
+    /**
+     * The default reminder lead time (minutes before start) prefilled on new
+     * **timed** events. `null` = no default reminder — the prior behaviour, kept
+     * as the factory default so existing users aren't surprised by reminders they
+     * never asked for. Stored as a string so "none" is distinct from a numeric
+     * value (and from an unset key, which is also "none"). Per-calendar overrides
+     * in [perCalendarReminderOverride] take precedence; all-day events instead use
+     * [defaultAllDayReminderMinutes]. Resolve with [resolveDefaultReminder].
+     */
+    val defaultReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+        prefs[DEFAULT_REMINDER_KEY].toReminderMinutes()
+    }
+
+    suspend fun setDefaultReminderMinutes(minutes: Int?) {
+        store.edit { it[DEFAULT_REMINDER_KEY] = minutes?.toString() ?: NONE }
+    }
+
+    /**
+     * The default reminder lead time prefilled on new **all-day** events, in
+     * minutes before the start of the day. All-day events want day-scale lead
+     * times ("1 day before"), so they have their own default rather than reusing
+     * the timed one. `null` = no default. Per-calendar overrides do **not** apply
+     * to all-day events — they always use this global value.
+     */
+    val defaultAllDayReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+        prefs[DEFAULT_ALLDAY_REMINDER_KEY].toReminderMinutes()
+    }
+
+    suspend fun setDefaultAllDayReminderMinutes(minutes: Int?) {
+        store.edit { it[DEFAULT_ALLDAY_REMINDER_KEY] = minutes?.toString() ?: NONE }
+    }
+
+    /**
+     * Wall-clock time, as minutes from local midnight, at which **all-day**
+     * reminders fire. All-day events live at UTC midnight, so a raw "1 day
+     * before" would fire at an off hour (02:00 local in CEST); this time is
+     * encoded into the provider offset so the reminder lands at, e.g., 09:00 the
+     * day before instead. Global for every all-day reminder; default 09:00.
+     * Stored/clamped to a valid 0..1439 minute-of-day.
+     */
+    val allDayReminderTimeMinutes: Flow<Int> = store.data.map { prefs ->
+        (prefs[ALLDAY_REMINDER_TIME_KEY] ?: DEFAULT_ALLDAY_REMINDER_TIME)
+            .coerceIn(0, MINUTES_PER_DAY - 1)
+    }
+
+    suspend fun setAllDayReminderTimeMinutes(minutesOfDay: Int) {
+        store.edit { it[ALLDAY_REMINDER_TIME_KEY] = minutesOfDay.coerceIn(0, MINUTES_PER_DAY - 1) }
+    }
+
+    /**
+     * Per-calendar overrides of [defaultReminderMinutes] for **timed** events,
+     * keyed by calendar id. A calendar **present** in the map overrides the global
+     * timed default for its new events: a `null` value means "no reminder", an int
+     * means that lead time. A calendar **absent** from the map inherits the global
+     * default. Serialised as `id=value;id=value`, with `none` for an explicit
+     * no-reminder override. (All-day events ignore this and use
+     * [defaultAllDayReminderMinutes].)
+     */
+    val perCalendarReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
+        parseReminderOverrides(prefs[CALENDAR_REMINDER_OVERRIDE_KEY])
+    }
+
+    suspend fun setCalendarReminderOverride(calendarId: Long, override: CalendarReminderOverride) {
+        store.edit { prefs ->
+            val current = parseReminderOverrides(prefs[CALENDAR_REMINDER_OVERRIDE_KEY]).toMutableMap()
+            current.applyOverride(calendarId, override)
+            prefs[CALENDAR_REMINDER_OVERRIDE_KEY] = serializeReminderOverrides(current)
+        }
+    }
+
+    /**
+     * Per-calendar overrides of [defaultAllDayReminderMinutes] for **all-day**
+     * events, with the same semantics as [perCalendarReminderOverride] (absent =
+     * inherit the global all-day default; present null = no reminder).
+     */
+    val perCalendarAllDayReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
+        parseReminderOverrides(prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY])
+    }
+
+    suspend fun setCalendarAllDayReminderOverride(
+        calendarId: Long,
+        override: CalendarReminderOverride,
+    ) {
+        store.edit { prefs ->
+            val current =
+                parseReminderOverrides(prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY]).toMutableMap()
+            current.applyOverride(calendarId, override)
+            prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY] = serializeReminderOverrides(current)
+        }
+    }
+
     private fun parseFormFields(stored: String?): Set<EventFormField> = when (stored) {
         null -> DEFAULT_FORM_FIELDS
         else -> stored.split(',')
@@ -125,10 +233,92 @@ class SettingsPrefs @Inject constructor(
         internal val FORM_FIELDS_KEY = stringPreferencesKey("event_form_default_fields")
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
         internal val REMINDER_ONBOARDING_KEY = booleanPreferencesKey("reminder_onboarding_done")
+        internal val ALLOW_COLOR_UNSUPPORTED_KEY =
+            booleanPreferencesKey("allow_color_unsupported_calendars")
+        internal val DEFAULT_REMINDER_KEY = stringPreferencesKey("default_reminder_minutes")
+        internal val DEFAULT_ALLDAY_REMINDER_KEY =
+            stringPreferencesKey("default_allday_reminder_minutes")
+        internal val ALLDAY_REMINDER_TIME_KEY =
+            intPreferencesKey("allday_reminder_time_minutes")
+        /** 09:00 as minutes from midnight; the default all-day reminder fire time. */
+        internal const val DEFAULT_ALLDAY_REMINDER_TIME = 540
+        private const val MINUTES_PER_DAY = 1_440
+        internal val CALENDAR_REMINDER_OVERRIDE_KEY =
+            stringPreferencesKey("per_calendar_reminder_override")
+        internal val CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY =
+            stringPreferencesKey("per_calendar_allday_reminder_override")
         internal val DEFAULT_FORM_FIELDS =
             setOf(EventFormField.Location, EventFormField.Description)
     }
 }
 
+/** A calendar's reminder-default override (see [SettingsPrefs.perCalendarReminderOverride]). */
+sealed interface CalendarReminderOverride {
+    /** No override — the calendar uses the global default. */
+    data object Inherit : CalendarReminderOverride
+    /** Explicit "no reminder" for this calendar, regardless of the global default. */
+    data object None : CalendarReminderOverride
+    /** A specific lead time in minutes before the event start. */
+    data class Minutes(val minutes: Int) : CalendarReminderOverride
+}
+
+/**
+ * The lead time to prefill on a new event: the matching per-calendar override
+ * if [calendarId] has one for this event kind, otherwise the global default for
+ * that kind. All-day events consult [allDayOverrides] / [allDayGlobal]; timed
+ * events consult [timedOverrides] / [timedGlobal]. `null` = no reminder. Pure so
+ * it can be unit-tested.
+ */
+fun resolveDefaultReminder(
+    timedGlobal: Int?,
+    allDayGlobal: Int?,
+    timedOverrides: Map<Long, Int?>,
+    allDayOverrides: Map<Long, Int?>,
+    calendarId: Long?,
+    isAllDay: Boolean,
+): Int? {
+    val overrides = if (isAllDay) allDayOverrides else timedOverrides
+    val global = if (isAllDay) allDayGlobal else timedGlobal
+    return if (calendarId != null && overrides.containsKey(calendarId)) {
+        overrides[calendarId]
+    } else {
+        global
+    }
+}
+
+/** Apply a [CalendarReminderOverride] to an override map ([Inherit] removes the key). */
+private fun MutableMap<Long, Int?>.applyOverride(
+    calendarId: Long,
+    override: CalendarReminderOverride,
+) {
+    when (override) {
+        CalendarReminderOverride.Inherit -> remove(calendarId)
+        CalendarReminderOverride.None -> put(calendarId, null)
+        is CalendarReminderOverride.Minutes -> put(calendarId, override.minutes)
+    }
+}
+
+private const val NONE = "none"
+private const val ENTRY_SEP = ";"
+private const val KEY_VALUE_SEP = "="
+
+private fun String?.toReminderMinutes(): Int? = when (this) {
+    null, "", NONE -> null
+    else -> toIntOrNull()
+}
+
+private fun parseReminderOverrides(stored: String?): Map<Long, Int?> {
+    if (stored.isNullOrBlank()) return emptyMap()
+    return stored.split(ENTRY_SEP).mapNotNull { entry ->
+        val parts = entry.split(KEY_VALUE_SEP).takeIf { it.size == 2 } ?: return@mapNotNull null
+        val id = parts[0].toLongOrNull() ?: return@mapNotNull null
+        val value = if (parts[1] == NONE) null else parts[1].toIntOrNull() ?: return@mapNotNull null
+        id to value
+    }.toMap()
+}
+
+private fun serializeReminderOverrides(map: Map<Long, Int?>): String =
+    map.entries.joinToString(ENTRY_SEP) { (id, minutes) -> "$id$KEY_VALUE_SEP${minutes ?: NONE}" }
+
 private inline fun <reified E : Enum<E>> String?.toEnum(default: E): E =
     this?.let { stored -> enumValues<E>().firstOrNull { it.name == stored } } ?: default

app/src/main/java/de/jeanlucmakiola/calendula/domain/EventForm.kt

@@ -30,6 +30,17 @@ data class EventForm(
      * those are kept verbatim until the user picks something else.
      */
     val rrule: String? = null,
+    /**
+     * The event's own colour, or null to inherit the calendar's colour.
+     * [colorKey] is a `Colors.COLOR_KEY` from the calendar account's published
+     * event palette (Google, some CalDAV) — written as `EVENT_COLOR_KEY` so it
+     * round-trips through sync. When it is null but [color] is set, [color] is
+     * a raw ARGB written as `EVENT_COLOR` (local calendars, or synced ones the
+     * user opted into despite no palette). [color] mirrors the key's swatch when
+     * [colorKey] is set, so the picker can highlight it.
+     */
+    val colorKey: String? = null,
+    val color: Int? = null,
 )
 
 /**
@@ -43,6 +54,7 @@ enum class EventFormField {
     Recurrence,
     Availability,
     Visibility,
+    Color,
 }
 
 enum class EventFormProblem {
@@ -91,6 +103,11 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
         availability = availability,
         accessLevel = accessLevel,
         rrule = rrule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
+        // The provider fills EVENT_COLOR from the key, so [color] is the
+        // swatch either way; a null colour means the event inherits its
+        // calendar's colour.
+        colorKey = eventColorKey,
+        color = eventColor,
     )
 }
 
@@ -130,6 +147,7 @@ fun EventForm.populatedFields(): Set<EventFormField> = buildSet {
     if (rrule != null) add(EventFormField.Recurrence)
     if (availability != Availability.Busy) add(EventFormField.Availability)
     if (accessLevel != AccessLevel.Default) add(EventFormField.Visibility)
+    if (colorKey != null || color != null) add(EventFormField.Color)
 }
 
 fun EventForm.problems(): Set<EventFormProblem> = buildSet {

app/src/main/java/de/jeanlucmakiola/calendula/domain/Models.kt

@@ -58,8 +58,25 @@ data class EventDetail(
     val eventTimezone: String? = null,
     /** This device user's own response (`Events.SELF_ATTENDEE_STATUS`). */
     val selfStatus: AttendeeStatus = AttendeeStatus.Unknown,
+    /**
+     * The event's own raw colour (`Events.EVENT_COLOR`), null when the event
+     * inherits its calendar's colour. Unlike [EventInstance.color] (which
+     * already folds in the calendar fallback for display) this stays null so
+     * the edit form can tell "has own colour" from "inherits".
+     */
+    val eventColor: Int? = null,
+    /** The event's `Events.EVENT_COLOR_KEY` (a calendar-palette key), or null. */
+    val eventColorKey: String? = null,
 )
 
+/**
+ * One selectable event colour published by a calendar's account
+ * (`CalendarContract.Colors`, `TYPE_EVENT`): [key] is the account-scoped
+ * `COLOR_KEY` written as `EVENT_COLOR_KEY` (so the colour survives sync),
+ * [argb] is the swatch it renders as.
+ */
+data class EventColorOption(val key: String, val argb: Int)
+
 data class Attendee(
     val name: String,
     val email: String?,

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/EventDetailIcs.kt

@@ -0,0 +1,29 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.EventDetail
+
+/**
+ * Build the [IcsEvent] for sharing a single event. We export the event the user
+ * is looking at as a **one-off** VEVENT (no RRULE): the detail screen shows one
+ * occurrence, so "share this event" should hand off exactly that instance, not
+ * a whole series anchored to a possibly-different DTSTART. Reminders are the
+ * already-decoded semantic lead times the detail screen holds.
+ */
+fun EventDetail.toShareIcsEvent(): IcsEvent {
+    val startMillis = instance.start.toEpochMilliseconds()
+    return IcsEvent(
+        uid = deriveIcsUid(existingUid = null, eventId = instance.eventId, dtStartMillis = startMillis),
+        summary = instance.title,
+        start = instance.start,
+        end = instance.end,
+        isAllDay = instance.isAllDay,
+        zoneId = eventTimezone?.takeIf { it.isNotBlank() } ?: "UTC",
+        recurrenceRule = null,
+        location = instance.location,
+        description = description,
+        reminderMinutes = reminders.map { it.minutes },
+        status = status,
+        availability = availability,
+        calendarName = null,
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsDuration.kt

@@ -0,0 +1,40 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+// Android's calendar provider (and Calendula's own writes) use the non-standard
+// single-unit forms P<n>S / P<n>D / P<n>W — seconds without the RFC-required
+// leading T. Matched first; anything else falls through to the general grammar.
+private val DURATION_SINGLE_UNIT = Regex("""([+-]?)P(\d+)([WDS])""")
+private val DURATION_GENERAL =
+    Regex("""([+-]?)P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?""")
+
+/**
+ * Milliseconds of a DURATION (`P1D`, `P3600S`, `PT1H30M`, `-PT15M`, `P1W`, …),
+ * sign-aware. Calendula writes `P<days>D` / `P<seconds>S`, but the parser also
+ * accepts the general RFC 5545 grammar so backup `DURATION` rows and foreign
+ * `VALARM` triggers round-trip. Unparseable input is treated as zero.
+ */
+fun parseRfc2445DurationMillis(duration: String?): Long {
+    if (duration.isNullOrBlank()) return 0L
+    val s = duration.trim()
+
+    DURATION_SINGLE_UNIT.matchEntire(s)?.let { m ->
+        val unitSeconds = when (m.groupValues[3]) {
+            "W" -> 7L * 24 * 60 * 60
+            "D" -> 24L * 60 * 60
+            else -> 1L // S
+        }
+        return m.signum() * m.groupValues[2].toLong() * unitSeconds * 1_000L
+    }
+
+    val m = DURATION_GENERAL.matchEntire(s) ?: return 0L
+    val weeks = m.groupValues[2].toLongOrNull() ?: 0L
+    val days = m.groupValues[3].toLongOrNull() ?: 0L
+    val hours = m.groupValues[4].toLongOrNull() ?: 0L
+    val minutes = m.groupValues[5].toLongOrNull() ?: 0L
+    val seconds = m.groupValues[6].toLongOrNull() ?: 0L
+    val totalSeconds = ((((weeks * 7 + days) * 24 + hours) * 60 + minutes) * 60 + seconds)
+    return m.signum() * totalSeconds * 1_000L
+}
+
+/** Sign carried by group 1 (`-` → -1, otherwise +1) of a duration match. */
+private fun MatchResult.signum(): Long = if (groupValues[1] == "-") -1L else 1L

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsEvent.kt

@@ -0,0 +1,43 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlin.time.Instant
+
+/**
+ * A single event ready to be serialised to a `VEVENT`, decoupled from the
+ * provider so [IcsWriter] stays pure-Kotlin and JVM-testable. [start]/[end] are
+ * absolute instants; [isAllDay] and [recurrenceRule] decide how they are
+ * rendered (see [IcsWriter]'s timezone rule).
+ */
+data class IcsEvent(
+    /** RFC 5545 UID — globally stable across exports (see [deriveIcsUid]). */
+    val uid: String,
+    val summary: String,
+    val start: Instant,
+    /** Exclusive end (for all-day: the next-day midnight, as the provider stores it). */
+    val end: Instant,
+    val isAllDay: Boolean,
+    /** IANA zone id (`Events.EVENT_TIMEZONE`); only used for recurring timed events. */
+    val zoneId: String,
+    /** Bare RRULE value (no `RRULE:` prefix), or null for a one-off event. */
+    val recurrenceRule: String? = null,
+    val location: String? = null,
+    val description: String? = null,
+    /** Reminder lead times in minutes before start (raw provider offsets). */
+    val reminderMinutes: List<Int> = emptyList(),
+    val status: EventStatus = EventStatus.Confirmed,
+    val availability: Availability = Availability.Busy,
+    /** Source calendar name, emitted as `X-CALENDULA-CALENDAR` so a combined backup can fan back out. */
+    val calendarName: String? = null,
+)
+
+/**
+ * The UID to export for a provider event. A row that already carries a UID
+ * (`Events.UID_2445`) keeps it; otherwise we synthesise a **stable** one from
+ * the event id and its DTSTART so the same legacy event yields the same UID
+ * across repeated backups — which keeps a later restore from duplicating it.
+ */
+fun deriveIcsUid(existingUid: String?, eventId: Long, dtStartMillis: Long): String =
+    existingUid?.trim()?.takeIf { it.isNotEmpty() }
+        ?: "$eventId-$dtStartMillis@calendula"

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt

@@ -0,0 +1,259 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.toInstant
+import kotlin.time.Instant
+
+/**
+ * A `VEVENT` parsed from an `.ics` file — the read-side mirror of [IcsEvent],
+ * but [uid] is nullable (an incoming event may carry none; the insert layer
+ * then assigns one). Times are absolute instants; [isAllDay]/[zoneId] mirror
+ * how the writer encoded them.
+ */
+data class ParsedIcsEvent(
+    val uid: String?,
+    val summary: String,
+    val start: Instant,
+    val end: Instant,
+    val isAllDay: Boolean,
+    val zoneId: String,
+    val recurrenceRule: String? = null,
+    val location: String? = null,
+    val description: String? = null,
+    val reminderMinutes: List<Int> = emptyList(),
+    val status: EventStatus = EventStatus.Confirmed,
+    val availability: Availability = Availability.Busy,
+    val calendarName: String? = null,
+)
+
+/** Things the parser dropped rather than failing — surfaced in the import report. */
+enum class IcsParseWarning {
+    /** A `RECURRENCE-ID` override occurrence (not modelled; only masters import). */
+    ModifiedOccurrenceSkipped,
+
+    /** A `VEVENT` with no parseable `DTSTART`. */
+    EventWithoutStartSkipped,
+
+    /** `ATTENDEE` rows were present; Calendula doesn't import attendees. */
+    AttendeesIgnored,
+
+    /** A `TZID` couldn't be resolved against the device tz database (used local zone). */
+    UnknownTimezone,
+}
+
+data class IcsParseResult(
+    val events: List<ParsedIcsEvent>,
+    val warnings: Set<IcsParseWarning>,
+)
+
+/** Outcome of a bulk `.ics` import into one calendar. */
+data class IcsImportSummary(val imported: Int, val skippedDuplicate: Int)
+
+/**
+ * Hand-rolled RFC 5545 reader, the inverse of [IcsWriter]. Pure and
+ * JVM-testable. Liberal-in/strict-out: unknown properties are ignored, a single
+ * malformed `VEVENT` is skipped (not fatal), and unsupported constructs
+ * (`RECURRENCE-ID`, attendees, unresolved `TZID`) are reported as [warnings]
+ * rather than silently dropped. `VTIMEZONE` blocks are skipped — a `TZID` is
+ * resolved against the OS tz database instead ([deviceZone] is the fallback).
+ */
+class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault()) {
+
+    fun parse(text: String): IcsParseResult {
+        val lines = unfoldLines(text)
+        val events = mutableListOf<ParsedIcsEvent>()
+        val warnings = mutableSetOf<IcsParseWarning>()
+        var calendarName: String? = null
+
+        var i = 0
+        while (i < lines.size) {
+            val line = parseContentLine(lines[i])
+            if (line == null) { i++; continue }
+            when {
+                line.isBegin("VEVENT") -> {
+                    val end = indexOfEnd(lines, i + 1, "VEVENT")
+                    parseVevent(lines.subList(i + 1, end), calendarName, warnings)
+                        ?.let(events::add)
+                    i = end + 1
+                }
+                line.isBegin("VTIMEZONE") -> {
+                    // Skipped wholesale; TZIDs resolve against the OS tz database.
+                    i = indexOfEnd(lines, i + 1, "VTIMEZONE") + 1
+                }
+                line.name == "X-WR-CALNAME" -> {
+                    calendarName = unescapeText(line.value).trim().ifEmpty { null }
+                    i++
+                }
+                else -> i++
+            }
+        }
+        return IcsParseResult(events, warnings)
+    }
+
+    private fun parseVevent(
+        body: List<String>,
+        fileCalendarName: String?,
+        warnings: MutableSet<IcsParseWarning>,
+    ): ParsedIcsEvent? {
+        var uid: String? = null
+        var summary = ""
+        var dtStart: IcsDateTime? = null
+        var dtEnd: IcsDateTime? = null
+        var duration: String? = null
+        var rrule: String? = null
+        var location: String? = null
+        var description: String? = null
+        var status = EventStatus.Confirmed
+        var availability = Availability.Busy
+        var calendarName = fileCalendarName
+        val reminders = mutableListOf<Int>()
+        var skipAsOverride = false
+
+        var i = 0
+        while (i < body.size) {
+            val line = parseContentLine(body[i])
+            if (line == null) { i++; continue }
+            when (line.name) {
+                "BEGIN" -> if (line.value.trim().equals("VALARM", true)) {
+                    val end = indexOfEnd(body, i + 1, "VALARM")
+                    parseAlarmMinutes(body.subList(i + 1, end))?.let(reminders::add)
+                    i = end + 1
+                    continue
+                }
+                "UID" -> uid = line.value.trim().ifEmpty { null }
+                "SUMMARY" -> summary = unescapeText(line.value)
+                "DTSTART" -> dtStart = parseIcsDateTime(line, warnings)
+                "DTEND" -> dtEnd = parseIcsDateTime(line, warnings)
+                "DURATION" -> duration = line.value.trim()
+                "RRULE" -> rrule = line.value.trim().ifEmpty { null }
+                "LOCATION" -> location = unescapeText(line.value).ifEmpty { null }
+                "DESCRIPTION" -> description = unescapeText(line.value).ifEmpty { null }
+                "STATUS" -> status = mapIcsStatus(line.value)
+                "TRANSP" -> availability =
+                    if (line.value.trim().equals("TRANSPARENT", true)) Availability.Free
+                    else Availability.Busy
+                "RECURRENCE-ID" -> skipAsOverride = true
+                "ATTENDEE" -> warnings.add(IcsParseWarning.AttendeesIgnored)
+                "X-CALENDULA-CALENDAR" ->
+                    calendarName = unescapeText(line.value).trim().ifEmpty { calendarName }
+            }
+            i++
+        }
+
+        if (skipAsOverride) {
+            warnings.add(IcsParseWarning.ModifiedOccurrenceSkipped)
+            return null
+        }
+        val start = dtStart ?: run {
+            warnings.add(IcsParseWarning.EventWithoutStartSkipped)
+            return null
+        }
+        val end = dtEnd
+            ?: duration?.let {
+                start.copy(
+                    instant = Instant.fromEpochMilliseconds(
+                        start.instant.toEpochMilliseconds() + parseRfc2445DurationMillis(it),
+                    ),
+                )
+            }
+            ?: start
+        return ParsedIcsEvent(
+            uid = uid,
+            summary = summary,
+            start = start.instant,
+            end = end.instant,
+            isAllDay = start.isAllDay,
+            zoneId = start.zoneId,
+            recurrenceRule = rrule,
+            location = location,
+            description = description,
+            reminderMinutes = reminders.distinct(),
+            status = status,
+            availability = availability,
+            calendarName = calendarName,
+        )
+    }
+
+    /** A VALARM's lead time in minutes before start, or null if not a usable relative trigger. */
+    private fun parseAlarmMinutes(body: List<String>): Int? {
+        val trigger = body.asSequence()
+            .mapNotNull { parseContentLine(it) }
+            .firstOrNull { it.name == "TRIGGER" }
+            ?: return null
+        // Absolute (DATE-TIME) triggers can't be expressed as a lead time.
+        if (trigger.params["VALUE"].equals("DATE-TIME", true)) return null
+        val millis = parseRfc2445DurationMillis(trigger.value)
+        // Negative = before start (the normal case) → positive lead minutes.
+        return (-millis / 60_000L).toInt().coerceAtLeast(0)
+    }
+
+    private fun parseIcsDateTime(line: IcsContentLine, warnings: MutableSet<IcsParseWarning>): IcsDateTime? {
+        val raw = line.value.trim()
+        val isDate = line.params["VALUE"].equals("DATE", true) ||
+            (raw.length == 8 && !raw.contains('T'))
+        if (isDate) {
+            val date = parseBasicDate(raw) ?: return null
+            return IcsDateTime(date.atStartOfDayIn(TimeZone.UTC), isAllDay = true, zoneId = "UTC")
+        }
+        val isUtc = raw.endsWith("Z")
+        val ldt = parseBasicDateTime(raw.removeSuffix("Z")) ?: return null
+        if (isUtc) return IcsDateTime(ldt.toInstant(TimeZone.UTC), isAllDay = false, zoneId = "UTC")
+
+        val tzid = line.params["TZID"]
+        val resolved = tzid?.let { id -> runCatching { TimeZone.of(id) }.getOrNull()?.let { id to it } }
+        if (tzid != null && resolved == null) warnings.add(IcsParseWarning.UnknownTimezone)
+        val (zoneId, zone) = resolved ?: (deviceZone.id to deviceZone)
+        return IcsDateTime(ldt.toInstant(zone), isAllDay = false, zoneId = zoneId)
+    }
+
+    private data class IcsDateTime(val instant: Instant, val isAllDay: Boolean, val zoneId: String)
+
+    private companion object {
+        fun IcsContentLine.isBegin(component: String) =
+            name == "BEGIN" && value.trim().equals(component, true)
+
+        /** Index of the matching `END:<component>` at/after [from], or list end. */
+        fun indexOfEnd(lines: List<String>, from: Int, component: String): Int {
+            var i = from
+            while (i < lines.size) {
+                val line = parseContentLine(lines[i])
+                if (line != null && line.name == "END" &&
+                    line.value.trim().equals(component, true)
+                ) {
+                    return i
+                }
+                i++
+            }
+            return lines.size
+        }
+
+        fun mapIcsStatus(value: String): EventStatus = when (value.trim().uppercase()) {
+            "TENTATIVE" -> EventStatus.Tentative
+            "CANCELLED" -> EventStatus.Cancelled
+            else -> EventStatus.Confirmed
+        }
+
+        fun parseBasicDate(s: String): LocalDate? = runCatching {
+            LocalDate(s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt())
+        }.getOrNull()
+
+        fun parseBasicDateTime(s: String): LocalDateTime? = runCatching {
+            val date = LocalDate(
+                s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt(),
+            )
+            // Format is YYYYMMDD 'T' HHMMSS; seconds optional.
+            val time = LocalTime(
+                s.substring(9, 11).toInt(),
+                s.substring(11, 13).toInt(),
+                if (s.length >= 15) s.substring(13, 15).toInt() else 0,
+            )
+            LocalDateTime(date, time)
+        }.getOrNull()
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsText.kt

@@ -0,0 +1,155 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+/**
+ * Low-level RFC 5545 text mechanics, kept separate from [IcsWriter] so the
+ * escaping and folding rules can be tested in isolation. Pure Kotlin — no
+ * Android, no time handling.
+ */
+
+/** iCalendar mandates CRLF line breaks, not the platform separator. */
+const val ICS_CRLF: String = "\r\n"
+
+/** RFC 5545 §3.1: content lines SHOULD be folded at 75 octets (excluding the break). */
+private const val MAX_OCTETS = 75
+
+/**
+ * Escape a TEXT value (SUMMARY, DESCRIPTION, LOCATION, …) per RFC 5545 §3.3.11:
+ * backslash, semicolon and comma are escaped, newlines become the literal `\n`.
+ * Backslash is handled first so it doesn't double-escape the others' markers.
+ */
+fun escapeText(value: String): String = buildString(value.length) {
+    for (ch in value) {
+        when (ch) {
+            '\\' -> append("\\\\")
+            ';' -> append("\\;")
+            ',' -> append("\\,")
+            '\n' -> append("\\n")
+            '\r' -> Unit // CR is dropped; a lone CRLF in source text folds to one \n
+            else -> append(ch)
+        }
+    }
+}
+
+/**
+ * Fold a single content line to ≤75 octets per physical line, inserting
+ * `CRLF + space` between segments (the space is part of the 75-octet budget of
+ * the continuation line, so its content caps at 74). Folding counts UTF-8
+ * octets, never splitting a multi-byte character across a boundary.
+ */
+fun foldLine(line: String): String {
+    if (line.toByteArray(Charsets.UTF_8).size <= MAX_OCTETS) return line
+    val out = StringBuilder()
+    var octetsThisLine = 0
+    var first = true
+    var i = 0
+    while (i < line.length) {
+        val cp = line.codePointAt(i)
+        val width = Character.charCount(cp)
+        val piece = line.substring(i, i + width)
+        val pieceOctets = piece.toByteArray(Charsets.UTF_8).size
+        // Continuation lines spend one octet on the leading space.
+        val budget = if (first) MAX_OCTETS else MAX_OCTETS - 1
+        if (octetsThisLine + pieceOctets > budget) {
+            out.append(ICS_CRLF).append(' ')
+            octetsThisLine = 0
+            first = false
+        }
+        out.append(piece)
+        octetsThisLine += pieceOctets
+        i += width
+    }
+    return out.toString()
+}
+
+/**
+ * Reverse of [escapeText]: turn `\n`/`\N` into newlines and unescape `\\`, `\;`,
+ * `\,`. A backslash before any other character is dropped, keeping the
+ * character (lenient — foreign files escape liberally).
+ */
+fun unescapeText(value: String): String = buildString(value.length) {
+    var i = 0
+    while (i < value.length) {
+        val c = value[i]
+        if (c == '\\' && i + 1 < value.length) {
+            when (val next = value[i + 1]) {
+                'n', 'N' -> append('\n')
+                else -> append(next) // \\, \;, \, and any other escaped char
+            }
+            i += 2
+        } else {
+            append(c)
+            i++
+        }
+    }
+}
+
+/**
+ * Reverse of [foldLine] across a whole document: split into physical lines on
+ * CRLF/LF/CR, then re-join any line that begins with a single space or tab onto
+ * the previous one (RFC 5545 unfolding). Returns the logical content lines.
+ */
+fun unfoldLines(text: String): List<String> {
+    val out = mutableListOf<String>()
+    for (physical in text.split("\r\n", "\n", "\r")) {
+        if (physical.isEmpty()) continue
+        val isContinuation = physical[0] == ' ' || physical[0] == '\t'
+        if (isContinuation && out.isNotEmpty()) {
+            out[out.lastIndex] = out.last() + physical.substring(1)
+        } else {
+            out.add(physical)
+        }
+    }
+    return out
+}
+
+/**
+ * One unfolded content line split into its property name, parameters and value:
+ * `SUMMARY;LANGUAGE=en:Lunch` → name `SUMMARY`, params `{LANGUAGE=en}`, value
+ * `Lunch`. The value is everything after the first colon that isn't inside a
+ * quoted parameter; param keys are upper-cased, quoted param values unquoted.
+ * Returns null for a line with no colon.
+ */
+data class IcsContentLine(val name: String, val params: Map<String, String>, val value: String)
+
+fun parseContentLine(line: String): IcsContentLine? {
+    var inQuote = false
+    var colon = -1
+    for (i in line.indices) {
+        when (line[i]) {
+            '"' -> inQuote = !inQuote
+            ':' -> if (!inQuote) { colon = i; break }
+        }
+    }
+    if (colon < 0) return null
+    val head = splitUnquoted(line.substring(0, colon), ';')
+    val name = head.firstOrNull()?.trim()?.uppercase().orEmpty()
+    if (name.isEmpty()) return null
+    val params = buildMap {
+        for (part in head.drop(1)) {
+            val eq = part.indexOf('=')
+            if (eq > 0) {
+                put(
+                    part.substring(0, eq).trim().uppercase(),
+                    part.substring(eq + 1).trim().removeSurrounding("\""),
+                )
+            }
+        }
+    }
+    return IcsContentLine(name, params, line.substring(colon + 1))
+}
+
+/** Split on [delimiter] except where it falls inside a double-quoted run. */
+private fun splitUnquoted(text: String, delimiter: Char): List<String> {
+    val parts = mutableListOf<String>()
+    val current = StringBuilder()
+    var inQuote = false
+    for (c in text) {
+        when {
+            c == '"' -> { inQuote = !inQuote; current.append(c) }
+            c == delimiter && !inQuote -> { parts.add(current.toString()); current.clear() }
+            else -> current.append(c)
+        }
+    }
+    parts.add(current.toString())
+    return parts
+}

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriter.kt

@@ -0,0 +1,124 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.number
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/** Default `PRODID` advertising the writer that produced the file. */
+const val ICS_PROD_ID: String = "-//Jean-Luc Makiola//Calendula//EN"
+
+/**
+ * Hand-rolled RFC 5545 serialiser for the subset Calendula models. No iCal
+ * library: we stay on `kotlinx-datetime` and own the output, exactly as
+ * `domain/Recurrence.kt` owns RRULE. Pure and JVM-testable — the caller
+ * supplies [dtStamp] (the export moment) so the writer never reads a clock.
+ *
+ * Timezone rule (see plan 05, decision 1):
+ *  - all-day      → `VALUE=DATE`, no zone;
+ *  - timed one-off → UTC instant with a `Z` suffix (an instant is an instant);
+ *  - timed recurring → `TZID`-labelled local wall time, so the series stays
+ *    anchored to wall-clock across DST. No `VTIMEZONE` block is emitted; import
+ *    resolves the `TZID` against the OS tz database.
+ */
+class IcsWriter(private val prodId: String = ICS_PROD_ID) {
+
+    fun writeCalendar(events: List<IcsEvent>, dtStamp: Instant): String {
+        val lines = buildList {
+            add("BEGIN:VCALENDAR")
+            add("VERSION:2.0")
+            add("PRODID:$prodId")
+            add("CALSCALE:GREGORIAN")
+            events.forEach { appendEvent(it, dtStamp) }
+            add("END:VCALENDAR")
+        }
+        return lines.joinToString(ICS_CRLF, postfix = ICS_CRLF) { foldLine(it) }
+    }
+
+    private fun MutableList<String>.appendEvent(event: IcsEvent, dtStamp: Instant) {
+        add("BEGIN:VEVENT")
+        add("UID:${event.uid}")
+        add("DTSTAMP:${utcStamp(dtStamp)}")
+        add("SUMMARY:${escapeText(event.summary)}")
+        appendTimes(event)
+        event.recurrenceRule?.takeIf { it.isNotBlank() }
+            ?.let { add("RRULE:${it.removePrefix("RRULE:")}") }
+        event.location?.takeIf { it.isNotBlank() }
+            ?.let { add("LOCATION:${escapeText(it)}") }
+        event.description?.takeIf { it.isNotBlank() }
+            ?.let { add("DESCRIPTION:${escapeText(it)}") }
+        add("STATUS:${statusValue(event.status)}")
+        add("TRANSP:${transpValue(event.availability)}")
+        event.calendarName?.takeIf { it.isNotBlank() }
+            ?.let { add("X-CALENDULA-CALENDAR:${escapeText(it)}") }
+        event.reminderMinutes.filter { it >= 0 }.distinct().forEach { minutes ->
+            appendAlarm(minutes, event.summary)
+        }
+        add("END:VEVENT")
+    }
+
+    private fun MutableList<String>.appendTimes(event: IcsEvent) = when {
+        event.isAllDay -> {
+            add("DTSTART;VALUE=DATE:${utcDate(event.start)}")
+            add("DTEND;VALUE=DATE:${utcDate(event.end)}")
+        }
+        // Recurring: anchor to wall-clock in the event's own zone.
+        event.recurrenceRule?.isNotBlank() == true -> {
+            val zone = runCatching { TimeZone.of(event.zoneId) }.getOrNull()
+            if (zone != null) {
+                add("DTSTART;TZID=${event.zoneId}:${localStamp(event.start, zone)}")
+                add("DTEND;TZID=${event.zoneId}:${localStamp(event.end, zone)}")
+            } else {
+                // Unknown zone id → fall back to plain UTC instants.
+                add("DTSTART:${utcStamp(event.start)}")
+                add("DTEND:${utcStamp(event.end)}")
+            }
+        }
+        else -> {
+            add("DTSTART:${utcStamp(event.start)}")
+            add("DTEND:${utcStamp(event.end)}")
+        }
+    }
+
+    private fun MutableList<String>.appendAlarm(minutes: Int, summary: String) {
+        add("BEGIN:VALARM")
+        add("ACTION:DISPLAY")
+        add("DESCRIPTION:${escapeText(summary.ifBlank { "Reminder" })}")
+        add("TRIGGER:${triggerValue(minutes)}")
+        add("END:VALARM")
+    }
+
+    private companion object {
+        fun statusValue(status: EventStatus): String = when (status) {
+            EventStatus.Confirmed -> "CONFIRMED"
+            EventStatus.Tentative -> "TENTATIVE"
+            EventStatus.Cancelled -> "CANCELLED"
+        }
+
+        // iCal TRANSP is binary; only an explicitly free event is TRANSPARENT.
+        fun transpValue(availability: Availability): String =
+            if (availability == Availability.Free) "TRANSPARENT" else "OPAQUE"
+
+        // A lead time of 0 fires at start (PT0M); anything positive is "before".
+        fun triggerValue(minutes: Int): String =
+            if (minutes <= 0) "PT0M" else "-PT${minutes}M"
+
+        fun utcStamp(instant: Instant): String =
+            basic(instant.toLocalDateTime(TimeZone.UTC)) + "Z"
+
+        fun localStamp(instant: Instant, zone: TimeZone): String =
+            basic(instant.toLocalDateTime(zone))
+
+        fun utcDate(instant: Instant): String {
+            val dt = instant.toLocalDateTime(TimeZone.UTC)
+            return "%04d%02d%02d".format(dt.year, dt.month.number, dt.day)
+        }
+
+        fun basic(dt: LocalDateTime): String = "%04d%02d%02dT%02d%02d%02d".format(
+            dt.year, dt.month.number, dt.day, dt.hour, dt.minute, dt.second,
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/ParsedIcsForm.kt

@@ -0,0 +1,38 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.EventForm
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+
+/**
+ * Prefill the create form from a single parsed `.ics` event (the "open one
+ * event" path). [calendarId] is left null so the form preselects the last-used
+ * calendar, exactly like a fresh create — the user confirms the target and
+ * reviews everything before saving. Mirrors `EventDetail.toEditForm`'s all-day
+ * handling (provider all-day times are UTC midnights with an exclusive end).
+ */
+fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
+    val (start, end) = if (isAllDay) {
+        val startDate = this.start.toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = this.end.toLocalDateTime(TimeZone.UTC).date
+        val endDate = maxOf(startDate, LocalDate.fromEpochDays(endExclusive.toEpochDays() - 1))
+        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
+    } else {
+        this.start.toLocalDateTime(zone) to this.end.toLocalDateTime(zone)
+    }
+    return EventForm(
+        calendarId = null,
+        title = summary,
+        isAllDay = isAllDay,
+        start = start,
+        end = end,
+        location = location.orEmpty(),
+        description = description.orEmpty(),
+        reminders = reminderMinutes.distinct().sorted(),
+        availability = availability,
+        rrule = recurrenceRule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt

@@ -15,17 +15,23 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaScreen
 import de.jeanlucmakiola.calendula.ui.calendars.CalendarsScreen
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.day.DayScreen
 import de.jeanlucmakiola.calendula.ui.detail.EventDetailScreen
 import de.jeanlucmakiola.calendula.ui.edit.EventEditScreen
+import de.jeanlucmakiola.calendula.ui.imports.ImportScreen
 import de.jeanlucmakiola.calendula.ui.month.MonthScreen
 import de.jeanlucmakiola.calendula.ui.settings.SettingsScreen
 import de.jeanlucmakiola.calendula.ui.week.WeekScreen
 import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
 
 /**
  * Holds the active top-level view (spec M1) and swaps between the calendar
@@ -42,6 +48,10 @@ fun CalendarHost(
     modifier: Modifier = Modifier,
     requestedDetailKey: LongArray? = null,
     onDetailKeyConsumed: () -> Unit = {},
+    widgetNavRequest: WidgetNavRequest? = null,
+    onWidgetNavConsumed: () -> Unit = {},
+    requestedImportUri: android.net.Uri? = null,
+    onImportConsumed: () -> Unit = {},
 ) {
     var view by rememberSaveable { mutableStateOf(CalendarView.Week) }
     val onSelectView: (CalendarView) -> Unit = { view = it }
@@ -115,6 +125,40 @@ fun CalendarHost(
     var editKey by rememberSaveable { mutableStateOf<LongArray?>(null) }
     var heldEditKey by remember { mutableStateOf<LongArray?>(null) }
 
+    // An opened/received .ics file. [ImportScreen] parses it and either opens
+    // the prefilled create form (one event → [importForm]) or its own bulk
+    // picker (many). A plain conditional overlay (no slide) — it's transient.
+    var importUri by remember { mutableStateOf<android.net.Uri?>(null) }
+    var importForm by remember { mutableStateOf<EventForm?>(null) }
+    LaunchedEffect(requestedImportUri) {
+        if (requestedImportUri != null) {
+            importUri = requestedImportUri
+            onImportConsumed()
+        }
+    }
+
+    // A home-screen widget launch asks to open a date (→ day view) or start a
+    // create. Handled once and cleared, mirroring [requestedDetailKey].
+    LaunchedEffect(widgetNavRequest) {
+        when (val req = widgetNavRequest) {
+            is WidgetNavRequest.OpenDate -> {
+                pendingDayIso = req.dateIso
+                view = CalendarView.Day
+                onWidgetNavConsumed()
+            }
+            is WidgetNavRequest.Create -> {
+                val iso = req.dateIso ?: Clock.System.now()
+                    .toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
+                heldCreateIso = iso
+                createDateIso = iso
+                heldCreateMinutes = null
+                createStartMinutes = null
+                onWidgetNavConsumed()
+            }
+            null -> {}
+        }
+    }
+
     val slideSpec = rememberCalendarSlideSpec()
 
     Box(modifier = modifier.fillMaxSize()) {
@@ -141,6 +185,13 @@ fun CalendarHost(
                 onOpenSettings = onOpenSettings,
                 onCreateEvent = onCreateEvent,
             )
+            CalendarView.Agenda -> AgendaScreen(
+                selectedView = view,
+                onSelectView = onSelectView,
+                onEventClick = onEventClick,
+                onOpenSettings = onOpenSettings,
+                onCreateEvent = onCreateEvent,
+            )
         }
 
         // Prefer the live key; fall back to the held one only while sliding out.
@@ -219,5 +270,26 @@ fun CalendarHost(
         ) {
             CalendarsScreen(onBack = { showCalendars = false })
         }
+
+        // Import flow for an opened/received .ics file. A single event routes
+        // into the create form (prefilled, for review); many open the picker.
+        importUri?.let { uri ->
+            ImportScreen(
+                uri = uri,
+                onClose = { importUri = null },
+                onOpenSingle = { form ->
+                    importUri = null
+                    importForm = form
+                },
+            )
+        }
+        importForm?.let { form ->
+            EventEditScreen(
+                initialDateIso = null,
+                initialForm = form,
+                onClose = { importForm = null },
+                onSaved = { importForm = null },
+            )
+        }
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/RootScreen.kt

@@ -25,6 +25,10 @@ fun RootScreen(
     modifier: Modifier = Modifier,
     requestedDetailKey: LongArray? = null,
     onDetailKeyConsumed: () -> Unit = {},
+    widgetNavRequest: WidgetNavRequest? = null,
+    onWidgetNavConsumed: () -> Unit = {},
+    requestedImportUri: android.net.Uri? = null,
+    onImportConsumed: () -> Unit = {},
 ) {
     val context = LocalContext.current
     var hasPermission by remember {
@@ -58,6 +62,10 @@ fun RootScreen(
                 modifier = modifier,
                 requestedDetailKey = requestedDetailKey,
                 onDetailKeyConsumed = onDetailKeyConsumed,
+                widgetNavRequest = widgetNavRequest,
+                onWidgetNavConsumed = onWidgetNavConsumed,
+                requestedImportUri = requestedImportUri,
+                onImportConsumed = onImportConsumed,
             )
             false -> ReminderOnboardingScreen(
                 onFinished = reminderOnboarding::finish,

app/src/main/java/de/jeanlucmakiola/calendula/ui/WidgetNavRequest.kt

@@ -0,0 +1,15 @@
+package de.jeanlucmakiola.calendula.ui
+
+/**
+ * A navigation a home-screen widget asked the app to perform when launched.
+ * Parsed from the launch intent in MainActivity and consumed once by
+ * [CalendarHost] (event taps reuse the existing reminder detail-key channel, so
+ * they are not modelled here).
+ */
+sealed interface WidgetNavRequest {
+    /** Open the day view anchored on [dateIso] (an ISO `yyyy-MM-dd` date). */
+    data class OpenDate(val dateIso: String) : WidgetNavRequest
+
+    /** Open the create-event form prefilled for [dateIso] (today when null). */
+    data class Create(val dateIso: String?) : WidgetNavRequest
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaScreen.kt

@@ -0,0 +1,344 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.EventAvailable
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material3.DrawerValue
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalNavigationDrawer
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TopAppBarScrollBehavior
+import androidx.compose.material3.rememberDrawerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
+import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.GroupedRow
+import de.jeanlucmakiola.calendula.ui.common.Position
+import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
+import de.jeanlucmakiola.calendula.ui.common.next
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.positionOf
+import kotlinx.coroutines.launch
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+import java.time.format.TextStyle as JavaTextStyle
+import java.util.Locale
+
+private val zone = TimeZone.currentSystemDefault()
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AgendaScreen(
+    selectedView: CalendarView,
+    onSelectView: (CalendarView) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
+    onOpenSettings: () -> Unit,
+    onCreateEvent: (LocalDate, Int?) -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: AgendaViewModel = hiltViewModel(),
+) {
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    val anchor by viewModel.anchor.collectAsStateWithLifecycle()
+
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+
+    val isOnToday = when (val s = state) {
+        is AgendaUiState.Success -> s.anchor == s.today
+        else -> true
+    }
+
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        drawerContent = {
+            CalendarDrawer(
+                currentView = selectedView,
+                currentDate = anchor,
+                onSelectView = { view ->
+                    onSelectView(view)
+                    scope.launch { drawerState.close() }
+                },
+                onJumpToDate = { target ->
+                    viewModel.goToDate(target)
+                    scope.launch { drawerState.close() }
+                },
+                onSettings = {
+                    onOpenSettings()
+                    scope.launch { drawerState.close() }
+                },
+            )
+        },
+    ) {
+        Scaffold(
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
+            topBar = {
+                AgendaTopBar(
+                    selectedView = selectedView,
+                    onCycleView = { onSelectView(selectedView.next()) },
+                    onOpenDrawer = { scope.launch { drawerState.open() } },
+                    scrollBehavior = scrollBehavior,
+                )
+            },
+            floatingActionButton = {
+                CalendarFabColumn(
+                    todayVisible = !isOnToday,
+                    todayText = stringResource(R.string.agenda_today_action),
+                    onToday = viewModel::goToToday,
+                    onCreate = { onCreateEvent(anchor, null) },
+                )
+            },
+        ) { innerPadding ->
+            AgendaContent(
+                state = state,
+                onRetry = viewModel::goToToday,
+                onEventClick = onEventClick,
+                modifier = Modifier
+                    .padding(innerPadding)
+                    .fillMaxSize(),
+            )
+        }
+    }
+}
+
+@Composable
+private fun AgendaContent(
+    state: AgendaUiState,
+    onRetry: () -> Unit,
+    onEventClick: (EventInstance) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    when (state) {
+        AgendaUiState.Loading -> Box(modifier)
+        is AgendaUiState.Failure -> Box(modifier) {
+            CalendarFailure(reason = state.reason, onRetry = onRetry)
+        }
+        is AgendaUiState.Success ->
+            if (state.days.isEmpty()) {
+                AgendaEmpty(modifier)
+            } else {
+                AgendaList(state = state, onEventClick = onEventClick, modifier = modifier)
+            }
+    }
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+private fun AgendaList(
+    state: AgendaUiState.Success,
+    onEventClick: (EventInstance) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    LazyColumn(
+        modifier = modifier,
+        // Bottom inset clears the FAB stack so the last row stays tappable.
+        contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
+    ) {
+        state.days.forEach { day ->
+            stickyHeader(key = "header-${day.date}") {
+                AgendaDayHeader(date = day.date, today = state.today)
+            }
+            itemsIndexed(
+                items = day.events,
+                key = { _, event -> event.instanceId },
+            ) { index, event ->
+                AgendaEventRow(
+                    event = event,
+                    position = positionOf(index, day.events.size),
+                    onClick = { onEventClick(event) },
+                )
+            }
+            item(key = "gap-${day.date}") { Spacer(Modifier.height(8.dp)) }
+        }
+    }
+}
+
+@Composable
+private fun AgendaDayHeader(date: LocalDate, today: LocalDate) {
+    Surface(
+        color = MaterialTheme.colorScheme.surface,
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Text(
+            text = agendaDayLabel(date, today),
+            style = MaterialTheme.typography.titleSmall,
+            color = if (date == today) {
+                MaterialTheme.colorScheme.primary
+            } else {
+                MaterialTheme.colorScheme.onSurfaceVariant
+            },
+            modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 16.dp, bottom = 8.dp),
+        )
+    }
+}
+
+@Composable
+private fun AgendaEventRow(
+    event: EventInstance,
+    position: Position,
+    onClick: () -> Unit,
+) {
+    val dark = isSystemInDarkTheme()
+    val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
+    GroupedRow(
+        title = title,
+        summary = agendaTimeSummary(event),
+        position = position,
+        minHeight = 64.dp,
+        leading = {
+            Box(
+                modifier = Modifier
+                    .size(width = 6.dp, height = 36.dp)
+                    .clip(RoundedCornerShape(3.dp))
+                    .background(pastelize(event.color, dark)),
+            )
+        },
+        onClick = onClick,
+    )
+}
+
+@Composable
+private fun AgendaEmpty(modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier.padding(32.dp),
+        verticalArrangement = Arrangement.Center,
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Icon(
+            imageVector = Icons.Filled.EventAvailable,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(48.dp),
+        )
+        Spacer(Modifier.height(16.dp))
+        Text(
+            text = stringResource(R.string.agenda_empty_title),
+            style = MaterialTheme.typography.titleMedium,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(4.dp))
+        Text(
+            text = stringResource(R.string.agenda_empty_subtitle),
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun AgendaTopBar(
+    selectedView: CalendarView,
+    onCycleView: () -> Unit,
+    onOpenDrawer: () -> Unit,
+    scrollBehavior: TopAppBarScrollBehavior,
+) {
+    TopAppBar(
+        title = {
+            Text(
+                text = stringResource(R.string.view_agenda),
+                style = MaterialTheme.typography.titleLarge,
+            )
+        },
+        navigationIcon = {
+            IconButton(onClick = onOpenDrawer) {
+                Icon(
+                    imageVector = Icons.Default.Menu,
+                    contentDescription = stringResource(R.string.month_open_menu),
+                )
+            }
+        },
+        actions = {
+            ViewSwitcherPill(
+                current = selectedView,
+                onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
+            )
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surfaceContainer,
+        ),
+        scrollBehavior = scrollBehavior,
+    )
+}
+
+/** "Today · Wed, 17. Jun 2026" — relative word for today/tomorrow, else the date. */
+@Composable
+private fun agendaDayLabel(date: LocalDate, today: LocalDate): String {
+    val relative = when (date) {
+        today -> stringResource(R.string.agenda_header_today)
+        today.plus(1, DateTimeUnit.DAY) -> stringResource(R.string.agenda_header_tomorrow)
+        else -> null
+    }
+    val formatted = formatAgendaDate(date)
+    return if (relative != null) "$relative · $formatted" else formatted
+}
+
+/** Time line under the title: "09:00 – 10:00 · Location", "All day", etc. */
+@Composable
+private fun agendaTimeSummary(event: EventInstance): String {
+    val time = if (event.isAllDay) {
+        stringResource(R.string.event_detail_all_day)
+    } else {
+        "${formatTime(event.start)} – ${formatTime(event.end)}"
+    }
+    val location = event.location?.takeIf { it.isNotBlank() }
+    return if (location != null) "$time · $location" else time
+}
+
+private fun formatTime(instant: Instant): String {
+    val t = instant.toLocalDateTime(zone).time
+    return "%02d:%02d".format(t.hour, t.minute)
+}
+
+private fun formatAgendaDate(date: LocalDate): String {
+    val locale = Locale.getDefault()
+    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
+    val weekday = java.dayOfWeek.getDisplayName(JavaTextStyle.SHORT, locale)
+    val monthName = java.month.getDisplayName(JavaTextStyle.SHORT, locale)
+    return "$weekday, ${date.day}. $monthName ${date.year}"
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaUiState.kt

@@ -0,0 +1,57 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+
+/** One calendar day with at least one event, for the agenda list. */
+data class AgendaDay(
+    val date: LocalDate,
+    /** Events on this day, all-day first then ascending by start time. */
+    val events: List<EventInstance>,
+)
+
+/**
+ * Group flat [instances] into forward-looking [AgendaDay]s (only days that
+ * actually carry events). An event that began before [anchor] (ongoing or
+ * multi-day) is clamped to the anchor day so it still surfaces on top. Within a
+ * day, all-day events sort first, then ascending by start time, then title.
+ *
+ * Shared by the Agenda screen and the agenda home-screen widget so both group
+ * and order identically.
+ */
+fun groupAgendaDays(
+    anchor: LocalDate,
+    instances: List<EventInstance>,
+    zone: TimeZone,
+): List<AgendaDay> =
+    instances
+        .groupBy { it.start.toLocalDateTime(zone).date.coerceAtLeast(anchor) }
+        .toSortedMap()
+        .map { (date, dayEvents) ->
+            AgendaDay(
+                date = date,
+                events = dayEvents.sortedWith(
+                    compareByDescending<EventInstance> { it.isAllDay }
+                        .thenBy { it.start }
+                        .thenBy { it.title },
+                ),
+            )
+        }
+
+/**
+ * State for the Agenda view: a flat, forward-looking list of upcoming events
+ * grouped by day (only days that actually have events appear).
+ */
+sealed interface AgendaUiState {
+    data object Loading : AgendaUiState
+    data class Failure(val reason: FailureReason) : AgendaUiState
+    data class Success(
+        /** First day of the loaded window (today, or a jumped-to date). */
+        val anchor: LocalDate,
+        val today: LocalDate,
+        val days: List<AgendaDay>,
+    ) : AgendaUiState
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaViewModel.kt

@@ -0,0 +1,96 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+import kotlin.time.Instant
+import javax.inject.Inject
+
+/** How far ahead the agenda loads events from its anchor day. */
+internal const val AGENDA_WINDOW_DAYS = 60
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+class AgendaViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val zone = TimeZone.currentSystemDefault()
+
+    private val todayDate: LocalDate
+        get() = Clock.System.now().toLocalDateTime(zone).date
+
+    private val _anchor = MutableStateFlow(todayDate)
+    val anchor: StateFlow<LocalDate> = _anchor
+
+    val state: StateFlow<AgendaUiState> = _anchor
+        .flatMapLatest { anchor ->
+            val range = agendaRange(anchor, AGENDA_WINDOW_DAYS, zone)
+            combine(
+                repository.calendars(),
+                repository.instances(range),
+            ) { calendars, instances ->
+                buildState(anchor, calendars, instances)
+            }
+        }
+        .catch { emit(AgendaUiState.Failure(FailureReason.ProviderUnavailable)) }
+        .flowOn(io)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = AgendaUiState.Loading,
+        )
+
+    fun goToToday() {
+        _anchor.value = todayDate
+    }
+
+    /** Jump the agenda window to start on a specific date (drawer jump-to-date). */
+    fun goToDate(date: LocalDate) {
+        _anchor.value = date
+    }
+
+    private fun buildState(
+        anchor: LocalDate,
+        calendars: List<CalendarSource>,
+        instances: List<EventInstance>,
+    ): AgendaUiState {
+        if (calendars.isEmpty()) {
+            return AgendaUiState.Failure(FailureReason.NoCalendarsConfigured)
+        }
+        val days = groupAgendaDays(anchor, instances, zone)
+        return AgendaUiState.Success(anchor = anchor, today = todayDate, days = days)
+    }
+}
+
+/** Inclusive instant range from the start of [anchor] through [days] days ahead. */
+internal fun agendaRange(anchor: LocalDate, days: Int, zone: TimeZone): ClosedRange<Instant> {
+    val from = anchor.atStartOfDayIn(zone)
+    val to = anchor.plus(days, DateTimeUnit.DAY).atTime(23, 59, 59).toInstant(zone)
+    return from..to
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt

@@ -5,15 +5,13 @@ import android.content.Context
 import android.content.Intent
 import android.provider.Settings
 import androidx.activity.compose.BackHandler
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
@@ -31,17 +29,15 @@ import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.automirrored.filled.Notes
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.CalendarMonth
-import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.filled.FileDownload
 import androidx.compose.material.icons.filled.OpenInNew
 import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.FilledTonalButton
-import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -70,14 +66,21 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.ui.common.CALENDAR_COLOR_PALETTE
+import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.CollapsingScaffold
+import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
+import de.jeanlucmakiola.calendula.ui.common.GroupedRow
 import de.jeanlucmakiola.calendula.ui.common.InlineTextField
+import de.jeanlucmakiola.calendula.ui.common.Position
 import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.positionOf
+import java.time.LocalDate
 
 /** Sentinel [editorId] meaning "the editor is composing a new calendar". */
 private const val NEW_CALENDAR_ID = Long.MIN_VALUE
@@ -96,6 +99,7 @@ fun CalendarsScreen(
 ) {
     val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val error by viewModel.error.collectAsStateWithLifecycle()
+    val backupResult by viewModel.backupResult.collectAsStateWithLifecycle()
 
     // null = list; NEW_CALENDAR_ID = create; any other id = edit that calendar.
     // [editorSession] bumps on every open so the editor's field state resets for
@@ -132,6 +136,9 @@ fun CalendarsScreen(
             synced = calendars.filterNot { it.isLocal },
             error = error,
             onConsumeError = viewModel::consumeError,
+            backupResult = backupResult,
+            onExportBackup = viewModel::exportBackup,
+            onConsumeBackupResult = viewModel::consumeBackupResult,
             onBack = onBack,
             onAdd = { editorSession++; editorId = NEW_CALENDAR_ID },
             onEdit = { calendar -> editorSession++; editorId = calendar.id },
@@ -139,22 +146,23 @@ fun CalendarsScreen(
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 private fun CalendarsList(
     local: List<CalendarSource>,
     synced: List<CalendarSource>,
     error: Boolean,
     onConsumeError: () -> Unit,
+    backupResult: BackupResult?,
+    onExportBackup: (android.net.Uri) -> Unit,
+    onConsumeBackupResult: () -> Unit,
     onBack: () -> Unit,
     onAdd: () -> Unit,
     onEdit: (CalendarSource) -> Unit,
 ) {
+    val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
     val writeErrorText = stringResource(R.string.calendars_write_error)
-    val dark = isSystemInDarkTheme()
 
-    BackHandler(onBack = onBack)
     LaunchedEffect(error) {
         if (error) {
             snackbarHostState.showSnackbar(writeErrorText)
@@ -162,42 +170,49 @@ private fun CalendarsList(
         }
     }
 
-    Scaffold(
-        modifier = Modifier
-            .fillMaxSize()
-            .background(MaterialTheme.colorScheme.surface),
-        topBar = {
-            TopAppBar(
-                title = { Text(stringResource(R.string.calendars_title)) },
-                navigationIcon = {
-                    IconButton(onClick = onBack) {
-                        Icon(
-                            Icons.AutoMirrored.Filled.ArrowBack,
-                            contentDescription = stringResource(R.string.settings_back),
+    // SAF "create document" target for the backup file. The picked Uri is handed
+    // to the VM to stream the .ics into.
+    val createBackup = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.CreateDocument("text/calendar"),
+    ) { uri -> uri?.let(onExportBackup) }
+
+    val backupFailedText = stringResource(R.string.calendars_backup_failed)
+    LaunchedEffect(backupResult) {
+        when (val r = backupResult) {
+            is BackupResult.Success -> {
+                snackbarHostState.showSnackbar(
+                    context.resources.getQuantityString(
+                        R.plurals.calendars_backup_done, r.eventCount, r.eventCount,
+                    ),
                 )
+                onConsumeBackupResult()
             }
-                },
-            )
-        },
+            BackupResult.Failure -> {
+                snackbarHostState.showSnackbar(backupFailedText)
+                onConsumeBackupResult()
+            }
+            null -> Unit
+        }
+    }
+
+    CollapsingScaffold(
+        title = stringResource(R.string.calendars_title),
+        onBack = onBack,
         snackbarHost = { SnackbarHost(snackbarHostState) },
-    ) { innerPadding ->
-        Column(
-            modifier = Modifier
-                .padding(innerPadding)
-                .fillMaxSize()
-                .verticalScroll(rememberScrollState()),
     ) {
+        // Local (device-only) calendars — the calendars the app owns. The
+        // "Add calendar" entry closes the group as its final row.
         SectionHeader(stringResource(R.string.calendars_local_header))
         if (local.isEmpty()) {
             HintText(stringResource(R.string.calendars_local_empty))
-            } else {
-                local.forEach { calendar ->
-                    CalendarRow(
-                        name = calendar.displayName,
-                        color = calendar.color,
-                        dark = dark,
-                        subtitle = calendar.description,
-                        onClick = { onEdit(calendar) },
+        }
+        val localCount = local.size + 1
+        local.forEachIndexed { index, calendar ->
+            GroupedRow(
+                title = calendar.displayName,
+                summary = calendar.description,
+                position = positionOf(index, localCount),
+                leading = { CalendarColorChip(calendar.color) },
                 trailing = {
                     Icon(
                         Icons.Default.Edit,
@@ -206,35 +221,59 @@ private fun CalendarsList(
                         modifier = Modifier.size(20.dp),
                     )
                 },
+                onClick = { onEdit(calendar) },
             )
         }
-            }
-            FilledTonalButton(
+        GroupedRow(
+            title = stringResource(R.string.calendars_add),
+            position = positionOf(local.size, localCount),
+            leading = { AddAvatar() },
             onClick = onAdd,
-                modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
-            ) {
-                Icon(Icons.Default.Add, contentDescription = null, modifier = Modifier.size(18.dp))
-                Spacer(Modifier.width(8.dp))
-                Text(stringResource(R.string.calendars_add))
+        )
+
+        // Backup — local calendars have no sync, so a .ics export is their only
+        // safety net. Offered only when there is something to back up.
+        if (local.isNotEmpty()) {
+            Spacer(Modifier.height(16.dp))
+            SectionHeader(stringResource(R.string.calendars_backup_header))
+            HintText(stringResource(R.string.calendars_backup_hint))
+            GroupedRow(
+                title = stringResource(R.string.calendars_backup_action),
+                position = Position.Alone,
+                leading = { LeadingAvatar(Icons.Default.FileDownload) },
+                onClick = {
+                    runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
+                },
+            )
         }
 
-            HorizontalDivider(Modifier.padding(vertical = 8.dp))
+        Spacer(Modifier.height(16.dp))
 
+        // Synced calendars — read-only, grouped by account, each with a
+        // per-account "manage in source app" link.
         SectionHeader(stringResource(R.string.calendars_synced_header))
         HintText(stringResource(R.string.calendars_synced_hint))
         synced
             .groupBy { it.accountName.ifBlank { it.accountType } }
             .forEach { (account, cals) ->
-                    SyncedAccountGroup(
-                        account = account,
-                        accountType = cals.first().accountType,
-                        calendars = cals,
-                        dark = dark,
+                AccountHeader(account = account, accountType = cals.first().accountType)
+                cals.forEachIndexed { index, calendar ->
+                    GroupedRow(
+                        title = calendar.displayName,
+                        position = positionOf(index, cals.size),
+                        leading = { CalendarColorChip(calendar.color) },
                     )
                 }
-            AddAccountButton()
-            Spacer(Modifier.height(24.dp))
             }
+        Spacer(Modifier.height(8.dp))
+        GroupedRow(
+            title = stringResource(R.string.calendars_add_account),
+            position = Position.Alone,
+            leading = { AddAvatar() },
+            onClick = {
+                runCatching { context.startActivity(Intent(Settings.ACTION_ADD_ACCOUNT)) }
+            },
+        )
     }
 }
 
@@ -335,7 +374,12 @@ private fun CalendarEditor(
                     color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
                 Spacer(Modifier.height(12.dp))
-                ColorPalette(selected = color, onSelect = { color = it }, dark = dark)
+                ColorSwatchRow(
+                    colors = CALENDAR_COLOR_PALETTE,
+                    selected = color,
+                    onSelect = { color = it },
+                    dark = dark,
+                )
             }
             EditorCard(
                 icon = Icons.AutoMirrored.Filled.Notes,
@@ -412,54 +456,13 @@ private fun EditorCard(
     }
 }
 
-@OptIn(ExperimentalLayoutApi::class)
 @Composable
-private fun ColorPalette(selected: Int, onSelect: (Int) -> Unit, dark: Boolean) {
-    FlowRow(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
-        CALENDAR_COLOR_PALETTE.forEach { argb ->
-            val isSelected = argb == selected
-            // Show the pastel the calendar will actually render as, not the raw hue.
-            Box(
-                contentAlignment = Alignment.Center,
-                modifier = Modifier
-                    .padding(vertical = 4.dp)
-                    .size(40.dp)
-                    .clip(CircleShape)
-                    .background(pastelize(argb, dark))
-                    .then(
-                        if (isSelected) {
-                            Modifier.border(2.dp, MaterialTheme.colorScheme.onSurface, CircleShape)
-                        } else {
-                            Modifier
-                        },
-                    )
-                    .clickable { onSelect(argb) },
-            ) {
-                if (isSelected) {
-                    Icon(
-                        Icons.Default.Check,
-                        contentDescription = null,
-                        tint = Color.Black.copy(alpha = 0.7f),
-                        modifier = Modifier.size(20.dp),
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun SyncedAccountGroup(
-    account: String,
-    accountType: String,
-    calendars: List<CalendarSource>,
-    dark: Boolean,
-) {
+private fun AccountHeader(account: String, accountType: String) {
     val context = LocalContext.current
     Row(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(start = 24.dp, end = 16.dp, top = 12.dp, bottom = 4.dp),
+            .padding(start = 28.dp, end = 16.dp, top = 16.dp, bottom = 4.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
         Text(
@@ -476,65 +479,43 @@ private fun SyncedAccountGroup(
             Text(stringResource(R.string.calendars_manage_in_app))
         }
     }
-    calendars.forEach { calendar ->
-        CalendarRow(name = calendar.displayName, color = calendar.color, dark = dark)
-    }
 }
 
+/** Neutral circular chip carrying an arbitrary icon — matches [AddAvatar]'s shape. */
 @Composable
-private fun AddAccountButton() {
-    val context = LocalContext.current
-    FilledTonalButton(
-        onClick = {
-            runCatching { context.startActivity(Intent(Settings.ACTION_ADD_ACCOUNT)) }
-        },
-        modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
-    ) {
-        Icon(Icons.Default.Add, contentDescription = null, modifier = Modifier.size(18.dp))
-        Spacer(Modifier.width(8.dp))
-        Text(stringResource(R.string.calendars_add_account))
-    }
-}
-
-@Composable
-private fun CalendarRow(
-    name: String,
-    color: Int,
-    dark: Boolean,
-    subtitle: String? = null,
-    onClick: (() -> Unit)? = null,
-    trailing: @Composable (() -> Unit)? = null,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .then(if (onClick != null) Modifier.clickable(onClick = onClick) else Modifier)
-            .padding(horizontal = 24.dp, vertical = 12.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
+private fun LeadingAvatar(icon: ImageVector) {
     Box(
         modifier = Modifier
-                .size(16.dp)
+            .size(40.dp)
             .clip(CircleShape)
-                .background(pastelize(color, dark)),
-        )
-        Spacer(Modifier.width(16.dp))
-        Column(modifier = Modifier.weight(1f)) {
-            Text(text = name, style = MaterialTheme.typography.bodyLarge)
-            if (!subtitle.isNullOrBlank()) {
-                Text(
-                    text = subtitle,
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    maxLines = 2,
-                    overflow = TextOverflow.Ellipsis,
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(22.dp),
         )
     }
-        }
-        if (trailing != null) {
-            Spacer(Modifier.width(8.dp))
-            trailing()
-        }
+}
+
+/** Neutral circular chip with a "+" — the leading icon for add-actions. */
+@Composable
+private fun AddAvatar() {
+    Box(
+        modifier = Modifier
+            .size(40.dp)
+            .clip(CircleShape)
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            Icons.Default.Add,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(22.dp),
+        )
     }
 }
 
@@ -588,15 +569,3 @@ private fun curatedSourcePackage(accountType: String): String? = when {
     else -> null
 }
 
-/** Google-Calendar-style palette; values are ARGB ints for `Calendars.CALENDAR_COLOR`. */
-internal val CALENDAR_COLOR_PALETTE: List<Int> = listOf(
-    0xFFD50000, // red
-    0xFFE67C00, // orange
-    0xFFF6BF26, // amber
-    0xFF33B679, // green
-    0xFF0B8043, // dark green
-    0xFF039BE5, // blue
-    0xFF3F51B5, // indigo
-    0xFF8E24AA, // purple
-    0xFF616161, // graphite
-).map { it.toInt() }

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt

@@ -1,11 +1,14 @@
 package de.jeanlucmakiola.calendula.ui.calendars
 
+import android.net.Uri
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
@@ -15,7 +18,9 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Clock
 import javax.inject.Inject
 
 /**
@@ -27,6 +32,7 @@ import javax.inject.Inject
 @HiltViewModel
 class CalendarsViewModel @Inject constructor(
     private val repository: CalendarRepository,
+    private val icsExporter: IcsExporter,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -45,6 +51,36 @@ class CalendarsViewModel @Inject constructor(
 
     fun consumeError() { _error.value = false }
 
+    private val _backupResult = MutableStateFlow<BackupResult?>(null)
+    val backupResult: StateFlow<BackupResult?> = _backupResult.asStateFlow()
+
+    fun consumeBackupResult() { _backupResult.value = null }
+
+    /**
+     * Serialise every event of the writable local calendars into the chosen SAF
+     * document [uri] as one `VCALENDAR`. Result (event count, or failure) lands
+     * in [backupResult] for a one-shot message.
+     */
+    fun exportBackup(uri: Uri) {
+        viewModelScope.launch {
+            _backupResult.value = try {
+                val count = withContext(io) {
+                    val events = repository.exportEvents()
+                    icsExporter.writeDocument(
+                        uri = uri,
+                        content = IcsWriter().writeCalendar(events, Clock.System.now()),
+                    )
+                    events.size
+                }
+                BackupResult.Success(count)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                BackupResult.Failure
+            }
+        }
+    }
+
     fun createCalendar(displayName: String, color: Int, description: String?) = write {
         repository.createLocalCalendar(displayName, color, description)
     }
@@ -69,3 +105,9 @@ class CalendarsViewModel @Inject constructor(
         }
     }
 }
+
+/** Outcome of a whole-calendar backup, surfaced once to the screen. */
+sealed interface BackupResult {
+    data class Success(val eventCount: Int) : BackupResult
+    data object Failure : BackupResult
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarColors.kt

@@ -1,6 +1,20 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
 
 /**
  * Soften a raw calendar color toward a pastel that fits the active theme.
@@ -15,3 +29,27 @@ fun pastelize(rawArgb: Int, dark: Boolean): Color {
     hsv[2] = if (dark) 0.82f else 0.72f
     return Color(android.graphics.Color.HSVToColor(hsv))
 }
+
+/**
+ * Leading avatar for a calendar: a neutral chip holding a calendar glyph tinted
+ * in the calendar's (pastelised) colour. Shared by the calendar manager and the
+ * visibility filter so they read identically.
+ */
+@Composable
+fun CalendarColorChip(color: Int, modifier: Modifier = Modifier) {
+    val dark = isSystemInDarkTheme()
+    Box(
+        modifier = modifier
+            .size(40.dp)
+            .clip(CircleShape)
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            Icons.Filled.CalendarMonth,
+            contentDescription = null,
+            tint = pastelize(color, dark),
+            modifier = Modifier.size(22.dp),
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDatePickerDialog.kt

@@ -0,0 +1,52 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.material3.DatePicker
+import androidx.compose.material3.DatePickerDialog
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.rememberDatePickerState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import de.jeanlucmakiola.calendula.R
+import kotlinx.datetime.LocalDate
+
+/** One UTC day in milliseconds — the unit the M3 [DatePicker] speaks. */
+const val MILLIS_PER_DAY: Long = 86_400_000L
+
+/**
+ * The app's standard Material 3 date picker, opened on [initial] and reporting
+ * the chosen day through [onConfirm]. Shared by the event form (start/end date,
+ * RRULE until) and the drawer's jump-to-date action.
+ *
+ * DatePicker speaks UTC-midnight millis; epoch-day arithmetic keeps the
+ * conversion zone-proof in both directions.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun CalendarDatePickerDialog(
+    initial: LocalDate,
+    onConfirm: (LocalDate) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val state = rememberDatePickerState(
+        initialSelectedDateMillis = initial.toEpochDays() * MILLIS_PER_DAY,
+    )
+    DatePickerDialog(
+        onDismissRequest = onDismiss,
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    state.selectedDateMillis?.let { millis ->
+                        onConfirm(LocalDate.fromEpochDays((millis / MILLIS_PER_DAY).toInt()))
+                    }
+                },
+            ) { Text(stringResource(R.string.dialog_ok)) }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
+        },
+    ) {
+        DatePicker(state = state)
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt

@@ -1,84 +1,154 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.DateRange
 import androidx.compose.material.icons.filled.Settings
-import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ModalDrawerSheet
-import androidx.compose.material3.NavigationDrawerItem
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.colorResource
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.ui.filter.CalendarFilterList
+import kotlinx.datetime.LocalDate
 
 /**
  * Navigation drawer shared by every top-level calendar screen.
  *
- * Visual language (kept deliberately small so sizes don't drift):
- *  - Drawer title — `titleLarge`
- *  - Section headers (e.g. "Calendars") — `titleSmall`, primary, text only
- *  - Nav items (the views, Today / Settings) — Material `NavigationDrawerItem`
- *    (`labelLarge` label + a single 24dp leading icon)
+ * Uses the app's grouped-card design system (see [GroupedRow]): a branded
+ * header, the View switcher as a grouped card (the active view highlighted),
+ * a jump-to-date action, the per-calendar visibility filter (M3) inline, and a
+ * pinned Settings row. The "View" section mirrors the top-bar switcher pill —
+ * tapping a view here selects it (and closes the drawer) rather than cycling.
+ * The host screen owns the drawer state.
  *
- * The "View" section mirrors the top-bar switcher pill: tapping a view here
- * selects it (and closes the drawer) rather than cycling. Also hosts the
- * per-calendar visibility filter (M3) inline — the calendar list with its
- * checkboxes lives here rather than in a separate sheet — plus a Settings
- * entry (M4). The host screen owns the drawer state.
+ * [currentDate] seeds the jump-to-date picker (the visible day/week-start/month
+ * anchor); [onJumpToDate] navigates the active view to the chosen day.
  */
 @Composable
 fun CalendarDrawer(
     currentView: CalendarView,
+    currentDate: LocalDate,
     onSelectView: (CalendarView) -> Unit,
+    onJumpToDate: (LocalDate) -> Unit,
     onSettings: () -> Unit,
 ) {
+    var showDatePicker by remember { mutableStateOf(false) }
+
     ModalDrawerSheet {
-        Column(Modifier.fillMaxHeight()) {
+        // The whole sidebar scrolls as one — header, views, the calendar filter
+        // and Settings all flow in a single scroll container.
+        Column(
+            Modifier
+                .fillMaxHeight()
+                .verticalScroll(rememberScrollState()),
+        ) {
+            DrawerHeader()
+
+            DrawerSectionHeader(stringResource(R.string.view_section))
+            IMPLEMENTED_VIEWS.forEachIndexed { index, view ->
+                GroupedRow(
+                    title = stringResource(view.labelRes),
+                    position = positionOf(index, IMPLEMENTED_VIEWS.size),
+                    selected = view == currentView,
+                    minHeight = 56.dp,
+                    leading = { Icon(view.icon, contentDescription = null) },
+                    onClick = { onSelectView(view) },
+                )
+            }
+
+            Spacer(Modifier.height(16.dp))
+            GroupedRow(
+                title = stringResource(R.string.drawer_jump_to_date),
+                position = Position.Alone,
+                minHeight = 56.dp,
+                leading = { Icon(Icons.Filled.DateRange, contentDescription = null) },
+                onClick = { showDatePicker = true },
+            )
+
+            Spacer(Modifier.height(16.dp))
+
+            DrawerSectionHeader(stringResource(R.string.filter_title))
+            CalendarFilterList()
+
+            Spacer(Modifier.height(16.dp))
+            GroupedRow(
+                title = stringResource(R.string.month_action_settings),
+                position = Position.Alone,
+                minHeight = 56.dp,
+                leading = { Icon(Icons.Filled.Settings, contentDescription = null) },
+                onClick = onSettings,
+            )
+            Spacer(Modifier.height(8.dp))
+        }
+    }
+
+    if (showDatePicker) {
+        CalendarDatePickerDialog(
+            initial = currentDate,
+            onConfirm = {
+                showDatePicker = false
+                onJumpToDate(it)
+            },
+            onDismiss = { showDatePicker = false },
+        )
+    }
+}
+
+/** Branded header: the app-icon chip beside the app name. */
+@Composable
+private fun DrawerHeader() {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(start = 28.dp, end = 28.dp, top = 24.dp, bottom = 16.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Box(
+            modifier = Modifier
+                .size(44.dp)
+                .clip(RoundedCornerShape(14.dp))
+                .background(colorResource(R.color.ic_launcher_background)),
+            contentAlignment = Alignment.Center,
+        ) {
+            Image(
+                painter = painterResource(R.drawable.ic_launcher_foreground),
+                contentDescription = null,
+                modifier = Modifier.requiredSize(66.dp),
+            )
+        }
+        Spacer(Modifier.width(16.dp))
         Text(
             text = stringResource(R.string.app_name),
             style = MaterialTheme.typography.titleLarge,
-                modifier = Modifier.padding(horizontal = 28.dp, vertical = 24.dp),
         )
-            HorizontalDivider()
-
-            DrawerSectionHeader(stringResource(R.string.view_section))
-            IMPLEMENTED_VIEWS.forEach { view ->
-                NavigationDrawerItem(
-                    icon = { Icon(view.icon, contentDescription = null) },
-                    label = { Text(stringResource(view.labelRes)) },
-                    selected = view == currentView,
-                    onClick = { onSelectView(view) },
-                    modifier = Modifier.padding(horizontal = 12.dp),
-                )
-            }
-            Spacer(Modifier.height(8.dp))
-            HorizontalDivider()
-
-            // Calendars (M3) — visibility checkboxes, scrollable, takes the slack
-            // between the top actions and the pinned Settings entry.
-            DrawerSectionHeader(stringResource(R.string.filter_title))
-            CalendarFilterList(modifier = Modifier.weight(1f))
-
-            HorizontalDivider()
-            Spacer(Modifier.height(8.dp))
-            NavigationDrawerItem(
-                icon = { Icon(Icons.Filled.Settings, contentDescription = null) },
-                label = { Text(stringResource(R.string.month_action_settings)) },
-                selected = false,
-                onClick = onSettings,
-                modifier = Modifier.padding(horizontal = 12.dp),
-            )
-            Spacer(Modifier.height(8.dp))
-        }
     }
 }
 

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarView.kt

@@ -5,17 +5,16 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.CalendarViewDay
 import androidx.compose.material.icons.filled.CalendarViewMonth
 import androidx.compose.material.icons.filled.CalendarViewWeek
+import androidx.compose.material.icons.filled.ViewAgenda
 import androidx.compose.ui.graphics.vector.ImageVector
 import de.jeanlucmakiola.calendula.R
 
-/**
- * The top-level calendar views the user can switch between (spec M1).
- * Day is declared but not yet implemented (v0.5) — see [IMPLEMENTED_VIEWS].
- */
+/** The top-level calendar views the user can switch between (spec M1). */
 enum class CalendarView {
     Month,
     Week,
     Day,
+    Agenda,
 }
 
 /** Switcher label, shared by the top-bar pill and the drawer's View section. */
@@ -25,6 +24,7 @@ val CalendarView.labelRes: Int
         CalendarView.Month -> R.string.view_month
         CalendarView.Week -> R.string.view_week
         CalendarView.Day -> R.string.view_day
+        CalendarView.Agenda -> R.string.view_agenda
     }
 
 /** Leading icon for the view in the drawer's View section. */
@@ -33,6 +33,7 @@ val CalendarView.icon: ImageVector
         CalendarView.Month -> Icons.Filled.CalendarViewMonth
         CalendarView.Week -> Icons.Filled.CalendarViewWeek
         CalendarView.Day -> Icons.Filled.CalendarViewDay
+        CalendarView.Agenda -> Icons.Filled.ViewAgenda
     }
 
 /**
@@ -40,7 +41,7 @@ val CalendarView.icon: ImageVector
  * through these in order.
  */
 val IMPLEMENTED_VIEWS: List<CalendarView> =
-    listOf(CalendarView.Month, CalendarView.Week, CalendarView.Day)
+    listOf(CalendarView.Month, CalendarView.Week, CalendarView.Day, CalendarView.Agenda)
 
 /** Next view in [available], wrapping around. Falls back to Month if absent. */
 fun CalendarView.next(available: List<CalendarView> = IMPLEMENTED_VIEWS): CalendarView {

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ColorSwatchRow.kt

@@ -0,0 +1,82 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+/**
+ * A wrapping row of round colour swatches; the one matching [selected] is
+ * ringed and checked. Shared by the calendar editor and the event-colour
+ * picker so both pick a colour the same way. Swatches render through
+ * [pastelize] — the softened colour the app actually paints, not the raw hue.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun ColorSwatchRow(
+    colors: List<Int>,
+    selected: Int?,
+    onSelect: (Int) -> Unit,
+    dark: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    FlowRow(modifier = modifier, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        colors.forEach { argb ->
+            val isSelected = argb == selected
+            Box(
+                contentAlignment = Alignment.Center,
+                modifier = Modifier
+                    .padding(vertical = 4.dp)
+                    .size(40.dp)
+                    .clip(CircleShape)
+                    .background(pastelize(argb, dark))
+                    .then(
+                        if (isSelected) {
+                            Modifier.border(2.dp, MaterialTheme.colorScheme.onSurface, CircleShape)
+                        } else {
+                            Modifier
+                        },
+                    )
+                    .clickable { onSelect(argb) },
+            ) {
+                if (isSelected) {
+                    Icon(
+                        Icons.Default.Check,
+                        contentDescription = null,
+                        tint = Color.Black.copy(alpha = 0.7f),
+                        modifier = Modifier.size(20.dp),
+                    )
+                }
+            }
+        }
+    }
+}
+
+/** Google-Calendar-style palette; ARGB ints for a raw `CALENDAR_COLOR` / `EVENT_COLOR`. */
+val CALENDAR_COLOR_PALETTE: List<Int> = listOf(
+    0xFFD50000, // red
+    0xFFE67C00, // orange
+    0xFFF6BF26, // amber
+    0xFF33B679, // green
+    0xFF0B8043, // dark green
+    0xFF039BE5, // blue
+    0xFF3F51B5, // indigo
+    0xFF8E24AA, // purple
+    0xFF616161, // graphite
+).map { it.toInt() }

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/DialogControls.kt

@@ -0,0 +1,94 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowDropDown
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+
+/**
+ * Tonal 3-digit number input shared by the custom reminder/recurrence steps and
+ * the reminder pickers — the app's [InlineTextField] over a tonal surface, so it
+ * matches the card/grouped-row design language (not Material's outlined field).
+ */
+@Composable
+fun DialogAmountField(
+    value: String,
+    onValueChange: (String) -> Unit,
+    placeholder: String,
+) {
+    // surfaceContainerHighest — the picker/dialog sits on surfaceContainerHigh,
+    // so anything lower vanishes.
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHighest,
+        shape = RoundedCornerShape(12.dp),
+    ) {
+        InlineTextField(
+            value = value,
+            onValueChange = { text ->
+                if (text.length <= 3 && text.all(Char::isDigit)) onValueChange(text)
+            },
+            placeholder = placeholder,
+            textStyle = MaterialTheme.typography.titleMedium,
+            keyboardType = KeyboardType.Number,
+            modifier = Modifier
+                .width(72.dp)
+                .padding(horizontal = 14.dp, vertical = 12.dp),
+        )
+    }
+}
+
+/** Tonal dropdown trigger + menu shared by the custom reminder/recurrence steps and pickers. */
+@Composable
+fun DialogUnitDropdown(
+    label: String,
+    entries: List<String>,
+    onPick: (Int) -> Unit,
+) {
+    var open by remember { mutableStateOf(false) }
+    Box {
+        Surface(
+            color = MaterialTheme.colorScheme.surfaceContainerHighest,
+            shape = RoundedCornerShape(12.dp),
+            onClick = { open = true },
+        ) {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.padding(start = 14.dp, end = 8.dp, top = 12.dp, bottom = 12.dp),
+            ) {
+                Text(text = label, style = MaterialTheme.typography.titleMedium)
+                Spacer(Modifier.width(4.dp))
+                Icon(imageVector = Icons.Default.ArrowDropDown, contentDescription = null)
+            }
+        }
+        DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
+            entries.forEachIndexed { index, entry ->
+                DropdownMenuItem(
+                    text = { Text(entry) },
+                    onClick = {
+                        onPick(index)
+                        open = false
+                    },
+                )
+            }
+        }
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/GroupedList.kt

@@ -0,0 +1,205 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsPressedAsState
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LargeTopAppBar
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberTopAppBarState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Position of a row within a grouped list, after the Android-15 settings
+ * pattern: a run of rows shares one rounded container, with full corners at the
+ * group's outer edges and small corners between, separated by small gaps.
+ */
+enum class Position { Top, Middle, Bottom, Alone }
+
+/** Maps an index within a group of [count] rows to its [Position]. */
+fun positionOf(index: Int, count: Int): Position = when {
+    count <= 1 -> Position.Alone
+    index == 0 -> Position.Top
+    index == count - 1 -> Position.Bottom
+    else -> Position.Middle
+}
+
+/**
+ * The app's standard full-screen list scaffold: a collapsing [LargeTopAppBar]
+ * whose title shrinks into the bar (next to the back button) as the content
+ * scrolls. Content is a scrollable column that feeds the toolbar via nested
+ * scroll. Used by Settings and the calendar manager so they share one shell.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun CollapsingScaffold(
+    title: String,
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+    snackbarHost: @Composable () -> Unit = {},
+    actions: @Composable RowScope.() -> Unit = {},
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    BackHandler(onBack = onBack)
+    val scrollBehavior =
+        TopAppBarDefaults.exitUntilCollapsedScrollBehavior(rememberTopAppBarState())
+    Scaffold(
+        modifier = modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.surface)
+            .nestedScroll(scrollBehavior.nestedScrollConnection),
+        topBar = {
+            LargeTopAppBar(
+                title = { Text(title) },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(
+                            Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.settings_back),
+                        )
+                    }
+                },
+                actions = actions,
+                scrollBehavior = scrollBehavior,
+                colors = TopAppBarDefaults.topAppBarColors(
+                    scrolledContainerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
+        },
+        snackbarHost = snackbarHost,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .padding(innerPadding)
+                // Mark the scaffold's system-bar insets as consumed so the
+                // imePadding below adds only the keyboard height beyond them
+                // (max, not sum) — otherwise the nav-bar inset double-counts and
+                // leaves an empty strip above the keyboard.
+                .consumeWindowInsets(innerPadding)
+                .fillMaxSize()
+                // Paint the surface across the full area before imePadding carves
+                // into it, so any sliver above the keyboard reads as surface — not
+                // the dialog window's black — during the IME animation.
+                .background(MaterialTheme.colorScheme.surface)
+                // Shrink the scroll viewport by the keyboard inset so a focused
+                // field (e.g. the custom-reminder amount) can scroll into view.
+                .imePadding()
+                .verticalScroll(rememberScrollState())
+                .padding(top = 8.dp, bottom = 24.dp),
+            content = content,
+        )
+    }
+}
+
+/**
+ * One row in a grouped list: an M3 [ListItem] over a tonal [Surface] whose
+ * corner radii come from its [position] (so a run of rows reads as a single
+ * rounded card). Corners round further on press. A null [onClick] makes the
+ * row non-interactive (e.g. read-only entries).
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun GroupedRow(
+    title: String,
+    position: Position,
+    modifier: Modifier = Modifier,
+    summary: String? = null,
+    selected: Boolean = false,
+    minHeight: Dp = 72.dp,
+    leading: @Composable (() -> Unit)? = null,
+    trailing: @Composable (() -> Unit)? = null,
+    onClick: (() -> Unit)? = null,
+) {
+    val interaction = remember { MutableInteractionSource() }
+    val pressed by interaction.collectIsPressedAsState()
+    val full by animateDpAsState(if (pressed) 36.dp else 22.dp, label = "fullCorner")
+    val small by animateDpAsState(if (pressed) 36.dp else 6.dp, label = "smallCorner")
+    val shape = when (position) {
+        Position.Alone -> RoundedCornerShape(full)
+        Position.Top -> RoundedCornerShape(
+            topStart = full, topEnd = full, bottomStart = small, bottomEnd = small,
+        )
+        Position.Middle -> RoundedCornerShape(small)
+        Position.Bottom -> RoundedCornerShape(
+            topStart = small, topEnd = small, bottomStart = full, bottomEnd = full,
+        )
+    }
+    val gap = when (position) {
+        Position.Top, Position.Middle -> Modifier.padding(bottom = 2.dp)
+        Position.Bottom, Position.Alone -> Modifier
+    }
+    val itemColors = if (selected) {
+        ListItemDefaults.colors(
+            containerColor = Color.Transparent,
+            headlineColor = MaterialTheme.colorScheme.onSecondaryContainer,
+            leadingIconColor = MaterialTheme.colorScheme.onSecondaryContainer,
+            supportingColor = MaterialTheme.colorScheme.onSecondaryContainer,
+            trailingIconColor = MaterialTheme.colorScheme.onSecondaryContainer,
+        )
+    } else {
+        ListItemDefaults.colors(containerColor = Color.Transparent)
+    }
+    val item: @Composable () -> Unit = {
+        ListItem(
+            headlineContent = { Text(title) },
+            supportingContent = summary?.let { text -> { Text(text) } },
+            leadingContent = leading,
+            trailingContent = trailing,
+            colors = itemColors,
+            modifier = Modifier.heightIn(min = minHeight),
+        )
+    }
+    val base = modifier
+        .fillMaxWidth()
+        .padding(horizontal = 16.dp)
+        .then(gap)
+    val containerColor = if (selected) {
+        MaterialTheme.colorScheme.secondaryContainer
+    } else {
+        MaterialTheme.colorScheme.surfaceContainerHigh
+    }
+    if (onClick != null) {
+        Surface(
+            onClick = onClick,
+            color = containerColor,
+            shape = shape,
+            interactionSource = interaction,
+            modifier = base,
+        ) { item() }
+    } else {
+        Surface(color = containerColor, shape = shape, modifier = base) { item() }
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/Picker.kt

@@ -0,0 +1,282 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SegmentedButton
+import androidx.compose.material3.SegmentedButtonDefaults
+import androidx.compose.material3.SingleChoiceSegmentedButtonRow
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import android.view.WindowManager
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.compose.ui.window.DialogWindowProvider
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
+
+/**
+ * Shared full-screen scaffold for selection pickers: a full-bleed [Dialog] that
+ * reuses the app's [CollapsingScaffold] (collapsing title + back button), so a
+ * picker is visually identical to a Settings sub-page and uses the full width.
+ * [content] places the connected grouped rows; selecting one calls [onDismiss].
+ */
+@Composable
+fun FullScreenPicker(
+    title: String,
+    onDismiss: () -> Unit,
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    Dialog(
+        onDismissRequest = onDismiss,
+        properties = DialogProperties(
+            usePlatformDefaultWidth = false,
+            decorFitsSystemWindows = false,
+        ),
+    ) {
+        // The dialog window pans by default when the keyboard opens, which —
+        // combined with the content's own imePadding — leaves a fixed black gap
+        // above the keyboard. Switch it to ADJUST_NOTHING so the window stays
+        // full-screen and imePadding alone lifts the focused field.
+        val view = LocalView.current
+        SideEffect {
+            (view.parent as? DialogWindowProvider)?.window
+                ?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
+        }
+        CollapsingScaffold(title = title, onBack = onDismiss, content = content)
+    }
+}
+
+/**
+ * General single-select picker, full-screen: each option is a connected grouped
+ * row and the current one carries a check. Drop-in for the former dialog
+ * (theme, week start, language, …).
+ */
+@Composable
+fun <T> OptionPicker(
+    title: String,
+    options: List<T>,
+    selected: T,
+    label: @Composable (T) -> String,
+    onSelect: (T) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    FullScreenPicker(title = title, onDismiss = onDismiss) {
+        options.forEachIndexed { index, option ->
+            val isSelected = option == selected
+            GroupedRow(
+                title = label(option),
+                position = positionOf(index, options.size),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = {
+                    onSelect(option)
+                    onDismiss()
+                },
+            )
+        }
+    }
+}
+
+/**
+ * Reminder-default picker, full-screen: the grouped list (with an optional "Use
+ * default reminder" row and a "None" row), the [presets] as lead-time rows, and
+ * a "Custom" row that expands an inline number field plus a segmented unit
+ * selector. Returns the choice as a [CalendarReminderOverride].
+ */
+@Composable
+fun ReminderDefaultPicker(
+    title: String,
+    presets: List<Int>,
+    selected: CalendarReminderOverride,
+    allowInherit: Boolean,
+    onSelect: (CalendarReminderOverride) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val selectedMinutes = (selected as? CalendarReminderOverride.Minutes)?.minutes
+    val customSelected = selectedMinutes != null && selectedMinutes !in presets
+    val seed = decomposeReminder(selectedMinutes?.takeIf { customSelected })
+
+    var customExpanded by rememberSaveable { mutableStateOf(false) }
+    var amountText by rememberSaveable { mutableStateOf(seed.first) }
+    var unit by rememberSaveable { mutableStateOf(seed.second) }
+
+    val options = buildList {
+        if (allowInherit) add(CalendarReminderOverride.Inherit)
+        add(CalendarReminderOverride.None)
+        presets.forEach { add(CalendarReminderOverride.Minutes(it)) }
+    }
+    val rowCount = options.size + 1 // + the custom row
+
+    FullScreenPicker(title = title, onDismiss = onDismiss) {
+        options.forEachIndexed { index, option ->
+            val isSelected = option == selected
+            GroupedRow(
+                title = reminderOverrideLabel(option),
+                position = positionOf(index, rowCount),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = {
+                    onSelect(option)
+                    onDismiss()
+                },
+            )
+        }
+        // When expanded, the Custom row connects downward into the editor card
+        // so the two read as one grouped container (the per-calendar pattern).
+        GroupedRow(
+            title = if (customSelected) {
+                stringResource(
+                    R.string.reminder_custom_with_value,
+                    reminderLeadTimeLabel(selectedMinutes!!),
+                )
+            } else {
+                stringResource(R.string.event_edit_reminder_custom)
+            },
+            position = if (customExpanded) Position.Top else positionOf(options.size, rowCount),
+            selected = customSelected,
+            trailing = if (customSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(visible = customExpanded) {
+            CustomReminderEditor(
+                amountText = amountText,
+                onAmountChange = { amountText = it },
+                unit = unit,
+                onUnitChange = { unit = it },
+                onConfirm = { minutes ->
+                    onSelect(CalendarReminderOverride.Minutes(minutes))
+                    onDismiss()
+                },
+            )
+        }
+    }
+}
+
+/**
+ * The expanded "Custom" lead-time editor: a tonal card connected to the Custom
+ * row above it (matching the grouped-row system, so the two read as one
+ * container). An amount field with a live preview of the resulting lead time, a
+ * single-choice unit toggle, and a tonal confirm enabled only for a valid
+ * 1–999 amount. [onConfirm] receives the final lead time in minutes.
+ */
+@Composable
+private fun CustomReminderEditor(
+    amountText: String,
+    onAmountChange: (String) -> Unit,
+    unit: ReminderUnit,
+    onUnitChange: (ReminderUnit) -> Unit,
+    onConfirm: (Int) -> Unit,
+) {
+    val amount = amountText.toIntOrNull()?.takeIf { it in 1..999 }
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        // A Position.Bottom shape: tight top corners meeting the row, full bottom.
+        shape = RoundedCornerShape(topStart = 6.dp, topEnd = 6.dp, bottomStart = 22.dp, bottomEnd = 22.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp),
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            // Unit toggle first so it stays visible above the keyboard once the
+            // amount field (the bottom row) is focused and scrolled into view.
+            SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
+                ReminderUnit.entries.forEachIndexed { index, entry ->
+                    SegmentedButton(
+                        selected = unit == entry,
+                        onClick = { onUnitChange(entry) },
+                        shape = SegmentedButtonDefaults.itemShape(index, ReminderUnit.entries.size),
+                        label = { Text(stringResource(reminderUnitLabel(entry))) },
+                    )
+                }
+            }
+            // Amount, a live preview of the lead time it resolves to, and Set —
+            // all on one row, sitting just above the keyboard.
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                DialogAmountField(
+                    value = amountText,
+                    onValueChange = onAmountChange,
+                    placeholder = "10",
+                )
+                Spacer(Modifier.width(16.dp))
+                Text(
+                    text = amount?.let { reminderLeadTimeLabel(it * unit.minutesFactor) }
+                        ?: stringResource(R.string.reminder_custom_amount),
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.weight(1f),
+                )
+                Spacer(Modifier.width(16.dp))
+                FilledTonalButton(
+                    onClick = { amount?.let { onConfirm(it * unit.minutesFactor) } },
+                    enabled = amount != null,
+                ) {
+                    Text(stringResource(R.string.reminder_custom_set))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun SelectedCheck() {
+    Icon(
+        imageVector = Icons.Default.Check,
+        contentDescription = null,
+        tint = MaterialTheme.colorScheme.primary,
+    )
+}
+
+@Composable
+private fun reminderOverrideLabel(override: CalendarReminderOverride): String = when (override) {
+    CalendarReminderOverride.Inherit -> stringResource(R.string.reminder_use_default)
+    CalendarReminderOverride.None -> stringResource(R.string.reminder_none)
+    is CalendarReminderOverride.Minutes -> reminderLeadTimeLabel(override.minutes)
+}
+
+/** Seed the custom editor: the largest exact unit for [minutes] (null → empty). */
+private fun decomposeReminder(minutes: Int?): Pair<String, ReminderUnit> = when {
+    minutes == null -> "" to ReminderUnit.Minutes
+    minutes % 10_080 == 0 -> (minutes / 10_080).toString() to ReminderUnit.Weeks
+    minutes % 1_440 == 0 -> (minutes / 1_440).toString() to ReminderUnit.Days
+    minutes % 60 == 0 -> (minutes / 60).toString() to ReminderUnit.Hours
+    else -> minutes.toString() to ReminderUnit.Minutes
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ReminderFormatting.kt

@@ -0,0 +1,46 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.annotation.StringRes
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import de.jeanlucmakiola.calendula.R
+
+/** Common reminder lead times offered as quick picks in the form and settings. */
+val REMINDER_PRESETS = listOf(0, 10, 30, 60, 1_440)
+
+/** The unit of a custom reminder lead time; [minutesFactor] converts to minutes. */
+enum class ReminderUnit(val minutesFactor: Int) {
+    Minutes(1),
+    Hours(60),
+    Days(1_440),
+    Weeks(10_080),
+}
+
+@StringRes
+fun reminderUnitLabel(unit: ReminderUnit): Int = when (unit) {
+    ReminderUnit.Minutes -> R.string.reminder_unit_minutes
+    ReminderUnit.Hours -> R.string.reminder_unit_hours
+    ReminderUnit.Days -> R.string.reminder_unit_days
+    ReminderUnit.Weeks -> R.string.reminder_unit_weeks
+}
+
+/**
+ * Humanise a reminder lead time (minutes before the event start) into one
+ * line: "Default reminder" (negative = the provider default), "At time of
+ * event" (0), "10 minutes before", "1 hour before", … Shared by the detail
+ * screen, the event form and the default-reminder settings so the wording
+ * never drifts.
+ */
+@Composable
+fun reminderLeadTimeLabel(minutes: Int): String = when {
+    minutes < 0 -> stringResource(R.string.reminder_default)
+    minutes == 0 -> stringResource(R.string.reminder_at_time)
+    minutes % 10_080 == 0 ->
+        pluralStringResource(R.plurals.reminder_weeks, minutes / 10_080, minutes / 10_080)
+    minutes % 1_440 == 0 ->
+        pluralStringResource(R.plurals.reminder_days, minutes / 1_440, minutes / 1_440)
+    minutes % 60 == 0 ->
+        pluralStringResource(R.plurals.reminder_hours, minutes / 60, minutes / 60)
+    else -> pluralStringResource(R.plurals.reminder_minutes, minutes, minutes)
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimePickerAlert.kt

@@ -0,0 +1,68 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import android.content.Context
+import android.content.res.Resources
+import android.provider.Settings
+import android.text.format.DateFormat
+import androidx.compose.material3.TimePicker
+import androidx.compose.material3.rememberTimePickerState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import de.jeanlucmakiola.calendula.R
+import kotlinx.datetime.LocalTime
+
+/**
+ * M3 time picker in an alert dialog, seeded with [initial]. Shared by the event
+ * form (start/end times) and Settings (the all-day reminder fire time).
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun TimePickerAlert(
+    initial: LocalTime,
+    onConfirm: (LocalTime) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val state = rememberTimePickerState(
+        initialHour = initial.hour,
+        initialMinute = initial.minute,
+        is24Hour = deviceUses24HourClock(LocalContext.current),
+    )
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        confirmButton = {
+            TextButton(onClick = { onConfirm(LocalTime(state.hour, state.minute)) }) {
+                Text(stringResource(R.string.dialog_ok))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
+        },
+        text = { TimePicker(state = state) },
+    )
+}
+
+/**
+ * Whether the clock should read 24-hour, matching the rest of the device.
+ *
+ * [DateFormat.is24HourFormat] resolves a "locale default" system setting against
+ * the *app's* context locale — and this app applies a per-app language
+ * (AppCompatDelegate), so an English UI on a German-region phone would wrongly
+ * read 12-hour while the system clock shows 24-hour. So we honour an explicit
+ * system 12/24 override, and otherwise fall back to the **device** locale
+ * (Resources.getSystem), not the app's.
+ */
+private fun deviceUses24HourClock(context: Context): Boolean =
+    when (Settings.System.getString(context.contentResolver, Settings.System.TIME_12_24)) {
+        "24" -> true
+        "12" -> false
+        // 'a' is the AM/PM marker; a best-fit pattern without it is 24-hour.
+        else -> {
+            val deviceLocale = Resources.getSystem().configuration.locales[0]
+            !DateFormat.getBestDateTimePattern(deviceLocale, "jm").contains('a')
+        }
+    }

app/src/main/java/de/jeanlucmakiola/calendula/ui/crash/CrashReportActivity.kt

@@ -0,0 +1,59 @@
+package de.jeanlucmakiola.calendula.ui.crash
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.ui.Modifier
+import de.jeanlucmakiola.calendula.data.crash.CrashReporter
+import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
+
+/**
+ * A deliberately minimal, standalone surface for a captured crash report.
+ * `MainActivity` routes here when it detects a startup crash-loop (see
+ * [CrashReporter.isCrashLoop]): the main UI can't be trusted to start, so this
+ * screen stays clear of the app's Hilt graph, DataStore-backed theme and
+ * Compose content — it only reads the report file and shows the report dialog.
+ * Plain [CalendulaTheme] defaults (follow-system, dynamic colour) avoid touching
+ * anything that might be the cause of the crash.
+ */
+class CrashReportActivity : ComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val report = CrashReporter.pendingReport(this)
+        if (report == null) {
+            finish()
+            return
+        }
+        enableEdgeToEdge()
+        setContent {
+            CalendulaTheme {
+                // Opaque backdrop so the dialog doesn't float over a bare task.
+                Surface(Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.surface) {}
+                CrashReportDialog(
+                    report = report,
+                    onSend = {
+                        submitCrashReport(this, report)
+                        CrashReporter.clearReport(this)
+                        finish()
+                    },
+                    onDismiss = {
+                        CrashReporter.clearReport(this)
+                        finish()
+                    },
+                )
+            }
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        // Reaching this screen breaks the loop; reset the timing trail so a
+        // later ordinary crash isn't mistaken for a loop.
+        CrashReporter.markHealthy(this)
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/crash/CrashReportDialog.kt

@@ -0,0 +1,75 @@
+package de.jeanlucmakiola.calendula.ui.crash
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.BugReport
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Asks the user to send a captured crash report as an issue. The full report is
+ * shown verbatim in a scrollable panel — the user sees exactly what will leave
+ * the device before choosing to share it (the privacy backstop). [onSend] hands
+ * off to [submitCrashReport]; [onDismiss] declines.
+ */
+@Composable
+fun CrashReportDialog(
+    report: String,
+    onSend: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        icon = { Icon(Icons.Default.BugReport, contentDescription = null) },
+        title = { Text(stringResource(R.string.crash_dialog_title)) },
+        text = {
+            Column {
+                Text(
+                    text = stringResource(R.string.crash_dialog_message),
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+                Spacer(Modifier.height(12.dp))
+                Surface(
+                    color = MaterialTheme.colorScheme.surfaceContainerHighest,
+                    shape = RoundedCornerShape(12.dp),
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Text(
+                        text = report,
+                        style = MaterialTheme.typography.bodySmall,
+                        fontFamily = FontFamily.Monospace,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier
+                            .heightIn(max = 220.dp)
+                            .verticalScroll(rememberScrollState())
+                            .padding(12.dp),
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onSend) { Text(stringResource(R.string.crash_dialog_report)) }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.crash_dialog_dismiss)) }
+        },
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/crash/CrashReportSubmit.kt

@@ -0,0 +1,61 @@
+package de.jeanlucmakiola.calendula.ui.crash
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.content.Intent
+import android.widget.Toast
+import androidx.core.net.toUri
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Hand the captured crash report off to the user's chosen channel: the report
+ * is copied to the clipboard (the reliable path for a full stack trace) and the
+ * project's Gitea "new issue" page is opened with the body prefilled. Nothing is
+ * sent automatically — the app has no network access; the user reviews and
+ * submits the issue themselves.
+ */
+fun submitCrashReport(context: Context, report: String) {
+    copyReportToClipboard(context, report)
+    val opened = runCatching {
+        context.startActivity(Intent(Intent.ACTION_VIEW, buildIssueUri(context, report)))
+    }.isSuccess
+    val message = if (opened) R.string.crash_report_copied else R.string.crash_report_open_failed
+    Toast.makeText(context, message, Toast.LENGTH_LONG).show()
+}
+
+/** Open the issue tracker's template chooser for a manual (non-crash) report. */
+fun openIssueTracker(context: Context) {
+    val uri = context.getString(R.string.report_issue_choose_url).toUri()
+    runCatching { context.startActivity(Intent(Intent.ACTION_VIEW, uri)) }
+}
+
+private fun copyReportToClipboard(context: Context, report: String) {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return
+    val label = context.getString(R.string.crash_report_clip_label)
+    clipboard.setPrimaryClip(ClipData.newPlainText(label, report))
+}
+
+/**
+ * The Gitea `issues/new` URL with `title` and `body` prefilled. A full report
+ * can blow past URL-length limits, so an over-long one is left out of the link
+ * (with a "paste from clipboard" placeholder) — the clipboard copy is the
+ * source of truth in that case.
+ */
+private fun buildIssueUri(context: Context, report: String) =
+    context.getString(R.string.report_issue_url).toUri().buildUpon()
+        .appendQueryParameter("title", context.getString(R.string.crash_report_issue_title))
+        .appendQueryParameter("body", buildIssueBody(context, report))
+        .build()
+
+private fun buildIssueBody(context: Context, report: String): String {
+    val block = if (report.length > MAX_URL_REPORT_CHARS) {
+        context.getString(R.string.crash_report_body_paste)
+    } else {
+        "```\n$report\n```"
+    }
+    return context.getString(R.string.crash_report_body_template, block)
+}
+
+/** Keep the prefilled body comfortably under common URL-length ceilings. */
+private const val MAX_URL_REPORT_CHARS = 6_000

app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt

@@ -151,6 +151,11 @@ fun DayScreen(
         }
         viewModel.goToToday()
     }
+    // Drawer jump-to-date: slide from the side the target lies on.
+    val jumpToDate: (LocalDate) -> Unit = { target ->
+        slideDir = if (target < date) -1 else 1
+        viewModel.goToDate(target)
+    }
 
     ModalNavigationDrawer(
         drawerState = drawerState,
@@ -159,10 +164,15 @@ fun DayScreen(
         drawerContent = {
             CalendarDrawer(
                 currentView = selectedView,
+                currentDate = date,
                 onSelectView = { view ->
                     onSelectView(view)
                     scope.launch { drawerState.close() }
                 },
+                onJumpToDate = { target ->
+                    jumpToDate(target)
+                    scope.launch { drawerState.close() }
+                },
                 onSettings = {
                     onOpenSettings()
                     scope.launch { drawerState.close() }

app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt

@@ -41,6 +41,7 @@ import androidx.compose.material.icons.filled.Place
 import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Repeat
 import androidx.compose.material.icons.filled.Schedule
+import androidx.compose.material.icons.filled.Share
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
@@ -59,6 +60,7 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -67,7 +69,6 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.core.content.ContextCompat
-import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.LinkAnnotation
@@ -96,6 +97,8 @@ import de.jeanlucmakiola.calendula.ui.common.OptionCard
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText
+import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
+import kotlinx.coroutines.launch
 import kotlinx.datetime.TimeZone
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
@@ -132,9 +135,30 @@ fun EventDetailScreen(
     BackHandler(onBack = onBack)
 
     val context = LocalContext.current
+    val scope = rememberCoroutineScope()
     val snackbarHostState = remember { SnackbarHostState() }
     var showDeleteDialog by rememberSaveable { mutableStateOf(false) }
 
+    // Sharing is read-only, so it needs no WRITE_CALENDAR upgrade. The VM stages
+    // an .ics in the cache and hands back a content Uri for the chooser.
+    val shareFailedMessage = stringResource(R.string.event_share_failed)
+    val shareChooserTitle = stringResource(R.string.event_share_chooser_title)
+    val onShareClick = {
+        scope.launch {
+            val uri = viewModel.shareUri()
+            val sent = uri != null && runCatching {
+                val send = Intent(Intent.ACTION_SEND).apply {
+                    type = "text/calendar"
+                    putExtra(Intent.EXTRA_STREAM, uri)
+                    addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                }
+                context.startActivity(Intent.createChooser(send, shareChooserTitle))
+            }.isSuccess
+            if (!sent) snackbarHostState.showSnackbar(shareFailedMessage)
+        }
+        Unit
+    }
+
     // v1.0 installs only hold READ_CALENDAR; the first write asks for the
     // upgrade in place. Granting continues straight into the tapped action.
     var pendingEdit by remember { mutableStateOf(false) }
@@ -203,9 +227,18 @@ fun EventDetailScreen(
                     }
                 },
                 actions = {
-                    // Only writable calendars get actions — WebCal subscriptions,
-                    // birthday calendars etc. are read-only at the provider level.
                     val s = state
+                    // Share works for any loaded event — it only reads the event.
+                    if (s is EventDetailUiState.Success) {
+                        IconButton(onClick = onShareClick) {
+                            Icon(
+                                imageVector = Icons.Default.Share,
+                                contentDescription = stringResource(R.string.event_detail_share),
+                            )
+                        }
+                    }
+                    // Edit/delete need a writable calendar — WebCal subscriptions,
+                    // birthday calendars etc. are read-only at the provider level.
                     if (s is EventDetailUiState.Success && s.canModify) {
                         IconButton(
                             onClick = onEditClick,
@@ -684,26 +717,7 @@ private fun attendeeRoleLabel(attendee: Attendee): Int? = when {
 
 /** Humanise a reminder's lead time, e.g. "10 minutes before" / "At time of event". */
 @Composable
-private fun reminderLeadText(reminder: Reminder): String {
-    val minutes = reminder.minutes
-    return when {
-        minutes < 0 -> stringResource(R.string.reminder_default)
-        minutes == 0 -> stringResource(R.string.reminder_at_time)
-        minutes % 10_080 == 0 -> {
-            val weeks = minutes / 10_080
-            pluralStringResource(R.plurals.reminder_weeks, weeks, weeks)
-        }
-        minutes % 1_440 == 0 -> {
-            val days = minutes / 1_440
-            pluralStringResource(R.plurals.reminder_days, days, days)
-        }
-        minutes % 60 == 0 -> {
-            val hours = minutes / 60
-            pluralStringResource(R.plurals.reminder_hours, hours, hours)
-        }
-        else -> pluralStringResource(R.plurals.reminder_minutes, minutes, minutes)
-    }
-}
+private fun reminderLeadText(reminder: Reminder): String = reminderLeadTimeLabel(reminder.minutes)
 
 /**
  * A localized label for [tz] (e.g. "Central European Time (Europe/Berlin)"),
@@ -762,14 +776,19 @@ private fun formatWhen(
     val allDayLabel = stringResource(R.string.event_detail_all_day)
 
     if (instance.isAllDay) {
-        // All-day end is the exclusive next midnight; step back to the last
-        // covered day so a one-day event reads as a single date.
-        val lastLdt = (instance.end - 1.seconds).toJavaLocalDateTime(zid)
-        return if (startLdt.toLocalDate() == lastLdt.toLocalDate()) {
-            allDayLabel to dateFull.format(startLdt.toLocalDate())
+        // All-day events live at UTC midnights with an exclusive end. Resolve
+        // the covered dates in UTC — not the device zone, which would shift the
+        // midnight boundaries off the intended date (east of UTC pushes the
+        // end past the last day; west of UTC pulls the start back) — and step
+        // the end back to the last covered day so a one-day event reads as a
+        // single date.
+        val utc = ZoneId.of("UTC")
+        val startDate = instance.start.toJavaLocalDateTime(utc).toLocalDate()
+        val lastDate = (instance.end - 1.seconds).toJavaLocalDateTime(utc).toLocalDate()
+        return if (startDate == lastDate) {
+            allDayLabel to dateFull.format(startDate)
         } else {
-            allDayLabel to
-                "${dateMedium.format(startLdt.toLocalDate())} – ${dateMedium.format(lastLdt.toLocalDate())}"
+            allDayLabel to "${dateMedium.format(startDate)} – ${dateMedium.format(lastDate)}"
         }
     }
 

app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailViewModel.kt

@@ -1,14 +1,20 @@
 package de.jeanlucmakiola.calendula.ui.detail
 
+import android.net.Uri
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
+import de.jeanlucmakiola.calendula.domain.ics.toShareIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import kotlin.time.Clock
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
@@ -34,6 +40,7 @@ import javax.inject.Inject
 @HiltViewModel
 class EventDetailViewModel @Inject constructor(
     private val repository: CalendarRepository,
+    private val icsExporter: IcsExporter,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -113,6 +120,24 @@ class EventDetailViewModel @Inject constructor(
         _deleteState.value = DeleteUiState.Idle
     }
 
+    /**
+     * Serialise the open event to a `.ics` cache file and return a shareable
+     * content Uri (for an ACTION_SEND), or null when nothing is loaded or the
+     * write fails. The event is exported as a one-off (see [toShareIcsEvent]).
+     */
+    suspend fun shareUri(): Uri? {
+        val detail = (state.value as? EventDetailUiState.Success)?.detail ?: return null
+        return runCatching {
+            withContext(io) {
+                val ics = IcsWriter().writeCalendar(
+                    events = listOf(detail.toShareIcsEvent()),
+                    dtStamp = Clock.System.now(),
+                )
+                icsExporter.stageShareFile(shareFileName(detail.instance.title), ics)
+            }
+        }.getOrNull()
+    }
+
     private suspend fun loadDetail(target: Target): EventDetailUiState = try {
         val detail = repository.eventDetail(target.eventId)
         // The Events row holds the series start; replace it with this
@@ -143,3 +168,13 @@ class EventDetailViewModel @Inject constructor(
     /** A tapped occurrence: the series [eventId] plus this occurrence's own times. */
     private data class Target(val eventId: Long, val beginMillis: Long, val endMillis: Long)
 }
+
+/** A filesystem-safe `.ics` file name from an event title (or a fallback). */
+private fun shareFileName(title: String): String {
+    val base = title.trim()
+        .replace(Regex("""[^\p{L}\p{Nd} _-]"""), "")
+        .replace(' ', '_')
+        .take(40)
+        .ifBlank { "event" }
+    return "$base.ics"
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt

@@ -41,6 +41,7 @@ import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.EventAvailable
 import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material.icons.filled.Notifications
+import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material.icons.filled.Place
 import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Repeat
@@ -50,8 +51,6 @@ import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.AssistChip
 import androidx.compose.material3.Button
-import androidx.compose.material3.DatePicker
-import androidx.compose.material3.DatePickerDialog
 import androidx.compose.material3.DropdownMenu
 import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -69,11 +68,8 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
-import androidx.compose.material3.TimePicker
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.material3.rememberDatePickerState
-import androidx.compose.material3.rememberTimePickerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -88,7 +84,6 @@ import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.graphics.isSpecified
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.TextStyle
@@ -102,6 +97,8 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
+import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.domain.EventFormProblem
 import de.jeanlucmakiola.calendula.domain.RecurrenceEnd
@@ -110,9 +107,20 @@ import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.SimpleRecurrence
 import de.jeanlucmakiola.calendula.domain.parseSimpleRecurrence
 import de.jeanlucmakiola.calendula.domain.toRRule
+import de.jeanlucmakiola.calendula.ui.common.CALENDAR_COLOR_PALETTE
+import de.jeanlucmakiola.calendula.ui.common.CalendarDatePickerDialog
+import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
+import de.jeanlucmakiola.calendula.ui.common.DialogAmountField
+import de.jeanlucmakiola.calendula.ui.common.DialogUnitDropdown
+import de.jeanlucmakiola.calendula.ui.common.MILLIS_PER_DAY
 import de.jeanlucmakiola.calendula.ui.common.InlineTextField
 import de.jeanlucmakiola.calendula.ui.common.OptionCard
+import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
+import de.jeanlucmakiola.calendula.ui.common.ReminderUnit
+import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
+import de.jeanlucmakiola.calendula.ui.common.reminderUnitLabel
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText
 import kotlinx.datetime.DayOfWeek
@@ -149,21 +157,25 @@ fun EventEditScreen(
     onSaved: () -> Unit,
     editKey: LongArray? = null,
     initialStartMinutes: Int? = null,
+    initialForm: EventForm? = null,
     viewModel: EventEditViewModel = hiltViewModel(),
 ) {
-    LaunchedEffect(initialDateIso, editKey) {
-        if (editKey != null) {
-            viewModel.openForEdit(
+    LaunchedEffect(initialDateIso, editKey, initialForm) {
+        when {
+            // Single-event .ics open: the form arrives prefilled for review.
+            initialForm != null -> viewModel.openImported(initialForm)
+            editKey != null -> viewModel.openForEdit(
                 eventId = editKey[0],
                 beginMillis = editKey[1],
                 endMillis = editKey[2],
             )
-        } else {
+            else -> {
                 val date = initialDateIso?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
                     ?: Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
                 viewModel.openNew(date, initialStartMinutes)
             }
         }
+    }
     val state by viewModel.state.collectAsStateWithLifecycle()
     val loadFailed by viewModel.loadFailed.collectAsStateWithLifecycle()
 
@@ -414,6 +426,7 @@ private fun EventEditContent(
     var showReminderPicker by rememberSaveable { mutableStateOf(false) }
     var showRecurrencePicker by rememberSaveable { mutableStateOf(false) }
     var showVisibilityPicker by rememberSaveable { mutableStateOf(false) }
+    var showColorPicker by rememberSaveable { mutableStateOf(false) }
     var showFieldPicker by rememberSaveable { mutableStateOf(false) }
 
     val selectedCalendar = state.calendars.firstOrNull { it.id == form.calendarId }
@@ -423,6 +436,16 @@ private fun EventEditContent(
         ?: MaterialTheme.colorScheme.primary
     val gap = 12.dp
 
+    // Per-event colour applicability for the resolved calendar:
+    //  - palette calendars (Google, …) and local calendars always support it;
+    //  - synced calendars with no palette only when the user opted in, and even
+    //    then the colour may not survive the calendar's next sync (the warning).
+    val isLocalCalendar = selectedCalendar?.isLocal == true
+    val colorSupported = state.colorPalette.isNotEmpty() || isLocalCalendar ||
+        state.allowColorOnUnsupportedCalendars
+    val colorSyncRisk = state.colorPalette.isEmpty() && !isLocalCalendar &&
+        state.allowColorOnUnsupportedCalendars
+
     Column(
         modifier = modifier
             // Shrink the scroll viewport by the keyboard instead of letting
@@ -692,6 +715,67 @@ private fun EventEditContent(
             }
         }
 
+        OptionalFormSection(visible = EventFormField.Color in state.visibleFields) {
+            Spacer(Modifier.height(gap))
+            // The swatch the event will paint with: its own colour, else the
+            // calendar's. The Palette icon takes that colour as a preview.
+            val swatch = form.color ?: selectedCalendar?.color
+            EditCard(
+                icon = Icons.Default.Palette,
+                iconContentDescription = stringResource(R.string.event_edit_color),
+                iconTint = if (colorSupported && swatch != null) {
+                    pastelize(swatch, dark)
+                } else {
+                    MaterialTheme.colorScheme.onSurfaceVariant
+                },
+                onClick = { showColorPicker = true }.takeIf { colorSupported },
+            ) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Column(modifier = Modifier.weight(1f)) {
+                        Text(
+                            text = stringResource(
+                                when {
+                                    !colorSupported -> R.string.event_edit_color_unsupported
+                                    form.color != null -> R.string.event_edit_color_custom
+                                    else -> R.string.event_edit_color_default
+                                },
+                            ),
+                            style = MaterialTheme.typography.titleMedium,
+                        )
+                        Text(
+                            text = stringResource(
+                                if (colorSupported) {
+                                    R.string.event_edit_color
+                                } else {
+                                    R.string.event_edit_color_unsupported_hint
+                                },
+                            ),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                        if (colorSyncRisk) {
+                            Spacer(Modifier.height(2.dp))
+                            Text(
+                                text = stringResource(R.string.event_edit_color_sync_warning),
+                                style = MaterialTheme.typography.bodySmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            )
+                        }
+                    }
+                    if (colorSupported) {
+                        Icon(
+                            imageVector = Icons.Default.ArrowDropDown,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+                }
+            }
+        }
+
         OptionalFormSection(visible = state.hiddenFields.isNotEmpty()) {
             Spacer(Modifier.height(20.dp))
             TextButton(
@@ -710,12 +794,12 @@ private fun EventEditContent(
     }
 
     when (picker) {
-        PickerTarget.StartDate -> DatePickerAlert(
+        PickerTarget.StartDate -> CalendarDatePickerDialog(
             initial = form.start.date,
             onConfirm = { viewModel.setStartDate(it); picker = null },
             onDismiss = { picker = null },
         )
-        PickerTarget.EndDate -> DatePickerAlert(
+        PickerTarget.EndDate -> CalendarDatePickerDialog(
             initial = form.end.date,
             onConfirm = { viewModel.setEndDate(it); picker = null },
             onDismiss = { picker = null },
@@ -779,6 +863,28 @@ private fun EventEditContent(
         )
     }
 
+    if (showColorPicker) {
+        ColorPickerDialog(
+            palette = state.colorPalette,
+            selected = form.color,
+            hasExplicitColor = form.color != null,
+            syncWarning = colorSyncRisk,
+            onPickKey = { key, argb ->
+                viewModel.setColorKey(key, argb)
+                showColorPicker = false
+            },
+            onPickRaw = { argb ->
+                viewModel.setColorRaw(argb)
+                showColorPicker = false
+            },
+            onClear = {
+                viewModel.clearColor()
+                showColorPicker = false
+            },
+            onDismiss = { showColorPicker = false },
+        )
+    }
+
     if (showFieldPicker) {
         FieldPickerDialog(
             hiddenFields = state.hiddenFields,
@@ -819,14 +925,7 @@ private fun FieldPickerDialog(
 }
 
 /** Quick-pick lead times offered as chips in the reminder dialog. */
-private val REMINDER_QUICK_PICKS = listOf(0, 10, 30, 60, 1_440)
-
-private enum class ReminderUnit(val minutesFactor: Int) {
-    Minutes(1),
-    Hours(60),
-    Days(1_440),
-    Weeks(10_080),
-}
+private val REMINDER_QUICK_PICKS = REMINDER_PRESETS
 
 /**
  * Reminder picker, two steps: the common lead times as a tappable list
@@ -1080,7 +1179,7 @@ private fun RecurrencePickerDialog(
     )
 
     if (showUntilPicker) {
-        DatePickerAlert(
+        CalendarDatePickerDialog(
             initial = untilDate ?: LocalDate.fromEpochDays(
                 (Clock.System.now().toEpochMilliseconds() / MILLIS_PER_DAY).toInt(),
             ),
@@ -1148,84 +1247,6 @@ private fun Set<DayOfWeek>.toMask(): Int = fold(0) { acc, day -> acc or day.toMa
 private fun Int.toDaySet(): Set<DayOfWeek> =
     DayOfWeek.entries.filter { this and it.toMaskBit() != 0 }.toSet()
 
-/** Tonal 3-digit number input shared by the custom reminder/recurrence steps. */
-@Composable
-private fun DialogAmountField(
-    value: String,
-    onValueChange: (String) -> Unit,
-    placeholder: String,
-) {
-    // surfaceContainerHighest — the dialog itself sits on
-    // surfaceContainerHigh, so anything lower vanishes.
-    Surface(
-        color = MaterialTheme.colorScheme.surfaceContainerHighest,
-        shape = RoundedCornerShape(12.dp),
-    ) {
-        InlineField(
-            value = value,
-            onValueChange = { text ->
-                if (text.length <= 3 && text.all(Char::isDigit)) {
-                    onValueChange(text)
-                }
-            },
-            placeholder = placeholder,
-            textStyle = MaterialTheme.typography.titleMedium,
-            keyboardType = KeyboardType.Number,
-            modifier = Modifier
-                .width(72.dp)
-                .padding(horizontal = 14.dp, vertical = 12.dp),
-        )
-    }
-}
-
-/** Tonal dropdown trigger + menu shared by the custom reminder/recurrence steps. */
-@Composable
-private fun DialogUnitDropdown(
-    label: String,
-    entries: List<String>,
-    onPick: (Int) -> Unit,
-) {
-    var open by remember { mutableStateOf(false) }
-    Box {
-        Surface(
-            color = MaterialTheme.colorScheme.surfaceContainerHighest,
-            shape = RoundedCornerShape(12.dp),
-            onClick = { open = true },
-        ) {
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.padding(
-                    start = 14.dp,
-                    end = 8.dp,
-                    top = 12.dp,
-                    bottom = 12.dp,
-                ),
-            ) {
-                Text(
-                    text = label,
-                    style = MaterialTheme.typography.titleMedium,
-                )
-                Spacer(Modifier.width(4.dp))
-                Icon(
-                    imageVector = Icons.Default.ArrowDropDown,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
-            }
-        }
-        DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
-            entries.forEachIndexed { index, entry ->
-                DropdownMenuItem(
-                    text = { Text(entry) },
-                    onClick = {
-                        onPick(index)
-                        open = false
-                    },
-                )
-            }
-        }
-    }
-}
 
 private fun recurrencePresetLabel(freq: RecurrenceFreq): Int = when (freq) {
     RecurrenceFreq.Daily -> R.string.recurrence_daily
@@ -1280,13 +1301,6 @@ private fun AddReminderChip(onClick: () -> Unit) {
     )
 }
 
-private fun reminderUnitLabel(unit: ReminderUnit): Int = when (unit) {
-    ReminderUnit.Minutes -> R.string.reminder_unit_minutes
-    ReminderUnit.Hours -> R.string.reminder_unit_hours
-    ReminderUnit.Days -> R.string.reminder_unit_days
-    ReminderUnit.Weeks -> R.string.reminder_unit_weeks
-}
-
 private fun fieldLabel(field: EventFormField): Int = when (field) {
     EventFormField.Location -> R.string.event_detail_location
     EventFormField.Description -> R.string.event_detail_description
@@ -1294,6 +1308,7 @@ private fun fieldLabel(field: EventFormField): Int = when (field) {
     EventFormField.Recurrence -> R.string.event_detail_recurrence
     EventFormField.Availability -> R.string.event_edit_availability
     EventFormField.Visibility -> R.string.event_edit_visibility
+    EventFormField.Color -> R.string.event_edit_color
 }
 
 private fun fieldIcon(field: EventFormField): ImageVector = when (field) {
@@ -1303,6 +1318,7 @@ private fun fieldIcon(field: EventFormField): ImageVector = when (field) {
     EventFormField.Recurrence -> Icons.Default.Repeat
     EventFormField.Availability -> Icons.Default.EventAvailable
     EventFormField.Visibility -> Icons.Default.Lock
+    EventFormField.Color -> Icons.Default.Palette
 }
 
 /**
@@ -1336,6 +1352,72 @@ private fun VisibilityPickerDialog(
     )
 }
 
+/**
+ * Event-colour picker: just the swatches. A non-empty [palette] (the calendar
+ * account's published colours) picks by key so the colour round-trips through
+ * sync; otherwise the app's own palette writes a raw colour, with a
+ * [syncWarning] when that calendar may not keep it. The "Reset" button (shown
+ * only once a colour is set) drops back to the calendar's own colour.
+ */
+@Composable
+private fun ColorPickerDialog(
+    palette: List<EventColorOption>,
+    selected: Int?,
+    hasExplicitColor: Boolean,
+    syncWarning: Boolean,
+    onPickKey: (String, Int) -> Unit,
+    onPickRaw: (Int) -> Unit,
+    onClear: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val dark = isSystemInDarkTheme()
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.event_edit_color)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                if (palette.isNotEmpty()) {
+                    ColorSwatchRow(
+                        colors = palette.map { it.argb },
+                        selected = selected,
+                        onSelect = { argb ->
+                            palette.firstOrNull { it.argb == argb }
+                                ?.let { onPickKey(it.key, it.argb) }
+                        },
+                        dark = dark,
+                    )
+                } else {
+                    ColorSwatchRow(
+                        colors = CALENDAR_COLOR_PALETTE,
+                        selected = selected,
+                        onSelect = onPickRaw,
+                        dark = dark,
+                    )
+                    if (syncWarning) {
+                        Text(
+                            text = stringResource(R.string.event_edit_color_sync_warning),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
+        },
+        dismissButton = if (hasExplicitColor) {
+            {
+                TextButton(onClick = onClear) {
+                    Text(stringResource(R.string.event_edit_color_reset))
+                }
+            }
+        } else {
+            null
+        },
+    )
+}
+
 private fun accessLevelIcon(level: AccessLevel): ImageVector = when (level) {
     AccessLevel.Default -> Icons.Default.Tune
     AccessLevel.Public -> Icons.Default.Public
@@ -1352,16 +1434,7 @@ private fun accessLevelLabel(level: AccessLevel): Int = when (level) {
 
 /** Humanise a reminder lead time, mirroring the detail screen's rendering. */
 @Composable
-private fun reminderLabel(minutes: Int): String = when {
-    minutes <= 0 -> stringResource(R.string.reminder_at_time)
-    minutes % 10_080 == 0 ->
-        pluralStringResource(R.plurals.reminder_weeks, minutes / 10_080, minutes / 10_080)
-    minutes % 1_440 == 0 ->
-        pluralStringResource(R.plurals.reminder_days, minutes / 1_440, minutes / 1_440)
-    minutes % 60 == 0 ->
-        pluralStringResource(R.plurals.reminder_hours, minutes / 60, minutes / 60)
-    else -> pluralStringResource(R.plurals.reminder_minutes, minutes, minutes)
-}
+private fun reminderLabel(minutes: Int): String = reminderLeadTimeLabel(minutes)
 
 /**
  * One info card mirroring the detail screen's DetailCard: tonal container,
@@ -1522,62 +1595,6 @@ private fun ScheduleRow(
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun DatePickerAlert(
-    initial: LocalDate,
-    onConfirm: (LocalDate) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    // DatePicker speaks UTC-midnight millis; epoch-day arithmetic keeps the
-    // conversion zone-proof in both directions.
-    val state = rememberDatePickerState(
-        initialSelectedDateMillis = initial.toEpochDays() * MILLIS_PER_DAY,
-    )
-    DatePickerDialog(
-        onDismissRequest = onDismiss,
-        confirmButton = {
-            TextButton(
-                onClick = {
-                    state.selectedDateMillis?.let { millis ->
-                        onConfirm(LocalDate.fromEpochDays((millis / MILLIS_PER_DAY).toInt()))
-                    }
-                },
-            ) { Text(stringResource(R.string.dialog_ok)) }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
-        },
-    ) {
-        DatePicker(state = state)
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun TimePickerAlert(
-    initial: LocalTime,
-    onConfirm: (LocalTime) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    val state = rememberTimePickerState(
-        initialHour = initial.hour,
-        initialMinute = initial.minute,
-    )
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        confirmButton = {
-            TextButton(onClick = { onConfirm(LocalTime(state.hour, state.minute)) }) {
-                Text(stringResource(R.string.dialog_ok))
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
-        },
-        text = { TimePicker(state = state) },
-    )
-}
-
 @Composable
 private fun CalendarPickerDialog(
     calendars: List<CalendarSource>,
@@ -1609,5 +1626,3 @@ private fun CalendarPickerDialog(
         },
     )
 }
-
-private const val MILLIS_PER_DAY = 86_400_000L

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditUiState.kt

@@ -1,6 +1,7 @@
 package de.jeanlucmakiola.calendula.ui.edit
 
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.domain.EventFormProblem
@@ -33,6 +34,18 @@ data class EventEditUiState(
      * then drops "only this event" (an exception row can't carry a rule).
      */
     val recurrenceChanged: Boolean = false,
+    /**
+     * The event-colour palette the resolved target calendar publishes; empty
+     * when it exposes none. Non-empty → the colour picker offers these swatches
+     * (written as a key, sync-safe); empty → see [colorMode].
+     */
+    val colorPalette: List<EventColorOption> = emptyList(),
+    /**
+     * Whether the user has opted into custom colours on calendars that publish
+     * no palette (a synced one may then drop the colour on sync). Mirrors the
+     * settings flag; ignored for local and palette-backed calendars.
+     */
+    val allowColorOnUnsupportedCalendars: Boolean = false,
 )
 
 /** One-shot state of a save request, mirroring DeleteUiState on the detail screen. */

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt

@@ -8,10 +8,12 @@ import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.prefs.resolveDefaultReminder
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EditSnapshot
+import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
@@ -19,12 +21,18 @@ import de.jeanlucmakiola.calendula.domain.populatedFields
 import de.jeanlucmakiola.calendula.domain.problems
 import de.jeanlucmakiola.calendula.domain.toEditSnapshot
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
@@ -65,6 +73,10 @@ class EventEditViewModel @Inject constructor(
     // Set while the form edits an existing event instead of composing a new one.
     private val _editTarget = MutableStateFlow<EditTarget?>(null)
     private val _loadFailed = MutableStateFlow(false)
+    // True once the user has hand-edited the reminders on a new event, which
+    // freezes the auto-applied default: switching calendars no longer overwrites
+    // their choice. Reset with the form.
+    private val _remindersTouched = MutableStateFlow(false)
 
     /** True when the event to edit couldn't be loaded; the screen closes itself. */
     val loadFailed: StateFlow<Boolean> = _loadFailed.asStateFlow()
@@ -94,23 +106,55 @@ class EventEditViewModel @Inject constructor(
         val editTarget: EditTarget?,
     )
 
+    private data class ReminderDefaults(
+        val timed: Int?,
+        val allDay: Int?,
+        val timedOverrides: Map<Long, Int?>,
+        val allDayOverrides: Map<Long, Int?>,
+    )
+
     private data class ExternalInputs(
         val writable: List<CalendarSource>,
         val lastUsed: Long?,
         val defaultFields: Set<EventFormField>,
+        val allowColorOnUnsupported: Boolean,
     )
 
+    /** Writable calendars — the only valid event targets. */
+    private val writableCalendars: Flow<List<CalendarSource>> = repository.calendars()
+        .map { calendars -> calendars.filter { it.canModifyContents } }
+        .catch { emit(emptyList()) }
+
+    /** The target calendar id, resolved exactly as the form shows it. */
+    private val resolvedCalendarId: Flow<Long?> = combine(
+        _form.map { it?.calendarId },
+        writableCalendars,
+        prefs.lastUsedCalendarId,
+    ) { picked, writable, lastUsed ->
+        picked
+            ?: lastUsed?.takeIf { id -> writable.any { it.id == id } }
+            ?: writable.firstOrNull()?.id
+    }.distinctUntilChanged()
+
+    /** The resolved calendar's published event palette, refetched when it changes. */
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private val colorPalette: Flow<List<EventColorOption>> = resolvedCalendarId
+        .flatMapLatest { id ->
+            flow { emit(id?.let { repository.eventColorPalette(it) }.orEmpty()) }
+        }
+        .flowOn(io)
+
     val state: StateFlow<EventEditUiState?> = combine(
         combine(_form, _saveState, _showProblems, _revealed, _editTarget, ::LocalInputs),
         combine(
-            repository.calendars()
-                .map { calendars -> calendars.filter { it.canModifyContents } }
-                .catch { emit(emptyList()) },
+            writableCalendars,
             prefs.lastUsedCalendarId,
             settingsPrefs.defaultFormFields,
+            settingsPrefs.allowColorOnUnsupportedCalendars,
             ::ExternalInputs,
         ).flowOn(io),
-    ) { local, external ->
+        colorPalette,
+    ) { local, external, palette ->
         val form = local.form ?: return@combine null
         val resolvedId = form.calendarId
             ?: external.lastUsed?.takeIf { id -> external.writable.any { it.id == id } }
@@ -129,6 +173,8 @@ class EventEditViewModel @Inject constructor(
             // the scope dialog drops "only this event" after a rule change.
             recurrenceChanged = local.editTarget != null &&
                 resolved.rrule != local.editTarget.original.rrule,
+            colorPalette = palette,
+            allowColorOnUnsupportedCalendars = external.allowColorOnUnsupported,
         )
     }
         .stateIn(
@@ -161,6 +207,63 @@ class EventEditViewModel @Inject constructor(
         }
         val end = (start.toInstant(zone) + 1.hours).toLocalDateTime(zone)
         _form.value = EventForm(calendarId = null, start = start, end = end)
+        applyDefaultReminder()
+    }
+
+    /**
+     * Seed a fresh event from a parsed `.ics` file (the single-event "open into
+     * the create form" path). [form] already carries the file's fields; its
+     * [EventForm.calendarId] is null so the calendar still resolves to the
+     * last-used/first-writable one, and reminders are frozen as touched so the
+     * settings default never overwrites what the file specified. No-op when a
+     * form is already open, so the prefill survives configuration changes.
+     */
+    fun openImported(form: EventForm) {
+        if (_form.value != null || _editTarget.value != null) return
+        _remindersTouched.value = true
+        _revealed.value = form.populatedFields()
+        _form.value = form
+    }
+
+    /**
+     * Prefill a new event's reminders from the settings default — the all-day
+     * default for all-day events, otherwise the resolved calendar's per-calendar
+     * override or the global timed default. No-op while editing an existing event
+     * or once the user has hand-edited the reminders, so the auto-default never
+     * clobbers a manual choice. [calendarId] short-circuits the resolution after a
+     * calendar switch; null resolves it as the form does.
+     */
+    private fun applyDefaultReminder(calendarId: Long? = null) {
+        if (_editTarget.value != null || _remindersTouched.value) return
+        viewModelScope.launch {
+            val defaults = combine(
+                settingsPrefs.defaultReminderMinutes,
+                settingsPrefs.defaultAllDayReminderMinutes,
+                settingsPrefs.perCalendarReminderOverride,
+                settingsPrefs.perCalendarAllDayReminderOverride,
+            ) { timed, allDay, timedOv, allDayOv ->
+                ReminderDefaults(timed, allDay, timedOv, allDayOv)
+            }.first()
+            val targetId = calendarId ?: resolvedCalendarId.first()
+            // Re-check after suspending: bail if the form closed or the user edited.
+            val form = _form.value ?: return@launch
+            if (_editTarget.value != null || _remindersTouched.value) return@launch
+            val default = resolveDefaultReminder(
+                timedGlobal = defaults.timed,
+                allDayGlobal = defaults.allDay,
+                timedOverrides = defaults.timedOverrides,
+                allDayOverrides = defaults.allDayOverrides,
+                calendarId = targetId,
+                isAllDay = form.isAllDay,
+            )
+            val reminders = listOfNotNull(default)
+            _form.value = form.copy(reminders = reminders)
+            // Surface the section so an auto-applied default is visible and
+            // removable, even when Reminders isn't a default-shown field.
+            if (reminders.isNotEmpty()) {
+                _revealed.value = _revealed.value + EventFormField.Reminders
+            }
+        }
     }
 
     /**
@@ -196,6 +299,7 @@ class EventEditViewModel @Inject constructor(
         _revealed.value = emptySet()
         _editTarget.value = null
         _loadFailed.value = false
+        _remindersTouched.value = false
     }
 
     /** Unfold one optional field, picked in the "more fields" dialog. */
@@ -206,20 +310,47 @@ class EventEditViewModel @Inject constructor(
     fun setTitle(value: String) = update { it.copy(title = value) }
     fun setLocation(value: String) = update { it.copy(location = value) }
     fun setDescription(value: String) = update { it.copy(description = value) }
-    fun setAllDay(value: Boolean) = update { it.copy(isAllDay = value) }
-    fun setCalendar(id: Long) = update { it.copy(calendarId = id) }
+    fun setAllDay(value: Boolean) {
+        update { it.copy(isAllDay = value) }
+        // The default reminder differs for all-day vs timed; re-apply the
+        // type-appropriate default unless the user has hand-edited it (guarded).
+        applyDefaultReminder()
+    }
+
+    /**
+     * Switching calendars drops any chosen colour: a palette key is
+     * account-scoped, and a raw colour may be invalid on the new calendar.
+     * The event falls back to the new calendar's colour until re-picked.
+     */
+    fun setCalendar(id: Long) {
+        update { it.copy(calendarId = id, colorKey = null, color = null) }
+        // A fresh event re-inherits the new calendar's default reminder unless
+        // the user has already hand-edited it (guarded inside).
+        applyDefaultReminder(id)
+    }
     fun setAvailability(value: Availability) = update { it.copy(availability = value) }
     fun setAccessLevel(value: AccessLevel) = update { it.copy(accessLevel = value) }
 
+    /** Pick a palette colour (round-trips via its key); [argb] is its swatch. */
+    fun setColorKey(key: String, argb: Int) = update { it.copy(colorKey = key, color = argb) }
+
+    /** Pick a raw colour (local / opted-in calendars), clearing any palette key. */
+    fun setColorRaw(argb: Int) = update { it.copy(colorKey = null, color = argb) }
+
+    /** Clear the colour so the event inherits its calendar's. */
+    fun clearColor() = update { it.copy(colorKey = null, color = null) }
+
     /** Bare RRULE value from the recurrence picker; null = does not repeat. */
     fun setRecurrence(rrule: String?) = update { it.copy(rrule = rrule) }
 
-    fun addReminder(minutes: Int) = update {
-        it.copy(reminders = (it.reminders + minutes).distinct().sorted())
+    fun addReminder(minutes: Int) {
+        _remindersTouched.value = true
+        update { it.copy(reminders = (it.reminders + minutes).distinct().sorted()) }
     }
 
-    fun removeReminder(minutes: Int) = update {
-        it.copy(reminders = it.reminders - minutes)
+    fun removeReminder(minutes: Int) {
+        _remindersTouched.value = true
+        update { it.copy(reminders = it.reminders - minutes) }
     }
 
     /** Moving the start drags the end along, preserving the duration. */

app/src/main/java/de/jeanlucmakiola/calendula/ui/filter/CalendarFilterList.kt

@@ -1,25 +1,17 @@
 package de.jeanlucmakiola.calendula.ui.filter
 
 import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material3.Checkbox
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
@@ -28,7 +20,9 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.GroupedRow
+import de.jeanlucmakiola.calendula.ui.common.positionOf
 
 /**
  * Calendar-visibility filter (M3), rendered inline in the navigation drawer.
@@ -53,67 +47,44 @@ fun CalendarFilterList(
     }
 }
 
+/**
+ * Renders as a plain (non-scrolling) [Column] so it flows inside the drawer's
+ * single scroll container — the whole sidebar scrolls as one. Calendar counts
+ * are small, so a lazy list isn't needed.
+ */
 @Composable
 private fun FilterList(
     groups: List<AccountGroup>,
     onSetVisible: (Long, Boolean) -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    val dark = isSystemInDarkTheme()
-    LazyColumn(
-        modifier = modifier.fillMaxWidth(),
-        contentPadding = PaddingValues(vertical = 4.dp),
-    ) {
+    Column(modifier = modifier.fillMaxWidth()) {
         groups.forEach { group ->
-            item(key = "header-${group.account}") {
             Text(
                 text = group.account,
                 style = MaterialTheme.typography.labelMedium,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
                 modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 12.dp, bottom = 4.dp),
             )
-            }
-            items(group.calendars, key = { it.id }) { cal ->
-                CalendarToggleRow(
-                    row = cal,
-                    dark = dark,
+            group.calendars.forEachIndexed { index, cal ->
+                GroupedRow(
+                    title = cal.displayName,
+                    position = positionOf(index, group.calendars.size),
+                    minHeight = 56.dp,
+                    leading = { CalendarColorChip(cal.color) },
+                    trailing = {
+                        Checkbox(
+                            checked = cal.visible,
                             onCheckedChange = { onSetVisible(cal.id, it) },
                         )
+                    },
+                    onClick = { onSetVisible(cal.id, !cal.visible) },
+                )
             }
         }
     }
 }
 
-@Composable
-private fun CalendarToggleRow(
-    row: CalendarRow,
-    dark: Boolean,
-    onCheckedChange: (Boolean) -> Unit,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 28.dp, vertical = 6.dp),
-        verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.spacedBy(16.dp),
-    ) {
-        Box(
-            modifier = Modifier
-                .size(14.dp)
-                .background(pastelize(row.color, dark), CircleShape),
-        )
-        Text(
-            text = row.displayName,
-            style = MaterialTheme.typography.bodyMedium,
-            modifier = Modifier.weight(1f),
-        )
-        Checkbox(
-            checked = row.visible,
-            onCheckedChange = onCheckedChange,
-        )
-    }
-}
-
 @Composable
 private fun FilterLoading(modifier: Modifier = Modifier) {
     Column(

app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt

@@ -0,0 +1,207 @@
+package de.jeanlucmakiola.calendula.ui.imports
+
+import android.net.Uri
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.ics.IcsParseWarning
+import de.jeanlucmakiola.calendula.ui.common.OptionCard
+
+/**
+ * Handles an opened/received `.ics` file. A single event is handed straight to
+ * the prefilled create form via [onOpenSingle]; several events show a target-
+ * calendar picker and import in bulk (dedup by UID), then a result summary.
+ * Empty/failed files show a short message and close.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ImportScreen(
+    uri: Uri,
+    onClose: () -> Unit,
+    onOpenSingle: (EventForm) -> Unit,
+    viewModel: ImportViewModel = hiltViewModel(),
+) {
+    LaunchedEffect(uri) { viewModel.load(uri) }
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    BackHandler(onBack = onClose)
+
+    // A single event isn't shown here — it opens the create form for review.
+    LaunchedEffect(state) {
+        (state as? ImportUiState.Single)?.let { onOpenSingle(it.form); onClose() }
+    }
+
+    Scaffold(
+        modifier = Modifier.fillMaxSize(),
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.import_title)) },
+                navigationIcon = {
+                    IconButton(onClick = onClose) {
+                        Icon(Icons.Default.Close, contentDescription = stringResource(R.string.event_edit_close))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
+        },
+    ) { padding ->
+        Box(Modifier.fillMaxSize().padding(padding)) {
+            when (val s = state) {
+                ImportUiState.Loading,
+                ImportUiState.Importing,
+                is ImportUiState.Single,
+                -> CircularProgressIndicator(Modifier.align(Alignment.Center))
+
+                ImportUiState.Empty -> CenteredMessage(stringResource(R.string.import_empty), onClose)
+                ImportUiState.Failed -> CenteredMessage(stringResource(R.string.import_failed), onClose)
+                is ImportUiState.Many -> ManyContent(s, onImport = viewModel::import)
+                is ImportUiState.Done -> DoneContent(s, onClose)
+            }
+        }
+    }
+}
+
+@Composable
+private fun ManyContent(state: ImportUiState.Many, onImport: (Long) -> Unit) {
+    // No writable calendar to import into — tell the user honestly.
+    if (state.calendars.isEmpty()) {
+        CenteredMessage(stringResource(R.string.import_no_calendar), onClose = null)
+        return
+    }
+    var selected by rememberSaveable { mutableStateOf(state.calendars.first().id) }
+
+    Column(
+        Modifier.fillMaxSize().verticalScroll(rememberScrollState())
+            .padding(horizontal = 16.dp, vertical = 8.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Text(
+            pluralStringResource(R.plurals.import_event_count, state.events.size, state.events.size),
+            style = MaterialTheme.typography.bodyLarge,
+            modifier = Modifier.padding(vertical = 8.dp),
+        )
+        Text(
+            stringResource(R.string.import_target_header),
+            style = MaterialTheme.typography.labelLarge,
+            color = MaterialTheme.colorScheme.primary,
+        )
+        state.calendars.forEach { calendar ->
+            OptionCard(
+                label = calendar.displayName,
+                onClick = { selected = calendar.id },
+                selected = calendar.id == selected,
+                icon = null,
+            )
+        }
+        state.warnings.forEach { WarningText(it) }
+        Button(
+            onClick = { onImport(selected) },
+            modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
+        ) {
+            Text(pluralStringResource(R.plurals.import_action, state.events.size, state.events.size))
+        }
+    }
+}
+
+@Composable
+private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
+    Column(
+        Modifier.fillMaxSize().padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(
+            stringResource(R.string.import_done_title),
+            style = MaterialTheme.typography.headlineSmall,
+            modifier = Modifier.padding(top = 24.dp),
+        )
+        Text(
+            pluralStringResource(
+                R.plurals.import_done_imported,
+                state.summary.imported,
+                state.summary.imported,
+            ),
+            style = MaterialTheme.typography.bodyLarge,
+        )
+        if (state.summary.skippedDuplicate > 0) {
+            Text(
+                pluralStringResource(
+                    R.plurals.import_done_skipped,
+                    state.summary.skippedDuplicate,
+                    state.summary.skippedDuplicate,
+                ),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+        Button(onClick = onClose, modifier = Modifier.padding(top = 12.dp)) {
+            Text(stringResource(R.string.import_close))
+        }
+    }
+}
+
+@Composable
+private fun WarningText(warning: IcsParseWarning) {
+    val text = when (warning) {
+        IcsParseWarning.ModifiedOccurrenceSkipped -> stringResource(R.string.import_warning_recurrence)
+        IcsParseWarning.EventWithoutStartSkipped -> stringResource(R.string.import_warning_no_start)
+        IcsParseWarning.AttendeesIgnored -> stringResource(R.string.import_warning_attendees)
+        IcsParseWarning.UnknownTimezone -> stringResource(R.string.import_warning_timezone)
+    }
+    Text(
+        text = text,
+        style = MaterialTheme.typography.bodySmall,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+    )
+}
+
+@Composable
+private fun CenteredMessage(message: String, onClose: (() -> Unit)?) {
+    Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+        Column(
+            Modifier.padding(24.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Text(message, style = MaterialTheme.typography.bodyLarge)
+            if (onClose != null) {
+                Button(onClick = onClose) { Text(stringResource(R.string.import_close)) }
+            }
+        }
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportViewModel.kt

@@ -0,0 +1,105 @@
+package de.jeanlucmakiola.calendula.ui.imports
+
+import android.net.Uri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.ics.IcsImporter
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
+import de.jeanlucmakiola.calendula.domain.ics.IcsParseWarning
+import de.jeanlucmakiola.calendula.domain.ics.IcsParser
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.toEventForm
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.datetime.TimeZone
+import kotlin.coroutines.cancellation.CancellationException
+import javax.inject.Inject
+
+/** What an opened/received `.ics` resolved to. */
+sealed interface ImportUiState {
+    data object Loading : ImportUiState
+    data object Importing : ImportUiState
+
+    /** The file held no importable event (or couldn't be read/parsed as one). */
+    data object Empty : ImportUiState
+    data object Failed : ImportUiState
+
+    /** Exactly one event → review it in the prefilled create form. */
+    data class Single(val form: EventForm, val warnings: Set<IcsParseWarning>) : ImportUiState
+
+    /** Several events → pick a target calendar and bulk-import. */
+    data class Many(
+        val events: List<ParsedIcsEvent>,
+        val warnings: Set<IcsParseWarning>,
+        val calendars: List<CalendarSource>,
+    ) : ImportUiState
+
+    data class Done(val summary: IcsImportSummary) : ImportUiState
+}
+
+/**
+ * Reads an `.ics` [Uri], parses it (pure [IcsParser]) and routes by event count:
+ * one event opens the create form for review, many open the bulk-import picker.
+ * The bulk import dedups by UID in the repository.
+ */
+@HiltViewModel
+class ImportViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    private val importer: IcsImporter,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val parser = IcsParser()
+    private val _state = MutableStateFlow<ImportUiState>(ImportUiState.Loading)
+    val state: StateFlow<ImportUiState> = _state.asStateFlow()
+    private var started = false
+
+    /** Read + parse [uri] once; subsequent calls (recomposition) are ignored. */
+    fun load(uri: Uri) {
+        if (started) return
+        started = true
+        viewModelScope.launch {
+            val parsed = withContext(io) {
+                importer.readText(uri)?.let(parser::parse)
+            }
+            _state.value = when {
+                parsed == null -> ImportUiState.Failed
+                parsed.events.isEmpty() -> ImportUiState.Empty
+                parsed.events.size == 1 -> ImportUiState.Single(
+                    form = parsed.events.single().toEventForm(TimeZone.currentSystemDefault()),
+                    warnings = parsed.warnings,
+                )
+                else -> ImportUiState.Many(
+                    events = parsed.events,
+                    warnings = parsed.warnings,
+                    calendars = repository.calendars().first().filter { it.canModifyContents },
+                )
+            }
+        }
+    }
+
+    /** Bulk-import the parsed events into [targetCalendarId]; result → [ImportUiState.Done]. */
+    fun import(targetCalendarId: Long) {
+        val many = _state.value as? ImportUiState.Many ?: return
+        viewModelScope.launch {
+            _state.value = ImportUiState.Importing
+            _state.value = try {
+                ImportUiState.Done(repository.importEvents(targetCalendarId, many.events))
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                ImportUiState.Failed
+            }
+        }
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthScreen.kt

@@ -124,6 +124,11 @@ fun MonthScreen(
         }
         viewModel.goToToday()
     }
+    // Drawer jump-to-date: slide from the side the target month lies on.
+    val jumpToDate: (LocalDate) -> Unit = { target ->
+        slideDir = if (YearMonth(target.year, target.month) < month) -1 else 1
+        viewModel.goToDate(target)
+    }
 
     ModalNavigationDrawer(
         drawerState = drawerState,
@@ -132,10 +137,15 @@ fun MonthScreen(
         drawerContent = {
             CalendarDrawer(
                 currentView = selectedView,
+                currentDate = LocalDate(month.year, month.month, 1),
                 onSelectView = { view ->
                     onSelectView(view)
                     scope.launch { drawerState.close() }
                 },
+                onJumpToDate = { target ->
+                    jumpToDate(target)
+                    scope.launch { drawerState.close() }
+                },
                 onSettings = {
                     onOpenSettings()
                     scope.launch { drawerState.close() }

app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthViewModel.kt

@@ -96,6 +96,11 @@ class MonthViewModel @Inject constructor(
         _month.value = YearMonth(todayDate.year, todayDate.month)
     }
 
+    /** Jump to the month containing [date] (drawer jump-to-date). */
+    fun goToDate(date: LocalDate) {
+        _month.value = YearMonth(date.year, date.month)
+    }
+
     private fun buildState(
         ym: YearMonth,
         weekStart: DayOfWeek,
@@ -108,21 +113,26 @@ class MonthViewModel @Inject constructor(
         return MonthUiState.Success(
             month = ym,
             today = todayDate,
-            weeks = layoutMonth(ym, weekStart, instances),
+            weeks = layoutMonthWeeks(ym, weekStart, instances, zone),
         )
     }
+}
 
-    /**
-     * Split the grid into week rows and resolve each row's events. An event is a
-     * spanning bar when it's all-day or touches more than one of the row's days;
+/**
+ * Split the month grid into week rows and resolve each row's events. An event is
+ * a spanning bar when it's all-day or touches more than one of the row's days;
  * everything else is a single-day timed pill. Bars get lanes from the shared
  * [layoutAllDay] so a multi-day event stays on one row across the week.
+ *
+ * Shared by the Month screen and the month home-screen widget so both lay out
+ * spans, lanes and per-day counts identically.
  */
-    private fun layoutMonth(
+internal fun layoutMonthWeeks(
     ym: YearMonth,
     weekStart: DayOfWeek,
     instances: List<EventInstance>,
-    ): List<MonthWeek> {
+    zone: TimeZone,
+): List<MonthWeek> {
     val firstOfMonth = LocalDate(ym.year, ym.month, 1)
     val gridStart = firstOfMonth.startOfGridWeek(weekStart)
     val leadOffset = ((firstOfMonth.dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
@@ -155,7 +165,6 @@ class MonthViewModel @Inject constructor(
             countByDay = days.associateWith { d -> weekEvents.count { it.coversDay(d, zone) } },
         )
     }
-    }
 }
 
 /**

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/AppLanguage.kt

@@ -1,36 +1,78 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
+import android.content.Context
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.os.LocaleListCompat
+import de.jeanlucmakiola.calendula.R
+import org.xmlpull.v1.XmlPullParser
+import java.util.Locale
 
-/** UI-facing language choice. AUTO follows the system languages. */
-enum class LanguagePref { AUTO, GERMAN, ENGLISH }
+private const val ANDROID_NS = "http://schemas.android.com/apk/res/android"
 
 /**
- * Per-app language via AppCompatDelegate. On API 33+ this delegates to the
- * platform per-app-languages API; below that the appcompat backport persists
- * the choice itself (manifest `autoStoreLocales` service), so we don't mirror
- * it in DataStore. Setting a locale recreates the activity, which re-reads the
- * current value for the dropdown.
+ * Per-app language via AppCompatDelegate, driven by res/xml/locales_config.xml.
+ *
+ * That file is the single source of truth for which languages we ship: dropping
+ * in a values-<tag> translation and adding a matching `<locale>` entry makes the
+ * language show up here and in the system per-app-language settings, with no
+ * other code change. The system-default choice is represented as `null`.
+ *
+ * On API 33+ this delegates to the platform per-app-languages API; below that
+ * the appcompat backport persists the choice itself (manifest `autoStoreLocales`
+ * service), so we don't mirror it in DataStore. Setting a locale recreates the
+ * activity, which re-reads the current value for the picker.
  */
 object AppLanguage {
 
-    fun current(): LanguagePref {
-        val locales = AppCompatDelegate.getApplicationLocales()
-        if (locales.isEmpty) return LanguagePref.AUTO
-        return when (locales[0]?.language) {
-            "de" -> LanguagePref.GERMAN
-            "en" -> LanguagePref.ENGLISH
-            else -> LanguagePref.AUTO
+    /**
+     * The BCP-47 tags the app ships translations for, in declaration order, as
+     * listed in locales_config.xml. Returns whatever could be parsed; a missing
+     * or malformed config yields an empty list (the picker then offers only the
+     * system-default entry rather than crashing).
+     */
+    fun supportedTags(context: Context): List<String> {
+        val tags = mutableListOf<String>()
+        val parser = context.resources.getXml(R.xml.locales_config)
+        try {
+            var event = parser.eventType
+            while (event != XmlPullParser.END_DOCUMENT) {
+                if (event == XmlPullParser.START_TAG && parser.name == "locale") {
+                    parser.getAttributeValue(ANDROID_NS, "name")?.let(tags::add)
                 }
+                event = parser.next()
+            }
+        } catch (_: Exception) {
+            // Fall back to whatever was parsed before the failure.
+        } finally {
+            parser.close()
+        }
+        return tags
     }
 
-    fun apply(pref: LanguagePref) {
-        val locales = when (pref) {
-            LanguagePref.AUTO -> LocaleListCompat.getEmptyLocaleList()
-            LanguagePref.GERMAN -> LocaleListCompat.forLanguageTags("de")
-            LanguagePref.ENGLISH -> LocaleListCompat.forLanguageTags("en")
+    /** The applied app language as a BCP-47 tag, or `null` when following the system. */
+    fun currentTag(): String? {
+        val locales = AppCompatDelegate.getApplicationLocales()
+        return if (locales.isEmpty) null else locales[0]?.toLanguageTag()
+    }
+
+    /** Apply a BCP-47 tag, or `null` to follow the system languages. */
+    fun apply(tag: String?) {
+        val locales = if (tag == null) {
+            LocaleListCompat.getEmptyLocaleList()
+        } else {
+            LocaleListCompat.forLanguageTags(tag)
         }
         AppCompatDelegate.setApplicationLocales(locales)
     }
+
+    /**
+     * The autonym for a tag — the language's own name in its own script, e.g.
+     * "Deutsch", "English", "Français" — so users find their language regardless
+     * of the current UI language. Capitalised per the language's own rules.
+     */
+    fun displayName(tag: String): String {
+        val locale = Locale.forLanguageTag(tag)
+        return locale.getDisplayName(locale)
+            .replaceFirstChar { if (it.isLowerCase()) it.titlecase(locale) else it.toString() }
+    }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt

@@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.ui.settings
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
+import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
 
 /**
@@ -20,4 +21,28 @@ data class SettingsUiState(
     val defaultFormFields: Set<EventFormField> = SettingsPrefs.DEFAULT_FORM_FIELDS,
     /** Whether Calendula posts reminder notifications (v1.4). */
     val remindersEnabled: Boolean = true,
+    /**
+     * The default reminder lead time (minutes) prefilled on new timed events;
+     * null = no default reminder. Per-calendar overrides take precedence.
+     */
+    val defaultReminderMinutes: Int? = null,
+    /** The default reminder lead time prefilled on new all-day events; null = none. */
+    val defaultAllDayReminderMinutes: Int? = null,
+    /** Wall-clock time (minutes from midnight) all-day reminders fire at; default 09:00. */
+    val allDayReminderTimeMinutes: Int = SettingsPrefs.DEFAULT_ALLDAY_REMINDER_TIME,
+    /**
+     * Per-calendar overrides of [defaultReminderMinutes] for timed events: a
+     * calendar present in the map overrides the global default (null value = no
+     * reminder); absent = inherit the global default.
+     */
+    val perCalendarReminderOverride: Map<Long, Int?> = emptyMap(),
+    /** Per-calendar overrides of [defaultAllDayReminderMinutes] for all-day events. */
+    val perCalendarAllDayReminderOverride: Map<Long, Int?> = emptyMap(),
+    /** Writable calendars, shown as per-calendar reminder-override rows. */
+    val writableCalendars: List<CalendarSource> = emptyList(),
+    /**
+     * Whether the event-colour picker is offered on calendars that publish no
+     * colour palette (the colour may then not survive their next sync).
+     */
+    val allowColorOnUnsupportedCalendars: Boolean = false,
 )

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt

@@ -4,13 +4,19 @@ import android.os.Build
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
+import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -18,11 +24,20 @@ import javax.inject.Inject
 @HiltViewModel
 class SettingsViewModel @Inject constructor(
     private val prefs: SettingsPrefs,
+    repository: CalendarRepository,
 ) : ViewModel() {
 
     private val dynamicColorAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
 
+    /** Writable calendars — the only ones that take a per-calendar reminder override. */
+    private val writableCalendars: Flow<List<CalendarSource>> = repository.calendars()
+        .map { calendars -> calendars.filter { it.canModifyContents } }
+        .catch { emit(emptyList()) }
+
     val state: StateFlow<SettingsUiState> =
+        combine(
+            // combine() types up to five flows, so the prefs split into two
+            // groups that fold together in the outer combine.
             combine(
                 prefs.themeMode,
                 prefs.dynamicColor,
@@ -38,12 +53,51 @@ class SettingsViewModel @Inject constructor(
                     defaultFormFields = formFields,
                     remindersEnabled = reminders,
                 )
+            },
+            combine(
+                prefs.allowColorOnUnsupportedCalendars,
+                prefs.defaultReminderMinutes,
+                prefs.defaultAllDayReminderMinutes,
+                prefs.allDayReminderTimeMinutes,
+            ) { allowColor, defaultReminder, allDayReminder, allDayReminderTime ->
+                ReminderDefaults(allowColor, defaultReminder, allDayReminder, allDayReminderTime)
+            },
+            combine(
+                prefs.perCalendarReminderOverride,
+                prefs.perCalendarAllDayReminderOverride,
+                writableCalendars,
+            ) { overrides, allDayOverrides, calendars ->
+                ReminderOverrides(overrides, allDayOverrides, calendars)
+            },
+        ) { base, defaults, overrides ->
+            base.copy(
+                allowColorOnUnsupportedCalendars = defaults.allowColor,
+                defaultReminderMinutes = defaults.defaultReminder,
+                defaultAllDayReminderMinutes = defaults.allDayReminder,
+                allDayReminderTimeMinutes = defaults.allDayReminderTime,
+                perCalendarReminderOverride = overrides.timed,
+                perCalendarAllDayReminderOverride = overrides.allDay,
+                writableCalendars = overrides.calendars,
+            )
         }.stateIn(
             scope = viewModelScope,
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = SettingsUiState(dynamicColorAvailable = dynamicColorAvailable),
         )
 
+    private data class ReminderDefaults(
+        val allowColor: Boolean,
+        val defaultReminder: Int?,
+        val allDayReminder: Int?,
+        val allDayReminderTime: Int,
+    )
+
+    private data class ReminderOverrides(
+        val timed: Map<Long, Int?>,
+        val allDay: Map<Long, Int?>,
+        val calendars: List<CalendarSource>,
+    )
+
     fun setThemeMode(mode: ThemeMode) {
         viewModelScope.launch { prefs.setThemeMode(mode) }
     }
@@ -63,4 +117,28 @@ class SettingsViewModel @Inject constructor(
     fun setRemindersEnabled(enabled: Boolean) {
         viewModelScope.launch { prefs.setRemindersEnabled(enabled) }
     }
+
+    fun setDefaultReminderMinutes(minutes: Int?) {
+        viewModelScope.launch { prefs.setDefaultReminderMinutes(minutes) }
+    }
+
+    fun setDefaultAllDayReminderMinutes(minutes: Int?) {
+        viewModelScope.launch { prefs.setDefaultAllDayReminderMinutes(minutes) }
+    }
+
+    fun setAllDayReminderTimeMinutes(minutesOfDay: Int) {
+        viewModelScope.launch { prefs.setAllDayReminderTimeMinutes(minutesOfDay) }
+    }
+
+    fun setCalendarReminderOverride(calendarId: Long, override: CalendarReminderOverride) {
+        viewModelScope.launch { prefs.setCalendarReminderOverride(calendarId, override) }
+    }
+
+    fun setCalendarAllDayReminderOverride(calendarId: Long, override: CalendarReminderOverride) {
+        viewModelScope.launch { prefs.setCalendarAllDayReminderOverride(calendarId, override) }
+    }
+
+    fun setAllowColorOnUnsupportedCalendars(enabled: Boolean) {
+        viewModelScope.launch { prefs.setAllowColorOnUnsupportedCalendars(enabled) }
+    }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt

@@ -156,6 +156,11 @@ fun WeekScreen(
         }
         viewModel.goToToday()
     }
+    // Drawer jump-to-date: slide from the side the target week lies on.
+    val jumpToDate: (LocalDate) -> Unit = { target ->
+        slideDir = if (target < weekStart) -1 else 1
+        viewModel.goToDate(target)
+    }
 
     ModalNavigationDrawer(
         drawerState = drawerState,
@@ -164,10 +169,15 @@ fun WeekScreen(
         drawerContent = {
             CalendarDrawer(
                 currentView = selectedView,
+                currentDate = weekStart,
                 onSelectView = { view ->
                     onSelectView(view)
                     scope.launch { drawerState.close() }
                 },
+                onJumpToDate = { target ->
+                    jumpToDate(target)
+                    scope.launch { drawerState.close() }
+                },
                 onSettings = {
                     onOpenSettings()
                     scope.launch { drawerState.close() }

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekViewModel.kt

@@ -107,6 +107,11 @@ class WeekViewModel @Inject constructor(
         _anchor.value = todayDate
     }
 
+    /** Jump to the week containing [date] (drawer jump-to-date). */
+    fun goToDate(date: LocalDate) {
+        _anchor.value = date
+    }
+
     private fun buildState(
         start: LocalDate,
         calendars: List<CalendarSource>,
@@ -176,6 +181,18 @@ internal fun weekRange(start: LocalDate, zone: TimeZone): ClosedRange<Instant> {
 
 /** True if this event overlaps the calendar [day] in [zone] (any portion). */
 internal fun EventInstance.coversDay(day: LocalDate, zone: TimeZone): Boolean {
+    if (isAllDay) {
+        // All-day events live at UTC midnights with an exclusive end. Compare
+        // calendar dates in UTC and step the exclusive end back to the last
+        // covered day (mirroring the detail/edit views), so a one-day event
+        // covers exactly its single date. Slicing the day in the device zone
+        // would push the exclusive end a few hours into the next local day
+        // east of UTC, making the event leak onto day + 1.
+        val startDate = start.toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = end.toLocalDateTime(TimeZone.UTC).date
+        val lastDay = maxOf(startDate, endExclusive.minus(1, DateTimeUnit.DAY))
+        return day in startDate..lastDay
+    }
     val dayStart = day.atStartOfDayIn(zone)
     val dayEnd = day.plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone)
     return start < dayEnd && end > dayStart

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetData.kt

@@ -0,0 +1,113 @@
+package de.jeanlucmakiola.calendula.widget
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import androidx.core.content.ContextCompat
+import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaDay
+import de.jeanlucmakiola.calendula.ui.agenda.agendaRange
+import de.jeanlucmakiola.calendula.ui.agenda.groupAgendaDays
+import kotlinx.coroutines.flow.first
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
+import kotlinx.datetime.minus
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import java.util.Locale
+import kotlin.time.Clock
+
+/** How far ahead the agenda widget loads (a month of upcoming events). */
+private const val AGENDA_WIDGET_DAYS = 30
+
+/**
+ * How far either side of today the month widget pre-loads. The displayed month
+ * is chosen reactively in the composition, so one wide read covers ~13 months of
+ * prev/next navigation without re-querying on every arrow tap.
+ */
+private const val MONTH_WIDGET_RANGE_DAYS = 400
+
+internal fun systemZone(): TimeZone = TimeZone.currentSystemDefault()
+
+internal fun today(zone: TimeZone): LocalDate =
+    Clock.System.now().toLocalDateTime(zone).date
+
+internal fun Context.hasCalendarPermission(): Boolean =
+    ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CALENDAR) ==
+        PackageManager.PERMISSION_GRANTED
+
+/** Snapshot rendered by the agenda widget. */
+sealed interface AgendaWidgetData {
+    /** Calendar permission not granted — the widget can't read events. */
+    data object NeedsPermission : AgendaWidgetData
+    data class Ready(val today: LocalDate, val days: List<AgendaDay>) : AgendaWidgetData
+}
+
+/**
+ * Source data for the month widget: a wide window of instances plus the
+ * week-start preference and today. The widget computes each displayed month's
+ * grid from this in-memory list (via `layoutMonthWeeks`) as the user pages,
+ * so month navigation is pure recomposition — no reload, no flaky widget
+ * session restart.
+ */
+sealed interface MonthWidgetSource {
+    data object NeedsPermission : MonthWidgetSource
+    data class Ready(
+        val today: LocalDate,
+        val weekStart: DayOfWeek,
+        val instances: List<EventInstance>,
+    ) : MonthWidgetSource
+}
+
+/**
+ * Process-lived cache of the wide month window. Month navigation re-runs
+ * `provideGlance` (via `updateAll`), and re-querying ~13 months of instances on
+ * every arrow tap is what made paging feel sluggish — so we load once and reuse
+ * the same snapshot for every nearby month. Invalidated by
+ * [invalidateMonthWidgetCache] when calendar data changes (the freshness
+ * receiver), and automatically when the day rolls over (the `today` guard).
+ */
+internal object MonthWidgetCache {
+    @Volatile
+    var data: MonthWidgetSource.Ready? = null
+}
+
+internal fun invalidateMonthWidgetCache() {
+    MonthWidgetCache.data = null
+}
+
+/**
+ * One-shot read of the upcoming agenda for the widget. Reuses the app's
+ * [agendaRange] window and [groupAgendaDays] grouping, and the repository's
+ * [first]-emitted snapshot already has hidden calendars filtered out.
+ */
+internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
+    if (!hasCalendarPermission()) return AgendaWidgetData.NeedsPermission
+    val zone = systemZone()
+    val anchor = today(zone)
+    val repo = widgetEntryPoint().calendarRepository()
+    val instances = repo.instances(agendaRange(anchor, AGENDA_WIDGET_DAYS, zone)).first()
+    return AgendaWidgetData.Ready(today = anchor, days = groupAgendaDays(anchor, instances, zone))
+}
+
+/** One-shot wide read backing the month widget's grid for any nearby month. */
+internal suspend fun Context.loadMonthWidgetSource(): MonthWidgetSource {
+    if (!hasCalendarPermission()) return MonthWidgetSource.NeedsPermission
+    val zone = systemZone()
+    val anchor = today(zone)
+    // Reuse the cached window unless the day changed (then it's stale for "today").
+    MonthWidgetCache.data?.let { if (it.today == anchor) return it }
+    val ep = widgetEntryPoint()
+    val weekStart = ep.settingsPrefs().weekStart.first().resolveFirstDay(Locale.getDefault())
+    val from = anchor.minus(MONTH_WIDGET_RANGE_DAYS, DateTimeUnit.DAY).atStartOfDayIn(zone)
+    val to = anchor.plus(MONTH_WIDGET_RANGE_DAYS, DateTimeUnit.DAY).atTime(23, 59, 59).toInstant(zone)
+    val instances = ep.calendarRepository().instances(from..to).first()
+    return MonthWidgetSource.Ready(today = anchor, weekStart = weekStart, instances = instances)
+        .also { MonthWidgetCache.data = it }
+}

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetEntryPoint.kt

@@ -0,0 +1,27 @@
+package de.jeanlucmakiola.calendula.widget
+
+import android.content.Context
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+
+/**
+ * Hilt bridge for the Glance widgets. A [androidx.glance.appwidget.GlanceAppWidget]
+ * is instantiated by the framework, not by Hilt, so it can't take constructor
+ * injection. We instead reach the singleton graph through this entry point and
+ * read the same [CalendarRepository] / [SettingsPrefs] the app uses — so widget
+ * data (hidden-calendar filtering, week-start preference, …) matches the app
+ * one-to-one.
+ */
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface WidgetEntryPoint {
+    fun calendarRepository(): CalendarRepository
+    fun settingsPrefs(): SettingsPrefs
+}
+
+internal fun Context.widgetEntryPoint(): WidgetEntryPoint =
+    EntryPointAccessors.fromApplication(applicationContext, WidgetEntryPoint::class.java)

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetTheme.kt

@@ -0,0 +1,36 @@
+package de.jeanlucmakiola.calendula.widget
+
+import android.os.Build
+import androidx.compose.runtime.Composable
+import androidx.glance.GlanceTheme
+import androidx.glance.material3.ColorProviders
+import de.jeanlucmakiola.calendula.ui.theme.CalendulaDarkFallback
+import de.jeanlucmakiola.calendula.ui.theme.CalendulaLightFallback
+
+/**
+ * Brand fallback for devices without Material You dynamic colour (API < 31).
+ * Reuses the exact same hand-tuned schemes as the in-app theme
+ * ([CalendulaLightFallback] / [CalendulaDarkFallback]) so a widget on an older
+ * device matches the app surface-for-surface.
+ */
+private val CalendulaGlanceColors = ColorProviders(
+    light = CalendulaLightFallback,
+    dark = CalendulaDarkFallback,
+)
+
+/**
+ * Glance equivalent of `CalendulaTheme`. On API 31+ it follows the system's
+ * Material You palette (so the widget matches the home screen / the app's
+ * dynamic colour); below that it falls back to the brand scheme. Either way the
+ * widget draws only from M3 colour-role tokens (`GlanceTheme.colors.*`) — never
+ * a hardcoded colour — so it tracks light/dark automatically.
+ */
+@Composable
+fun CalendulaGlanceTheme(content: @Composable () -> Unit) {
+    val colors = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        GlanceTheme.colors
+    } else {
+        CalendulaGlanceColors
+    }
+    GlanceTheme(colors = colors, content = content)
+}

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetUpdateReceiver.kt

@@ -0,0 +1,41 @@
+package de.jeanlucmakiola.calendula.widget
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import androidx.glance.appwidget.updateAll
+import de.jeanlucmakiola.calendula.widget.agenda.AgendaWidget
+import de.jeanlucmakiola.calendula.widget.month.MonthWidget
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/**
+ * Redraws both home-screen widgets when their data goes stale. Triggered by:
+ *  - `PROVIDER_CHANGED` from the calendar provider — fires on any data change,
+ *    so it covers both the app's own writes and external sync.
+ *  - `DATE_CHANGED` / `TIME_SET` / `TIMEZONE_CHANGED` — so "today" highlighting
+ *    and the upcoming window roll over at midnight / on a clock change.
+ *
+ * Both widgets also carry an `updatePeriodMillis` backstop in their provider
+ * XML, and the month widget's refresh button forces an immediate redraw.
+ */
+class WidgetUpdateReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val pending = goAsync()
+        val appContext = context.applicationContext
+        // Calendar data may have changed (sync / our own write) — drop the cached
+        // month window so the widgets reload fresh. Month paging does NOT call
+        // this, so arrow taps stay instant.
+        invalidateMonthWidgetCache()
+        CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+            try {
+                AgendaWidget().updateAll(appContext)
+                MonthWidget().updateAll(appContext)
+            } finally {
+                pending.finish()
+            }
+        }
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidget.kt

@@ -0,0 +1,279 @@
+package de.jeanlucmakiola.calendula.widget.agenda
+
+import android.content.Context
+import android.content.res.Configuration
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.glance.ColorFilter
+import androidx.glance.GlanceId
+import androidx.glance.GlanceModifier
+import androidx.glance.GlanceTheme
+import androidx.glance.Image
+import androidx.glance.ImageProvider
+import androidx.glance.action.ActionParameters
+import androidx.glance.action.clickable
+import androidx.glance.appwidget.GlanceAppWidget
+import androidx.glance.appwidget.action.ActionCallback
+import androidx.glance.appwidget.action.actionRunCallback
+import androidx.glance.appwidget.action.actionStartActivity
+import androidx.glance.appwidget.cornerRadius
+import androidx.glance.appwidget.lazy.LazyColumn
+import androidx.glance.appwidget.lazy.items
+import androidx.glance.appwidget.provideContent
+import androidx.glance.appwidget.updateAll
+import androidx.glance.background
+import androidx.glance.layout.Alignment
+import androidx.glance.layout.Box
+import androidx.glance.layout.Column
+import androidx.glance.layout.Row
+import androidx.glance.layout.Spacer
+import androidx.glance.layout.fillMaxSize
+import androidx.glance.layout.fillMaxWidth
+import androidx.glance.layout.height
+import androidx.glance.layout.padding
+import androidx.glance.layout.size
+import androidx.glance.layout.width
+import androidx.glance.text.FontWeight
+import androidx.glance.text.Text
+import androidx.glance.text.TextStyle
+import de.jeanlucmakiola.calendula.MainActivity
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.widget.AgendaWidgetData
+import de.jeanlucmakiola.calendula.widget.CalendulaGlanceTheme
+import de.jeanlucmakiola.calendula.widget.loadAgendaWidgetData
+import de.jeanlucmakiola.calendula.widget.systemZone
+import de.jeanlucmakiola.calendula.widget.today
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+import java.time.format.TextStyle as JavaTextStyle
+import java.util.Locale
+
+/**
+ * "Upcoming" agenda widget — a continuously scrolling list of the next ~30 days
+ * of events grouped under day headers (the Google "Schedule" widget model).
+ * Reuses the app's [groupAgendaDays] grouping so it matches the in-app agenda.
+ */
+class AgendaWidget : GlanceAppWidget() {
+
+    override suspend fun provideGlance(context: Context, id: GlanceId) {
+        val data = context.loadAgendaWidgetData()
+        val dark = (context.resources.configuration.uiMode and
+            Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+        provideContent {
+            CalendulaGlanceTheme {
+                AgendaWidgetBody(data = data, dark = dark)
+            }
+        }
+    }
+}
+
+/** Re-reads the calendar and redraws the widget (header refresh button). */
+class RefreshAgendaAction : ActionCallback {
+    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
+        AgendaWidget().updateAll(context.applicationContext)
+    }
+}
+
+/** Flat row model so the [LazyColumn] can mix day headers and events. */
+private sealed interface AgendaRow {
+    data class Header(val date: LocalDate, val today: LocalDate) : AgendaRow
+    data class Event(val event: EventInstance) : AgendaRow
+}
+
+@Composable
+private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
+    Column(
+        modifier = GlanceModifier
+            .fillMaxSize()
+            .background(GlanceTheme.colors.surface)
+            .padding(horizontal = 8.dp, vertical = 6.dp),
+    ) {
+        AgendaHeader()
+        Spacer(GlanceModifier.height(4.dp))
+        when (data) {
+            AgendaWidgetData.NeedsPermission -> WidgetMessage(R.string.widget_needs_permission)
+            is AgendaWidgetData.Ready ->
+                if (data.days.isEmpty()) {
+                    WidgetMessage(R.string.agenda_empty_title)
+                } else {
+                    val rows = buildList {
+                        data.days.forEach { day ->
+                            add(AgendaRow.Header(day.date, data.today))
+                            day.events.forEach { add(AgendaRow.Event(it)) }
+                        }
+                    }
+                    LazyColumn(modifier = GlanceModifier.fillMaxSize()) {
+                        items(rows.size) { index ->
+                            when (val row = rows[index]) {
+                                is AgendaRow.Header -> DayHeaderRow(row.date, row.today)
+                                is AgendaRow.Event -> EventRow(row.event, dark)
+                            }
+                        }
+                    }
+                }
+        }
+    }
+}
+
+@Composable
+private fun AgendaHeader() {
+    val context = androidx.glance.LocalContext.current
+    Row(
+        modifier = GlanceModifier.fillMaxWidth().padding(horizontal = 4.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = context.getString(R.string.widget_agenda_title),
+            style = TextStyle(
+                color = GlanceTheme.colors.primary,
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Medium,
+            ),
+            modifier = GlanceModifier.defaultWeight(),
+        )
+        IconButton(
+            resId = R.drawable.ic_widget_refresh,
+            contentDescription = context.getString(R.string.widget_refresh),
+            onClick = GlanceModifier.clickable(actionRunCallback<RefreshAgendaAction>()),
+        )
+        IconButton(
+            resId = R.drawable.ic_widget_add,
+            contentDescription = context.getString(R.string.widget_new_event),
+            onClick = GlanceModifier.clickable(
+                actionStartActivity(
+                    MainActivity.openCreateIntent(context, today(systemZone())),
+                ),
+            ),
+        )
+    }
+}
+
+@Composable
+private fun IconButton(resId: Int, contentDescription: String, onClick: GlanceModifier) {
+    Box(
+        modifier = GlanceModifier.size(40.dp).then(onClick),
+        contentAlignment = Alignment.Center,
+    ) {
+        Image(
+            provider = ImageProvider(resId),
+            contentDescription = contentDescription,
+            colorFilter = ColorFilter.tint(GlanceTheme.colors.onSurfaceVariant),
+            modifier = GlanceModifier.size(22.dp),
+        )
+    }
+}
+
+@Composable
+private fun DayHeaderRow(date: LocalDate, today: LocalDate) {
+    val context = androidx.glance.LocalContext.current
+    Text(
+        text = agendaDayLabel(context, date, today),
+        style = TextStyle(
+            color = if (date == today) GlanceTheme.colors.primary
+            else GlanceTheme.colors.onSurfaceVariant,
+            fontSize = 13.sp,
+            fontWeight = FontWeight.Medium,
+        ),
+        modifier = GlanceModifier
+            .fillMaxWidth()
+            .padding(start = 8.dp, end = 8.dp, top = 10.dp, bottom = 4.dp)
+            .clickable(actionStartActivity(MainActivity.openDateIntent(context, date))),
+    )
+}
+
+@Composable
+private fun EventRow(event: EventInstance, dark: Boolean) {
+    val context = androidx.glance.LocalContext.current
+    val title = event.title.ifBlank { context.getString(R.string.event_untitled) }
+    Row(
+        modifier = GlanceModifier
+            .fillMaxWidth()
+            .padding(horizontal = 4.dp, vertical = 4.dp)
+            .clickable(
+                actionStartActivity(
+                    MainActivity.eventDetailIntent(
+                        context = context,
+                        eventId = event.eventId,
+                        beginMillis = event.start.toEpochMilliseconds(),
+                        endMillis = event.end.toEpochMilliseconds(),
+                    ),
+                ),
+            ),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Box(
+            modifier = GlanceModifier
+                .width(5.dp)
+                .height(36.dp)
+                .cornerRadius(3.dp)
+                .background(pastelize(event.color, dark)),
+        ) {}
+        Spacer(GlanceModifier.width(10.dp))
+        Column(modifier = GlanceModifier.defaultWeight()) {
+            Text(
+                text = title,
+                maxLines = 1,
+                style = TextStyle(color = GlanceTheme.colors.onSurface, fontSize = 14.sp),
+            )
+            Text(
+                text = eventTimeSummary(context, event),
+                maxLines = 1,
+                style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 12.sp),
+            )
+        }
+    }
+}
+
+@Composable
+private fun WidgetMessage(resId: Int) {
+    val context = androidx.glance.LocalContext.current
+    Box(
+        modifier = GlanceModifier.fillMaxSize().padding(16.dp),
+        contentAlignment = Alignment.Center,
+    ) {
+        Text(
+            text = context.getString(resId),
+            style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 14.sp),
+        )
+    }
+}
+
+private fun zone(): TimeZone = systemZone()
+
+/** "Today · Wed, 17 Jun" — relative word for today/tomorrow, else the date. */
+private fun agendaDayLabel(context: Context, date: LocalDate, today: LocalDate): String {
+    val relative = when (date) {
+        today -> context.getString(R.string.agenda_header_today)
+        today.plus(1, DateTimeUnit.DAY) -> context.getString(R.string.agenda_header_tomorrow)
+        else -> null
+    }
+    val locale = Locale.getDefault()
+    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
+    val weekday = java.dayOfWeek.getDisplayName(JavaTextStyle.SHORT, locale)
+    val monthName = java.month.getDisplayName(JavaTextStyle.SHORT, locale)
+    val formatted = "$weekday, ${date.day} $monthName"
+    return if (relative != null) "$relative · $formatted" else formatted
+}
+
+private fun eventTimeSummary(context: Context, event: EventInstance): String {
+    val time = if (event.isAllDay) {
+        context.getString(R.string.event_detail_all_day)
+    } else {
+        "${formatTime(event.start)} – ${formatTime(event.end)}"
+    }
+    val location = event.location?.takeIf { it.isNotBlank() }
+    return if (location != null) "$time · $location" else time
+}
+
+private fun formatTime(instant: Instant): String {
+    val t = instant.toLocalDateTime(zone()).time
+    return "%02d:%02d".format(t.hour, t.minute)
+}

app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidgetReceiver.kt

@@ -0,0 +1,13 @@
+package de.jeanlucmakiola.calendula.widget.agenda
+
+import androidx.glance.appwidget.GlanceAppWidget
+import androidx.glance.appwidget.GlanceAppWidgetReceiver
+
+/**
+ * Host-facing receiver for the agenda widget. Declared in the manifest with the
+ * `appwidget_info_agenda` provider metadata; delegates all rendering to
+ * [AgendaWidget].
+ */
+class AgendaWidgetReceiver : GlanceAppWidgetReceiver() {
+    override val glanceAppWidget: GlanceAppWidget = AgendaWidget()
+}

app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidget.kt

@@ -0,0 +1,433 @@
+package de.jeanlucmakiola.calendula.widget.month
+
+import android.content.Context
+import android.content.res.Configuration
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.glance.ColorFilter
+import androidx.glance.GlanceId
+import androidx.glance.GlanceModifier
+import androidx.glance.GlanceTheme
+import androidx.glance.Image
+import androidx.glance.ImageProvider
+import androidx.glance.LocalContext
+import androidx.glance.LocalSize
+import androidx.glance.action.ActionParameters
+import androidx.glance.action.actionParametersOf
+import androidx.glance.action.clickable
+import androidx.glance.appwidget.GlanceAppWidget
+import androidx.glance.appwidget.SizeMode
+import androidx.glance.appwidget.action.ActionCallback
+import androidx.glance.appwidget.action.actionRunCallback
+import androidx.glance.appwidget.action.actionStartActivity
+import androidx.glance.appwidget.cornerRadius
+import androidx.glance.appwidget.provideContent
+import androidx.glance.appwidget.state.updateAppWidgetState
+import androidx.glance.appwidget.updateAll
+import androidx.glance.background
+import androidx.glance.currentState
+import androidx.glance.layout.Alignment
+import androidx.glance.layout.Box
+import androidx.glance.layout.Column
+import androidx.glance.layout.Row
+import androidx.glance.layout.Spacer
+import androidx.glance.layout.fillMaxSize
+import androidx.glance.layout.fillMaxWidth
+import androidx.glance.layout.height
+import androidx.glance.layout.padding
+import androidx.glance.layout.size
+import androidx.glance.layout.width
+import androidx.glance.state.PreferencesGlanceStateDefinition
+import androidx.glance.text.FontWeight
+import androidx.glance.text.Text
+import androidx.glance.text.TextAlign
+import androidx.glance.text.TextStyle
+import androidx.glance.unit.ColorProvider
+import de.jeanlucmakiola.calendula.MainActivity
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.month.MonthWeek
+import de.jeanlucmakiola.calendula.ui.month.layoutMonthWeeks
+import de.jeanlucmakiola.calendula.widget.CalendulaGlanceTheme
+import de.jeanlucmakiola.calendula.widget.MonthWidgetSource
+import de.jeanlucmakiola.calendula.widget.loadMonthWidgetSource
+import de.jeanlucmakiola.calendula.widget.systemZone
+import de.jeanlucmakiola.calendula.widget.today
+import androidx.compose.ui.unit.Dp
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.Month
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.YearMonth
+import java.time.format.TextStyle as JavaTextStyle
+import java.util.Locale
+
+/** Per-widget state: the displayed month as `year * 12 + monthOrdinal`. */
+private val MONTH_INDEX_KEY = intPreferencesKey("month_index")
+
+/** Event rows (lanes) shown per week before the rest collapse into "+N". */
+private const val MAX_LANES = 3
+private val LANE_HEIGHT = 14.dp
+private val DAY_NUMBER_HEIGHT = 18.dp
+private val GRID_HPADDING = 8.dp
+
+/** Dark ink that reads on the pastelized event fills, like the in-app MonthBar. */
+private val EventInk = ColorProvider(Color(0xDE000000))
+
+private fun currentMonthIndex(zone: TimeZone): Int {
+    val t = today(zone)
+    return t.year * 12 + t.month.ordinal
+}
+
+private fun yearMonthOf(index: Int): YearMonth =
+    YearMonth(index / 12, Month(index % 12 + 1))
+
+/**
+ * Month-grid widget: a 6×7 calendar with today highlighted, connected multi-day
+ * event bars and titled single-day pills (the in-app lane layout via
+ * [layoutMonthWeeks]), and prev/next/today navigation.
+ *
+ * Columns are sized explicitly from [LocalSize] (hence [SizeMode.Exact]) so a
+ * multi-day span renders as a single Box spanning its columns — connected, no
+ * inter-cell seam, with rounded end caps. The displayed month lives in Glance
+ * state and is read reactively in the composition ([currentState]) so the arrows
+ * move it via plain recomposition, not a (here-unreliable) widget session reload.
+ */
+class MonthWidget : GlanceAppWidget() {
+
+    override val stateDefinition = PreferencesGlanceStateDefinition
+    override val sizeMode = SizeMode.Exact
+
+    override suspend fun provideGlance(context: Context, id: GlanceId) {
+        val source = context.loadMonthWidgetSource()
+        val dark = (context.resources.configuration.uiMode and
+            Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+        provideContent {
+            CalendulaGlanceTheme {
+                MonthWidgetBody(source = source, dark = dark)
+            }
+        }
+    }
+}
+
+/** Step the displayed month by the `delta` action parameter (±1). */
+class ShiftMonthAction : ActionCallback {
+    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
+        val delta = parameters[deltaKey] ?: 0
+        updateAppWidgetState(context, glanceId) { prefs ->
+            val cur = prefs[MONTH_INDEX_KEY] ?: currentMonthIndex(systemZone())
+            prefs[MONTH_INDEX_KEY] = cur + delta
+        }
+        MonthWidget().updateAll(context.applicationContext)
+    }
+
+    companion object {
+        val deltaKey = ActionParameters.Key<Int>("delta")
+    }
+}
+
+/** Jump the displayed month back to the current month. */
+class ResetMonthAction : ActionCallback {
+    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
+        updateAppWidgetState(context, glanceId) { prefs -> prefs.remove(MONTH_INDEX_KEY) }
+        MonthWidget().updateAll(context.applicationContext)
+    }
+}
+
+@Composable
+private fun MonthWidgetBody(source: MonthWidgetSource, dark: Boolean) {
+    Column(
+        modifier = GlanceModifier
+            .fillMaxSize()
+            .background(GlanceTheme.colors.surface)
+            .padding(horizontal = GRID_HPADDING, vertical = 6.dp),
+    ) {
+        when (source) {
+            MonthWidgetSource.NeedsPermission -> {
+                MonthHeader(label = "Calendula")
+                PermissionMessage()
+            }
+            is MonthWidgetSource.Ready -> {
+                val zone = systemZone()
+                val index = currentState(MONTH_INDEX_KEY) ?: currentMonthIndex(zone)
+                val ym = yearMonthOf(index)
+                // Column width from the live widget size, minus our H padding.
+                val colW = (LocalSize.current.width - GRID_HPADDING * 2) / 7
+                val weeks = layoutMonthWeeks(ym, source.weekStart, source.instances, zone)
+
+                MonthHeader(label = monthLabel(ym))
+                Spacer(GlanceModifier.height(2.dp))
+                WeekdayHeader(weekStart = source.weekStart, colW = colW)
+                weeks.forEach { week ->
+                    WeekRow(
+                        week = week,
+                        currentMonth = ym.month,
+                        today = source.today,
+                        dark = dark,
+                        colW = colW,
+                        modifier = GlanceModifier.defaultWeight(),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun MonthHeader(label: String) {
+    val context = LocalContext.current
+    Row(
+        modifier = GlanceModifier.fillMaxWidth(),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        HeaderIcon(
+            resId = R.drawable.ic_widget_chevron_left,
+            contentDescription = context.getString(R.string.widget_prev_month),
+            onClick = GlanceModifier.clickable(
+                actionRunCallback<ShiftMonthAction>(
+                    actionParametersOf(ShiftMonthAction.deltaKey to -1),
+                ),
+            ),
+        )
+        Text(
+            text = label,
+            style = TextStyle(
+                color = GlanceTheme.colors.primary,
+                fontSize = 15.sp,
+                fontWeight = FontWeight.Medium,
+                textAlign = TextAlign.Center,
+            ),
+            modifier = GlanceModifier
+                .defaultWeight()
+                .clickable(actionRunCallback<ResetMonthAction>()),
+        )
+        HeaderIcon(
+            resId = R.drawable.ic_widget_today,
+            contentDescription = context.getString(R.string.widget_today),
+            onClick = GlanceModifier.clickable(
+                actionStartActivity(MainActivity.openDateIntent(context, today(systemZone()))),
+            ),
+        )
+        HeaderIcon(
+            resId = R.drawable.ic_widget_chevron_right,
+            contentDescription = context.getString(R.string.widget_next_month),
+            onClick = GlanceModifier.clickable(
+                actionRunCallback<ShiftMonthAction>(
+                    actionParametersOf(ShiftMonthAction.deltaKey to 1),
+                ),
+            ),
+        )
+    }
+}
+
+@Composable
+private fun HeaderIcon(resId: Int, contentDescription: String, onClick: GlanceModifier) {
+    Box(
+        modifier = GlanceModifier.size(40.dp).then(onClick),
+        contentAlignment = Alignment.Center,
+    ) {
+        Image(
+            provider = ImageProvider(resId),
+            contentDescription = contentDescription,
+            colorFilter = ColorFilter.tint(GlanceTheme.colors.onSurfaceVariant),
+            modifier = GlanceModifier.size(20.dp),
+        )
+    }
+}
+
+@Composable
+private fun WeekdayHeader(weekStart: DayOfWeek, colW: Dp) {
+    Row(modifier = GlanceModifier.fillMaxWidth()) {
+        weekdayNarrowNames(weekStart).forEach { name ->
+            Text(
+                text = name,
+                style = TextStyle(
+                    color = GlanceTheme.colors.onSurfaceVariant,
+                    fontSize = 11.sp,
+                    textAlign = TextAlign.Center,
+                ),
+                modifier = GlanceModifier.width(colW),
+            )
+        }
+    }
+}
+
+/** Narrow weekday initials starting at [weekStart], in the device locale.
+ * Computed outside the composable so the locale read stays observable-safe. */
+private fun weekdayNarrowNames(weekStart: DayOfWeek): List<String> {
+    val locale = Locale.getDefault()
+    return (0 until 7).map { i ->
+        java.time.DayOfWeek.of((weekStart.ordinal + i) % 7 + 1)
+            .getDisplayName(JavaTextStyle.NARROW, locale)
+    }
+}
+
+@Composable
+private fun WeekRow(
+    week: MonthWeek,
+    currentMonth: Month,
+    today: LocalDate,
+    dark: Boolean,
+    colW: Dp,
+    modifier: GlanceModifier,
+) {
+    Column(modifier = modifier.fillMaxWidth()) {
+        // Day numbers.
+        Row(modifier = GlanceModifier.fillMaxWidth()) {
+            week.days.forEach { date ->
+                DayNumber(
+                    date = date,
+                    isToday = date == today,
+                    inMonth = date.month == currentMonth,
+                    colW = colW,
+                )
+            }
+        }
+        Spacer(GlanceModifier.height(2.dp))
+        // One lane row per event row. A multi-day span is a single Box spanning
+        // its columns (colW * n) so it's connected with no seam and rounded ends.
+        repeat(MAX_LANES) { lane ->
+            LaneRow(week = week, lane = lane, dark = dark, colW = colW)
+            Spacer(GlanceModifier.height(1.dp))
+        }
+        OverflowRow(week = week, colW = colW)
+    }
+}
+
+@Composable
+private fun DayNumber(date: LocalDate, isToday: Boolean, inMonth: Boolean, colW: Dp) {
+    Box(
+        modifier = GlanceModifier.width(colW).height(DAY_NUMBER_HEIGHT),
+        contentAlignment = Alignment.Center,
+    ) {
+        Box(
+            modifier = GlanceModifier
+                .size(DAY_NUMBER_HEIGHT)
+                .then(if (isToday) GlanceModifier.cornerRadius(DAY_NUMBER_HEIGHT / 2).background(GlanceTheme.colors.primary) else GlanceModifier),
+            contentAlignment = Alignment.Center,
+        ) {
+            Text(
+                text = date.day.toString(),
+                style = TextStyle(
+                    color = when {
+                        isToday -> GlanceTheme.colors.onPrimary
+                        inMonth -> GlanceTheme.colors.onSurface
+                        else -> GlanceTheme.colors.onSurfaceVariant
+                    },
+                    fontSize = 11.sp,
+                    fontWeight = if (isToday) FontWeight.Bold else FontWeight.Normal,
+                ),
+            )
+        }
+    }
+}
+
+@Composable
+private fun LaneRow(week: MonthWeek, lane: Int, dark: Boolean, colW: Dp) {
+    Row(modifier = GlanceModifier.fillMaxWidth()) {
+        var col = 0
+        while (col < 7) {
+            val span = week.spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }
+            if (span != null) {
+                val cols = span.endCol - col + 1
+                SpanBar(event = span.event, dark = dark, width = colW * cols)
+                col = span.endCol + 1
+            } else {
+                val timed = timedEventAt(week, lane, col, week.days[col])
+                if (timed != null) {
+                    SpanBar(event = timed, dark = dark, width = colW)
+                } else {
+                    Box(GlanceModifier.width(colW).height(LANE_HEIGHT)) {}
+                }
+                col += 1
+            }
+        }
+    }
+}
+
+/** A single connected, rounded event bar [width] wide with its clipped title. */
+@Composable
+private fun SpanBar(event: EventInstance, dark: Boolean, width: Dp) {
+    val context = LocalContext.current
+    Box(modifier = GlanceModifier.width(width).height(LANE_HEIGHT).padding(horizontal = 1.dp)) {
+        Box(
+            modifier = GlanceModifier
+                .fillMaxSize()
+                .cornerRadius(4.dp)
+                .background(pastelize(event.color, dark)),
+            contentAlignment = Alignment.CenterStart,
+        ) {
+            Text(
+                text = event.title.ifBlank { context.getString(R.string.event_untitled) },
+                maxLines = 1,
+                style = TextStyle(color = EventInk, fontSize = 9.sp),
+                modifier = GlanceModifier.padding(horizontal = 3.dp),
+            )
+        }
+    }
+}
+
+@Composable
+private fun OverflowRow(week: MonthWeek, colW: Dp) {
+    Row(modifier = GlanceModifier.fillMaxWidth()) {
+        week.days.forEachIndexed { col, date ->
+            val shownSpans = week.spans.count { col in it.startCol..it.endCol && it.lane < MAX_LANES }
+            val freeSlots = (MAX_LANES - shownSpans).coerceAtLeast(0)
+            val timedShown = minOf(freeSlots, week.timedByDay[date].orEmpty().size)
+            val hidden = (week.countByDay[date] ?: 0) - shownSpans - timedShown
+            Box(
+                modifier = GlanceModifier.width(colW).height(LANE_HEIGHT),
+                contentAlignment = Alignment.CenterStart,
+            ) {
+                if (hidden > 0) {
+                    Text(
+                        text = "+$hidden",
+                        maxLines = 1,
+                        style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 9.sp),
+                        modifier = GlanceModifier.padding(start = 3.dp),
+                    )
+                }
+            }
+        }
+    }
+}
+
+/** The timed single-day event that fills lane [lane] on day [col], if any. */
+private fun timedEventAt(week: MonthWeek, lane: Int, col: Int, date: LocalDate): EventInstance? {
+    val occupied = week.spans
+        .filter { col in it.startCol..it.endCol && it.lane < MAX_LANES }
+        .map { it.lane }
+        .toSet()
+    val freeSlots = (0 until MAX_LANES).filter { it !in occupied }
+    val timed = week.timedByDay[date].orEmpty()
+    return timed.getOrNull(freeSlots.indexOf(lane))
+}
+
+@Composable
+private fun PermissionMessage() {
+    val context = LocalContext.current
+    Box(
+        modifier = GlanceModifier.fillMaxSize().padding(16.dp),
+        contentAlignment = Alignment.Center,
+    ) {
+        Text(
+            text = context.getString(R.string.widget_needs_permission),
+            style = TextStyle(
+                color = GlanceTheme.colors.onSurfaceVariant,
+                fontSize = 14.sp,
+                textAlign = TextAlign.Center,
+            ),
+        )
+    }
+}
+
+private fun monthLabel(month: YearMonth): String {
+    val locale = Locale.getDefault()
+    val name = java.time.Month.of(month.month.ordinal + 1)
+        .getDisplayName(JavaTextStyle.FULL, locale)
+    return "$name ${month.year}"
+}

app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidgetReceiver.kt

@@ -0,0 +1,12 @@
+package de.jeanlucmakiola.calendula.widget.month
+
+import androidx.glance.appwidget.GlanceAppWidget
+import androidx.glance.appwidget.GlanceAppWidgetReceiver
+
+/**
+ * Host-facing receiver for the month widget. Declared in the manifest with the
+ * `appwidget_info_month` provider metadata; delegates rendering to [MonthWidget].
+ */
+class MonthWidgetReceiver : GlanceAppWidgetReceiver() {
+    override val glanceAppWidget: GlanceAppWidget = MonthWidget()
+}

app/src/main/res/drawable/ic_gitea.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Gitea brand mark, used on the "Source" button in Settings → About.
+    Single-path logo from Simple Icons (https://simpleicons.org, CC0),
+    pathData kept verbatim so Android's PathParser reads the arc flags.
+    fillColor is a placeholder; the Compose Icon recolours it via tint.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M4.209 4.603c-.247 0-.525.02-.84.088-.333.07-1.28.283-2.054 1.027C-.403 7.25.035 9.685.089 10.052c.065.446.263 1.687 1.21 2.768 1.749 2.141 5.513 2.092 5.513 2.092s.462 1.103 1.168 2.119c.955 1.263 1.936 2.248 2.89 2.367 2.406 0 7.212-.004 7.212-.004s.458.004 1.08-.394c.535-.324 1.013-.893 1.013-.893s.492-.527 1.18-1.73c.21-.37.385-.729.538-1.068 0 0 2.107-4.471 2.107-8.823-.042-1.318-.367-1.55-.443-1.627-.156-.156-.366-.153-.366-.153s-4.475.252-6.792.306c-.508.011-1.012.023-1.512.027v4.474l-.634-.301c0-1.39-.004-4.17-.004-4.17-1.107.016-3.405-.084-3.405-.084s-5.399-.27-5.987-.324c-.187-.011-.401-.032-.648-.032zm.354 1.832h.111s.271 2.269.6 3.597C5.549 11.147 6.22 13 6.22 13s-.996-.119-1.641-.348c-.99-.324-1.409-.714-1.409-.714s-.73-.511-1.096-1.52C1.444 8.73 2.021 7.7 2.021 7.7s.32-.859 1.47-1.145c.395-.106.863-.12 1.072-.12zm8.33 2.554c.26.003.509.127.509.127l.868.422-.529 1.075a.686.686 0 0 0-.614.359.685.685 0 0 0 .072.756l-.939 1.924a.69.69 0 0 0-.66.527.687.687 0 0 0 .347.763.686.686 0 0 0 .867-.206.688.688 0 0 0-.069-.882l.916-1.874a.667.667 0 0 0 .237-.02.657.657 0 0 0 .271-.137 8.826 8.826 0 0 1 1.016.512.761.761 0 0 1 .286.282c.073.21-.073.569-.073.569-.087.29-.702 1.55-.702 1.55a.692.692 0 0 0-.676.477.681.681 0 1 0 1.157-.252c.073-.141.141-.282.214-.431.19-.397.515-1.16.515-1.16.035-.066.218-.394.103-.814-.095-.435-.48-.638-.48-.638-.467-.301-1.116-.58-1.116-.58s0-.156-.042-.27a.688.688 0 0 0-.148-.241l.516-1.062 2.89 1.401s.48.218.583.619c.073.282-.019.534-.069.657-.24.587-2.1 4.317-2.1 4.317s-.232.554-.748.588a1.065 1.065 0 0 1-.393-.045l-.202-.08-4.31-2.1s-.417-.218-.49-.596c-.083-.31.104-.691.104-.691l2.073-4.272s.183-.37.466-.497a.855.855 0 0 1 .35-.077z" />
+</vector>

app/src/main/res/drawable/ic_shortcut_new_event.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Launcher long-press shortcut icon ("New event"): a brand-coloured circle
+     with a white calendar+plus glyph, as one scalable vector. Self-contained so
+     it stays visible on any launcher surface (shortcut icons aren't tinted, so a
+     bare white glyph would vanish on a light sheet). -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#3B5364"
+        android:pathData="M0,12 a12,12 0 1,0 24,0 a12,12 0 1,0 -24,0 Z" />
+    <group
+        android:scaleX="0.58"
+        android:scaleY="0.58"
+        android:translateX="5"
+        android:translateY="5">
+        <path
+            android:fillColor="@android:color/white"
+            android:pathData="M19,3h-1V1h-2v2H8V1H6v2H5C3.89,3 3.01,3.9 3.01,5L3,19c0,1.1 0.89,2 2,2h14c1.1,0 2,-0.9 2,-2V5C21,3.9 20.1,3 19,3zM19,19H5V8h14V19z" />
+        <path
+            android:fillColor="@android:color/white"
+            android:pathData="M11.5,10.5h1v2h2v1h-2v2h-1v-2h-2v-1h2z" />
+    </group>
+</vector>

app/src/main/res/drawable/ic_widget_add.xml

@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp" android:height="24dp"
+    android:viewportWidth="24" android:viewportHeight="24">
+    <path android:fillColor="@android:color/white"
+        android:pathData="M19,13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"/>
+</vector>

app/src/main/res/drawable/ic_widget_chevron_left.xml

@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp" android:height="24dp"
+    android:viewportWidth="24" android:viewportHeight="24">
+    <path android:fillColor="@android:color/white"
+        android:pathData="M15.41,7.41L14,6l-6,6 6,6 1.41,-1.41L10.83,12z"/>
+</vector>

app/src/main/res/drawable/ic_widget_chevron_right.xml

@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp" android:height="24dp"
+    android:viewportWidth="24" android:viewportHeight="24">
+    <path android:fillColor="@android:color/white"
+        android:pathData="M10,6L8.59,7.41 13.17,12l-4.58,4.59L10,18l6,-6z"/>
+</vector>

app/src/main/res/drawable/ic_widget_refresh.xml

@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp" android:height="24dp"
+    android:viewportWidth="24" android:viewportHeight="24">
+    <path android:fillColor="@android:color/white"
+        android:pathData="M17.65,6.35C16.2,4.9 14.21,4 12,4c-4.42,0 -7.99,3.58 -7.99,8s3.57,8 7.99,8c3.73,0 6.84,-2.55 7.73,-6h-2.08c-0.82,2.33 -3.04,4 -5.65,4 -3.31,0 -6,-2.69 -6,-6s2.69,-6 6,-6c1.66,0 3.14,0.69 4.22,1.78L13,11h7V4l-2.35,2.35z"/>
+</vector>

app/src/main/res/drawable/ic_widget_today.xml

@@ -0,0 +1,6 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp" android:height="24dp"
+    android:viewportWidth="24" android:viewportHeight="24">
+    <path android:fillColor="@android:color/white"
+        android:pathData="M19,3h-1V1h-2v2H8V1H6v2H5C3.89,3 3.01,3.9 3.01,5L3,19c0,1.1 0.89,2 2,2h14c1.1,0 2,-0.9 2,-2V5c0,-1.1 -0.9,-2 -2,-2zM19,19H5V8h14v11zM7,10h5v5H7z"/>
+</vector>

app/src/main/res/drawable/preview_stripe.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="#4F7CAC" />
+    <corners android:radius="3dp" />
+</shape>

app/src/main/res/drawable/preview_today_circle.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <solid android:color="@color/widget_preview_primary" />
+</shape>

app/src/main/res/drawable/preview_widget_bg.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="@color/widget_preview_surface" />
+    <corners android:radius="20dp" />
+</shape>

app/src/main/res/layout/widget_preview_agenda.xml

@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Static mock shown in the widget picker (android:previewLayout). Not the
+     runtime layout — the live widget is rendered by Glance. Colours are the
+     brand light scheme so the picker preview reads on its light sheet. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:background="@drawable/preview_widget_bg"
+    android:padding="14dp">
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/widget_agenda_title"
+        android:textColor="@color/widget_preview_primary"
+        android:textSize="15sp"
+        android:textStyle="bold" />
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="8dp"
+        android:text="@string/agenda_header_today"
+        android:textColor="@color/widget_preview_primary"
+        android:textSize="12sp"
+        android:textStyle="bold" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="10dp"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
+        <ImageView
+            android:layout_width="5dp"
+            android:layout_height="34dp"
+            android:contentDescription="@null"
+            android:background="@drawable/preview_stripe"
+            android:backgroundTint="#4F7CAC" />
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:orientation="vertical">
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="Standup"
+                android:textColor="@color/widget_preview_on_surface"
+                android:textSize="14sp" />
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="09:00 – 09:30"
+                android:textColor="@color/widget_preview_variant"
+                android:textSize="12sp" />
+        </LinearLayout>
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="8dp"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
+        <ImageView
+            android:layout_width="5dp"
+            android:layout_height="34dp"
+            android:contentDescription="@null"
+            android:background="@drawable/preview_stripe"
+            android:backgroundTint="#6FA37A" />
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:orientation="vertical">
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="Design review"
+                android:textColor="@color/widget_preview_on_surface"
+                android:textSize="14sp" />
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="11:30 – 12:30"
+                android:textColor="@color/widget_preview_variant"
+                android:textSize="12sp" />
+        </LinearLayout>
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="8dp"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
+        <ImageView
+            android:layout_width="5dp"
+            android:layout_height="34dp"
+            android:contentDescription="@null"
+            android:background="@drawable/preview_stripe"
+            android:backgroundTint="#C58A56" />
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="10dp"
+            android:orientation="vertical">
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="1:1 with Mara"
+                android:textColor="@color/widget_preview_on_surface"
+                android:textSize="14sp" />
+            <TextView
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="14:00 – 14:30"
+                android:textColor="@color/widget_preview_variant"
+                android:textSize="12sp" />
+        </LinearLayout>
+    </LinearLayout>
+</LinearLayout>

app/src/main/res/layout/widget_preview_month.xml

@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Static mock shown in the widget picker (android:previewLayout). The live
+     widget is rendered by Glance with real events; this only needs to read as
+     "a month grid" in the picker. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:background="@drawable/preview_widget_bg"
+    android:padding="12dp">
+
+    <!-- Header -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="‹"
+            android:textColor="@color/widget_preview_variant"
+            android:textSize="16sp" />
+        <TextView
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:gravity="center"
+            android:text="June 2026"
+            android:textColor="@color/widget_preview_primary"
+            android:textSize="15sp"
+            android:textStyle="bold" />
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="›"
+            android:textColor="@color/widget_preview_variant"
+            android:textSize="16sp" />
+    </LinearLayout>
+
+    <!-- Weekday header -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="6dp"
+        android:orientation="horizontal">
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="M" android:textColor="@color/widget_preview_variant" android:textSize="11sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="T" android:textColor="@color/widget_preview_variant" android:textSize="11sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="W" android:textColor="@color/widget_preview_variant" android:textSize="11sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="T" android:textColor="@color/widget_preview_variant" android:textSize="11sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="F" android:textColor="@color/widget_preview_variant" android:textSize="11sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="S" android:textColor="@color/widget_preview_variant" android:textSize="11sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="S" android:textColor="@color/widget_preview_variant" android:textSize="11sp" />
+    </LinearLayout>
+
+    <!-- Week 1: 1..7 (event bar on the 3rd) -->
+    <LinearLayout android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:orientation="horizontal" android:layout_marginTop="4dp">
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="1" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="2" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="3" android:textColor="#4F7CAC" android:textStyle="bold" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="4" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="5" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="6" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="7" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+    </LinearLayout>
+
+    <!-- Week 2: 8..14 (bars on 11,12,13) -->
+    <LinearLayout android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:orientation="horizontal" android:layout_marginTop="4dp">
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="8" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="9" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="10" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="11" android:textColor="#6FA37A" android:textStyle="bold" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="12" android:textColor="#6FA37A" android:textStyle="bold" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="13" android:textColor="#6FA37A" android:textStyle="bold" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="14" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+    </LinearLayout>
+
+    <!-- Week 3: 15..21 (17 = today) -->
+    <LinearLayout android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:orientation="horizontal" android:layout_marginTop="4dp">
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="15" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="16" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <LinearLayout android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:orientation="horizontal">
+            <TextView android:layout_width="22dp" android:layout_height="22dp" android:gravity="center"
+                android:text="17" android:textColor="@color/widget_preview_on_primary" android:textStyle="bold" android:textSize="12sp"
+                android:background="@drawable/preview_today_circle" />
+        </LinearLayout>
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="18" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="19" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="20" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="21" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+    </LinearLayout>
+
+    <!-- Week 4: 22..28 (bar on 24) -->
+    <LinearLayout android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:orientation="horizontal" android:layout_marginTop="4dp">
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="22" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="23" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="24" android:textColor="#C58A56" android:textStyle="bold" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="25" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="26" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="27" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="28" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+    </LinearLayout>
+
+    <!-- Week 5: 29, 30, then trailing July days greyed -->
+    <LinearLayout android:layout_width="match_parent" android:layout_height="0dp" android:layout_weight="1" android:orientation="horizontal" android:layout_marginTop="4dp">
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="29" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="30" android:textColor="@color/widget_preview_on_surface" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="1" android:textColor="@color/widget_preview_variant" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="2" android:textColor="@color/widget_preview_variant" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="3" android:textColor="@color/widget_preview_variant" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="4" android:textColor="@color/widget_preview_variant" android:textSize="12sp" />
+        <TextView android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:gravity="center" android:text="5" android:textColor="@color/widget_preview_variant" android:textSize="12sp" />
+    </LinearLayout>
+</LinearLayout>

app/src/main/res/values-de/strings.xml

@@ -47,6 +47,9 @@
     <string name="event_detail_back">Zurück</string>
     <string name="event_detail_edit">Bearbeiten</string>
     <string name="event_detail_delete">Löschen</string>
+    <string name="event_detail_share">Teilen</string>
+    <string name="event_share_chooser_title">Termin teilen</string>
+    <string name="event_share_failed">Termin konnte nicht geteilt werden.</string>
     <string name="event_delete_title">Termin löschen?</string>
     <string name="event_delete_body">Der Termin wird aus deinem Kalender und von allen synchronisierten Geräten entfernt.</string>
     <string name="event_delete_recurring_title">Wiederkehrenden Termin löschen</string>
@@ -82,6 +85,15 @@
     <string name="event_edit_availability">Verfügbarkeit</string>
     <string name="event_edit_visibility">Sichtbarkeit</string>
 
+    <!-- Termin-Formular — eigene Terminfarbe -->
+    <string name="event_edit_color">Farbe</string>
+    <string name="event_edit_color_default">Kalenderfarbe</string>
+    <string name="event_edit_color_custom">Eigene Farbe</string>
+    <string name="event_edit_color_reset">Zurücksetzen</string>
+    <string name="event_edit_color_unsupported">Für diesen Kalender nicht verfügbar</string>
+    <string name="event_edit_color_unsupported_hint">Dieser Kalender stellt keine Farbpalette bereit. Du kannst eigene Farben für solche Kalender in den Einstellungen aktivieren.</string>
+    <string name="event_edit_color_sync_warning">Dieser Kalender verwirft oder überschreibt die Farbe unter Umständen bei der nächsten Synchronisierung.</string>
+
     <!-- Termin-Formular — Speicher-Konflikt (v2.0) -->
     <string name="event_edit_conflict_title">Termin wurde extern geändert</string>
     <string name="event_edit_conflict_body">Während du bearbeitet hast, wurde dieser Termin anderswo geändert — durch Synchronisierung oder eine andere App. Was soll mit deinen Änderungen passieren?</string>
@@ -187,8 +199,34 @@
     <string name="view_month">Monat</string>
     <string name="view_week">Woche</string>
     <string name="view_day">Tag</string>
+    <string name="view_agenda">Agenda</string>
     <string name="view_section">Ansicht</string>
 
+    <!-- Zu Datum springen (Navigationsleiste) -->
+    <string name="drawer_jump_to_date">Zu Datum springen</string>
+
+    <!-- Agenda-Ansicht -->
+    <string name="agenda_today_action">Heute</string>
+    <string name="agenda_header_today">Heute</string>
+    <string name="agenda_header_tomorrow">Morgen</string>
+    <string name="agenda_empty_title">Nichts geplant</string>
+    <string name="agenda_empty_subtitle">Anstehende Termine erscheinen hier.</string>
+
+    <!-- Startbildschirm-Widgets -->
+    <string name="widget_agenda_title">Anstehend</string>
+    <string name="widget_agenda_label">Calendula Agenda</string>
+    <string name="widget_month_label">Calendula Monat</string>
+    <string name="widget_refresh">Aktualisieren</string>
+    <string name="widget_new_event">Neuer Termin</string>
+    <string name="widget_needs_permission">Öffne Calendula, um Kalenderzugriff zu erlauben</string>
+    <string name="widget_prev_month">Vorheriger Monat</string>
+    <string name="widget_next_month">Nächster Monat</string>
+    <string name="widget_today">Heute</string>
+
+    <!-- Verknüpfungen (Long-Press auf das App-Symbol) -->
+    <string name="shortcut_new_event_short">Neuer Termin</string>
+    <string name="shortcut_new_event_long">Neuen Termin erstellen</string>
+
     <!-- Kalender-Filter (M3) -->
     <string name="filter_title">Kalender</string>
 
@@ -208,23 +246,44 @@
     <string name="settings_week_start_sunday">Sonntag</string>
     <string name="settings_section_event_form">Termin-Formular</string>
     <string name="settings_form_fields_hint">Standardmäßig angezeigte Felder — alles Weitere liegt hinter \"Weitere Felder\"</string>
+    <string name="settings_color_unsupported">Farben auf nicht unterstützten Kalendern erlauben</string>
+    <string name="settings_color_unsupported_hint">Manche Kalender (z. B. bestimmte CalDAV) stellen keine Farbpalette bereit; eine eigene Terminfarbe wird dort bei der nächsten Synchronisierung unter Umständen verworfen oder überschrieben. Das ist eine Einschränkung dieser Kalender und kann von Calendula nicht behoben werden.</string>
     <string name="settings_section_notifications">Benachrichtigungen</string>
     <string name="settings_reminders">Termin-Erinnerungen</string>
     <string name="settings_reminders_hint">Erinnerungen doppelt? Eine andere Kalender-App zeigt sie ebenfalls — schalte sie in einer der beiden ab.</string>
+    <string name="settings_default_reminder">Standard-Erinnerung</string>
+    <string name="settings_default_reminder_allday">Ganztägige Termine</string>
+    <string name="settings_allday_reminder_time">Uhrzeit für ganztägige Erinnerungen</string>
+    <string name="settings_allday_reminder_time_hint">Erinnerungen für ganztägige Termine werden um %1$s ausgelöst</string>
+    <string name="reminder_none">Keine</string>
+    <string name="reminder_use_default">Standard-Erinnerung verwenden</string>
+    <string name="reminder_custom_amount">Anzahl</string>
+    <string name="reminder_custom_with_value">Benutzerdefiniert (%1$s)</string>
+    <string name="reminder_custom_set">Übernehmen</string>
+    <string name="settings_calendar_reminders_hint">Standard pro Kalender überschreiben — getrennt für Termine mit Uhrzeit und ganztägige Termine. Ein Kalender kann den Standard übernehmen, weglassen oder einen eigenen festlegen.</string>
+    <string name="settings_calendar_reminder_inherits">Standard (%1$s)</string>
+    <string name="settings_reliable_delivery">Zuverlässige Zustellung</string>
+    <string name="settings_reliable_delivery_hint">Android verzögert Erinnerungen womöglich, um Akku zu sparen. Nimm Calendula aus, damit sie pünktlich ankommen.</string>
+    <string name="settings_reliable_delivery_exempt">Von der Akku-Optimierung ausgenommen — Erinnerungen kommen pünktlich.</string>
     <string name="settings_section_calendars">Kalender</string>
     <string name="settings_manage_calendars">Kalender verwalten</string>
     <string name="settings_manage_calendars_hint">Lokale Kalender anlegen, synchronisierte verwalten</string>
     <string name="settings_section_language">Sprache</string>
     <string name="settings_language">App-Sprache</string>
     <string name="settings_language_auto">Systemstandard</string>
-    <string name="settings_language_german">Deutsch</string>
-    <string name="settings_language_english">English</string>
+    <!-- Hub category subtitles -->
+    <string name="settings_appearance_subtitle">Design, dynamische Farben, Wochenstart</string>
+    <string name="settings_event_form_subtitle">Standardfelder für neue Termine</string>
+    <string name="settings_notifications_subtitle">Termin-Erinnerungen</string>
     <string name="settings_section_about">Über</string>
-    <string name="settings_version">Version</string>
     <string name="settings_license">Lizenz</string>
     <string name="settings_license_value">MIT</string>
-    <string name="settings_source">Quellcode</string>
-    <string name="settings_source_open">Öffnen</string>
+    <string name="settings_about_author">von Jean-Luc Makiola</string>
+    <string name="settings_about_source">Quellcode</string>
+    <string name="settings_about_version">Version %1$s</string>
+    <string name="settings_about_logo_desc">Calendula-App-Symbol</string>
+    <string name="settings_report_problem">Problem melden</string>
+    <string name="settings_report_problem_hint">Absturzbericht senden oder Issue-Tracker öffnen</string>
 
     <!-- Calendar manager -->
     <string name="calendars_title">Kalender</string>
@@ -243,4 +302,53 @@
     <string name="calendars_delete_confirm_title">Kalender löschen?</string>
     <string name="calendars_delete_confirm_message">\"%1$s\" und alle zugehörigen Termine werden dauerhaft von diesem Gerät entfernt.</string>
     <string name="calendars_write_error">Änderung konnte nicht gespeichert werden.</string>
+    <!-- Backup (whole-calendar .ics export) -->
+    <string name="calendars_backup_header">Sicherung</string>
+    <string name="calendars_backup_hint">Lokale Kalender werden nirgends synchronisiert – exportiere sie als .ics-Datei, um eine Kopie zu behalten.</string>
+    <string name="calendars_backup_action">Als .ics-Datei exportieren</string>
+    <string name="calendars_backup_failed">Sicherung konnte nicht exportiert werden.</string>
+    <plurals name="calendars_backup_done">
+        <item quantity="one">%d Termin exportiert.</item>
+        <item quantity="other">%d Termine exportiert.</item>
+    </plurals>
+    <!-- Import (.ics) -->
+    <string name="import_title">Termine importieren</string>
+    <string name="import_target_header">Zu Kalender hinzufügen</string>
+    <string name="import_empty">In dieser Datei wurden keine Termine gefunden.</string>
+    <string name="import_failed">Datei konnte nicht gelesen werden.</string>
+    <string name="import_no_calendar">Kein beschreibbarer Kalender zum Importieren. Lege zuerst einen lokalen Kalender an.</string>
+    <string name="import_done_title">Import abgeschlossen</string>
+    <string name="import_close">Schließen</string>
+    <string name="import_warning_recurrence">Einige geänderte Einzeltermine wiederkehrender Termine wurden übersprungen.</string>
+    <string name="import_warning_no_start">Ein Termin ohne Startzeit wurde übersprungen.</string>
+    <string name="import_warning_attendees">Gästelisten wurden nicht importiert.</string>
+    <string name="import_warning_timezone">Eine unbekannte Zeitzone wurde durch die deines Geräts ersetzt.</string>
+    <plurals name="import_event_count">
+        <item quantity="one">%d Termin in dieser Datei.</item>
+        <item quantity="other">%d Termine in dieser Datei.</item>
+    </plurals>
+    <plurals name="import_action">
+        <item quantity="one">%d Termin importieren</item>
+        <item quantity="other">%d Termine importieren</item>
+    </plurals>
+    <plurals name="import_done_imported">
+        <item quantity="one">%d Termin importiert.</item>
+        <item quantity="other">%d Termine importiert.</item>
+    </plurals>
+    <plurals name="import_done_skipped">
+        <item quantity="one">%d bereits in diesem Kalender übersprungen.</item>
+        <item quantity="other">%d bereits in diesem Kalender übersprungen.</item>
+    </plurals>
+
+    <!-- Absturzberichte: vom Nutzer selbst als Gitea-Issue einreichbar -->
+    <string name="crash_dialog_title">Calendula ist abgestürzt</string>
+    <string name="crash_dialog_message">Calendula wurde beim letzten Mal unerwartet beendet. Du kannst bei der Behebung helfen, indem du diesen Bericht als Issue sendest. Er bleibt auf deinem Gerät, bis du ihn teilst, und enthält keine persönlichen Daten oder Kalenderinhalte — nur die technischen Angaben unten.</string>
+    <string name="crash_dialog_report">Melden</string>
+    <string name="crash_dialog_dismiss">Nicht jetzt</string>
+    <string name="crash_report_issue_title">Absturzbericht</string>
+    <string name="crash_report_clip_label">Calendula-Absturzbericht</string>
+    <string name="crash_report_copied">Bericht in die Zwischenablage kopiert</string>
+    <string name="crash_report_open_failed">Der Issue-Tracker konnte nicht geöffnet werden. Der Bericht ist in deiner Zwischenablage.</string>
+    <string name="crash_report_body_template">Danke, dass du einen Absturz in Calendula meldest. Bitte ergänze, was du gerade getan hast, und sende dann ab.\n\n### Was ist passiert\n\n\n### Absturzbericht\n%1$s\n</string>
+    <string name="crash_report_body_paste">_(Der Bericht war zu lang für diesen Link — füge ihn aus deiner Zwischenablage hier ein.)_</string>
 </resources>

app/src/main/res/values-night-v31/widget_preview_colors.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="widget_preview_surface">@android:color/system_neutral1_900</color>
+    <color name="widget_preview_on_surface">@android:color/system_neutral1_50</color>
+    <color name="widget_preview_variant">@android:color/system_neutral2_200</color>
+    <color name="widget_preview_primary">@android:color/system_accent1_200</color>
+    <color name="widget_preview_on_primary">@android:color/system_accent1_800</color>
+</resources>

app/src/main/res/values-night/colors.xml

@@ -0,0 +1,6 @@
+<resources>
+    <!-- Dark-scheme window backdrop, matching the Compose dark background/surface
+         (#101316) so activity recreation (e.g. language switch) doesn't flash a
+         lighter grey. See values/colors.xml. -->
+    <color name="window_background">#FF101316</color>
+</resources>

app/src/main/res/values-night/widget_preview_colors.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="widget_preview_surface">#101316</color>
+    <color name="widget_preview_on_surface">#E1E3E6</color>
+    <color name="widget_preview_variant">#A8ADB2</color>
+    <color name="widget_preview_primary">#A3CBE2</color>
+    <color name="widget_preview_on_primary">#003348</color>
+</resources>

app/src/main/res/values-v31/widget_preview_colors.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="widget_preview_surface">@android:color/system_neutral1_50</color>
+    <color name="widget_preview_on_surface">@android:color/system_neutral1_900</color>
+    <color name="widget_preview_variant">@android:color/system_neutral2_700</color>
+    <color name="widget_preview_primary">@android:color/system_accent1_600</color>
+    <color name="widget_preview_on_primary">@android:color/system_accent1_0</color>
+</resources>

app/src/main/res/values/colors.xml

@@ -3,4 +3,8 @@
     <color name="seed">#FF5C6B7A</color>
     <!-- Adaptive icon background -->
     <color name="ic_launcher_background">#FF5C6B7A</color>
+    <!-- Window backdrop shown during activity recreation (e.g. on a language
+         switch). Matches the Compose light scheme background/surface so the
+         recreation is seamless; overridden for dark in values-night. -->
+    <color name="window_background">#FFFBFCFE</color>
 </resources>

app/src/main/res/values/strings.xml

@@ -48,6 +48,9 @@
     <string name="event_detail_back">Back</string>
     <string name="event_detail_edit">Edit</string>
     <string name="event_detail_delete">Delete</string>
+    <string name="event_detail_share">Share</string>
+    <string name="event_share_chooser_title">Share event</string>
+    <string name="event_share_failed">Couldn\'t share this event.</string>
     <string name="event_delete_title">Delete event?</string>
     <string name="event_delete_body">The event is removed from your calendar and from every device it syncs to.</string>
     <string name="event_delete_recurring_title">Delete recurring event</string>
@@ -83,6 +86,15 @@
     <string name="event_edit_availability">Availability</string>
     <string name="event_edit_visibility">Visibility</string>
 
+    <!-- Event form — per-event color -->
+    <string name="event_edit_color">Color</string>
+    <string name="event_edit_color_default">Calendar color</string>
+    <string name="event_edit_color_custom">Custom color</string>
+    <string name="event_edit_color_reset">Reset</string>
+    <string name="event_edit_color_unsupported">Not available for this calendar</string>
+    <string name="event_edit_color_unsupported_hint">This calendar publishes no color set. You can allow custom colors for such calendars in Settings.</string>
+    <string name="event_edit_color_sync_warning">This calendar may drop or overwrite the color on its next sync.</string>
+
     <!-- Event form — save conflict (v2.0) -->
     <string name="event_edit_conflict_title">Event changed elsewhere</string>
     <string name="event_edit_conflict_body">While you were editing, this event was changed — by sync or another app. What should happen to your changes?</string>
@@ -188,8 +200,30 @@
     <string name="view_month">Month</string>
     <string name="view_week">Week</string>
     <string name="view_day">Day</string>
+    <string name="view_agenda">Agenda</string>
     <string name="view_section">View</string>
 
+    <!-- Jump to date (drawer) -->
+    <string name="drawer_jump_to_date">Jump to date</string>
+
+    <!-- Agenda view -->
+    <string name="agenda_today_action">Today</string>
+    <string name="agenda_header_today">Today</string>
+    <string name="agenda_header_tomorrow">Tomorrow</string>
+    <string name="agenda_empty_title">Nothing scheduled</string>
+    <string name="agenda_empty_subtitle">Upcoming events will show up here.</string>
+
+    <!-- Home-screen widgets -->
+    <string name="widget_agenda_title">Upcoming</string>
+    <string name="widget_agenda_label">Calendula agenda</string>
+    <string name="widget_month_label">Calendula month</string>
+    <string name="widget_refresh">Refresh</string>
+    <string name="widget_new_event">New event</string>
+    <string name="widget_needs_permission">Open Calendula to grant calendar access</string>
+    <string name="widget_prev_month">Previous month</string>
+    <string name="widget_next_month">Next month</string>
+    <string name="widget_today">Today</string>
+
     <!-- Calendar filter (M3) -->
     <string name="filter_title">Calendars</string>
 
@@ -209,23 +243,44 @@
     <string name="settings_week_start_sunday">Sunday</string>
     <string name="settings_section_event_form">New event form</string>
     <string name="settings_form_fields_hint">Fields shown by default — everything else sits behind \"More fields\"</string>
+    <string name="settings_color_unsupported">Allow colors on unsupported calendars</string>
+    <string name="settings_color_unsupported_hint">Some calendars (e.g. certain CalDAV) publish no color set; a custom event color may be dropped or overwritten on their next sync. That\'s a limitation of those calendars, not something Calendula can fix.</string>
     <string name="settings_section_notifications">Notifications</string>
     <string name="settings_reminders">Event reminders</string>
     <string name="settings_reminders_hint">Seeing reminders twice? Another calendar app is posting them too — turn them off in one of the two.</string>
+    <string name="settings_default_reminder">Default reminder</string>
+    <string name="settings_default_reminder_allday">All-day events</string>
+    <string name="settings_allday_reminder_time">All-day reminder time</string>
+    <string name="settings_allday_reminder_time_hint">Reminders for all-day events fire at %1$s</string>
+    <string name="reminder_none">None</string>
+    <string name="reminder_use_default">Use default reminder</string>
+    <string name="reminder_custom_amount">Amount</string>
+    <string name="reminder_custom_with_value">Custom (%1$s)</string>
+    <string name="reminder_custom_set">Set</string>
+    <string name="settings_calendar_reminders_hint">Override the default per calendar — separately for timed and all-day events. A calendar can keep the default, drop it, or set its own.</string>
+    <string name="settings_calendar_reminder_inherits">Default (%1$s)</string>
+    <string name="settings_reliable_delivery">Reliable delivery</string>
+    <string name="settings_reliable_delivery_hint">Android may delay reminders to save battery. Exempt Calendula so they arrive on time.</string>
+    <string name="settings_reliable_delivery_exempt">Exempt from battery optimisation — reminders arrive on time.</string>
     <string name="settings_section_calendars">Calendars</string>
     <string name="settings_manage_calendars">Manage calendars</string>
     <string name="settings_manage_calendars_hint">Create local calendars; manage synced ones</string>
     <string name="settings_section_language">Language</string>
     <string name="settings_language">App language</string>
     <string name="settings_language_auto">System default</string>
-    <string name="settings_language_german">Deutsch</string>
-    <string name="settings_language_english">English</string>
+    <!-- Hub category subtitles -->
+    <string name="settings_appearance_subtitle">Theme, dynamic colour, week start</string>
+    <string name="settings_event_form_subtitle">Default fields for new events</string>
+    <string name="settings_notifications_subtitle">Event reminders</string>
     <string name="settings_section_about">About</string>
-    <string name="settings_version">Version</string>
     <string name="settings_license">License</string>
     <string name="settings_license_value">MIT</string>
-    <string name="settings_source">Source code</string>
-    <string name="settings_source_open">Open</string>
+    <string name="settings_about_author">by Jean-Luc Makiola</string>
+    <string name="settings_about_source">Source</string>
+    <string name="settings_about_version">Version %1$s</string>
+    <string name="settings_about_logo_desc">Calendula app icon</string>
+    <string name="settings_report_problem">Report a problem</string>
+    <string name="settings_report_problem_hint">Send a crash report or open the issue tracker</string>
 
     <!-- Calendar manager -->
     <string name="calendars_title">Calendars</string>
@@ -244,5 +299,62 @@
     <string name="calendars_delete_confirm_title">Delete calendar?</string>
     <string name="calendars_delete_confirm_message">\"%1$s\" and all of its events will be permanently removed from this device.</string>
     <string name="calendars_write_error">Couldn\'t save the change.</string>
+    <!-- Backup (whole-calendar .ics export) -->
+    <string name="calendars_backup_header">Backup</string>
+    <string name="calendars_backup_hint">Local calendars aren\'t synced anywhere, so export them to an .ics file to keep a copy.</string>
+    <string name="calendars_backup_action">Export as .ics file</string>
+    <string name="calendars_backup_failed">Couldn\'t export the backup.</string>
+    <plurals name="calendars_backup_done">
+        <item quantity="one">Exported %d event.</item>
+        <item quantity="other">Exported %d events.</item>
+    </plurals>
+    <!-- Import (.ics) -->
+    <string name="import_title">Import events</string>
+    <string name="import_target_header">Add to calendar</string>
+    <string name="import_empty">No events found in this file.</string>
+    <string name="import_failed">Couldn\'t read this file.</string>
+    <string name="import_no_calendar">No writable calendar to import into. Create a local calendar first.</string>
+    <string name="import_done_title">Import complete</string>
+    <string name="import_close">Close</string>
+    <string name="import_warning_recurrence">Some changed occurrences of recurring events were skipped.</string>
+    <string name="import_warning_no_start">An event without a start time was skipped.</string>
+    <string name="import_warning_attendees">Guest lists weren\'t imported.</string>
+    <string name="import_warning_timezone">An unknown time zone fell back to your device\'s.</string>
+    <plurals name="import_event_count">
+        <item quantity="one">%d event in this file.</item>
+        <item quantity="other">%d events in this file.</item>
+    </plurals>
+    <plurals name="import_action">
+        <item quantity="one">Import %d event</item>
+        <item quantity="other">Import %d events</item>
+    </plurals>
+    <plurals name="import_done_imported">
+        <item quantity="one">Imported %d event.</item>
+        <item quantity="other">Imported %d events.</item>
+    </plurals>
+    <plurals name="import_done_skipped">
+        <item quantity="one">Skipped %d already in this calendar.</item>
+        <item quantity="other">Skipped %d already in this calendar.</item>
+    </plurals>
+    <!-- Launcher long-press shortcuts -->
+    <string name="shortcut_new_event_short">New event</string>
+    <string name="shortcut_new_event_long">Create a new event</string>
+
     <string name="about_source_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula</string>
+    <string name="about_license_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula/src/branch/main/LICENSE</string>
+
+    <!-- Crash reporting: a captured report the user can submit, by hand, as a
+         Gitea issue (the app sends nothing automatically). -->
+    <string name="crash_dialog_title">Calendula crashed</string>
+    <string name="crash_dialog_message">Calendula closed unexpectedly last time. You can help fix it by sending this report as an issue. It stays on your device until you choose to share it, and includes no personal data or calendar content — only the technical details below.</string>
+    <string name="crash_dialog_report">Report</string>
+    <string name="crash_dialog_dismiss">Not now</string>
+    <string name="crash_report_issue_title">Crash report</string>
+    <string name="crash_report_clip_label">Calendula crash report</string>
+    <string name="crash_report_copied">Report copied to your clipboard</string>
+    <string name="crash_report_open_failed">Couldn\'t open the issue tracker. The report is on your clipboard.</string>
+    <string name="crash_report_body_template">Thanks for reporting a crash in Calendula. Please add anything you remember about what you were doing, then submit.\n\n### What happened\n\n\n### Crash report\n%1$s\n</string>
+    <string name="crash_report_body_paste">_(The report was too long for this link — paste it from your clipboard here.)_</string>
+    <string name="report_issue_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula/issues/new</string>
+    <string name="report_issue_choose_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula/issues/new/choose</string>
 </resources>

app/src/main/res/values/themes.xml

@@ -1,5 +1,10 @@
 <resources xmlns:tools="http://schemas.android.com/tools">
-    <style name="Theme.Calendula" parent="android:Theme.Material.Light.NoActionBar">
+    <!-- AppCompat (DayNight) parent so MainActivity can be an AppCompatActivity,
+         which is required for AppCompatDelegate.setApplicationLocales (the in-app
+         language picker) to sync to the system. Actual colours are driven by the
+         Compose theme; this is essentially the launch/backdrop theme. -->
+    <style name="Theme.Calendula" parent="Theme.AppCompat.DayNight.NoActionBar">
+        <item name="android:windowBackground">@color/window_background</item>
         <item name="android:statusBarColor">@android:color/transparent</item>
         <item name="android:navigationBarColor">@android:color/transparent</item>
         <item name="android:windowLightStatusBar">true</item>

app/src/main/res/values/widget_preview_colors.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Colours for the static widget-picker previews. Base = brand light fallback
+     (API < 31). values-v31 maps them to the Material You dynamic palette so the
+     preview matches the live Glance widget; -night holds the dark variants. -->
+<resources>
+    <color name="widget_preview_surface">#FBFCFE</color>
+    <color name="widget_preview_on_surface">#191C1F</color>
+    <color name="widget_preview_variant">#6E7479</color>
+    <color name="widget_preview_primary">#3B5364</color>
+    <color name="widget_preview_on_primary">#FFFFFF</color>
+</resources>