docs(changelog): note the ACTION_EDIT intent and .ics MIME types

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
feat(intent): handle ACTION_EDIT and broaden .ics MIME types
2026-07-15 17:25:56 +02:00 · 2026-07-15 17:23:40 +02:00 · 2026-07-15 17:23:31 +02:00 · 2026-07-13 15:35:03 +00:00 · 2026-07-13 17:25:51 +02:00 · 2026-07-13 14:39:18 +00:00
26 changed files with 1484 additions and 185 deletions
--- a/.gitea/workflows/translations.yaml
+++ b/.gitea/workflows/translations.yaml
@@ -3,13 +3,15 @@ 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).
+#
+# Runs on every PR (no path filter) so the required "Translations / check"
+# status is always reported — like the `ci` job. A path-filtered workflow is
+# skipped on unrelated PRs and never posts its status, which leaves that
+# required check pending forever and blocks the merge of any code-only PR into a
+# release/* branch. The check itself is cheap and simply passes when the
+# committed translations are consistent, so always running it costs nothing.
 on:
  pull_request:
-    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 }}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,7 +7,63 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+### Added
+- A custom snooze duration. The **Snooze duration** setting (Settings →
+  Notifications) gains a **Custom…** option next to the minute presets: pick any
+  amount and switch between minutes and hours, so a snoozed reminder comes back
+  after exactly the delay you want instead of only a preset one ([#40]).
+- Move an event to another calendar. When editing an existing event, the
+  calendar row is now tappable — pick a different calendar and saving moves the
+  event across, instead of having to delete it and recreate it elsewhere.
+  Recurring series move as a whole, keeping their individually-edited and
+  cancelled occurrences, and any reminders and guests come along too. A calendar
+  can't simply be reassigned underneath an event, so Calendula recreates it on
+  the target and removes the original — the same approach other calendar apps
+  take. Thanks to @prismplex for the suggestion ([#39]).
+- Open an event straight into the edit form from another app. Calendula already
+  answered the "new event" and "open this event" hand-offs from other apps and
+  widgets; it now also answers the "edit this event" one, so an assistant, task
+  app, or widget can send an existing event to Calendula and land on its edit
+  screen rather than the read-only details. A hand-off with no event attached
+  opens the same prefilled create form as "new event". Calendula also recognises
+  a couple more file labels the same calendar data arrives under (`.vcs`
+  vCalendar files and the `application/ics` type), so opening or sharing those
+  into Calendula works too.
+
 ### Fixed
+- Reminders for events on another day no longer read as if they were today. A
+  reminder fired ahead of time — say, the day before — used to show only the
+  event's time, making it look like it was happening now. The notification now
+  says which day: **Tomorrow** or **Yesterday**, the weekday for another day this
+  week, or the date for anything further out. Thanks to @moonj for the report
+  ([#46]).
+
+## [2.14.1] — 2026-07-13
+
+### Fixed
+- Deleting one occurrence of a repeating event no longer breaks the series.
+  Choosing "This event" when deleting an occurrence of a recurring event could
+  wipe out every *other* occurrence while leaving the one you deleted behind as
+  a stale, still-tappable ghost — and deleting it again brought the series back.
+  A single-occurrence delete now removes exactly that occurrence and leaves the
+  rest of the series untouched, and the deleted occurrence disappears from the
+  grid straight away. This holds on every kind of calendar, including the
+  on-device ones Calendula keeps for contact birthdays and anniversaries, where
+  the series is a yearly repeat. Thanks to @moonj for the report ([#47]).
+- Tapping an event in a third-party widget opens it in Calendula. v2.13.1 taught
+  Calendula to answer the "new event" hand-off from other apps and widgets; now
+  it also answers the "open this event" one, so tapping an existing event in a
+  widget such as Todo Agenda offers Calendula and lands on that event's details.
+  Thanks to @bushrang3r for the report ([#48]).
+- Events created from other apps get your default reminder. An event handed over
+  by another app or widget — Google Maps' "add to calendar", the Todo Agenda
+  widget's "+" — opened with no reminder at all, ignoring the default set in
+  Settings. It now starts with your default reminder, the same as an event you
+  create in Calendula. An event opened from an `.ics` file is treated differently,
+  because the file has its own say: Calendula keeps whatever reminders it carries
+  (including none at all) and asks you once whether to apply your default instead
+  — it never quietly overrides the file. If you have no default set, it doesn't
+  ask ([#49]).
 - A tidy colour picker on CalDAV calendars. For calendars synced by a CalDAV
  app (such as DAVx5), the event colour picker showed every colour the account
  publishes — nearly 150 swatches in alphabetical order, many of them
@@ -888,3 +944,9 @@ automatically, with zero telemetry and no internet permission.
 [#33]: https://codeberg.org/jlmakiola/calendula/issues/33
 [#34]: https://codeberg.org/jlmakiola/calendula/issues/34
 [#37]: https://codeberg.org/jlmakiola/calendula/issues/37
+[#39]: https://codeberg.org/jlmakiola/calendula/issues/39
+[#40]: https://codeberg.org/jlmakiola/calendula/issues/40
+[#46]: https://codeberg.org/jlmakiola/calendula/issues/46
+[#47]: https://codeberg.org/jlmakiola/calendula/issues/47
+[#48]: https://codeberg.org/jlmakiola/calendula/issues/48
+[#49]: https://codeberg.org/jlmakiola/calendula/issues/49
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -28,8 +28,8 @@ android {
        // which builds this version and then creates the matching vX.Y.Z tag +
        // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
        // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 21400
-        versionName = "2.14.0"
+        versionCode = 21401
+        versionName = "2.14.1"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt
@@ -18,6 +18,8 @@ import android.util.Log
 import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.Attendee
+import de.jeanlucmakiola.calendula.domain.AttendeeRelationship
+import de.jeanlucmakiola.calendula.domain.AttendeeType
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
@@ -179,6 +181,25 @@ interface CalendarDataSource {
        allDayReminderTimeMinutes: Int,
    )

+    /**
+     * Move an event (for recurring events: the whole series, with its modified
+     * and cancelled occurrences) to [targetCalendarId], returning the new
+     * `Events._ID`. `CALENDAR_ID` is sync-adapter-owned and can't be updated in
+     * place, so this is copy+delete: the row is re-inserted on the target (its
+     * `UID_2445` preserved), its exceptions, reminders and editable guests
+     * replayed, the [original]→[updated] field edits applied, then the source
+     * deleted. The source is removed only once the copy fully succeeds; a failure
+     * before that rolls the new event back, leaving the original untouched.
+     * [allDayReminderTimeMinutes]: see [insertEvent].
+     */
+    fun moveEvent(
+        eventId: Long,
+        targetCalendarId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long
+
    /**
     * Change a single occurrence of a recurring event by inserting a
     * modified-occurrence exception at [beginMillis] (the occurrence's
@@ -885,6 +906,190 @@ class AndroidCalendarDataSource @Inject constructor(
        }
    }

+    override fun moveEvent(
+        eventId: Long,
+        targetCalendarId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long {
+        // CALENDAR_ID can't be updated in place, so re-create the event on the
+        // target calendar and delete the source. Everything that identifies or
+        // hangs off the event is copied first; the source row is removed only
+        // once the copy (including its exceptions) is complete — a failure
+        // anywhere before that rolls the new event back, so the move is
+        // all-or-nothing and never leaves a half-copied duplicate.
+        val master = queryMoveMaster(eventId)
+            ?: throw WriteFailedException("read event to move id=$eventId")
+        // Keep the source UID so an .ics backup dedups and a sync adapter can
+        // recognise the moved event; mint one only if the source carried none.
+        val uid = master.uid?.takeIf { it.isNotEmpty() } ?: "${UUID.randomUUID()}@calendula"
+        val newEventId = resolver.insert(
+            CalendarContract.Events.CONTENT_URI,
+            buildMovedMasterValues(master.event, targetCalendarId, uid).toContentValues(),
+        )?.let(ContentUris::parseId)
+            ?: throw WriteFailedException("insert moved event into calendar id=$targetCalendarId")
+        try {
+            copyReminderRows(fromEventId = eventId, toEventId = newEventId)
+            insertAttendees(newEventId, editableAttendees(eventId))
+            copyExceptions(fromEventId = eventId, toEventId = newEventId)
+            // Apply the user's field edits exactly as a same-calendar "all
+            // events" save would: the moved master carries the source's values,
+            // so the dirty diff against [original] writes only what changed
+            // (including a time or rrule edit made in the same save).
+            updateEvent(newEventId, original, updated, allDayReminderTimeMinutes)
+        } catch (t: Throwable) {
+            // Undo the partial copy so a failed move leaves nothing behind; the
+            // source is still intact (it's deleted only past this point).
+            runCatching { deleteEvent(newEventId) }
+            throw t
+        }
+        deleteEvent(eventId)
+        return newEventId
+    }
+
+    /** The master row of the event to move, as a verbatim-insert snapshot. */
+    private fun queryMoveMaster(eventId: Long): MoveMaster? = resolver.query(
+        ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+        MoveMasterProjection.COLUMNS,
+        null, null, null,
+    )?.use { c ->
+        if (!c.moveToFirst()) return@use null
+        val r = CursorColumnReader(c)
+        MoveMaster(
+            uid = r.getString(MoveMasterProjection.IDX_UID),
+            event = MasterEventSnapshot(
+                title = r.getString(MoveMasterProjection.IDX_TITLE).orEmpty(),
+                isAllDay = r.getInt(MoveMasterProjection.IDX_ALL_DAY) != 0,
+                dtStartMillis = r.getLong(MoveMasterProjection.IDX_DTSTART),
+                dtEndMillis = r.getLong(MoveMasterProjection.IDX_DTEND)
+                    .takeUnless { r.isNull(MoveMasterProjection.IDX_DTEND) },
+                duration = r.getString(MoveMasterProjection.IDX_DURATION),
+                rrule = r.getString(MoveMasterProjection.IDX_RRULE)?.takeIf { it.isNotBlank() },
+                rdate = r.getString(MoveMasterProjection.IDX_RDATE),
+                exdate = r.getString(MoveMasterProjection.IDX_EXDATE),
+                timezone = r.getString(MoveMasterProjection.IDX_EVENT_TIMEZONE),
+                availability = r.getInt(MoveMasterProjection.IDX_AVAILABILITY),
+                accessLevel = r.getInt(MoveMasterProjection.IDX_ACCESS_LEVEL),
+                status = r.getInt(MoveMasterProjection.IDX_STATUS)
+                    .takeUnless { r.isNull(MoveMasterProjection.IDX_STATUS) },
+                location = r.getString(MoveMasterProjection.IDX_LOCATION),
+                description = r.getString(MoveMasterProjection.IDX_DESCRIPTION),
+            ),
+        )
+    }
+
+    private data class MoveMaster(val uid: String?, val event: MasterEventSnapshot)
+
+    /** Copy every stored reminder row (raw offsets and method) onto [toEventId]. */
+    private fun copyReminderRows(fromEventId: Long, toEventId: Long) = resolver.query(
+        CalendarContract.Reminders.CONTENT_URI,
+        arrayOf(CalendarContract.Reminders.MINUTES, CalendarContract.Reminders.METHOD),
+        CalendarContract.Reminders.EVENT_ID + " = ?",
+        arrayOf(fromEventId.toString()),
+        null,
+    )?.use { c ->
+        while (c.moveToNext()) {
+            val values = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, toEventId)
+                put(CalendarContract.Reminders.MINUTES, c.getInt(0))
+                put(CalendarContract.Reminders.METHOD, c.getInt(1))
+            }
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, values) == null) {
+                Log.w(TAG, "Failed to copy a reminder to moved event $toEventId")
+            }
+        }
+    } ?: Unit
+
+    /**
+     * The event's editable guests as [EventAttendee]s — the rows the move
+     * re-creates. Mirrors the edit form's filter: the organizer and resource
+     * rows (backend-owned, not user-editable) and any without an email are
+     * dropped; the response status resets to "invited" on re-insert.
+     */
+    private fun editableAttendees(eventId: Long): List<EventAttendee> = queryAttendees(eventId)
+        .filter {
+            it.relationship != AttendeeRelationship.Organizer && it.type != AttendeeType.Resource
+        }
+        .mapNotNull { a ->
+            a.email?.takeIf { it.isNotBlank() }?.let { email ->
+                EventAttendee(email = email, name = a.name, optional = a.type == AttendeeType.Optional)
+            }
+        }
+
+    /**
+     * Replay every exception of the series [fromEventId] against the moved series
+     * [toEventId]. The copy preserved the recurrence skeleton, so each occurrence
+     * time still resolves: a cancelled occurrence is re-hidden with a cancelled
+     * exception, a modified one is re-inserted with its fields (then its reminders
+     * reconciled and editable guests copied). No-op for a non-recurring event.
+     */
+    private fun copyExceptions(fromEventId: Long, toEventId: Long) {
+        queryExceptionRows(fromEventId).forEach { ex ->
+            if (ex.isCancelled) {
+                val values = ContentValues().apply {
+                    put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, ex.originalInstanceMillis)
+                    put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
+                }
+                resolver.insert(
+                    ContentUris.withAppendedId(
+                        CalendarContract.Events.CONTENT_EXCEPTION_URI, toEventId,
+                    ),
+                    values,
+                ) ?: throw WriteFailedException("copy cancelled occurrence to event id=$toEventId")
+            } else {
+                val uri = resolver.insert(
+                    ContentUris.withAppendedId(
+                        CalendarContract.Events.CONTENT_EXCEPTION_URI, toEventId,
+                    ),
+                    buildCopiedExceptionValues(ex).toContentValues(),
+                ) ?: throw WriteFailedException("copy modified occurrence to event id=$toEventId")
+                val newExceptionId = ContentUris.parseId(uri)
+                // The provider may clone the parent's reminders onto the new
+                // exception; reconcile to the source exception's exact set so
+                // they neither double nor drop. Same DTSTART → same all-day
+                // encoding, so the stored offsets match directly.
+                reconcileReminders(
+                    newExceptionId,
+                    queryReminders(ex.exceptionEventId).map { it.minutes },
+                )
+                insertAttendees(newExceptionId, editableAttendees(ex.exceptionEventId))
+            }
+        }
+    }
+
+    /** The series' exception rows (modified + cancelled), oldest occurrence first. */
+    private fun queryExceptionRows(seriesEventId: Long): List<ExceptionRowSnapshot> = resolver.query(
+        CalendarContract.Events.CONTENT_URI,
+        ExceptionProjection.COLUMNS,
+        "${CalendarContract.Events.ORIGINAL_ID} = ? AND ${CalendarContract.Events.DELETED} = 0",
+        arrayOf(seriesEventId.toString()),
+        CalendarContract.Events.ORIGINAL_INSTANCE_TIME + " ASC",
+    )?.use { c ->
+        c.mapAll {
+            val r = CursorColumnReader(c)
+            val status = r.getInt(ExceptionProjection.IDX_STATUS)
+                .takeUnless { r.isNull(ExceptionProjection.IDX_STATUS) }
+            ExceptionRowSnapshot(
+                exceptionEventId = r.getLong(ExceptionProjection.IDX_ID),
+                originalInstanceMillis = r.getLong(ExceptionProjection.IDX_ORIGINAL_INSTANCE_TIME),
+                isCancelled = status == CalendarContract.Events.STATUS_CANCELED,
+                status = status,
+                title = r.getString(ExceptionProjection.IDX_TITLE).orEmpty(),
+                isAllDay = r.getInt(ExceptionProjection.IDX_ALL_DAY) != 0,
+                dtStartMillis = r.getLong(ExceptionProjection.IDX_DTSTART),
+                dtEndMillis = r.getLong(ExceptionProjection.IDX_DTEND)
+                    .takeUnless { r.isNull(ExceptionProjection.IDX_DTEND) },
+                duration = r.getString(ExceptionProjection.IDX_DURATION),
+                timezone = r.getString(ExceptionProjection.IDX_EVENT_TIMEZONE),
+                availability = r.getInt(ExceptionProjection.IDX_AVAILABILITY),
+                accessLevel = r.getInt(ExceptionProjection.IDX_ACCESS_LEVEL),
+                location = r.getString(ExceptionProjection.IDX_LOCATION),
+                description = r.getString(ExceptionProjection.IDX_DESCRIPTION),
+            )
+        }
+    } ?: emptyList()
+
    override fun updateOccurrence(
        eventId: Long,
        beginMillis: Long,
@@ -979,6 +1184,8 @@ class AndroidCalendarDataSource @Inject constructor(
            CalendarContract.Events.EVENT_TIMEZONE,
            CalendarContract.Events.DURATION,
            CalendarContract.Events.ALL_DAY,
+            CalendarContract.Events._SYNC_ID,
+            CalendarContract.Events.EXDATE,
        ),
        null, null, null,
    )?.use { c ->
@@ -989,6 +1196,8 @@ class AndroidCalendarDataSource @Inject constructor(
                timezone = c.getString(2),
                duration = c.getString(3),
                allDay = c.getInt(4),
+                syncId = c.getString(5),
+                exdate = c.getString(6),
            )
        } else {
            null
@@ -1001,6 +1210,9 @@ class AndroidCalendarDataSource @Inject constructor(
        val timezone: String?,
        val duration: String?,
        val allDay: Int,
+        /** Null on a local calendar (and before a synced event's first push). */
+        val syncId: String? = null,
+        val exdate: String? = null,
    ) {
        /** UNTIL cutoff for ending the series before the occurrence at [beginMillis]. */
        fun truncationCutoff(beginMillis: Long): Long = previousLocalDayEndUtcMillis(
@@ -1191,15 +1403,38 @@ class AndroidCalendarDataSource @Inject constructor(
    }

    override fun deleteOccurrence(eventId: Long, beginMillis: Long) {
-        // A cancelled exception row hides exactly this occurrence; the sync
-        // adapter turns it into an EXDATE/cancelled VEVENT upstream. It has to
-        // carry the full time set (DTSTART + DURATION + zone), not just STATUS:
-        // the provider only demotes the cloned exception to a single instance —
-        // clearing the inherited RRULE — when it can derive that instance from
-        // those columns. A STATUS-only cancel left the RRULE standing and
-        // cancelled the whole series, wiping every other occurrence (#47), the
-        // same trap the edit path documents (Codeberg #16).
        val row = querySeriesRow(eventId)
+        if (row.syncId == null) {
+            // No _sync_id — a local calendar, or a synced event not pushed yet.
+            // A cancelled exception can only attach to its parent through
+            // ORIGINAL_SYNC_ID, so with none the link never forms and the
+            // provider's expansion of the *parent* collapses, taking every other
+            // occurrence with it (#47 on a local calendar). EXDATE needs no link.
+            // Calendula's own contact special-date calendars are local and hold
+            // yearly series, so this path is reached in normal use.
+            val values = buildOccurrenceExdateValues(
+                existingExdate = row.exdate,
+                occurrenceMillis = beginMillis,
+                dtStartMillis = row.dtStartMillis,
+                rrule = row.rrule,
+                duration = row.duration,
+                timezone = row.timezone,
+                allDay = row.allDay,
+            )
+            val updated = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(), null, null,
+            )
+            if (updated == 0) {
+                throw WriteFailedException("exdate occurrence event id=$eventId begin=$beginMillis")
+            }
+            return
+        }
+        // A cancelled exception row hides exactly this occurrence; the sync
+        // adapter turns it into an EXDATE/cancelled VEVENT upstream. It carries
+        // the full time set (DTSTART + DURATION + zone) so the provider derives a
+        // single instance rather than cloning the master's RRULE — the same trap
+        // the edit path documents (Codeberg #16).
        val values = buildOccurrenceCancelValues(
            originalInstanceMillis = beginMillis,
            dtStartMillis = beginMillis,
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt
@@ -61,6 +61,20 @@ interface CalendarRepository {
     */
    suspend fun updateEvent(eventId: Long, original: EventForm, updated: EventForm)

+    /**
+     * Move an event (recurring: the whole series, with its exceptions) to
+     * [targetCalendarId] and apply the [original]→[updated] field edits; returns
+     * the new event's `Events._ID`. Copy+delete under the hood
+     * (see [CalendarDataSource.moveEvent]) — `CALENDAR_ID` can't be updated in
+     * place.
+     */
+    suspend fun moveEvent(
+        eventId: Long,
+        targetCalendarId: Long,
+        original: EventForm,
+        updated: EventForm,
+    ): Long
+
    /**
     * Change a single occurrence of a recurring event (exception row with the
     * form's values); returns the exception's `Events._ID`.
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt
@@ -157,6 +157,17 @@ class CalendarRepositoryImpl @Inject constructor(
        dataSource.deleteEvent(eventId)
    }

+    override suspend fun moveEvent(
+        eventId: Long,
+        targetCalendarId: Long,
+        original: EventForm,
+        updated: EventForm,
+    ): Long = withContext(io) {
+        dataSource.moveEvent(
+            eventId, targetCalendarId, original, updated, allDayReminderTimeMinutes(),
+        )
+    }
+
    override suspend fun updateOccurrence(
        eventId: Long,
        beginMillis: Long,
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventDetailMapper.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventDetailMapper.kt
@@ -14,6 +14,7 @@ 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 de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
@@ -36,15 +37,18 @@ internal fun ColumnReader.toEventDetailCore(
    val begin = getLong(EventDetailProjection.IDX_DTSTART)

    // Recurring events store DURATION instead of DTEND, so the series row's
-    // DTEND is null. Keep the event (end == begin); callers that opened a
-    // specific occurrence supply the real per-occurrence times from
-    // CalendarContract.Instances. A present-but-backwards DTEND is malformed,
-    // but dropping the row would make the event un-openable — the same trap as
-    // the pre-1970 DTSTART bug above (issue #34): it would surface as the
-    // generic error screen with no way to open the event and fix it. Clamp to a
-    // zero-length event instead (matching SearchMapper's coerceAtLeast).
+    // DTEND is null — derive the length from DURATION (as SearchMapper and
+    // IcsExportMapper do). Callers that opened a specific occurrence overwrite
+    // both times with the per-occurrence values from CalendarContract.Instances;
+    // a caller that names no occurrence (a bare content://.../events/<id> VIEW
+    // intent, issue #48) keeps this row's own times, so the length has to be
+    // right here or the series renders zero-length. A present-but-backwards
+    // DTEND is malformed, but dropping the row would make the event un-openable
+    // — the same trap as the pre-1970 DTSTART bug above (issue #34): it would
+    // surface as the generic error screen with no way to open the event and fix
+    // it. Clamp to a zero-length event instead (matching SearchMapper).
    val end = if (isNull(EventDetailProjection.IDX_DTEND)) {
-        begin
+        begin + parseRfc2445DurationMillis(getString(EventDetailProjection.IDX_DURATION))
    } else {
        getLong(EventDetailProjection.IDX_DTEND).coerceAtLeast(begin)
    }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt
@@ -43,10 +43,19 @@ internal fun EventForm.toWriteTimes(zone: ZoneId): EventWriteTimes = if (isAllDa
 * DURATION instead of DTEND when an RRULE is set): whole days for all-day
 * events, seconds otherwise.
 */
-internal fun EventWriteTimes.toRfc2445Duration(isAllDay: Boolean): String = if (isAllDay) {
-    "P${(dtEndMillis - dtStartMillis) / MILLIS_PER_DAY}D"
+internal fun EventWriteTimes.toRfc2445Duration(isAllDay: Boolean): String =
+    rfc2445Duration(dtEndMillis - dtStartMillis, isAllDay)
+
+/**
+ * RFC 2445 duration for a [spanMillis]-long event: whole days for all-day
+ * events (the provider's convention), seconds otherwise. Shared by the write
+ * paths that need a DURATION but start from a raw millisecond span (the series
+ * copy and exception replay of a calendar move) rather than [EventWriteTimes].
+ */
+internal fun rfc2445Duration(spanMillis: Long, isAllDay: Boolean): String = if (isAllDay) {
+    "P${spanMillis / MILLIS_PER_DAY}D"
 } else {
-    "P${(dtEndMillis - dtStartMillis) / 1_000L}S"
+    "P${spanMillis / 1_000L}S"
 }

 /**
@@ -182,6 +191,121 @@ internal fun buildOccurrenceExceptionValues(
    putAll(eventColorColumns(form.colorKey, form.color))
 }

+/**
+ * Raw provider snapshot of a master/one-off Events row, enough to re-insert it
+ * verbatim on another calendar (a calendar move is copy+delete — `CALENDAR_ID`
+ * is sync-adapter-owned and can't be updated in place). Recurring rows carry
+ * [rrule]/[duration] (and any [rdate]/[exdate]) with a null [dtEndMillis];
+ * one-off rows carry [dtEndMillis]. Colour is deliberately absent: a raw
+ * `EVENT_COLOR` or account-scoped `EVENT_COLOR_KEY` may be invalid on the target
+ * account, so the moved copy inherits the target calendar's colour instead.
+ */
+internal data class MasterEventSnapshot(
+    val title: String,
+    val isAllDay: Boolean,
+    val dtStartMillis: Long,
+    val dtEndMillis: Long?,
+    val duration: String?,
+    val rrule: String?,
+    val rdate: String?,
+    val exdate: String?,
+    val timezone: String?,
+    val availability: Int,
+    val accessLevel: Int,
+    val status: Int?,
+    val location: String?,
+    val description: String?,
+)
+
+/**
+ * Column values re-creating [snapshot] as a fresh Events row on
+ * [targetCalendarId], keeping its [uid] so `.ics` backup dedup and sync identity
+ * survive the move. Preserves the recurrence skeleton (DTSTART/RRULE/DURATION,
+ * RDATE/EXDATE) so the series' generated instances — and therefore the
+ * ORIGINAL_INSTANCE_TIME of every copied exception — line up unchanged. The
+ * caller layers the user's field edits on top with a normal series update.
+ */
+internal fun buildMovedMasterValues(
+    snapshot: MasterEventSnapshot,
+    targetCalendarId: Long,
+    uid: String,
+): Map<String, Any?> = buildMap {
+    put(CalendarContract.Events.CALENDAR_ID, targetCalendarId)
+    put(CalendarContract.Events.UID_2445, uid)
+    put(CalendarContract.Events.TITLE, snapshot.title)
+    put(CalendarContract.Events.ALL_DAY, if (snapshot.isAllDay) 1 else 0)
+    put(CalendarContract.Events.DTSTART, snapshot.dtStartMillis)
+    put(CalendarContract.Events.EVENT_TIMEZONE, snapshot.timezone ?: "UTC")
+    if (snapshot.rrule != null) {
+        put(CalendarContract.Events.RRULE, snapshot.rrule)
+        snapshot.rdate?.takeIf { it.isNotBlank() }?.let { put(CalendarContract.Events.RDATE, it) }
+        snapshot.exdate?.takeIf { it.isNotBlank() }?.let { put(CalendarContract.Events.EXDATE, it) }
+        put(CalendarContract.Events.DURATION, snapshot.movedDuration())
+    } else {
+        snapshot.dtEndMillis?.let { put(CalendarContract.Events.DTEND, it) }
+    }
+    put(CalendarContract.Events.AVAILABILITY, snapshot.availability)
+    put(CalendarContract.Events.ACCESS_LEVEL, snapshot.accessLevel)
+    snapshot.status?.let { put(CalendarContract.Events.STATUS, it) }
+    put(CalendarContract.Events.EVENT_LOCATION, snapshot.location?.ifEmpty { null })
+    put(CalendarContract.Events.DESCRIPTION, snapshot.description?.ifEmpty { null })
+}
+
+/** The recurring copy's DURATION: its own if present, else derived from DTEND. */
+private fun MasterEventSnapshot.movedDuration(): String = duration?.takeIf { it.isNotBlank() }
+    ?: rfc2445Duration((dtEndMillis ?: dtStartMillis) - dtStartMillis, isAllDay)
+
+/**
+ * Raw provider snapshot of one exception row of a recurring series (a modified
+ * or cancelled occurrence, `ORIGINAL_ID` = the series). [originalInstanceMillis]
+ * ties it to the occurrence it overrides; a [isCancelled] row only needs that.
+ */
+internal data class ExceptionRowSnapshot(
+    val exceptionEventId: Long,
+    val originalInstanceMillis: Long,
+    val isCancelled: Boolean,
+    val status: Int?,
+    val title: String,
+    val isAllDay: Boolean,
+    val dtStartMillis: Long,
+    val dtEndMillis: Long?,
+    val duration: String?,
+    val timezone: String?,
+    val availability: Int,
+    val accessLevel: Int,
+    val location: String?,
+    val description: String?,
+)
+
+/**
+ * Column values replaying a *modified* occurrence [snapshot] against the moved
+ * series via `CONTENT_EXCEPTION_URI`. Like [buildOccurrenceExceptionValues] the
+ * length travels as DURATION (the provider rejects DTEND on an exception). A
+ * cancelled occurrence is written separately (ORIGINAL_INSTANCE_TIME +
+ * STATUS_CANCELED) — this builder is only for the modified case.
+ */
+internal fun buildCopiedExceptionValues(snapshot: ExceptionRowSnapshot): Map<String, Any?> =
+    buildMap {
+        put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, snapshot.originalInstanceMillis)
+        put(CalendarContract.Events.TITLE, snapshot.title)
+        put(CalendarContract.Events.ALL_DAY, if (snapshot.isAllDay) 1 else 0)
+        put(CalendarContract.Events.DTSTART, snapshot.dtStartMillis)
+        put(
+            CalendarContract.Events.DURATION,
+            snapshot.duration?.takeIf { it.isNotBlank() }
+                ?: rfc2445Duration(
+                    (snapshot.dtEndMillis ?: snapshot.dtStartMillis) - snapshot.dtStartMillis,
+                    snapshot.isAllDay,
+                ),
+        )
+        put(CalendarContract.Events.EVENT_TIMEZONE, snapshot.timezone ?: "UTC")
+        put(CalendarContract.Events.AVAILABILITY, snapshot.availability)
+        put(CalendarContract.Events.ACCESS_LEVEL, snapshot.accessLevel)
+        put(CalendarContract.Events.EVENT_LOCATION, snapshot.location?.ifEmpty { null })
+        put(CalendarContract.Events.DESCRIPTION, snapshot.description?.ifEmpty { null })
+        snapshot.status?.let { put(CalendarContract.Events.STATUS, it) }
+    }
+
 /**
 * Column values for a *cancelled*-occurrence exception row ("delete only this
 * event"): inserting them at `Events.CONTENT_EXCEPTION_URI/<id>` makes the
@@ -209,6 +333,73 @@ internal fun buildOccurrenceCancelValues(
    put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
 }

+/**
+ * The master-row columns that drop the occurrence at [occurrenceMillis] from a
+ * series by adding it to `EXDATE` — the path for events that have **no
+ * `_sync_id`** (a local calendar, or a synced event not yet pushed).
+ *
+ * A cancelled exception row (see [buildOccurrenceCancelValues]) only attaches to
+ * its parent through `ORIGINAL_SYNC_ID`. Without a `_sync_id` the link never
+ * forms, and the provider's expansion of the *parent* collapses — every other
+ * occurrence disappears (Codeberg #47, reproduced on a local calendar). EXDATE
+ * needs no link, and is the canonical iCalendar way to drop an occurrence, so a
+ * sync adapter carries it upstream unchanged if the calendar later syncs.
+ *
+ * The whole time/recurrence set is rewritten alongside it on purpose. The
+ * provider does **not** treat an EXDATE-only update as a recurrence change: it
+ * leaves the expanded `Instances` rows untouched, so the occurrence stays visible
+ * (and, symmetrically, un-excluding one leaves it hidden). Writing DTSTART with
+ * it forces the re-expansion — but DTSTART *alone* makes the provider recompute
+ * `lastDate` as if the event were a single instance, collapsing the series to its
+ * first occurrence. Passing DTSTART + DURATION + RRULE + zone together is what
+ * re-expands it correctly. All observed on a Pixel; see the #47 notes.
+ *
+ * EXDATE is a comma-separated list, so an existing one is appended to (a repeat
+ * of the same occurrence is folded away). All-day series take the `VALUE=DATE`
+ * form (`yyyyMMdd`), timed ones the UTC date-time form (`yyyyMMddTHHmmssZ`).
+ */
+internal fun buildOccurrenceExdateValues(
+    existingExdate: String?,
+    occurrenceMillis: Long,
+    dtStartMillis: Long,
+    rrule: String?,
+    duration: String?,
+    timezone: String?,
+    allDay: Int,
+): Map<String, Any?> {
+    val stamp = formatExdateStamp(occurrenceMillis, isAllDay = allDay != 0)
+    val existing = existingExdate?.split(',')
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        .orEmpty()
+    val merged = (existing + stamp).distinct().joinToString(",")
+    return mapOf(
+        CalendarContract.Events.EXDATE to merged,
+        CalendarContract.Events.DTSTART to dtStartMillis,
+        CalendarContract.Events.RRULE to rrule,
+        CalendarContract.Events.DURATION to duration,
+        CalendarContract.Events.EVENT_TIMEZONE to timezone,
+        CalendarContract.Events.ALL_DAY to allDay,
+    )
+}
+
+/**
+ * One EXDATE entry for the occurrence starting at [occurrenceMillis]. Both forms
+ * are UTC: the provider stores an all-day DTSTART at UTC midnight, so its date
+ * reads off the UTC calendar day.
+ */
+private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String {
+    val utc = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC)
+    return if (isAllDay) {
+        "%04d%02d%02d".format(utc.year, utc.monthValue, utc.dayOfMonth)
+    } else {
+        "%04d%02d%02dT%02d%02d%02dZ".format(
+            utc.year, utc.monthValue, utc.dayOfMonth,
+            utc.hour, utc.minute, utc.second,
+        )
+    }
+}
+
 /**
 * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
 * [colorKey] writes the key alone (the provider derives `EVENT_COLOR` from the
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt
@@ -84,6 +84,9 @@ internal object EventDetailProjection {
        CalendarContract.Events.EVENT_TIMEZONE,
        CalendarContract.Events.SELF_ATTENDEE_STATUS,
        CalendarContract.Events.EVENT_COLOR_KEY,
+        // Recurring rows carry DURATION instead of DTEND; the detail screen
+        // needs it to render a series opened without a named occurrence.
+        CalendarContract.Events.DURATION,
    )

    const val IDX_EVENT_ID = 0
@@ -104,6 +107,7 @@ internal object EventDetailProjection {
    const val IDX_EVENT_TIMEZONE = 15
    const val IDX_SELF_ATTENDEE_STATUS = 16
    const val IDX_EVENT_COLOR_KEY = 17
+    const val IDX_DURATION = 18
 }

 /**
@@ -186,6 +190,86 @@ internal object SearchProjection {
    const val IDX_RDATE = 11
 }

+/**
+ * The master/one-off Events row of an event about to be moved to another
+ * calendar, read for a verbatim re-insert (see [MasterEventSnapshot]). Carries
+ * the full recurrence skeleton (RRULE/DURATION, RDATE/EXDATE) so the moved copy
+ * generates the same instances, and `UID_2445` so identity survives the move.
+ */
+internal object MoveMasterProjection {
+    val COLUMNS: Array<String> = arrayOf(
+        CalendarContract.Events.UID_2445,
+        CalendarContract.Events.TITLE,
+        CalendarContract.Events.DTSTART,
+        CalendarContract.Events.DTEND,
+        CalendarContract.Events.DURATION,
+        CalendarContract.Events.RRULE,
+        CalendarContract.Events.RDATE,
+        CalendarContract.Events.EXDATE,
+        CalendarContract.Events.EVENT_TIMEZONE,
+        CalendarContract.Events.ALL_DAY,
+        CalendarContract.Events.AVAILABILITY,
+        CalendarContract.Events.ACCESS_LEVEL,
+        CalendarContract.Events.STATUS,
+        CalendarContract.Events.EVENT_LOCATION,
+        CalendarContract.Events.DESCRIPTION,
+    )
+
+    const val IDX_UID = 0
+    const val IDX_TITLE = 1
+    const val IDX_DTSTART = 2
+    const val IDX_DTEND = 3
+    const val IDX_DURATION = 4
+    const val IDX_RRULE = 5
+    const val IDX_RDATE = 6
+    const val IDX_EXDATE = 7
+    const val IDX_EVENT_TIMEZONE = 8
+    const val IDX_ALL_DAY = 9
+    const val IDX_AVAILABILITY = 10
+    const val IDX_ACCESS_LEVEL = 11
+    const val IDX_STATUS = 12
+    const val IDX_LOCATION = 13
+    const val IDX_DESCRIPTION = 14
+}
+
+/**
+ * The exception rows of a recurring series (`ORIGINAL_ID` = the series), read to
+ * replay them against a moved copy (see [ExceptionRowSnapshot]). Both modified
+ * occurrences and cancellations (`STATUS_CANCELED`) are read; the query filters
+ * `DELETED = 0` so provider tombstones aren't replayed.
+ */
+internal object ExceptionProjection {
+    val COLUMNS: Array<String> = arrayOf(
+        CalendarContract.Events._ID,
+        CalendarContract.Events.ORIGINAL_INSTANCE_TIME,
+        CalendarContract.Events.STATUS,
+        CalendarContract.Events.TITLE,
+        CalendarContract.Events.ALL_DAY,
+        CalendarContract.Events.DTSTART,
+        CalendarContract.Events.DTEND,
+        CalendarContract.Events.DURATION,
+        CalendarContract.Events.EVENT_TIMEZONE,
+        CalendarContract.Events.AVAILABILITY,
+        CalendarContract.Events.ACCESS_LEVEL,
+        CalendarContract.Events.EVENT_LOCATION,
+        CalendarContract.Events.DESCRIPTION,
+    )
+
+    const val IDX_ID = 0
+    const val IDX_ORIGINAL_INSTANCE_TIME = 1
+    const val IDX_STATUS = 2
+    const val IDX_TITLE = 3
+    const val IDX_ALL_DAY = 4
+    const val IDX_DTSTART = 5
+    const val IDX_DTEND = 6
+    const val IDX_DURATION = 7
+    const val IDX_EVENT_TIMEZONE = 8
+    const val IDX_AVAILABILITY = 9
+    const val IDX_ACCESS_LEVEL = 10
+    const val IDX_LOCATION = 11
+    const val IDX_DESCRIPTION = 12
+}
+
 internal object AttendeeProjection {
    val COLUMNS: Array<String> = arrayOf(
        CalendarContract.Attendees.ATTENDEE_NAME,
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt
@@ -17,7 +17,11 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
+import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import kotlinx.coroutines.flow.first
+import kotlinx.datetime.isoDayNumber
+import java.time.DayOfWeek
+import java.time.Instant
 import java.time.ZoneId
 import java.util.Locale
 import javax.inject.Inject
@@ -55,13 +59,22 @@ class ReminderNotifier @Inject constructor(
        val title = alert.title.ifBlank { context.getString(R.string.event_untitled) }
        val is24Hour = settingsPrefs.timeFormat.first()
            .is24Hour(android.text.format.DateFormat.is24HourFormat(context))
+        val zone = ZoneId.systemDefault()
+        val locale = Locale.getDefault()
+        // resolveFirstDay yields a kotlinx.datetime day; bridge it to java.time by
+        // its shared ISO number (1..7) for the date math in reminderTimeText.
+        val firstDayOfWeek = DayOfWeek.of(settingsPrefs.weekStart.first().resolveFirstDay(locale).isoDayNumber)
        val time = reminderTimeText(
            beginMillis = alert.beginMillis,
            endMillis = alert.endMillis,
            isAllDay = alert.isAllDay,
-            zone = ZoneId.systemDefault(),
-            locale = Locale.getDefault(),
+            zone = zone,
+            locale = locale,
            is24Hour = is24Hour,
+            today = Instant.now().atZone(zone).toLocalDate(),
+            firstDayOfWeek = firstDayOfWeek,
+            tomorrowLabel = context.getString(R.string.reminder_day_tomorrow),
+            yesterdayLabel = context.getString(R.string.reminder_day_yesterday),
        )
        val text = listOfNotNull(time, alert.location).joinToString(" · ")
        val notification = NotificationCompat.Builder(context, CHANNEL_ID)
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeText.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeText.kt
@@ -1,23 +1,37 @@
 package de.jeanlucmakiola.calendula.data.reminders

 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
+import java.time.DayOfWeek
 import java.time.Instant
+import java.time.LocalDate
 import java.time.ZoneId
 import java.time.ZoneOffset
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
+import java.time.format.TextStyle
+import java.time.temporal.ChronoUnit
 import java.util.Locale

 /**
 * The one line of time context in a reminder notification. Pure so it can be
- * JVM-tested:
+ * JVM-tested.
 *
- * - timed, same day:      "09:30 – 10:00"
- * - timed, crossing days: "11 Jun, 23:30 – 12 Jun, 00:30" (medium date + short time)
+ * Timed events that fall on a day other than [today] are prefixed with that
+ * day, so a reminder fired ahead of time no longer reads as if the event were
+ * today (issue #46). The prefix prefers natural language and stays short:
+ *
+ * - today:                "09:30 – 10:00"                 (no prefix)
+ * - tomorrow / yesterday: "Tomorrow, 09:30 – 10:00"       ([tomorrowLabel] / [yesterdayLabel])
+ * - elsewhere this week:  "Thu, 09:30 – 10:00"            (localized short weekday)
+ * - further out:          "16 Jul, 09:30 – 10:00"         (medium date — a weekday
+ *                                                          alone would be ambiguous)
+ * - timed, crossing days: "11 Jun, 23:30 – 12 Jun, 00:30" (medium date + short time,
+ *                                                          already unambiguous)
 * - all-day, one day:     "11 Jun 2026"
 * - all-day, multi-day:   "11 Jun 2026 – 12 Jun 2026"
 *
- * All-day instances store UTC midnights with an exclusive end, so they are
+ * All-day instances already carry an explicit date, so they never gain a
+ * relative prefix. They store UTC midnights with an exclusive end, so they are
 * read in UTC and the end day is the last *covered* day.
 */
 fun reminderTimeText(
@@ -27,6 +41,10 @@ fun reminderTimeText(
    zone: ZoneId,
    locale: Locale,
    is24Hour: Boolean,
+    today: LocalDate,
+    firstDayOfWeek: DayOfWeek,
+    tomorrowLabel: String,
+    yesterdayLabel: String,
 ): String {
    if (isAllDay) {
        val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
@@ -43,18 +61,70 @@ fun reminderTimeText(
    }

    val timeFormat = timeOfDayFormatter(is24Hour, locale)
+    val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
    val begin = Instant.ofEpochMilli(beginMillis).atZone(zone)
    val end = Instant.ofEpochMilli(endMillis).atZone(zone)
    return if (begin.toLocalDate() == end.toLocalDate()) {
-        timeFormat.format(begin) + RANGE + timeFormat.format(end)
+        val range = timeFormat.format(begin) + RANGE + timeFormat.format(end)
+        val prefix = relativeDayPrefix(
+            day = begin.toLocalDate(),
+            today = today,
+            firstDayOfWeek = firstDayOfWeek,
+            locale = locale,
+            dateFormat = dateFormat,
+            tomorrowLabel = tomorrowLabel,
+            yesterdayLabel = yesterdayLabel,
+        )
+        if (prefix == null) range else "$prefix, $range"
    } else {
        // Cross-day: medium date + the chosen short time, joined per side. Built
        // from the two formatters (not ofLocalizedDateTime) so the 12/24h choice
-        // applies to the time portion too.
-        val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
+        // applies to the time portion too. The explicit dates already say which
+        // day, so no relative prefix is layered on top.
        val dateTime = { z: java.time.ZonedDateTime -> "${dateFormat.format(z)}, ${timeFormat.format(z)}" }
        dateTime(begin) + RANGE + dateTime(end)
    }
 }

+/**
+ * A short label for [day] relative to [today], or `null` when it *is* today (the
+ * common case, which needs no prefix). Weekday names are used only within the
+ * current week — a "next Wednesday" would be indistinguishable from this one, so
+ * anything past this week falls back to the exact date.
+ */
+private fun relativeDayPrefix(
+    day: LocalDate,
+    today: LocalDate,
+    firstDayOfWeek: DayOfWeek,
+    locale: Locale,
+    dateFormat: DateTimeFormatter,
+    tomorrowLabel: String,
+    yesterdayLabel: String,
+): String? = when (ChronoUnit.DAYS.between(today, day)) {
+    0L -> null
+    1L -> tomorrowLabel
+    -1L -> yesterdayLabel
+    else -> if (isSameWeek(day, today, firstDayOfWeek)) {
+        day.dayOfWeek.getDisplayName(TextStyle.SHORT, locale)
+    } else {
+        dateFormat.format(day)
+    }
+}
+
+/**
+ * True when [day] and [today] share the same week. The week boundary honours the
+ * user's *week starts on* setting (already resolved to a concrete [firstDayOfWeek],
+ * with [firstDayOfWeek] falling back to the locale default upstream).
+ */
+private fun isSameWeek(day: LocalDate, today: LocalDate, firstDayOfWeek: DayOfWeek): Boolean {
+    val startOfWeek = today.previousOrSame(firstDayOfWeek)
+    return !day.isBefore(startOfWeek) && day.isBefore(startOfWeek.plusWeeks(1))
+}
+
+/** The most recent [target] on or before this date (this date itself when it matches). */
+private fun LocalDate.previousOrSame(target: DayOfWeek): LocalDate {
+    val backtrack = (dayOfWeek.value - target.value + 7) % 7
+    return minusDays(backtrack.toLong())
+}
+
 private const val RANGE = " – "
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/Picker.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/Picker.kt
@@ -1,26 +1,14 @@
 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.height
 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.Checkbox
-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 androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
@@ -29,13 +17,12 @@ 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 de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.floret.components.DialogAmountField
+import de.jeanlucmakiola.floret.components.CustomAmountEditor
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
@@ -195,56 +182,18 @@ private fun CustomReminderEditor(
    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))
-                }
-            }
-        }
-    }
+    CustomAmountEditor(
+        amountText = amountText,
+        onAmountChange = onAmountChange,
+        unitLabels = ReminderUnit.entries.map { stringResource(reminderUnitLabel(it)) },
+        selectedUnit = unit.ordinal,
+        onUnitChange = { onUnitChange(ReminderUnit.entries[it]) },
+        preview = amount?.let { reminderLeadTimeLabel(it * unit.minutesFactor) }
+            ?: stringResource(R.string.reminder_custom_amount),
+        setLabel = stringResource(R.string.reminder_custom_set),
+        confirmEnabled = amount != null,
+        onConfirm = { amount?.let { onConfirm(it * unit.minutesFactor) } },
+    )
 }

 /** A short explanatory paragraph shown under a picker's title, above the rows. */
@@ -364,41 +313,136 @@ private fun CustomDaysEditor(
 ) {
    val days = amountText.toIntOrNull()
        ?.takeIf { it in AgendaRange.MIN_CUSTOM_DAYS..AgendaRange.MAX_CUSTOM_DAYS }
-    Surface(
-        color = MaterialTheme.colorScheme.surfaceContainerHigh,
-        shape = RoundedCornerShape(topStart = 6.dp, topEnd = 6.dp, bottomStart = 22.dp, bottomEnd = 22.dp),
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 16.dp),
-    ) {
-        Row(
-            modifier = Modifier.padding(16.dp),
-            verticalAlignment = Alignment.CenterVertically,
+    CustomAmountEditor(
+        amountText = amountText,
+        onAmountChange = onAmountChange,
+        placeholder = "30",
+        preview = days?.let { pluralStringResource(R.plurals.agenda_range_days, it, it) }
+            ?: stringResource(R.string.agenda_range_custom_hint),
+        setLabel = stringResource(R.string.reminder_custom_set),
+        confirmEnabled = days != null,
+        onConfirm = { days?.let(onConfirm) },
+    )
+}
+
+/**
+ * Snooze-duration picker, full-screen and **single-select**: the [presets]
+ * (whole-minute delays) each sit as a checkmark row, with a "Custom" row that
+ * expands an inline amount field plus a Minutes/Hours unit toggle to enter an
+ * arbitrary delay. Mirrors [AgendaRangePicker]'s custom-expand pattern; picking
+ * a preset or confirming a custom value applies via [onSelect] and closes.
+ * [label] renders a delay in minutes as a duration ("10 minutes", "1 hour") and
+ * is reused for both the rows and the custom preview.
+ */
+@Composable
+fun SnoozeDurationPicker(
+    title: String,
+    presets: List<Int>,
+    selected: Int,
+    label: @Composable (Int) -> String,
+    onSelect: (Int) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val customSelected = selected !in presets
+    val rowCount = presets.size + 1 // + the custom row
+
+    var customExpanded by rememberSaveable { mutableStateOf(false) }
+    var amountText by rememberSaveable {
+        mutableStateOf(if (customSelected) snoozeCustomAmount(selected).toString() else "")
+    }
+    var unit by rememberSaveable {
+        mutableStateOf(if (customSelected) snoozeCustomUnit(selected) else ReminderUnit.Minutes)
+    }
+
+    FullScreenPicker(title = title, onDismiss = onDismiss, predictiveBack = true) {
+        presets.forEachIndexed { index, minute ->
+            val isSelected = minute == selected
+            GroupedRow(
+                title = label(minute),
+                position = positionOf(index, rowCount),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = {
+                    onSelect(minute)
+                    onDismiss()
+                },
+            )
+        }
+        // The Custom row connects downward into the editor card when expanded, so
+        // the two read as one grouped container (the shared custom-expand pattern).
+        GroupedRow(
+            title = if (customSelected) label(selected) else stringResource(R.string.event_edit_reminder_custom),
+            position = if (customExpanded) Position.Top else positionOf(presets.size, rowCount),
+            selected = customSelected,
+            trailing = if (customSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(
+            visible = customExpanded,
+            enter = expandEnter(),
+            exit = collapseExit(),
        ) {
-            DialogAmountField(
-                value = amountText,
-                onValueChange = onAmountChange,
-                placeholder = "30",
+            CustomSnoozeEditor(
+                amountText = amountText,
+                onAmountChange = { amountText = it },
+                unit = unit,
+                onUnitChange = { unit = it },
+                label = label,
+                onConfirm = { minutes ->
+                    onSelect(minutes)
+                    onDismiss()
+                },
            )
-            Spacer(Modifier.width(16.dp))
-            Text(
-                text = days?.let { pluralStringResource(R.plurals.agenda_range_days, it, it) }
-                    ?: stringResource(R.string.agenda_range_custom_hint),
-                style = MaterialTheme.typography.bodyLarge,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                modifier = Modifier.weight(1f),
-            )
-            Spacer(Modifier.width(16.dp))
-            FilledTonalButton(
-                onClick = { days?.let(onConfirm) },
-                enabled = days != null,
-            ) {
-                Text(stringResource(R.string.reminder_custom_set))
-            }
        }
    }
 }

+/** Whole hours if the delay divides evenly, else minutes. */
+private fun snoozeCustomUnit(minutes: Int): ReminderUnit =
+    if (minutes % ReminderUnit.Hours.minutesFactor == 0) ReminderUnit.Hours else ReminderUnit.Minutes
+
+private fun snoozeCustomAmount(minutes: Int): Int =
+    if (minutes % ReminderUnit.Hours.minutesFactor == 0) minutes / ReminderUnit.Hours.minutesFactor else minutes
+
+/**
+ * The expanded "Custom" snooze editor: a tonal card connected to the Custom row
+ * above it. A Minutes/Hours unit toggle, an amount field with a live preview of
+ * the delay it resolves to, and a tonal confirm enabled only for a valid 1–999
+ * amount. [onConfirm] receives the final delay in minutes.
+ */
+@Composable
+private fun CustomSnoozeEditor(
+    amountText: String,
+    onAmountChange: (String) -> Unit,
+    unit: ReminderUnit,
+    onUnitChange: (ReminderUnit) -> Unit,
+    label: @Composable (Int) -> String,
+    onConfirm: (Int) -> Unit,
+) {
+    val units = remember { listOf(ReminderUnit.Minutes, ReminderUnit.Hours) }
+    val amount = amountText.toIntOrNull()?.takeIf { it in 1..999 }
+    CustomAmountEditor(
+        amountText = amountText,
+        onAmountChange = onAmountChange,
+        unitLabels = units.map { stringResource(reminderUnitLabel(it)) },
+        selectedUnit = units.indexOf(unit).coerceAtLeast(0),
+        onUnitChange = { onUnitChange(units[it]) },
+        preview = amount?.let { label(it * unit.minutesFactor) }
+            ?: stringResource(R.string.reminder_custom_amount),
+        setLabel = stringResource(R.string.reminder_custom_set),
+        confirmEnabled = amount != null,
+        onConfirm = { amount?.let { onConfirm(it * unit.minutesFactor) } },
+    )
+}
+
 /** Human label for an [AgendaRange] (used by the picker rows and settings summary). */
@Composable
 fun agendaRangeLabel(range: AgendaRange): String = when (range) {
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt
@@ -672,15 +672,16 @@ private fun EventEditContent(

        Spacer(Modifier.height(gap))

-        // Calendar card — tap anywhere to pick the target calendar. Editing
-        // keeps the owning calendar (moving events between calendars is a
-        // sync-adapter minefield; every stock calendar app locks it too).
+        // Calendar card — tap anywhere to pick the target calendar. Picking a
+        // different one while editing *moves* the event (copy+delete on save,
+        // since CALENDAR_ID can't be updated in place). Managed special-dates
+        // events stay locked: the contact sync owns their calendar.
        EditCard(
            icon = Icons.Default.CalendarMonth,
            iconContentDescription = stringResource(R.string.event_detail_calendar),
            iconTint = accent,
            onClick = { showCalendarPicker = true }
-                .takeIf { state.calendars.isNotEmpty() && !state.isEditing },
+                .takeIf { state.calendars.isNotEmpty() && !state.isManaged },
        ) {
            Text(
                text = selectedCalendar?.displayName
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt
@@ -548,10 +548,15 @@ class EventEditViewModel @Inject constructor(
            _saveState.value = SaveUiState.Saved
            return
        }
+        // Changing the calendar moves the event (copy+delete — CALENDAR_ID can't
+        // be updated in place) and is inherently whole-series: an occurrence
+        // can't live in a different calendar than its series, so a move skips the
+        // scope dialog even for a recurring event.
+        val movingCalendar = target != null && form.calendarId != target.original.calendarId
        // Managed events are a yearly series whose editable fields (reminders,
        // notes, location) live on the series row — never offer the scope dialog,
        // which would split the series into an exception the sync then reverts.
-        if (target != null && target.original.rrule != null && !current.isManaged) {
+        if (target != null && target.original.rrule != null && !current.isManaged && !movingCalendar) {
            _saveState.value = SaveUiState.AwaitingScope
            return
        }
@@ -606,6 +611,17 @@ class EventEditViewModel @Inject constructor(
                if (target == null) {
                    repository.createEvent(form)
                    prefs.setLastUsedCalendarId(requireNotNull(form.calendarId))
+                } else if (form.calendarId != target.original.calendarId) {
+                    // Move to the picked calendar (copy+delete), carrying any
+                    // field edits made in the same save. The target becomes the
+                    // last-used calendar, like a create does.
+                    repository.moveEvent(
+                        eventId = target.eventId,
+                        targetCalendarId = requireNotNull(form.calendarId),
+                        original = target.original,
+                        updated = form,
+                    )
+                    prefs.setLastUsedCalendarId(requireNotNull(form.calendarId))
                } else {
                    when (scope) {
                        RecurringWriteScope.ThisEvent ->
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt
@@ -133,6 +133,7 @@ import de.jeanlucmakiola.calendula.ui.common.ReminderDefaultPicker
 import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
+import de.jeanlucmakiola.calendula.ui.common.SnoozeDurationPicker
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldIcon
@@ -1174,10 +1175,9 @@ private fun NotificationsScreen(
    }

    if (showSnooze) {
-        OptionPicker(
+        SnoozeDurationPicker(
            title = stringResource(R.string.settings_snooze_duration),
-            predictiveBack = true,
-            options = SNOOZE_PRESETS,
+            presets = SNOOZE_PRESETS,
            selected = state.snoozeMinutes,
            label = { snoozeDurationLabel(it) },
            onSelect = { viewModel.setSnoozeMinutes(it) },
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -310,7 +310,7 @@
    <string name="settings_language">App-Sprache</string>
    <string name="settings_language_auto">Systemstandard</string>
    <!-- Hub category subtitles -->
-    <string name="settings_appearance_subtitle">Design, Standartansicht, Wochenstart</string>
+    <string name="settings_appearance_subtitle">Design, Standardansicht, 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>
@@ -474,4 +474,20 @@
    <string name="special_dates_default_title_birthday">Geburtstag von {name} ({year})</string>
    <string name="special_dates_default_title_anniversary">Jahrestag von {name} ({year})</string>
    <string name="special_dates_default_title_custom">{name}</string>
+    <string name="settings_week_numbers">Kalenderwochen</string>
+    <string name="settings_week_numbers_summary">Kalenderwochen der Monatsansicht anzeigen</string>
+    <string name="calendars_export_title">Kalender exportieren</string>
+    <string name="calendars_export_hint">Wähle aus, welche Kalender in die .ics-Datei aufgenommen werden sollen.</string>
+    <string name="calendars_export_action">Exportieren</string>
+    <string name="calendars_restore_header">Wiederherstellen</string>
+    <string name="calendars_restore_action">Aus .ics-Datei wiederherstellen</string>
+    <string name="calendars_restore_hint">Importiere Ereignisse aus einem Backup oder einer anderen Kalender-App.</string>
+    <string name="import_done_dedup_note">Bereits im Kalender vorhandene Ereignisse wurden übersprungen.</string>
+    <string name="import_done_added_label">Hinzugefügt</string>
+    <string name="import_done_skipped_label">Duplikate</string>
+    <string name="import_button">Importieren</string>
+    <plurals name="import_title_count">
+        <item quantity="one">%d Ereignis wird importiert</item>
+        <item quantity="other">%d Ereignisse werden importiert</item>
+    </plurals>
 </resources>
--- a/app/src/main/res/values-it/strings.xml
+++ b/app/src/main/res/values-it/strings.xml
@@ -16,17 +16,17 @@
    <string name="state_failure_no_calendars">Nessun calendario configurato.</string>
    <string name="state_failure_no_calendars_action">Apri le impostazioni calendario di sistema</string>
    <string name="state_failure_provider">Errore nella lettura del calendario.</string>
-    <string name="permission_rationale_title">Guarda tutti i tuoi eventi, magnificamente</string>
-    <string name="permission_rationale_body">Calendula ha bisogno di accedere al tuo calendario per mostrare e gestire gli eventi. È l\'unica cosa che ti chiederà.</string>
+    <string name="permission_rationale_title">Gestisci magnificamente tutti i tuoi eventi</string>
+    <string name="permission_rationale_body">Calendula ha bisogno di accedere al tuo calendario per mostrare e gestire gli eventi. È l\'unica cosa di cui ha bisogno e nessuna informazione lascerà mai il tuo dispositivo.</string>
    <string name="permission_request_button">Concedi l\'accesso al calendario</string>
    <string name="permission_denied_title">Accesso al calendario negato</string>
    <string name="permission_denied_body">Calendula non può mostrare gli eventi senza accesso al calendario. Puoi concederlo dalle impostazioni di sistema.</string>
    <string name="permission_open_settings_button">Apri le impostazioni di sistema</string>
    <string name="permission_retry_button">Riprova</string>
    <string name="permission_benefit_private_title">Rimane sul tuo dispositivo</string>
-    <string name="permission_benefit_private_body">I tuoi calendari sono letti localmente e non lasciano mai il tuo telefono.</string>
+    <string name="permission_benefit_private_body">I tuoi calendari sono letti localmente e non lasciano mai il tuo dispositivo.</string>
    <string name="permission_benefit_sync_title">Tutti i tuoi calendari, insieme</string>
-    <string name="permission_benefit_sync_body">Google, CalDAV, locali - qualsiasi calendario sincronizzato sul dispositivo semplicemente compare.</string>
+    <string name="permission_benefit_sync_body">Google, CalDAV, locali - qualsiasi calendario sincronizzato sul dispositivo, semplicemente, compare.</string>
    <string name="permission_benefit_privacy_title">Nessun tracking, per sempre</string>
    <string name="permission_benefit_privacy_body">Zero telemetria, zero analytics, zero pubblicità.</string>
    <string name="permission_privacy_footnote">Rimane sul tuo dispositivo - nessun accesso a internet</string>
@@ -38,7 +38,7 @@
    <string name="month_action_settings">Impostazioni</string>
    <string name="month_a11y_today_prefix">Oggi</string>
    <string name="week_today_action">Questa settimana</string>
-    <string name="week_number_label">Wk</string>
+    <string name="week_number_label">Sett.</string>
    <string name="day_today_action">Oggi</string>
    <string name="event_detail_back">Indietro</string>
    <string name="event_detail_edit">Modifica</string>
@@ -73,14 +73,14 @@
    <string name="event_edit_remove_reminder">Rimuovi promemoria</string>
    <string name="event_edit_attendees">Partecipanti</string>
    <string name="event_edit_add_guest">Aggiungi partecipante</string>
-    <string name="event_edit_add_guest_hint">Aggiungi un partecipante via email…</string>
+    <string name="event_edit_add_guest_hint">Aggiungi un partecipante tramite indirizzo email…</string>
    <string name="event_edit_add_guest_from_contacts">Aggiungi dai contatti</string>
    <string name="event_edit_location_from_contacts">Scegli un indirizzo dai contatti</string>
    <string name="event_edit_remove_guest">Rimuovi partecipante</string>
    <string name="event_edit_attendee_required">Obbligatorio</string>
    <string name="event_edit_attendee_optional">Facoltativo</string>
    <string name="event_edit_attendees_note_synced">Calendula non manda gli inviti agli eventi. Il tuo account calendario potrà inviare le email ai partecipanti al momento della sincronizzazione.</string>
-    <string name="event_edit_attendees_note_local">Salvato sul dispositivo. Nessuno ha ricevuto notifiche.</string>
+    <string name="event_edit_attendees_note_local">Salvato sul dispositivo. Nessuno dei partecipanti ha ricevuto notifiche.</string>
    <string name="event_edit_reminder_custom">Personalizza</string>
    <string name="reminder_unit_minutes">minuti</string>
    <string name="reminder_unit_hours">ore</string>
@@ -89,7 +89,7 @@
    <string name="event_edit_availability">Disponibilità</string>
    <string name="event_edit_visibility">Visibilità</string>
    <string name="event_edit_color">Colore</string>
-    <string name="event_edit_color_default">Colore calendario</string>
+    <string name="event_edit_color_default">Colore del calendario</string>
    <string name="event_edit_color_custom">Colore personalizzato</string>
    <string name="event_edit_color_reset">Reset</string>
    <string name="event_edit_color_unsupported">Non disponibile per questo calendario</string>
@@ -99,13 +99,13 @@
    <string name="event_edit_conflict_body">Durante la modifica l\'evento è stato cambiato, tramite sincronizzazione o tramite altra app. Cosa fare con le modifiche in corso?</string>
    <string name="event_edit_conflict_overwrite">Salva le modifiche</string>
    <string name="event_edit_conflict_overwrite_hint">Sovrascrivi solo i campi modificati</string>
-    <string name="event_edit_conflict_discard">Annulla le mie modifiche</string>
-    <string name="event_edit_conflict_discard_hint">Mantieni l\'evento com\'è ora</string>
+    <string name="event_edit_conflict_discard">Annulla le modifiche</string>
+    <string name="event_edit_conflict_discard_hint">Lascia l\'evento invariato</string>
    <string name="event_edit_gone_title">Evento eliminato</string>
    <string name="event_edit_gone_body">Nel frattempo, questo evento è stato eliminato, ad esempio su un altro dispositivo. Le modifiche non possono più essere salvate.</string>
    <string name="event_edit_recurrence_none">Non si ripete</string>
    <string name="event_edit_recurrence_custom">Personalizza</string>
-    <string name="event_edit_recurrence_every">La serie</string>
+    <string name="event_edit_recurrence_every">Ogni</string>
    <string name="recurrence_unit_days">giorni</string>
    <string name="recurrence_unit_weeks">settimane</string>
    <string name="recurrence_unit_months">mesi</string>
@@ -113,7 +113,7 @@
    <string name="event_edit_recurrence_ends">Fine</string>
    <string name="event_edit_recurrence_end_never">Mai</string>
    <string name="event_edit_recurrence_end_until">Fino alla data</string>
-    <string name="event_edit_recurrence_end_count">Dopo un certo numero di occorrenze</string>
+    <string name="event_edit_recurrence_end_count">Numero di occorrenze</string>
    <string name="event_edit_recurrence_times">occorrenze</string>
    <string name="event_edit_error_recurrence_ends_before_start">Fine antecedente l\'inizio</string>
    <string name="event_availability_busy">Occupato</string>
@@ -125,7 +125,7 @@
    <string name="event_detail_location">Luogo</string>
    <string name="event_detail_description">Descrizione</string>
    <string name="event_detail_attendees">Partecipanti</string>
-    <string name="recurrence_daily">Ogni giorni</string>
+    <string name="recurrence_daily">Ogni giorno</string>
    <string name="recurrence_weekly">Ogni settimana</string>
    <string name="recurrence_monthly">Ogni mese</string>
    <string name="recurrence_yearly">Ogni anno</string>
@@ -204,7 +204,7 @@
    <string name="reminder_benefit_reversible_body">Lo switch è nelle Impostazioni, sezione Notifiche.</string>
    <string name="reminder_onboarding_enable_button">Attiva i promemoria</string>
    <string name="reminder_onboarding_skip_button">Non ora</string>
-    <string name="reminder_action_snooze">Posponi</string>
+    <string name="reminder_action_snooze">Posticipa</string>
    <string name="reminder_action_dismiss">Ignora</string>
    <string name="view_month">Mese</string>
    <string name="view_week">Settimana</string>
@@ -418,16 +418,16 @@
    <string name="settings_default_reminder">Promemoria standard</string>
    <string name="settings_notifications_subtitle">Promemoria evento</string>
    <string name="shortcut_new_event_short">Nuovo evento</string>
-    <string name="event_edit_managed_hint">Gestito da “%1$s” - titolo, data e ripetizioni sono sincronizzate dai tuoi contatti. Promemoria e note sono modificabili dall\'utente</string>
-    <string name="settings_font_headings">Carattere dell\'intestazione</string>
+    <string name="event_edit_managed_hint">Gestito da “%1$s” - titolo, data e ripetizioni sono sincronizzate dai tuoi contatti. Promemoria e note sono modificabili dall\'utente.</string>
+    <string name="settings_font_headings">Carattere del titolo</string>
    <string name="settings_font_body">Carattere del corpo</string>
    <string name="settings_font_system">Predefinito di sistema</string>
    <string name="settings_font_choose_file">Scegli file…</string>
-    <string name="settings_font_custom_selected">Carattere personalizzato</string>
+    <string name="settings_font_custom_selected">Font personalizzato</string>
    <string name="settings_font_import_failed">Impossibile leggere il file come font</string>
    <string name="settings_section_views">Viste</string>
    <string name="settings_quick_switch_header">Pulsante di cambio rapido</string>
-    <string name="settings_quick_switch_hint">Scegli attraverso quali viste scorrere mediante il pulsante in alto a destra, trascinale per riordinarle. Le viste disattivate rimangono raggiungibili dal menù di navigazione.</string>
+    <string name="settings_quick_switch_hint">Scegli attraverso quali viste scorrere col pulsante in alto a destra, trascinale per riordinarle. Le viste disattivate rimangono raggiungibili dal menù di navigazione.</string>
    <string name="settings_drawer_order_header">Menù di navigazione</string>
    <string name="settings_drawer_order_hint">Trascina per riordinare le viste elencate nel menù di navigazione.</string>
    <string name="reorder_drag_handle">Trascina per riordinare</string>
@@ -463,4 +463,7 @@
    <string name="special_dates_calendar_custom">Date speciali</string>
    <string name="special_dates_default_title_birthday">Compleanno di {name} ({year})</string>
    <string name="special_dates_default_title_anniversary">Anniversario di {name} ({year})</string>
+    <string name="font_lora">Lora</string>
+    <string name="font_jetbrains_mono">JetBrains Mono</string>
+    <string name="special_dates_default_title_custom">{name}</string>
 </resources>
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -236,6 +236,9 @@
    <string name="reminder_onboarding_skip_button">Not now</string>
    <string name="reminder_action_snooze">Snooze</string>
    <string name="reminder_action_dismiss">Dismiss</string>
+    <!-- Day context prefix in a reminder for an event on another day (v2.15.0) -->
+    <string name="reminder_day_tomorrow">Tomorrow</string>
+    <string name="reminder_day_yesterday">Yesterday</string>

    <!-- View switcher (M1) -->
    <string name="view_month">Month</string>
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt
@@ -312,6 +312,46 @@ class CalendarRepositoryImplTest {
        assertThat(fake.updatedEvents).containsExactly(Triple(42L, original, updated))
    }

+    @Test
+    fun `moveEvent forwards id, target calendar and both forms`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply { nextInsertId = 77L }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
+        val original = EventForm(
+            calendarId = 1L,
+            title = "Stand-up",
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15)),
+        )
+        val updated = original.copy(calendarId = 3L)
+
+        val newId = repo.moveEvent(eventId = 42L, targetCalendarId = 3L, original = original, updated = updated)
+
+        assertThat(newId).isEqualTo(77L)
+        assertThat(fake.movedEvents).containsExactly(
+            FakeCalendarDataSource.MovedEvent(42L, 3L, original, updated),
+        )
+    }
+
+    @Test
+    fun `moveEvent propagates write failures`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            writeError = WriteFailedException("insert moved event into calendar id=3")
+        }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
+        val form = EventForm(
+            calendarId = 1L,
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+        )
+
+        try {
+            repo.moveEvent(eventId = 42L, targetCalendarId = 3L, original = form, updated = form.copy(calendarId = 3L))
+            error("Expected WriteFailedException")
+        } catch (expected: WriteFailedException) {
+            assertThat(expected.message).contains("3")
+        }
+    }
+
    @Test
    fun `updateEvent propagates write failures`(@TempDir tempDir: Path) = runTest {
        val fake = FakeCalendarDataSource().apply {
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventDetailMapperTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventDetailMapperTest.kt
@@ -32,6 +32,7 @@ class EventDetailMapperTest {
        accessLevel: Any? = null,
        timezone: String? = null,
        selfStatus: Any? = null,
+        duration: String? = null,
    ): MapColumnReader = MapColumnReader(
        EventDetailProjection.IDX_EVENT_ID to eventId,
        EventDetailProjection.IDX_TITLE to title,
@@ -51,6 +52,7 @@ class EventDetailMapperTest {
        EventDetailProjection.IDX_EVENT_TIMEZONE to timezone,
        EventDetailProjection.IDX_SELF_ATTENDEE_STATUS to selfStatus,
        EventDetailProjection.IDX_EVENT_COLOR_KEY to eventColorKey,
+        EventDetailProjection.IDX_DURATION to duration,
    )

    private fun attendeeReader(
@@ -134,12 +136,32 @@ class EventDetailMapperTest {
    fun `pre-1970 negative dtstart is kept, not dropped (issue #34)`() {
        // A yearly birthday/anniversary anchored before the epoch has a
        // legitimately negative UTC epoch-millis DTSTART; recurring rows carry
-        // no DTEND (they use DURATION), so it stays end == begin.
+        // no DTEND (they use DURATION), so the length comes from DURATION.
        val begin = -157_766_400_000L // 1965-01-01T00:00:00Z
-        val detail = detailReader(dtstart = begin, dtend = null).toDetail()
+        val detail = detailReader(dtstart = begin, dtend = null, duration = "P1D").toDetail()
        assertThat(detail).isNotNull()
        assertThat(detail!!.instance.start.toEpochMilliseconds()).isEqualTo(begin)
-        assertThat(detail.instance.end.toEpochMilliseconds()).isEqualTo(begin)
+        assertThat(detail.instance.end.toEpochMilliseconds()).isEqualTo(begin + 86_400_000L)
+    }
+
+    @Test
+    fun `absent dtend takes its length from DURATION (issue #48)`() {
+        // A recurring series row has no DTEND. Opened without a named
+        // occurrence — a bare content://…/events/<id> VIEW intent — the row's
+        // own times are what render, so DURATION has to supply the length or
+        // the event shows as zero-length (10:00–10:00).
+        val begin = 1_000_000_000L
+        val detail = detailReader(dtstart = begin, dtend = null, duration = "PT1H").toDetail()
+        assertThat(detail).isNotNull()
+        assertThat(detail!!.instance.end.toEpochMilliseconds()).isEqualTo(begin + 3_600_000L)
+    }
+
+    @Test
+    fun `absent dtend and absent DURATION stays zero-length`() {
+        val begin = 1_000_000_000L
+        val detail = detailReader(dtstart = begin, dtend = null, duration = null).toDetail()
+        assertThat(detail).isNotNull()
+        assertThat(detail!!.instance.end.toEpochMilliseconds()).isEqualTo(begin)
    }

    @Test
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt
@@ -260,6 +260,77 @@ class EventWriteMapperTest {
            .isEqualTo(CalendarContract.Events.STATUS_CANCELED)
    }

+    // --- buildOccurrenceExdateValues ("delete only this event", no _sync_id) ---
+
+    @Test
+    fun `exdate drop excludes the occurrence and rewrites the recurrence set`() {
+        // 2026-07-15T08:00:00Z.
+        val values = buildOccurrenceExdateValues(
+            existingExdate = null,
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715T080000Z")
+        // The whole time/recurrence set rides along: an EXDATE-only update is not
+        // treated as a recurrence change, so the provider would leave the expanded
+        // instances (and the occurrence) in place. DTSTART alone is worse — it
+        // makes the provider recompute lastDate as a single instance and collapse
+        // the series to its first occurrence.
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_783_929_600_000L)
+        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=DAILY;COUNT=5")
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("PT1H")
+        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
+    }
+
+    @Test
+    fun `exdate drop appends to an existing exdate list`() {
+        val values = buildOccurrenceExdateValues(
+            existingExdate = "20260714T080000Z",
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE])
+            .isEqualTo("20260714T080000Z,20260715T080000Z")
+    }
+
+    @Test
+    fun `exdate drop folds away a repeated occurrence`() {
+        val values = buildOccurrenceExdateValues(
+            existingExdate = "20260715T080000Z",
+            occurrenceMillis = 1_784_102_400_000L,
+            dtStartMillis = 1_783_929_600_000L,
+            rrule = "FREQ=DAILY;COUNT=5",
+            duration = "PT1H",
+            timezone = "Europe/Berlin",
+            allDay = 0,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715T080000Z")
+    }
+
+    @Test
+    fun `all-day exdate drop uses the date-only form`() {
+        // An all-day DTSTART sits at UTC midnight, so the date reads off UTC.
+        val values = buildOccurrenceExdateValues(
+            existingExdate = null,
+            occurrenceMillis = 1_784_073_600_000L, // 2026-07-15T00:00:00Z
+            dtStartMillis = 1_783_900_800_000L,
+            rrule = "FREQ=YEARLY",
+            duration = "P1D",
+            timezone = "UTC",
+            allDay = 1,
+        )
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260715")
+        assertThat(values[CalendarContract.Events.ALL_DAY]).isEqualTo(1)
+    }
+
    // --- per-event colour ---

    @Test
@@ -338,4 +409,114 @@ class EventWriteMapperTest {
        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR, null)
        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR_KEY, null)
    }
+
+    // --- buildMovedMasterValues (calendar move: verbatim series copy) ---
+
+    private fun masterSnapshot(
+        isAllDay: Boolean = false,
+        dtStartMillis: Long = 1_781_164_800_000L,
+        dtEndMillis: Long? = 1_781_164_800_000L + 5_400_000L,
+        duration: String? = null,
+        rrule: String? = null,
+        rdate: String? = null,
+        exdate: String? = null,
+    ) = MasterEventSnapshot(
+        title = "Standup",
+        isAllDay = isAllDay,
+        dtStartMillis = dtStartMillis,
+        dtEndMillis = dtEndMillis,
+        duration = duration,
+        rrule = rrule,
+        rdate = rdate,
+        exdate = exdate,
+        timezone = "Europe/Berlin",
+        availability = CalendarContract.Events.AVAILABILITY_BUSY,
+        accessLevel = CalendarContract.Events.ACCESS_DEFAULT,
+        status = CalendarContract.Events.STATUS_CONFIRMED,
+        location = "Room 1",
+        description = "",
+    )
+
+    @Test
+    fun `moved one-off carries target calendar, uid and DTEND but no recurrence`() {
+        val values = buildMovedMasterValues(masterSnapshot(), targetCalendarId = 9L, uid = "u@calendula")
+        assertThat(values[CalendarContract.Events.CALENDAR_ID]).isEqualTo(9L)
+        assertThat(values[CalendarContract.Events.UID_2445]).isEqualTo("u@calendula")
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
+        assertThat(values[CalendarContract.Events.DTEND]).isEqualTo(1_781_164_800_000L + 5_400_000L)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.DURATION)
+        // Empty description clears explicitly; a raw/keyed colour is never copied
+        // (may be invalid on the target account — the copy inherits its colour).
+        assertThat(values).containsEntry(CalendarContract.Events.DESCRIPTION, null)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_COLOR)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_COLOR_KEY)
+    }
+
+    @Test
+    fun `moved series preserves the recurrence skeleton as RRULE plus DURATION`() {
+        val values = buildMovedMasterValues(
+            masterSnapshot(dtEndMillis = null, duration = "P5400S", rrule = "FREQ=WEEKLY", exdate = "20260618T080000Z"),
+            targetCalendarId = 9L,
+            uid = "u@calendula",
+        )
+        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=WEEKLY")
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
+        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260618T080000Z")
+        // Recurring rows never carry DTEND (the provider's invariant).
+        assertThat(values).doesNotContainKey(CalendarContract.Events.DTEND)
+    }
+
+    @Test
+    fun `moved series without a stored duration derives it from DTEND`() {
+        val values = buildMovedMasterValues(
+            masterSnapshot(duration = null, rrule = "FREQ=DAILY"),
+            targetCalendarId = 9L,
+            uid = "u@calendula",
+        )
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
+    }
+
+    // --- buildCopiedExceptionValues (calendar move: exception replay) ---
+
+    private fun exceptionSnapshot(
+        isCancelled: Boolean = false,
+        duration: String? = null,
+        // Occurrence starts one hour into the day and runs 30 minutes.
+        dtEndMillis: Long? = 1_781_164_800_000L + 3_600_000L + 1_800_000L,
+    ) = ExceptionRowSnapshot(
+        exceptionEventId = 42L,
+        originalInstanceMillis = 1_781_164_800_000L,
+        isCancelled = isCancelled,
+        status = if (isCancelled) CalendarContract.Events.STATUS_CANCELED else CalendarContract.Events.STATUS_CONFIRMED,
+        title = "Moved occurrence",
+        isAllDay = false,
+        dtStartMillis = 1_781_164_800_000L + 3_600_000L,
+        dtEndMillis = dtEndMillis,
+        duration = duration,
+        timezone = "Europe/Berlin",
+        availability = CalendarContract.Events.AVAILABILITY_BUSY,
+        accessLevel = CalendarContract.Events.ACCESS_DEFAULT,
+        location = "",
+        description = "Notes",
+    )
+
+    @Test
+    fun `copied modified occurrence carries the original instance and DURATION not DTEND`() {
+        val values = buildCopiedExceptionValues(exceptionSnapshot())
+        assertThat(values[CalendarContract.Events.ORIGINAL_INSTANCE_TIME])
+            .isEqualTo(1_781_164_800_000L)
+        assertThat(values[CalendarContract.Events.TITLE]).isEqualTo("Moved occurrence")
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L + 3_600_000L)
+        // 30-minute occurrence derived from DTEND, written as DURATION only.
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P1800S")
+        assertThat(values).doesNotContainKey(CalendarContract.Events.DTEND)
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_LOCATION, null)
+    }
+
+    @Test
+    fun `copied modified occurrence keeps a stored duration verbatim`() {
+        val values = buildCopiedExceptionValues(exceptionSnapshot(duration = "P900S", dtEndMillis = null))
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P900S")
+    }
 }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt
@@ -34,6 +34,13 @@ internal class FakeCalendarDataSource : CalendarDataSource {

    val insertedForms = mutableListOf<EventForm>()
    val updatedEvents = mutableListOf<Triple<Long, EventForm, EventForm>>()
+    data class MovedEvent(
+        val eventId: Long,
+        val targetCalendarId: Long,
+        val original: EventForm,
+        val updated: EventForm,
+    )
+    val movedEvents = mutableListOf<MovedEvent>()
    val updatedOccurrences = mutableListOf<Triple<Long, Long, EventForm>>()
    val updatedFromOccurrences = mutableListOf<Triple<Long, Long, EventForm>>()
    val deletedEventIds = mutableListOf<Long>()
@@ -116,6 +123,19 @@ internal class FakeCalendarDataSource : CalendarDataSource {
        allDayReminderTimes += allDayReminderTimeMinutes
    }

+    override fun moveEvent(
+        eventId: Long,
+        targetCalendarId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long {
+        writeError?.let { throw it }
+        movedEvents += MovedEvent(eventId, targetCalendarId, original, updated)
+        allDayReminderTimes += allDayReminderTimeMinutes
+        return nextInsertId
+    }
+
    override fun updateOccurrence(
        eventId: Long,
        beginMillis: Long,
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeTextTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeTextTest.kt
@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.data.reminders

 import com.google.common.truth.Truth.assertThat
 import org.junit.jupiter.api.Test
+import java.time.DayOfWeek
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.ZoneId
@@ -18,41 +19,110 @@ class ReminderTimeTextTest {
    private fun utcMidnight(date: LocalDate): Long =
        date.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()

+    /** Wrapper defaulting `today` to the event's own begin day, so unrelated tests read "today". */
+    private fun text(
+        beginMillis: Long,
+        endMillis: Long,
+        isAllDay: Boolean = false,
+        zone: ZoneId = berlin,
+        locale: Locale = Locale.GERMANY,
+        is24Hour: Boolean = true,
+        today: LocalDate? = null,
+        firstDayOfWeek: DayOfWeek = DayOfWeek.MONDAY,
+    ): String = reminderTimeText(
+        beginMillis = beginMillis,
+        endMillis = endMillis,
+        isAllDay = isAllDay,
+        zone = zone,
+        locale = locale,
+        is24Hour = is24Hour,
+        today = today ?: java.time.Instant.ofEpochMilli(beginMillis).atZone(zone).toLocalDate(),
+        firstDayOfWeek = firstDayOfWeek,
+        tomorrowLabel = "Tomorrow",
+        yesterdayLabel = "Yesterday",
+    )
+
    @Test
-    fun `timed event on one day shows just the time range`() {
-        val text = reminderTimeText(
+    fun `timed event today shows just the time range`() {
+        val text = text(
            beginMillis = millisAt(LocalDateTime.of(2026, 6, 11, 9, 30), berlin),
            endMillis = millisAt(LocalDateTime.of(2026, 6, 11, 10, 0), berlin),
-            isAllDay = false,
-            zone = berlin,
-            locale = Locale.GERMANY,
-            is24Hour = true,
        )
        assertThat(text).isEqualTo("09:30 – 10:00")
    }

    @Test
    fun `12-hour preference renders an am-pm time range`() {
-        val text = reminderTimeText(
+        val text = text(
            beginMillis = millisAt(LocalDateTime.of(2026, 6, 11, 14, 0), berlin),
            endMillis = millisAt(LocalDateTime.of(2026, 6, 11, 15, 0), berlin),
-            isAllDay = false,
-            zone = berlin,
            locale = Locale.US,
            is24Hour = false,
        )
        assertThat(text).isEqualTo("2:00 PM – 3:00 PM")
    }

+    @Test
+    fun `tomorrow's event is prefixed with the tomorrow label`() {
+        val text = text(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 12, 9, 30), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 12, 10, 0), berlin),
+            today = LocalDate.of(2026, 6, 11),
+        )
+        assertThat(text).isEqualTo("Tomorrow, 09:30 – 10:00")
+    }
+
+    @Test
+    fun `yesterday's event is prefixed with the yesterday label`() {
+        val text = text(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 10, 9, 30), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 10, 10, 0), berlin),
+            today = LocalDate.of(2026, 6, 11),
+        )
+        assertThat(text).isEqualTo("Yesterday, 09:30 – 10:00")
+    }
+
+    @Test
+    fun `an event later this week is prefixed with the short weekday`() {
+        // 2026-06-11 is a Thursday; +3 days lands on Sunday, still this (Mon-based) week.
+        val text = text(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 14, 9, 30), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 14, 10, 0), berlin),
+            today = LocalDate.of(2026, 6, 11),
+        )
+        assertThat(text).isEqualTo("So., 09:30 – 10:00")
+    }
+
+    @Test
+    fun `the week boundary honours the week-start setting`() {
+        // Today Thu 2026-06-11, event Sun 2026-06-14. With a Sunday-start week the
+        // Thursday's week runs Sun 06-07..Sat 06-13, so 06-14 is already next week
+        // and must render as a date — the opposite of the Monday-start case above.
+        val text = text(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 14, 9, 30), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 14, 10, 0), berlin),
+            today = LocalDate.of(2026, 6, 11),
+            firstDayOfWeek = DayOfWeek.SUNDAY,
+        )
+        assertThat(text).isEqualTo("14.06.2026, 09:30 – 10:00")
+    }
+
+    @Test
+    fun `an event next week falls back to the exact date, not a weekday`() {
+        // 2026-06-15 is the following Monday — a weekday alone would be ambiguous.
+        val text = text(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 15, 9, 30), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 15, 10, 0), berlin),
+            today = LocalDate.of(2026, 6, 11),
+        )
+        assertThat(text).isEqualTo("15.06.2026, 09:30 – 10:00")
+    }
+
    @Test
    fun `timed event crossing midnight includes both dates`() {
-        val text = reminderTimeText(
+        val text = text(
            beginMillis = millisAt(LocalDateTime.of(2026, 6, 11, 23, 30), berlin),
            endMillis = millisAt(LocalDateTime.of(2026, 6, 12, 0, 30), berlin),
-            isAllDay = false,
-            zone = berlin,
-            locale = Locale.GERMANY,
-            is24Hour = true,
        )
        assertThat(text).contains("11.06.2026")
        assertThat(text).contains("12.06.2026")
@@ -61,28 +131,35 @@ class ReminderTimeTextTest {

    @Test
    fun `all-day single day shows one date, read in UTC`() {
-        val text = reminderTimeText(
+        val text = text(
            beginMillis = utcMidnight(LocalDate.of(2026, 6, 11)),
            endMillis = utcMidnight(LocalDate.of(2026, 6, 12)),
            isAllDay = true,
            // Zone must not matter for all-day events: UTC midnight is
            // 02:00 in Berlin — naive local reading would shift the day.
-            zone = berlin,
-            locale = Locale.GERMANY,
-            is24Hour = true,
+            today = LocalDate.of(2026, 6, 11),
        )
        assertThat(text).isEqualTo("11.06.2026")
    }

+    @Test
+    fun `all-day event tomorrow still shows the exact date, no relative prefix`() {
+        val text = text(
+            beginMillis = utcMidnight(LocalDate.of(2026, 6, 12)),
+            endMillis = utcMidnight(LocalDate.of(2026, 6, 13)),
+            isAllDay = true,
+            today = LocalDate.of(2026, 6, 11),
+        )
+        assertThat(text).isEqualTo("12.06.2026")
+    }
+
    @Test
    fun `all-day multi-day shows the last covered day, not the exclusive end`() {
-        val text = reminderTimeText(
+        val text = text(
            beginMillis = utcMidnight(LocalDate.of(2026, 6, 11)),
            endMillis = utcMidnight(LocalDate.of(2026, 6, 13)),
            isAllDay = true,
-            zone = berlin,
-            locale = Locale.GERMANY,
-            is24Hour = true,
+            today = LocalDate.of(2026, 6, 11),
        )
        assertThat(text).isEqualTo("11.06.2026 – 12.06.2026")
    }
@@ -90,13 +167,11 @@ class ReminderTimeTextTest {
    @Test
    fun `degenerate all-day range never renders an inverted span`() {
        val day = utcMidnight(LocalDate.of(2026, 6, 11))
-        val text = reminderTimeText(
+        val text = text(
            beginMillis = day,
            endMillis = day,
            isAllDay = true,
-            zone = berlin,
-            locale = Locale.GERMANY,
-            is24Hour = true,
+            today = LocalDate.of(2026, 6, 11),
        )
        assertThat(text).isEqualTo("11.06.2026")
    }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModelTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModelTest.kt
@@ -0,0 +1,158 @@
+package de.jeanlucmakiola.calendula.ui.edit
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepositoryImpl
+import de.jeanlucmakiola.calendula.data.calendar.FakeCalendarDataSource
+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.EventDetail
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.Dispatchers
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Path
+import kotlin.time.Instant
+
+/**
+ * Focuses on the save-time branch that decides between an in-place update and a
+ * calendar *move* (copy+delete). The provider-level move itself is verified
+ * on-device; here the fake records which repository call the ViewModel chose.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class EventEditViewModelTest {
+
+    private val dispatcher = UnconfinedTestDispatcher()
+
+    @BeforeEach fun setUp() = Dispatchers.setMain(dispatcher)
+    @AfterEach fun tearDown() = Dispatchers.resetMain()
+
+    private val beginMillis = 1_781_164_800_000L
+    private val endMillis = beginMillis + 3_600_000L
+
+    private fun cal(id: Long): CalendarSource = CalendarSource(
+        id = id, displayName = "Cal $id", accountName = "acc@local", accountType = "LOCAL",
+        color = 0xFF112233.toInt(), isVisibleInSystem = true, canModifyContents = true,
+    )
+
+    private fun detail(calendarId: Long, rrule: String? = null): EventDetail = EventDetail(
+        instance = EventInstance(
+            instanceId = 42L, eventId = 42L, calendarId = calendarId, title = "Standup",
+            start = Instant.fromEpochMilliseconds(beginMillis),
+            end = Instant.fromEpochMilliseconds(endMillis),
+            isAllDay = false, color = 0xFF000000.toInt(), location = null,
+        ),
+        description = null, organizer = null, attendees = emptyList(), rrule = rrule,
+    )
+
+    // Pin the DataStore's scope to the test dispatcher so a settings write (e.g.
+    // last-used calendar) completes under advanceUntilIdle instead of on a real
+    // IO thread the virtual clock can't observe.
+    private fun prefs(tempDir: Path): CalendarPrefs = CalendarPrefs(
+        PreferenceDataStoreFactory.create(
+            scope = CoroutineScope(dispatcher),
+            produceFile = { tempDir.resolve("vm_prefs.preferences_pb").toFile() },
+        ),
+    )
+
+    private fun settings(tempDir: Path): SettingsPrefs = SettingsPrefs(
+        PreferenceDataStoreFactory.create(
+            scope = CoroutineScope(dispatcher),
+            produceFile = { tempDir.resolve("vm_settings.preferences_pb").toFile() },
+        ),
+    )
+
+    private fun viewModel(
+        tempDir: Path,
+        fake: FakeCalendarDataSource,
+    ): EventEditViewModel {
+        val p = prefs(tempDir)
+        val s = settings(tempDir)
+        val repo = CalendarRepositoryImpl(fake, p, s, dispatcher as CoroutineDispatcher)
+        return EventEditViewModel(repo, p, s, dispatcher)
+    }
+
+    /** Keep [EventEditViewModel.state] hot so it computes while the test drives it. */
+    private fun CoroutineScope.activate(vm: EventEditViewModel): Job = launch { vm.state.collect {} }
+
+    @Test
+    fun `changing the calendar routes the save through a move, not an update`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L), cal(2L))
+            eventDetailResult = { detail(calendarId = 1L) }
+            nextInsertId = 99L
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        vm.setCalendar(2L)
+        vm.save()
+        advanceUntilIdle()
+
+        assertThat(fake.movedEvents).hasSize(1)
+        assertThat(fake.movedEvents.single().eventId).isEqualTo(42L)
+        assertThat(fake.movedEvents.single().targetCalendarId).isEqualTo(2L)
+        assertThat(fake.updatedEvents).isEmpty()
+        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.Saved)
+        job.cancel()
+    }
+
+    @Test
+    fun `moving a recurring event skips the scope dialog`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L), cal(2L))
+            eventDetailResult = { detail(calendarId = 1L, rrule = "FREQ=WEEKLY") }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        vm.setCalendar(2L)
+        vm.save()
+        advanceUntilIdle()
+
+        // No AwaitingScope park: a move is inherently whole-series.
+        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.Saved)
+        assertThat(fake.movedEvents).hasSize(1)
+        job.cancel()
+    }
+
+    @Test
+    fun `editing a recurring event without moving still asks for the scope`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L), cal(2L))
+            eventDetailResult = { detail(calendarId = 1L, rrule = "FREQ=WEEKLY") }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        vm.setTitle("Renamed")
+        vm.save()
+        advanceUntilIdle()
+
+        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.AwaitingScope)
+        assertThat(fake.movedEvents).isEmpty()
+        job.cancel()
+    }
+}
--- a/fastlane/metadata/android/en-US/changelogs/21401.txt
+++ b/fastlane/metadata/android/en-US/changelogs/21401.txt
@@ -0,0 +1,34 @@
+### Fixed
+- Deleting one occurrence of a repeating event no longer breaks the series.
+  Choosing "This event" when deleting an occurrence of a recurring event could
+  wipe out every *other* occurrence while leaving the one you deleted behind as
+  a stale, still-tappable ghost — and deleting it again brought the series back.
+  A single-occurrence delete now removes exactly that occurrence and leaves the
+  rest of the series untouched, and the deleted occurrence disappears from the
+  grid straight away. This holds on every kind of calendar, including the
+  on-device ones Calendula keeps for contact birthdays and anniversaries, where
+  the series is a yearly repeat. Thanks to @moonj for the report ([#47]).
+- Tapping an event in a third-party widget opens it in Calendula. v2.13.1 taught
+  Calendula to answer the "new event" hand-off from other apps and widgets; now
+  it also answers the "open this event" one, so tapping an existing event in a
+  widget such as Todo Agenda offers Calendula and lands on that event's details.
+  Thanks to @bushrang3r for the report ([#48]).
+- Events created from other apps get your default reminder. An event handed over
+  by another app or widget — Google Maps' "add to calendar", the Todo Agenda
+  widget's "+" — opened with no reminder at all, ignoring the default set in
+  Settings. It now starts with your default reminder, the same as an event you
+  create in Calendula. An event opened from an `.ics` file is treated differently,
+  because the file has its own say: Calendula keeps whatever reminders it carries
+  (including none at all) and asks you once whether to apply your default instead
+  — it never quietly overrides the file. If you have no default set, it doesn't
+  ask ([#49]).
+- A tidy colour picker on CalDAV calendars. For calendars synced by a CalDAV
+  app (such as DAVx5), the event colour picker showed every colour the account
+  publishes — nearly 150 swatches in alphabetical order, many of them
+  duplicates or near-identical shades. The picker now shows only visually
+  distinct colours, arranged as a rainbow; near-duplicate shades and the
+  washed-out neutrals are folded away so no two swatches look alike. Picked
+  colours still sync exactly as before, and calendars with hand-picked
+  palettes (like Google's) are unaffected. Thanks to @ptab for the report
+  ([#22]).
+
--- a/2
+++ b/2
Author	SHA1	Message	Date
Jean-Luc Makiola	1b731a4ab0	docs(changelog): note the ACTION_EDIT intent and .ics MIME types Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-15 17:25:56 +02:00
Jean-Luc Makiola	ab631365b2	feat(intent): handle ACTION_EDIT and broaden .ics MIME types Round out the calendar-intent surface toward AOSP/Etar parity — the app already handled VIEW (date + event), INSERT, and .ics open/share, but was missing the edit action and the alternate .ics MIME labels. - ACTION_EDIT on content://com.android.calendar/events/<id> now opens the event in the edit form (previously only VIEW → read-only detail existed). An assistant, task app, or widget can hand an event to Calendula to edit. A bare EDIT URI with no occurrence extras falls back to the event row's own DTSTART/DTEND, mirroring the #48 view-event fallback. - ACTION_EDIT with no event id (AOSP's "edit a new event") maps to the same prefilled create form as ACTION_INSERT. - The .ics VIEW/SEND filters now also accept text/x-vcalendar (vCalendar 1.0 / .vcs) and application/ics — the alternate labels the same calendar data arrives under from some file/mail apps (matches Etar's ImportActivity). Deliberately excluded: webcal:// / http(s) remote-calendar subscription (needs INTERNET, which the app doesn't have) and the Google-web-link handler (Google-specific + network). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-15 17:23:40 +02:00
Jean-Luc Makiola	9aa370d583	Merge remote-tracking branch 'origin/main' into release/v2.15.0 # Conflicts: # CHANGELOG.md # app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt	2026-07-15 17:23:31 +02:00
Jean-Luc Makiola	23e9a5a35b	Merge pull request 'fix(reminders): show the day for reminders on another day (#46 )' (!75 ) from fix/reminder-day-context into release/v2.15.0 Reviewed-on: #75	2026-07-13 15:35:03 +00:00
Jean-Luc Makiola	38a35be0f0	fix(reminders): show the day for reminders on another day (#46 ) All checks were successful CI / ci (pull_request) Successful in 5m31s Details Translations / check (pull_request) Successful in 5s Details A reminder fired ahead of an event on a different day showed only the event's time (e.g. "09:30 – 10:00"), making it look like it was happening today. reminderTimeText now prefixes timed events with a relative day: "Tomorrow"/"Yesterday", the short weekday for another day this week, or the exact date for anything further out. The this-week boundary honours the user's "week starts on" setting: the resolved first day of week is threaded through from ReminderNotifier, so e.g. a Sunday reads as next week under a Sunday-start locale. All-day events keep their explicit date (never ambiguous), and cross-midnight timed events keep both explicit dates. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 17:25:51 +02:00
Jean-Luc Makiola	f9f0572ec5	Merge pull request 'docs(changelog): add the custom snooze duration entry (#40 )' (!74 ) from docs/changelog-snooze into release/v2.15.0 Reviewed-on: #74	2026-07-13 14:39:18 +00:00
Jean-Luc Makiola	0221972e6d	docs(changelog): add the custom snooze duration entry (#40 ) All checks were successful Translations / check (pull_request) Successful in 4s Details CI / ci (pull_request) Successful in 12s Details The custom snooze duration shipped in `3c97673` but had no changelog entry; add it to the Unreleased section so it's in the 2.15.0 release notes. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 16:38:35 +02:00
Jean-Luc Makiola	86ea72d56f	Merge pull request 'feat(edit): move an event to another calendar (#39 )' (#73 ) from feat/change-event-calendar into release/v2.15.0	2026-07-13 14:30:07 +00:00
Jean-Luc Makiola	114db7939c	ci(translations): run on every PR so the required check always reports All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 2m27s Details The release/* branch protection requires the "Translations / check" status, but the workflow was path-filtered to translation resources. A code-only PR targeting a release branch never touches those, so the workflow never ran, never posted its status, and the required check stayed pending forever — permanently blocking the merge (only PRs that happened to change strings could satisfy it). Drop the path filter so it runs on every PR, mirroring the always-on `ci` job. The parity check is SDK-free and passes when the committed translations are consistent, so running it on unrelated PRs is effectively free. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 16:27:10 +02:00
Jean-Luc Makiola	4503847c0d	feat(edit): move an event to another calendar (#39 ) All checks were successful CI / ci (pull_request) Successful in 8m40s Details The calendar row in the editor is now tappable when editing an existing event: picking a different calendar moves the event there on save, rather than forcing a delete-and-recreate. CALENDAR_ID is sync-adapter-owned and can't be updated in place, so the move is copy+delete: the master row is re-inserted on the target calendar (preserving UID_2445 so backup dedup and sync identity survive), its reminders and editable guests are copied, and — for a recurring series — every exception is replayed against the new master (modified occurrences via CONTENT_EXCEPTION_URI, cancellations as STATUS_CANCELED). The user's field edits are then applied with the normal series update. Everything on the new side is built before the source is deleted (post-before-delete), with a rollback of the copy on any failure, so a move is all-or-nothing. A calendar change forces whole-series scope, so it skips the recurring scope dialog. Managed special-dates calendars stay locked. Colour is not carried across (a raw/keyed colour may be invalid on the target account), matching the existing calendar-switch behaviour. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 16:11:32 +02:00
Jean-Luc Makiola	95c5fe76e6	Merge pull request 'Release 2.14.1' (!72 ) from release/v2.14.1 into main All checks were successful Release — F-Droid repo + Gitea release / detect (push) Successful in 6s Details Release — F-Droid repo + Gitea release / release (push) Successful in 8m5s Details Reviewed-on: #72	2026-07-13 13:48:22 +00:00
Jean-Luc Makiola	34fa9c9c3e	chore(release): cut 2.14.1 All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 8m43s Details Move the Unreleased fixes (#47, #48, #49, #22) under a 2.14.1 heading, bump versionName/versionCode to 2.14.1/21401, and sync the F-Droid per-version changelog. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 15:32:16 +02:00
Jean-Luc Makiola	53793bfb68	docs(changelog): describe the .ics reminder prompt accurately (#49 ) The prompt is raised whenever a default is configured and the file's reminders differ from it — including when the file carries none at all, not only when it brings its own. On-device verified. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 15:24:18 +02:00
Jean-Luc Makiola	9c7c8cb03a	docs(changelog): note the #47 fix covers local calendars too Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 15:01:37 +02:00
Jean-Luc Makiola	4fea176e28	fix: drop occurrences via EXDATE on calendars with no _sync_id (#47 ) The cancelled-exception fix works on synced calendars but not local ones. A cancelled exception only attaches to its parent through ORIGINAL_SYNC_ID; a local event has no _sync_id, so the link never forms and the provider's expansion of the parent collapses — every other occurrence disappears, which is the original #47 corruption, just on a different calendar type. Verified on-device both ways: a DAVx5 series survives a single-occurrence delete, the same series on a LOCAL calendar vanishes entirely. deleteOccurrence now branches on _sync_id. Synced events keep the (verified) exception path. Events without one — local calendars, and synced events not yet pushed — add the occurrence to the master's EXDATE, which needs no parent link and is the canonical iCalendar way to drop one; a sync adapter carries it upstream unchanged if the calendar later syncs. Two provider quirks shape the write (both observed on a Pixel): - An EXDATE-only update is not treated as a recurrence change: the expanded Instances rows are left alone, so the occurrence stays visible. The time/recurrence set has to ride along to force re-expansion. - DTSTART alone is worse — the provider then recomputes lastDate as if the event were a single instance and collapses the series to its first occurrence. DTSTART + DURATION + RRULE + zone together re-expand it correctly. This path is reached in normal use: Calendula's own contact special-date calendars are local and hold all-day yearly series, so deleting one birthday occurrence went through it. All-day series take the VALUE=DATE EXDATE form. Adds pure buildOccurrenceExdateValues + JVM tests (timed, append, duplicate fold, all-day). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-13 15:01:11 +02:00
Jean-Luc Makiola	cf9492c7ba	fix(detail): derive series length from DURATION when DTEND is null (#48 ) A recurring series row carries DURATION, not DTEND, so EventDetailMapper's end == begin fallback rendered it zero-length. That was harmless while every caller supplied per-occurrence times from Instances, but the bare content://…/events/<id> VIEW intent added in #48 names no occurrence and keeps the row's own times — so a series opened from a third-party widget without begin/end extras showed as "10:00 – 10:00". Read DURATION in the detail projection and derive the end from it, the same way SearchMapper and IcsExportMapper already do. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-12 12:55:05 +02:00
Jean-Luc Makiola	e6def9e5f7	docs(changelog): log the #47/#48/#49 fixes under Unreleased The 2.14.1 branch carried four fixes but only the CalDAV colour picker (#22) had a changelog entry. Adds the recurring single-instance delete fix (#47), the external VIEW-intent handling (#48) and the default reminder on ACTION_INSERT / .ics import prompt (#49), plus their issue link definitions. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-12 12:34:08 +02:00
Jean-Luc Makiola	8ddc11159b	Merge pull request 'Translations update from Weblate' (!66 ) from weblate-bot/calendula:weblate-calendula-strings into main All checks were successful Release — F-Droid repo + Gitea release / detect (push) Successful in 6s Details Release — F-Droid repo + Gitea release / release (push) Has been skipped Details Renovate / renovate (push) Successful in 1m8s Details Reviewed-on: #66	2026-07-12 08:50:03 +00:00
Kachelkaiser	6736bae5ee	Translated using Weblate (German) All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 10m17s Details Currently translated at 100.0% (424 of 424 strings) Translation: Calendula/Strings Translate-URL: https://weblate.dev.jeanlucmakiola.de/projects/calendula/strings/de/	2026-07-10 23:01:07 +00:00
Jean-Luc Makiola	60aa889c57	Merge pull request 'feat(settings): custom snooze duration, extract editor card to floret-kit' (!67 ) from feat/custom-snooze-duration into release/v2.15.0 Reviewed-on: #67	2026-07-08 16:10:32 +00:00
Jean-Luc Makiola	3c9767387b	feat(settings): custom snooze duration, extract editor card to floret-kit All checks were successful CI / ci (pull_request) Successful in 10m14s Details The Snooze-duration setting gains a Custom… option: a new single-select SnoozeDurationPicker keeps the minute presets and adds a Custom row that expands an amount field with a Minutes/Hours toggle, so any delay is settable (not just the fixed presets). Closes the settings half of the snooze request. The three presets-plus-custom editors (reminder default, agenda range, snooze) now delegate to floret-kit's new CustomAmountEditor instead of each duplicating the tonal editor card — the app keeps its domain math, strings and labels. Re-pin the floret-kit submodule to the branch commit carrying CustomAmountEditor. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-08 18:02:13 +02:00
Sam Gamgee	21d1726d7a	Translated using Weblate (Italian) All checks were successful Translations / check (pull_request) Successful in 6s Details CI / ci (pull_request) Successful in 10m38s Details Currently translated at 100.0% (410 of 410 strings) Translation: Calendula/Strings Translate-URL: https://weblate.dev.jeanlucmakiola.de/projects/calendula/strings/it/	2026-07-07 14:42:36 +00:00