Drop the ellipsis in week and day event chips too (#164)

#183 only covered the month grid, but a week column is just as narrow. The
all-day chips and the drag copy take the same treatment; the timed blocks
only when they are showing a single line, since wrapping needs softWrap on
and clipping with it on breaks at the last whole word.

The rule now lives in one helper instead of being copied per chip.

CHANGELOG.md

@@ -7,6 +7,89 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+- Month-view event titles no longer end in an ellipsis. The "…" took the width
+  of a couple of characters and told you nothing you couldn't already see, so
+  the title now simply runs to the edge of its chip — a few more letters per
+  cell, which is often the difference between two events you can tell apart and
+  two you can't ([#164]).
+
+## [2.19.1] — 2026-08-11
+
+### Added
+- **Drag to reschedule can be turned off.** Settings → Views → *Drag to
+  reschedule*, on by default. Off, no event can be picked up in the month, week
+  or day view — for anyone who kept moving appointments by accident while
+  scrolling ([#173]).
+- An early Brazilian Portuguese translation. Calendula has started speaking
+  Brazilian Portuguese, contributed as a community translation through
+  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
+  About a third of the app is covered, so the rest still shows in English — you
+  can pick it under Settings → Language or in Android's per-app language
+  settings. Thanks to
+  [bkrz](https://weblate.dev.jeanlucmakiola.de/user/bkrz/) for getting it
+  started; help finishing it is very welcome.
+
+### Fixed
+- **The language picker forgot which language was picked.** Android hands the
+  applied language back with its script filled in — Simplified Chinese goes in
+  as `zh-CN` and comes out as `zh-Hans-CN` — so after a restart no entry in
+  Settings → Language showed as selected, and the row above it named the
+  language the long way round. Only languages that imply a script were
+  affected.
+
+## [2.19.0] — 2026-08-10
+
+### Added
+- **Drag an event to reschedule it.** Press and hold an event in the month,
+  week or day view and drop it on another time or day — the only way to move an
+  appointment used to be opening it and editing its start and end by hand. The
+  block follows your finger, the timeline scrolls when you carry it to an edge,
+  and the event's length is preserved: a 90-minute meeting dropped on 09:00 ends
+  at 10:30. In week and day view the drop snaps to 15-minute steps; in month
+  view it moves the event to the day you dropped it on and leaves the time
+  alone. A confirmation names the new slot and offers **Undo** wherever the move
+  can be taken back in one step. Events you can't edit — read-only calendars, and
+  birthdays and anniversaries mirrored from your contacts — can't be picked up.
+  Rescheduling isn't pointer-only: a screen reader gets a **Move…** action on
+  every event that can be moved ([#68]).
+- Dragging a **recurring** event asks what it should apply to, the same *this
+  event / this and following / all events* choice a save does. Where moving the
+  whole series would change which weekday it falls on, the rule is rewritten to
+  match — a weekly Monday event dropped on a Wednesday becomes a weekly
+  Wednesday event. Where it can't be rewritten safely, the prompt says so and
+  offers to move just the one occurrence, rather than quietly leaving the
+  series behind ([#68]).
+- **Delete several search results at once.** Long-press a hit in search to enter
+  selection mode, tap the rest (or **Select all**), and delete the lot in one
+  action — finding and removing, say, every leftover event with the same title
+  no longer means opening them one at a time. Recurring hits in the batch ask
+  once for the whole selection instead of once each, results on read-only
+  calendars can't be selected, and the deletion is confirmed before it runs
+  ([#80]).
+
+### Changed
+- **First launch is now a short wizard** instead of a single permission screen.
+  It counts its steps, each one can be stepped back out of, and beyond granting
+  calendar access it offers two things worth deciding once: turning on automatic
+  backup — chosen inline, folder picker and all, since events that live only on
+  the phone are lost with it — and choosing which view Calendula opens on, with
+  a live preview of the month, week, day and agenda layouts rather than four
+  names in a list. Both are skippable, everything chosen is changeable in
+  Settings afterwards, and the backup step is offered only where nothing
+  writable is being synced anywhere. Existing installs are not re-onboarded —
+  revoking and re-granting the calendar permission later does not restart the
+  wizard ([#163]).
+- The one-time notice about calendars switched off for this device is now a step
+  in the flow rather than a dialog thrown over the app on first open.
+
+### Fixed
+- Removed the deprecated `statusBarColor` / `navigationBarColor` theme
+  attributes the Play Console flags on Android 15 and up, where they no longer
+  do anything. The launch backdrop now picks its status-bar icons from the
+  light/dark resource instead, so they stay legible over it either way
+  ([#123]).
+
 ## [2.18.1] — 2026-08-06
 
 ### Fixed
@@ -1333,3 +1416,9 @@ automatically, with zero telemetry and no internet permission.
 [#56]: https://codeberg.org/jlmakiola/calendula/issues/56
 [#114]: https://codeberg.org/jlmakiola/calendula/issues/114
 [#148]: https://codeberg.org/jlmakiola/calendula/issues/148
+[#68]: https://codeberg.org/jlmakiola/calendula/issues/68
+[#80]: https://codeberg.org/jlmakiola/calendula/issues/80
+[#123]: https://codeberg.org/jlmakiola/calendula/issues/123
+[#163]: https://codeberg.org/jlmakiola/calendula/issues/163
+[#173]: https://codeberg.org/jlmakiola/calendula/issues/173
+[#164]: https://codeberg.org/jlmakiola/calendula/issues/164

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 = 21801
-        versionName = "2.18.1"
+        versionCode = 21901
+        versionName = "2.19.1"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/androidTest/java/de/jeanlucmakiola/calendula/ui/onboarding/PermissionScreenTest.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.createComposeRule

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

@@ -27,8 +27,10 @@ import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.EventSearch
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.contacts.MANAGED_UID_PREFIX
 import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
@@ -62,12 +64,14 @@ interface CalendarDataSource {
     fun eventDetail(eventId: Long, allDayReminderTimeMinutes: Int): EventDetail?
 
     /**
-     * Master/one-off events whose title, description or location contains
-     * [query] (case-insensitive), across all calendars, newest first. Reads the
-     * Events table directly so the search is unbounded in time; exception rows
-     * are excluded (see [SearchProjection]). [query] is assumed non-blank.
+     * Master/one-off events that may match [query], across all calendars: every
+     * whitespace-separated token has to appear in the title, description or
+     * location. Reads the Events table directly so the search is unbounded in
+     * time; exception rows are excluded (see [SearchProjection]). A deliberate
+     * superset — [EventSearch] makes the final call and orders the hits.
+     * [query] is assumed non-blank.
      */
-    fun searchEvents(query: String): List<EventInstance>
+    fun searchEvents(query: String): List<SearchCandidate>
 
     /**
      * The event-colour palette the calendar's account publishes
@@ -585,20 +589,23 @@ class AndroidCalendarDataSource @Inject constructor(
         )?.use { c -> c.mapAllNotNull { CursorColumnReader(c).toEventInstance() } } ?: emptyList()
     }
 
-    override fun searchEvents(query: String): List<EventInstance> {
+    override fun searchEvents(query: String): List<SearchCandidate> {
         ensureObserversRegistered()
-        val trimmed = query.trim()
-        if (trimmed.isEmpty()) return emptyList()
-        // Escape the SQL LIKE wildcards so a literal % or _ in the query matches
-        // itself instead of acting as a wildcard.
-        val escaped = trimmed
-            .replace("\\", "\\\\")
-            .replace("%", "\\%")
-            .replace("_", "\\_")
-        val like = "%$escaped%"
-        val match = "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
+        val tokens = EventSearch.tokenize(query).take(MAX_SEARCH_TOKENS)
+        if (tokens.isEmpty()) return emptyList()
+        // Only a pre-filter: EventSearch re-checks every token, including the
+        // ones the cap above dropped.
+        val patterns = tokens.map { likePatterns(it) }
+        val match = patterns.joinToString(" AND ") { variants ->
+            variants.joinToString(" OR ", prefix = "(", postfix = ")") {
+                "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
                     "${CalendarContract.Events.DESCRIPTION} LIKE ? ESCAPE '\\' OR " +
                     "${CalendarContract.Events.EVENT_LOCATION} LIKE ? ESCAPE '\\'"
+            }
+        }
+        val args = patterns
+            .flatMap { variants -> variants.flatMap { pattern -> List(3) { pattern } } }
+            .toTypedArray()
         val selection = "($match) AND " +
             "${CalendarContract.Events.DELETED} = 0 AND " +
             "${CalendarContract.Events.ORIGINAL_ID} IS NULL"
@@ -606,19 +613,17 @@ class AndroidCalendarDataSource @Inject constructor(
             CalendarContract.Events.CONTENT_URI,
             SearchProjection.COLUMNS,
             selection,
-            arrayOf(like, like, like),
+            args,
             CalendarContract.Events.DTSTART + " DESC",
         )?.use { c ->
             val reader = CursorColumnReader(c)
-            val out = ArrayList<EventInstance>(c.count)
+            val out = ArrayList<SearchCandidate>(c.count)
             while (c.moveToNext()) {
+                val description = reader.getString(SearchProjection.IDX_DESCRIPTION)
                 val base = reader.toSearchResult() ?: continue
-                // A recurring master's DTSTART is the series start; show its
-                // nearest occurrence instead so the date is the one the user
-                // actually cares about (and sorting reflects it).
-                val recurring = !reader.getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
-                    !reader.getString(SearchProjection.IDX_RDATE).isNullOrEmpty()
-                out += if (recurring) {
+                // A recurring master's DTSTART is the series start; date the row
+                // by its nearest occurrence instead.
+                val event = if (base.isRecurring) {
                     nearestOccurrenceMillis(base.eventId)?.let { (begin, end) ->
                         base.copy(
                             start = begin.toKotlinInstantFromEpochMillis(),
@@ -628,11 +633,44 @@ class AndroidCalendarDataSource @Inject constructor(
                 } else {
                     base
                 }
+                // The raw title, so matching can't catch on the placeholder an
+                // untitled event is drawn with.
+                out += SearchCandidate(
+                    event = event,
+                    description = description,
+                    title = reader.getString(SearchProjection.IDX_TITLE),
+                )
             }
             out
         } ?: emptyList()
     }
 
+    /**
+     * One token as the `LIKE` patterns to OR together. SQLite folds case for
+     * ASCII only, so a token with cased non-ASCII letters is also queried lower-,
+     * upper- and title-cased, which is how "ärzte" reaches "Ärzte". Wildcarding
+     * those letters away instead would make "москва" `%______%` — a full scan.
+     */
+    private fun likePatterns(token: String): List<String> {
+        if (token.none { it.code > 127 && (it.isUpperCase() || it.isLowerCase()) }) {
+            return listOf(likePattern(token))
+        }
+        val lower = token.lowercase()
+        return listOf(token, lower, token.uppercase(), lower.replaceFirstChar(Char::uppercaseChar))
+            .distinct()
+            .map(::likePattern)
+    }
+
+    private fun likePattern(token: String): String {
+        val sb = StringBuilder("%")
+        for (c in token) {
+            // A literal wildcard from the query matches itself.
+            if (c == '%' || c == '_' || c == '\\') sb.append('\\')
+            sb.append(c)
+        }
+        return sb.append('%').toString()
+    }
+
     /**
      * The occurrence of [eventId] nearest to now: the soonest upcoming one
      * within [OCCURRENCE_WINDOW_MILLIS] ahead, else the most recent past one
@@ -1593,5 +1631,12 @@ class AndroidCalendarDataSource @Inject constructor(
          * next fires beyond it falls back to its series-start date.
          */
         const val OCCURRENCE_WINDOW_MILLIS = 2L * 365 * 24 * 60 * 60 * 1000
+
+        /**
+         * Tokens the SQL pre-filter is built from. Bounds the statement for a
+         * pasted paragraph; the ranker still requires every token, so a capped
+         * search returns fewer rows to check, never more hits.
+         */
+        const val MAX_SEARCH_TOKENS = 8
     }
 }

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

@@ -5,6 +5,7 @@ import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
@@ -17,11 +18,11 @@ interface CalendarRepository {
     suspend fun eventDetail(eventId: Long): EventDetail
 
     /**
-     * Events whose title, description or location contains [query], with hidden
-     * calendars removed and newest first. Empty when [query] is blank. Searches
-     * the whole history/future (see [CalendarDataSource.searchEvents]).
+     * Candidate matches for [query] with hidden calendars removed; empty when
+     * [query] is blank. Searches the whole history/future and leaves matching
+     * and ranking to [de.jeanlucmakiola.calendula.domain.EventSearch].
      */
-    suspend fun searchEvents(query: String): List<EventInstance>
+    suspend fun searchEvents(query: String): List<SearchCandidate>
 
     /**
      * The event-colour palette a calendar's account publishes; empty when it

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

@@ -9,6 +9,7 @@ import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
@@ -162,13 +163,13 @@ class CalendarRepositoryImpl @Inject constructor(
             ?: throw NoSuchEventException(eventId)
     }
 
-    override suspend fun searchEvents(query: String): List<EventInstance> = withContext(io) {
+    override suspend fun searchEvents(query: String): List<SearchCandidate> = withContext(io) {
         if (query.isBlank()) return@withContext emptyList()
         val excluded = prefs.hiddenCalendarIds.first() +
             prefs.pendingDisabledCalendarIds.first() +
             invisibleCalendarIds()
         dataSource.searchEvents(query)
-            .let { if (excluded.isEmpty()) it else it.filterNot { e -> e.calendarId in excluded } }
+            .let { if (excluded.isEmpty()) it else it.filterNot { c -> c.event.calendarId in excluded } }
     }
 
     override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =

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

@@ -125,6 +125,7 @@ internal fun ColumnReader.toEventDetailCore(
         selfStatus = mapAttendeeStatus(getInt(EventDetailProjection.IDX_SELF_ATTENDEE_STATUS)),
         eventColor = eventColor,
         eventColorKey = eventColorKey,
+        isException = !isNull(EventDetailProjection.IDX_ORIGINAL_ID),
     )
 }
 

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

@@ -89,6 +89,9 @@ internal object EventDetailProjection {
         // Recurring rows carry DURATION instead of DTEND; the detail screen
         // needs it to render a series opened without a named occurrence.
         CalendarContract.Events.DURATION,
+        // Non-null on a modified-occurrence exception row; "no RRULE" alone
+        // can't tell an exception from a master (#68).
+        CalendarContract.Events.ORIGINAL_ID,
     )
 
     const val IDX_EVENT_ID = 0
@@ -110,6 +113,7 @@ internal object EventDetailProjection {
     const val IDX_SELF_ATTENDEE_STATUS = 16
     const val IDX_EVENT_COLOR_KEY = 17
     const val IDX_DURATION = 18
+    const val IDX_ORIGINAL_ID = 19
 }
 
 /**
@@ -176,6 +180,8 @@ internal object SearchProjection {
         // display its nearest occurrence, not the series-start DTSTART.
         CalendarContract.Events.RRULE,
         CalendarContract.Events.RDATE,
+        // Excerpted, not just filtered on: a hit has to show what it matched.
+        CalendarContract.Events.DESCRIPTION,
     )
 
     const val IDX_ID = 0
@@ -190,6 +196,7 @@ internal object SearchProjection {
     const val IDX_LOCATION = 9
     const val IDX_RRULE = 10
     const val IDX_RDATE = 11
+    const val IDX_DESCRIPTION = 12
 }
 
 /**

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

@@ -40,5 +40,7 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
         isAllDay = getInt(SearchProjection.IDX_ALL_DAY) != 0,
         color = color,
         location = getString(SearchProjection.IDX_LOCATION),
+        isRecurring = !getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
+            !getString(SearchProjection.IDX_RDATE).isNullOrEmpty(),
     )
 }

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

@@ -301,6 +301,19 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[TODAY_BUTTON_IN_TOOLBAR_KEY] = enabled }
     }
 
+    /**
+     * Whether events can be dragged to another slot in the calendar views (#68,
+     * #173). Defaults to ON. Off means no block registers a drag gesture at all;
+     * rescheduling then goes through the edit form.
+     */
+    val dragToReschedule: Flow<Boolean> = store.data.map { prefs ->
+        prefs[DRAG_TO_RESCHEDULE_KEY] ?: true
+    }
+
+    suspend fun setDragToReschedule(enabled: Boolean) {
+        store.edit { it[DRAG_TO_RESCHEDULE_KEY] = enabled }
+    }
+
     /**
      * How far ahead the in-app Agenda screen shows events (v2.11). Defaults to
      * [AgendaRange.Month] — a month of upcoming events. Independent of the
@@ -550,8 +563,87 @@ class SettingsPrefs @Inject constructor(
         prefs[REMINDER_ONBOARDING_KEY] ?: false
     }
 
-    suspend fun setReminderOnboardingDone() {
-        store.edit { it[REMINDER_ONBOARDING_KEY] = true }
+    /** Cleared, not just set: the wizard's back button re-asks a step (#163). */
+    suspend fun setReminderOnboardingDone(done: Boolean = true) {
+        store.edit { it[REMINDER_ONBOARDING_KEY] = done }
+    }
+
+    /**
+     * Whether this install is a fresh one still owing the wizard's optional
+     * steps (#163). Armed on any launch that holds the calendar permission and
+     * has not finished the reminder step, and cleared again by
+     * [finishOnboardingWizard], so an existing user who revokes and re-grants
+     * the permission isn't re-onboarded.
+     */
+    val onboardingWizardArmed: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_WIZARD_ARMED_KEY] ?: false
+    }
+
+    suspend fun armOnboardingWizard() {
+        store.edit { prefs ->
+            if (prefs[REMINDER_ONBOARDING_KEY] != true) prefs[ONBOARDING_WIZARD_ARMED_KEY] = true
+        }
+    }
+
+    /** Whether the wizard's backup step has been answered (or skipped). */
+    val onboardingBackupDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_BACKUP_KEY] ?: false
+    }
+
+    suspend fun setOnboardingBackupDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_BACKUP_KEY] = done }
+    }
+
+    /** Whether the wizard's default-view step has been answered (or skipped). */
+    val onboardingViewDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_VIEW_KEY] ?: false
+    }
+
+    suspend fun setOnboardingViewDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_VIEW_KEY] = done }
+    }
+
+    /** Whether the wizard's month-style step has been answered (or skipped). */
+    val onboardingMonthStyleDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_MONTH_STYLE_KEY] ?: false
+    }
+
+    suspend fun setOnboardingMonthStyleDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_MONTH_STYLE_KEY] = done }
+    }
+
+    /**
+     * Whether the wizard's calendar-visibility notice has been read. Separate
+     * from [CalendarPrefs.visibilityNoticePending], which says whether this
+     * install has anything to announce at all.
+     */
+    val onboardingVisibilityDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_VISIBILITY_KEY] ?: false
+    }
+
+    suspend fun setOnboardingVisibilityDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_VISIBILITY_KEY] = done }
+    }
+
+    /** Whether the wizard's closing screen has been seen. */
+    val onboardingDoneShown: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_DONE_KEY] ?: false
+    }
+
+    suspend fun setOnboardingDoneShown(shown: Boolean = true) {
+        store.edit { it[ONBOARDING_DONE_KEY] = shown }
+    }
+
+    /**
+     * Close the wizard for good: the closing screen has been seen and the
+     * install stops counting as fresh, so a later revoke-and-re-grant is only
+     * the permission screen. One edit, so the plan can't see it half-closed.
+     */
+    suspend fun finishOnboardingWizard() {
+        store.edit { prefs ->
+            prefs[ONBOARDING_DONE_KEY] = true
+            prefs[ONBOARDING_WIZARD_ARMED_KEY] = false
+        }
     }
 
     /**
@@ -866,6 +958,7 @@ class SettingsPrefs @Inject constructor(
         internal val MONTH_VIEW_STYLE_KEY = stringPreferencesKey("month_view_style")
         internal val TIMELINE_SCALE_KEY = stringPreferencesKey("timeline_scale")
         internal val TODAY_BUTTON_IN_TOOLBAR_KEY = booleanPreferencesKey("today_button_in_toolbar")
+        internal val DRAG_TO_RESCHEDULE_KEY = booleanPreferencesKey("drag_to_reschedule")
         internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val QUICK_SWITCH_VIEWS_KEY = stringPreferencesKey("quick_switch_views")
         internal val DRAWER_VIEW_ORDER_KEY = stringPreferencesKey("drawer_view_order")
@@ -882,6 +975,14 @@ class SettingsPrefs @Inject constructor(
         internal const val MAX_EVENT_DURATION = 1_440
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
         internal val REMINDER_ONBOARDING_KEY = booleanPreferencesKey("reminder_onboarding_done")
+        internal val ONBOARDING_WIZARD_ARMED_KEY = booleanPreferencesKey("onboarding_wizard_armed")
+        internal val ONBOARDING_BACKUP_KEY = booleanPreferencesKey("onboarding_backup_done")
+        internal val ONBOARDING_VIEW_KEY = booleanPreferencesKey("onboarding_view_done")
+        internal val ONBOARDING_MONTH_STYLE_KEY =
+            booleanPreferencesKey("onboarding_month_style_done")
+        internal val ONBOARDING_VISIBILITY_KEY =
+            booleanPreferencesKey("onboarding_visibility_done")
+        internal val ONBOARDING_DONE_KEY = booleanPreferencesKey("onboarding_done_shown")
         internal val ALLOW_COLOR_UNSUPPORTED_KEY =
             booleanPreferencesKey("allow_color_unsupported_calendars")
         internal val DEFAULT_REMINDER_KEY = stringPreferencesKey("default_reminder_minutes")

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

@@ -44,6 +44,14 @@ val CalendarSource.hasVisibilitySwitch: Boolean
 val CalendarSource.isEventTarget: Boolean
     get() = canModifyContents && isVisibleInSystem && !isManaged && !isNotSynced
 
+/**
+ * Whether this calendar's events may have their times rewritten by a drag (#68).
+ * Deliberately not [isEventTarget]: a managed event stays editable (reminders,
+ * notes) yet must never move, since the next contacts sync would put it back.
+ */
+val CalendarSource.allowsEventMove: Boolean
+    get() = canModifyContents && !isManaged
+
 /** Every state worth naming on this calendar's row, in reading order. */
 fun CalendarSource.stateLabels(): List<CalendarStateLabel> = buildList {
     if (isManaged) add(CalendarStateLabel.MANAGED)

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

@@ -0,0 +1,256 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.number
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/** An event with the free text the search may have matched it on. */
+data class SearchCandidate(
+    val event: EventInstance,
+    val description: String? = null,
+    /** Null when the event has none: [EventInstance.title] is then a display
+     *  placeholder, which the query must not catch on. */
+    val title: String? = event.title,
+)
+
+/** A matched run inside one of a hit's texts, for highlighting. */
+data class MatchSpan(val start: Int, val end: Int)
+
+/** The part of a description a token matched, elided to what fits a row. */
+data class DescriptionSnippet(
+    val text: String,
+    val spans: List<MatchSpan>,
+)
+
+/** One result: the event, plus where the query matched it. */
+data class SearchHit(
+    val event: EventInstance,
+    val titleSpans: List<MatchSpan> = emptyList(),
+    val locationSpans: List<MatchSpan> = emptyList(),
+    val descriptionSnippet: DescriptionSnippet? = null,
+    /** Already over, so the row can say so. Finished-today counts. */
+    val isPast: Boolean = false,
+)
+
+/** One month's worth of hits, as the results list draws them under a header. */
+data class SearchMonth(
+    val year: Int,
+    /** 1–12, so the UI can build the month's first day for a localized label. */
+    val monthNumber: Int,
+    val hits: List<SearchHit>,
+)
+
+/** A finished search: a calendar of hits, plus the description-only ones. */
+data class SearchResults(
+    val months: List<SearchMonth>,
+    val inDescriptions: List<SearchHit>,
+) {
+    val isEmpty: Boolean get() = months.isEmpty() && inDescriptions.isEmpty()
+
+    /** Every hit, whichever section it sits in — for select-all and delete. */
+    val allHits: List<SearchHit> get() = months.flatMap { it.hits } + inDescriptions
+}
+
+/**
+ * Turning a typed query into the results list.
+ *
+ * An event has to carry *every* whitespace-separated token, each in any of
+ * title / location / description; case is folded in Kotlin rather than by SQL's
+ * ASCII-only `LIKE`, so "ärzte" finds "Ärzte".
+ *
+ * Results are a calendar, not a ranking: months from the current one, then
+ * forwards, then backwards, and inside a month what is still to come before
+ * what has passed. The day is the boundary, not the moment. A hit the query
+ * only reached through its description is held back in
+ * [SearchResults.inDescriptions] rather than dated among the real ones.
+ */
+object EventSearch {
+
+    /** Characters of description kept around the match in a row's snippet. */
+    private const val SNIPPET_LENGTH = 96
+
+    /** Characters of lead-in shown before the match, when there is room. */
+    private const val SNIPPET_LEAD = 24
+
+    private val WHITESPACE = Regex("\\s+")
+
+    /** Shared with the data layer so its SQL pre-filter tokenises identically. */
+    fun tokenize(query: String): List<String> =
+        query.trim().split(WHITESPACE).filter { it.isNotEmpty() }
+
+    /**
+     * Search [candidates] for [query], dropping any that don't carry every token.
+     * [now] marks a hit as over, [todayStart] is where it stops being current.
+     * [zone] places each event on the calendar through the span rule, so an
+     * all-day event keeps its own day whichever side of UTC we are on (#82).
+     */
+    fun search(
+        candidates: List<SearchCandidate>,
+        query: String,
+        now: Instant,
+        todayStart: Instant,
+        zone: TimeZone,
+    ): SearchResults {
+        val tokens = tokenize(query)
+        if (tokens.isEmpty()) return SearchResults(emptyList(), emptyList())
+
+        val today = todayStart.toLocalDateTime(zone).date
+        val matched = candidates.mapNotNull { candidate -> match(candidate, tokens, now, zone) }
+        val upcoming = { m: Matched -> m.event.spanLastDay(zone) >= today }
+        val order = compareBy<Matched> { if (upcoming(it)) 0 else 1 }
+            .thenComparator { a, b ->
+                // What is left reads forwards; what is behind us reads backwards
+                // from today, nearest first.
+                if (upcoming(a)) {
+                    a.event.dayStart(zone).compareTo(b.event.dayStart(zone))
+                } else {
+                    b.event.dayStart(zone).compareTo(a.event.dayStart(zone))
+                }
+            }
+
+        val (inDescriptions, dated) = matched.sortedWith(order).partition { it.descriptionOnly }
+        return SearchResults(
+            months = groupByMonth(dated, zone, todayStart),
+            inDescriptions = inDescriptions.map { it.hit },
+        )
+    }
+
+    /** Months from the current one, then forwards, then backwards. */
+    private fun groupByMonth(
+        dated: List<Matched>,
+        zone: TimeZone,
+        todayStart: Instant,
+    ): List<SearchMonth> {
+        val currentKey = monthKey(todayStart.toLocalDateTime(zone).date)
+        return dated
+            .groupBy { monthKey(it.event.spanFirstDay(zone)) }
+            .entries
+            .sortedWith(
+                compareBy<Map.Entry<Int, List<Matched>>> {
+                    when {
+                        it.key == currentKey -> 0
+                        it.key > currentKey -> 1
+                        else -> 2
+                    }
+                }.thenComparator { a, b ->
+                    if (a.key > currentKey) a.key.compareTo(b.key) else b.key.compareTo(a.key)
+                },
+            )
+            .map { (key, entries) ->
+                SearchMonth(
+                    year = key / 12,
+                    monthNumber = key % 12 + 1,
+                    hits = entries.map { it.hit },
+                )
+            }
+    }
+
+    /** Year and month as one comparable number. */
+    private fun monthKey(date: LocalDate): Int = date.year * 12 + (date.month.number - 1)
+
+    private fun match(
+        candidate: SearchCandidate,
+        tokens: List<String>,
+        now: Instant,
+        zone: TimeZone,
+    ): Matched? {
+        val title = candidate.title?.takeIf { it.isNotBlank() }
+        val location = candidate.event.location?.takeIf { it.isNotBlank() }
+        // Collapsed so a multi-line description matches the way it is drawn.
+        val description = candidate.description
+            ?.replace(WHITESPACE, " ")
+            ?.trim()
+            ?.takeIf { it.isNotEmpty() }
+
+        // Mid-word counts: "termin" has to keep finding "Zahnarzttermin".
+        val present = { token: String ->
+            title?.contains(token, ignoreCase = true) == true ||
+                location?.contains(token, ignoreCase = true) == true ||
+                description?.contains(token, ignoreCase = true) == true
+        }
+        if (!tokens.all(present)) return null
+
+        val descriptionSpans = description?.let { spansIn(it, tokens) }.orEmpty()
+        val titleSpans = title?.let { spansIn(it, tokens) }.orEmpty()
+        val locationSpans = location?.let { spansIn(it, tokens) }.orEmpty()
+        return Matched(
+            hit = SearchHit(
+                event = candidate.event,
+                titleSpans = titleSpans,
+                locationSpans = locationSpans,
+                descriptionSnippet = description
+                    ?.takeIf { descriptionSpans.isNotEmpty() }
+                    ?.let { snippet(it, descriptionSpans) },
+                isPast = candidate.event.dayEnd(zone) < now,
+            ),
+            // Nothing in the name or the place caught the query: it is only here
+            // for something in its notes.
+            descriptionOnly = titleSpans.isEmpty() && locationSpans.isEmpty(),
+        )
+    }
+
+    /** Every occurrence of every token in [text], merged where they overlap. */
+    private fun spansIn(text: String, tokens: List<String>): List<MatchSpan> {
+        val raw = mutableListOf<MatchSpan>()
+        for (token in tokens) {
+            var index = text.indexOf(token, startIndex = 0, ignoreCase = true)
+            while (index >= 0) {
+                raw += MatchSpan(index, index + token.length)
+                index = text.indexOf(token, startIndex = index + 1, ignoreCase = true)
+            }
+        }
+        if (raw.isEmpty()) return emptyList()
+        val sorted = raw.sortedBy { it.start }
+        val merged = mutableListOf(sorted.first())
+        for (span in sorted.drop(1)) {
+            val last = merged.last()
+            if (span.start <= last.end) {
+                merged[merged.lastIndex] = MatchSpan(last.start, maxOf(last.end, span.end))
+            } else {
+                merged += span
+            }
+        }
+        return merged
+    }
+
+    /**
+     * A window of [description] around its first match, elided at both ends,
+     * with the spans rebased onto it and any falling outside dropped.
+     */
+    private fun snippet(description: String, spans: List<MatchSpan>): DescriptionSnippet {
+        if (description.length <= SNIPPET_LENGTH) {
+            return DescriptionSnippet(description, spans)
+        }
+        val first = spans.first().start
+        val start = (first - SNIPPET_LEAD).coerceIn(0, (description.length - SNIPPET_LENGTH))
+        val end = (start + SNIPPET_LENGTH).coerceAtMost(description.length)
+        val prefix = if (start > 0) "…" else ""
+        val suffix = if (end < description.length) "…" else ""
+        val text = prefix + description.substring(start, end) + suffix
+        val shift = prefix.length - start
+        val rebased = spans
+            .filter { it.start >= start && it.end <= end }
+            .map { MatchSpan(it.start + shift, it.end + shift) }
+        return DescriptionSnippet(text, rebased)
+    }
+
+    private data class Matched(val hit: SearchHit, val descriptionOnly: Boolean) {
+        val event: EventInstance get() = hit.event
+    }
+
+    /**
+     * The event's first day as an instant in [zone]. An all-day event sits at
+     * UTC midnight, so its raw start would rank it on a day it isn't drawn on.
+     */
+    private fun EventInstance.dayStart(zone: TimeZone): Instant =
+        if (isAllDay) spanFirstDay(zone).atStartOfDayIn(zone) else start
+
+    /** The moment the event's last day is over in [zone], exclusive. */
+    private fun EventInstance.dayEnd(zone: TimeZone): Instant =
+        if (isAllDay) spanLastDay(zone).plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone) else end
+}

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

@@ -0,0 +1,53 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/**
+ * The zone this form's wall-clock times mean, matching what the data layer
+ * resolves them in at write time: the form's own pinned zone, else [deviceZone].
+ */
+fun EventForm.resolvedZone(deviceZone: TimeZone): TimeZone =
+    timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: deviceZone
+
+/**
+ * The form moved so it starts at [newStart], keeping its **instant** duration —
+ * a recurring event's length travels to the provider as `DURATION`, so keeping
+ * wall clock instead would rewrite the series' length across a DST boundary.
+ *
+ * All-day events are date-anchored — use [shiftedByDays]; this returns them
+ * untouched.
+ */
+fun EventForm.shiftedTo(newStart: Instant, deviceZone: TimeZone): EventForm {
+    if (isAllDay) return this
+    val zone = resolvedZone(deviceZone)
+    val span = end.toInstant(zone) - start.toInstant(zone)
+    return copy(
+        start = newStart.toLocalDateTime(zone),
+        end = (newStart + span).toLocalDateTime(zone),
+    )
+}
+
+/**
+ * The form moved [days] calendar days, keeping its time of day and its span.
+ * All-day events are pure date arithmetic; a timed one preserves its **instant**
+ * duration, for the same reason [shiftedTo] does.
+ */
+fun EventForm.shiftedByDays(days: Int, deviceZone: TimeZone): EventForm {
+    if (days == 0) return this
+    val newStart = LocalDateTime(start.date.plus(days, DateTimeUnit.DAY), start.time)
+    if (isAllDay) {
+        return copy(
+            start = newStart,
+            end = LocalDateTime(end.date.plus(days, DateTimeUnit.DAY), end.time),
+        )
+    }
+    val zone = resolvedZone(deviceZone)
+    val span = end.toInstant(zone) - start.toInstant(zone)
+    return copy(start = newStart, end = (newStart.toInstant(zone) + span).toLocalDateTime(zone))
+}

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

@@ -62,6 +62,11 @@ data class EventInstance(
     val isAllDay: Boolean,
     val color: Int,
     val location: String?,
+    /**
+     * Only search results, which read the series master, fill this in — the
+     * Instances query already yields one row per occurrence.
+     */
+    val isRecurring: Boolean = false,
 )
 
 /**
@@ -124,6 +129,12 @@ data class EventDetail(
     val eventColor: Int? = null,
     /** The event's `Events.EVENT_COLOR_KEY` (a calendar-palette key), or null. */
     val eventColorKey: String? = null,
+    /**
+     * True when this row is a modified occurrence of a series (`ORIGINAL_ID` is
+     * set) rather than a master, so a reschedule takes the plain whole-row path
+     * whatever [rrule] a sync adapter left on it.
+     */
+    val isException: Boolean = false,
 )
 
 /**

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

@@ -138,7 +138,7 @@ fun SimpleRecurrence.toRRule(zone: TimeZone = TimeZone.currentSystemDefault()):
     }
 }
 
-private val RRULE_DAY_CODES: Map<DayOfWeek, String> = mapOf(
+internal val RRULE_DAY_CODES: Map<DayOfWeek, String> = mapOf(
     DayOfWeek.MONDAY to "MO",
     DayOfWeek.TUESDAY to "TU",
     DayOfWeek.WEDNESDAY to "WE",

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

@@ -0,0 +1,48 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.LocalDate
+
+/**
+ * [rrule] re-anchored from an occurrence on [oldStart] to one on [newStart].
+ *
+ * `Events.RRULE` is written verbatim while DTSTART moves, so `FREQ=WEEKLY;BYDAY=MO`
+ * would keep naming Monday after the anchor became a Wednesday and the series
+ * would not move at all — `BYDAY` is re-derived from [newStart].
+ *
+ * Only weekly `BYDAY` is realigned, and only for a whole-day move: the rule has
+ * to agree with the series *anchor*, and weekday arithmetic is the only kind
+ * that survives the same wall-clock shift unchanged. Everything else returns
+ * null, as do rules one moved occurrence can't resolve (`BYDAY=MO,WE`, `2TH`,
+ * `BYSETPOS`). The accepted parts are a subset of [parseSimpleRecurrence], so
+ * anything realignable is also a rule [problems] can check the `UNTIL` of.
+ */
+fun realignRecurrence(rrule: String, oldStart: LocalDate, newStart: LocalDate): String? {
+    if (oldStart == newStart) return rrule
+    val prefix = if (rrule.startsWith("RRULE:")) "RRULE:" else ""
+    val parts = rrule.removePrefix("RRULE:").split(';').filter { it.isNotBlank() }
+    if (parts.isEmpty()) return null
+    var weekly = false
+    val rebuilt = parts.map { part ->
+        val eq = part.indexOf('=')
+        if (eq <= 0) return null
+        val key = part.substring(0, eq).uppercase()
+        val value = part.substring(eq + 1).trim()
+        when (key) {
+            "FREQ" -> {
+                weekly = value.equals("WEEKLY", ignoreCase = true)
+                part
+            }
+            "BYDAY" -> {
+                val old = RRULE_DAY_CODES[oldStart.dayOfWeek] ?: return null
+                if (!value.equals(old, ignoreCase = true)) return null
+                "BYDAY=${RRULE_DAY_CODES.getValue(newStart.dayOfWeek)}"
+            }
+            "INTERVAL", "COUNT", "UNTIL", "WKST" -> part
+            else -> return null
+        }
+    }
+    // BYDAY is only simple on a weekly rule, matching parseSimpleRecurrence.
+    if (!weekly && parts.any { it.substringBefore('=').trim().uppercase() == "BYDAY" }) return null
+    if (parts.none { it.substringBefore('=').trim().uppercase() == "FREQ" }) return null
+    return prefix + rebuilt.joinToString(";")
+}

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

@@ -10,6 +10,7 @@ import androidx.compose.animation.slideOutHorizontally
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -27,6 +28,10 @@ import de.jeanlucmakiola.calendula.ui.calendars.BackupScreen
 import de.jeanlucmakiola.calendula.ui.calendars.CalendarsScreen
 import de.jeanlucmakiola.floret.identity.fadeThrough
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.EventMoveHost
+import de.jeanlucmakiola.calendula.ui.common.EventMoveScope
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.RescheduleViewModel
 import de.jeanlucmakiola.calendula.ui.common.drillToDay
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.selectView
@@ -294,6 +299,33 @@ fun CalendarHost(
         }
     }
 
+    // Drag to reschedule (#68). Hosted here so one instance serves every view and
+    // survives view switches; the calendar surfaces read it out of LocalEventMove.
+    val reschedule: RescheduleViewModel = hiltViewModel()
+    val movableCalendarIds by reschedule.movableCalendarIds.collectAsStateWithLifecycle()
+    val onEditEvent: (EventInstance) -> Unit = { event ->
+        val key = longArrayOf(
+            event.eventId,
+            event.start.toEpochMilliseconds(),
+            event.end.toEpochMilliseconds(),
+        )
+        heldEditKey = key
+        editKey = key
+    }
+    // Off by preference (#173) switches off the gesture, not the scope: blocks
+    // register no drag, while the edit form and its TalkBack action stay put.
+    val dragToReschedule = viewModel.dragToReschedule.collectAsStateWithLifecycle().value
+    val moveScope = remember(movableCalendarIds, reschedule, dragToReschedule) {
+        EventMoveScope(
+            movableCalendarIds = movableCalendarIds,
+            dragEnabled = dragToReschedule,
+            move = reschedule::move,
+            inFlight = reschedule.inFlight,
+            undoStarted = reschedule.undoStarted,
+            edit = onEditEvent,
+        )
+    }
+
     val slideSpec = rememberCalendarSlideSpec()
 
     // Base-level back: pop the view stack while no overlay covers it (each overlay
@@ -311,6 +343,7 @@ fun CalendarHost(
         // navigation, so it fades through rather than sliding — paging *within* a
         // view keeps the directional slide. AnimatedContent keyed on the view type.
         val viewSwitch = fadeThrough()
+        CompositionLocalProvider(LocalEventMove provides moveScope) {
         AnimatedContent(
             targetState = view,
             transitionSpec = { viewSwitch },
@@ -367,6 +400,11 @@ fun CalendarHost(
                 )
             }
         }
+        }
+
+        // Scope prompt + confirmation/undo snackbar for a dropped event, declared
+        // right after the calendar views so later overlays cover it.
+        EventMoveHost(reschedule, modifier = Modifier.fillMaxSize())
 
         // Search overlay — below detail/edit in the Box so a tapped result's
         // detail screen draws on top, and closing it returns to the results.

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

@@ -53,4 +53,18 @@ class CalendarHostViewModel @Inject constructor(
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
+
+    /**
+     * Whether events may be dragged to another slot to reschedule them (#68, #173).
+     * Off until the stored value arrives, even though the preference itself defaults
+     * on: the wrong guess costs an enabled user a gesture for the few frames a cold
+     * start takes to read DataStore, but re-arms the one thing a disabled user
+     * switched off to be rid of.
+     */
+    val dragToReschedule: StateFlow<Boolean> = prefs.dragToReschedule
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = false,
+        )
 }

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

@@ -2,12 +2,15 @@ package de.jeanlucmakiola.calendula.ui
 
 import android.Manifest
 import android.content.pm.PackageManager
-import androidx.compose.animation.Crossfade
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
-import androidx.compose.material3.MaterialTheme
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.togetherWith
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -22,13 +25,22 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.hasContactsPermission
-import de.jeanlucmakiola.calendula.ui.calendars.CalendarVisibilityNoticeDialog
-import de.jeanlucmakiola.calendula.ui.calendars.CalendarVisibilityNoticeViewModel
-import de.jeanlucmakiola.calendula.ui.permission.PermissionScreen
-import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingScreen
-import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingViewModel
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingStep
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingSteps
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingViewModel
+import de.jeanlucmakiola.calendula.ui.onboarding.onboardingSlideTransition
+import de.jeanlucmakiola.calendula.ui.onboarding.rememberOnboardingSlideSpec
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+
+/** What the root is showing: a wizard step, the app, or neither yet. */
+private sealed interface RootTarget {
+    /** DataStore has not emitted yet — render nothing rather than the wrong screen. */
+    data object Loading : RootTarget
+    data object App : RootTarget
+    data class Step(val step: OnboardingStep) : RootTarget
+}
 
-@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun RootScreen(
     modifier: Modifier = Modifier,
@@ -76,33 +88,63 @@ fun RootScreen(
         onDispose { lifecycle.removeObserver(obs) }
     }
 
-    // Cross-fade the one-time onboarding gates so granting permission / finishing
-    // onboarding eases into the next screen instead of snapping. A fade carries no
-    // spatial motion, so it stays appropriate under "remove animations" too.
-    val gateSpec = MaterialTheme.motionScheme.fastEffectsSpec<Float>()
-    Crossfade(targetState = hasPermission, animationSpec = gateSpec, label = "permissionGate") { granted ->
-        if (granted) {
-            // Second onboarding gate (v1.4, one-time): reminder notifications.
-            // Null until DataStore's first emission — render nothing for that
-            // frame instead of flashing the wrong screen.
-            val reminderOnboarding: ReminderOnboardingViewModel = hiltViewModel()
-            val onboardingDone by reminderOnboarding.onboardingDone.collectAsStateWithLifecycle()
-            // One-time explainer for the switch to the device's own calendar
-            // visibility (#75), armed by the reconciler.
-            val visibilityNotice: CalendarVisibilityNoticeViewModel = hiltViewModel()
-            val noticePending by visibilityNotice.pending.collectAsStateWithLifecycle()
-            // Runs on entry however the permission was granted, including via
-            // Android's app-settings screen (caught by the ON_RESUME above).
-            LaunchedEffect(Unit) {
-                visibilityNotice.reconcile()
-                if (!grantedAtLaunch) reminderOnboarding.rearmAfterGrant()
+    val onboarding: OnboardingViewModel = hiltViewModel()
+    val plan by onboarding.plan.collectAsStateWithLifecycle()
+    // The grant is reported however it was taken, including via Android's
+    // app-settings screen (caught by the ON_RESUME above); arming the wizard
+    // hangs off that, not off the in-app callback.
+    LaunchedEffect(hasPermission) {
+        onboarding.setHasPermission(hasPermission)
+        if (hasPermission && !grantedAtLaunch) onboarding.onPermissionGranted()
     }
-            if (onboardingDone == true && noticePending) {
-                CalendarVisibilityNoticeDialog(onDismiss = visibilityNotice::dismiss)
+
+    // Arms the one-time explainer for the switch to the device's own calendar
+    // visibility (#75), which the wizard then carries as a step of its own.
+    LaunchedEffect(hasPermission) {
+        if (hasPermission) onboarding.reconcileCalendarVisibility()
     }
-            Crossfade(targetState = onboardingDone, animationSpec = gateSpec, label = "onboardingGate") { done ->
-                when (done) {
-                    true -> CalendarHost(
+
+    val current = plan
+    val target: RootTarget = when {
+        current == null -> RootTarget.Loading
+        current.current == null -> RootTarget.App
+        else -> RootTarget.Step(current.current)
+    }
+
+    // Which way the flow is moving, so a step-back slides back. The app sorts
+    // after every step, so finishing the wizard reads as one more move forward.
+    val ordinal = when (target) {
+        RootTarget.Loading -> Int.MIN_VALUE
+        RootTarget.App -> Int.MAX_VALUE
+        is RootTarget.Step -> current?.steps?.indexOf(target.step) ?: 0
+    }
+    var lastOrdinal by remember { mutableIntStateOf(ordinal) }
+    val slideDir = if (ordinal < lastOrdinal) -1 else 1
+    SideEffect { lastOrdinal = ordinal }
+
+    val slideSpec = rememberOnboardingSlideSpec()
+    val fadeSpec = rememberCalendarFadeSpec()
+    val reduceMotion = rememberReduceMotion()
+    AnimatedContent(
+        targetState = target,
+        transitionSpec = {
+            // Coming off the blank first frame is not a step change.
+            if (initialState == RootTarget.Loading) {
+                fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
+            } else {
+                onboardingSlideTransition(
+                    slideDir = slideDir,
+                    spec = slideSpec,
+                    fadeSpec = fadeSpec,
+                    reduceMotion = reduceMotion,
+                )
+            }
+        },
+        label = "onboardingGate",
+    ) { shown ->
+        when (shown) {
+            RootTarget.Loading -> Unit
+            RootTarget.App -> CalendarHost(
                 modifier = modifier,
                 requestedDetailKey = requestedDetailKey,
                 onDetailKeyConsumed = onDetailKeyConsumed,
@@ -116,18 +158,17 @@ fun RootScreen(
                 requestedEditKey = requestedEditKey,
                 onEditKeyConsumed = onEditKeyConsumed,
             )
-                    false -> ReminderOnboardingScreen(
-                        onFinished = reminderOnboarding::finish,
-                        modifier = modifier,
-                    )
-                    null -> {}
-                }
-            }
-        } else {
-            PermissionScreen(
-                onGranted = { hasPermission = true },
+            // Both halves of a transition read their position out of the live
+            // plan; the one the outgoing step was drawn with is already gone.
+            is RootTarget.Step -> current?.let { plan ->
+                OnboardingSteps(
+                    step = shown.step,
+                    plan = plan,
+                    viewModel = onboarding,
+                    onPermissionGranted = { hasPermission = true },
                     modifier = modifier,
                 )
             }
         }
     }
+}

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

@@ -276,7 +276,7 @@ private fun AgendaRangeBanner(
 }
 
 @Composable
-private fun AgendaContent(
+internal fun AgendaContent(
     state: AgendaUiState,
     pastDisplay: PastEventDisplay,
     showToday: Boolean,

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

@@ -0,0 +1,64 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.sampleAgendaEvents
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+
+/** How far ahead the agenda preview's stand-in window runs. */
+private const val PREVIEW_WINDOW_DAYS = 14
+
+/**
+ * A live, scaled-down Agenda view for the onboarding view chooser. Today and
+ * the day headers are real; only the events are stand-ins.
+ */
+@Composable
+internal fun AgendaViewPreview(
+    height: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
+    val state = remember(today, zone) { sampleAgendaState(today, zone) }
+
+    ScaledViewPreview(height = height, modifier = modifier) {
+        AgendaContent(
+            state = state,
+            // Stand-in events are all upcoming, so the past-event preference
+            // cannot change what the preview shows — keep it at the default.
+            pastDisplay = PastEventDisplay.SHOW,
+            showToday = true,
+            onRetry = {},
+            onEventClick = {},
+            onOpenDay = {},
+            modifier = Modifier.fillMaxSize(),
+        )
+    }
+}
+
+/** Sample agenda state, grouped through the same helper the live view uses. */
+private fun sampleAgendaState(today: LocalDate, zone: TimeZone): AgendaUiState.Success {
+    val windowEnd = today.plus(PREVIEW_WINDOW_DAYS, DateTimeUnit.DAY)
+    return AgendaUiState.Success(
+        anchor = today,
+        today = today,
+        days = groupAgendaDays(today, windowEnd, sampleAgendaEvents(today, zone), zone),
+        range = AgendaRange.Custom(PREVIEW_WINDOW_DAYS),
+        rangeIsOverride = false,
+        rangeEnd = windowEnd,
+        // The range bar belongs to the screen, not the list — the preview shows
+        // the list only.
+        showRangeBar = false,
+        zone = zone,
+    )
+}

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

@@ -1,71 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.VisibilityOff
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.calendar.CalendarVisibilityReconciler
-import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * The one-time notice that Calendula now follows the device's per-calendar
- * visibility (#75), armed by `CalendarVisibilityReconciler`. The app does not
- * switch those calendars back on — that would un-hide them everywhere else too.
- */
-@HiltViewModel
-class CalendarVisibilityNoticeViewModel @Inject constructor(
-    private val prefs: CalendarPrefs,
-    private val reconciler: CalendarVisibilityReconciler,
-) : ViewModel() {
-
-    /**
-     * Reconcile whenever the app comes up with the calendar permission held,
-     * rather than off one grant route: a permission granted on Android's
-     * app-settings screen never reaches the permission screen's callback.
-     */
-    fun reconcile() {
-        viewModelScope.launch { reconciler.run() }
-    }
-
-    val pending: StateFlow<Boolean> = prefs.visibilityNoticePending
-        .map { it == true }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = false,
-        )
-
-    fun dismiss() {
-        viewModelScope.launch { prefs.setVisibilityNoticePending(false) }
-    }
-}
-
-/** Plain informational dialog — one acknowledgement, nothing to decide. */
-@Composable
-fun CalendarVisibilityNoticeDialog(onDismiss: () -> Unit) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        icon = { Icon(Icons.Default.VisibilityOff, contentDescription = null) },
-        title = { Text(stringResource(R.string.calendars_visibility_notice_title)) },
-        text = { Text(stringResource(R.string.calendars_visibility_notice_message)) },
-        confirmButton = {
-            TextButton(onClick = onDismiss) {
-                Text(stringResource(R.string.dialog_ok))
-            }
-        },
-    )
-}

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

@@ -0,0 +1,75 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.FiniteAnimationSpec
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.snap
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+
+/**
+ * A timed block's own time label, crossfaded rather than replaced — the block
+ * slides to its new slot, so the label shouldn't change in a single frame.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun BlockTimeLabel(label: String, color: Color, modifier: Modifier = Modifier) {
+    val spec: FiniteAnimationSpec<Float> = if (rememberReduceMotion()) {
+        snap()
+    } else {
+        MaterialTheme.motionScheme.fastEffectsSpec()
+    }
+    Crossfade(
+        targetState = label,
+        animationSpec = spec,
+        label = "block-time",
+        modifier = modifier,
+    ) { text ->
+        Text(
+            text = text,
+            style = MaterialTheme.typography.labelSmall,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            color = color,
+        )
+    }
+}
+
+/** Where a timed block sits in its column, after tweening. */
+@Immutable
+data class BlockPlacement(val x: Dp, val y: Dp, val width: Dp, val height: Dp)
+
+/**
+ * A timed block's placement, tweened rather than jumped. Continuity comes from
+ * the caller keying each block by identity; a block composed for the first time
+ * starts at its target, so nothing flies in on the first frame.
+ *
+ * A pinch-zoom rewrites the hour height every pointer frame, and the gutter and
+ * grid lines follow it instantly — so the tween stands down for the gesture
+ * rather than leaving the blocks trailing the ruler they are measured against.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun animatedBlockPlacement(x: Dp, y: Dp, width: Dp, height: Dp): BlockPlacement {
+    val spec: FiniteAnimationSpec<Dp> = if (rememberReduceMotion() ||
+        LocalTimelineZoom.current.isPinching
+    ) {
+        snap()
+    } else {
+        MaterialTheme.motionScheme.fastSpatialSpec()
+    }
+    val animatedX by animateDpAsState(x, spec, label = "block-x")
+    val animatedY by animateDpAsState(y, spec, label = "block-y")
+    val animatedWidth by animateDpAsState(width, spec, label = "block-width")
+    val animatedHeight by animateDpAsState(height, spec, label = "block-height")
+    return BlockPlacement(animatedX, animatedY, animatedWidth, animatedHeight)
+}

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

@@ -0,0 +1,150 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.platform.LocalViewConfiguration
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+
+/** How far the finger may wander during the hold — well under touch slop. */
+private val PICKUP_TOLERANCE = 6.dp
+
+/**
+ * Pick an event block up with a long press and drag it, without
+ * `detectDragGesturesAfterLongPress`: the stock detector cancels as soon as an
+ * ancestor consumes or the finger leaves the block, which a
+ * `MIN_EVENT_FRACTION`-tall block loses immediately. Movement before the timeout
+ * is deliberately not consumed, so a scroll starting on top of a block survives.
+ */
+@Composable
+fun rememberEventDragSource(
+    enabled: Boolean,
+    key: Any?,
+    onPickUp: (pointerInRoot: Offset, blockInRoot: Offset, size: IntSize) -> Unit,
+    onMove: (pointerInRoot: Offset) -> Unit,
+    onDrop: () -> Unit,
+    onCancel: () -> Unit,
+): Modifier = rememberDragSurface(
+    enabled = enabled,
+    key = key,
+    onPickUp = { _, pointerInRoot, nodeInRoot, size ->
+        onPickUp(pointerInRoot, nodeInRoot, size)
+        true
+    },
+    onMove = onMove,
+    onDrop = onDrop,
+    onCancel = onCancel,
+)
+
+/**
+ * The same pickup, for a surface that carries many draggable pieces rather than
+ * being one itself — the month grid, whose chips are covered by a full-bleed tap
+ * layer. [onPickUp] receives the press position local to this node and answers
+ * whether anything is there; false abandons the gesture.
+ */
+@Composable
+fun rememberDragSurface(
+    enabled: Boolean,
+    key: Any?,
+    onPickUp: (local: Offset, pointerInRoot: Offset, nodeInRoot: Offset, size: IntSize) -> Boolean,
+    onMove: (pointerInRoot: Offset) -> Unit,
+    onDrop: () -> Unit,
+    onCancel: () -> Unit,
+): Modifier {
+    if (!enabled) return Modifier
+    val holdMillis = LocalViewConfiguration.current.longPressTimeoutMillis
+    val tolerance = with(LocalDensity.current) { PICKUP_TOLERANCE.toPx() }
+    val coordinates = remember { arrayOfNulls<LayoutCoordinates>(1) }
+    val currentPickUp by rememberUpdatedState(onPickUp)
+    val currentMove by rememberUpdatedState(onMove)
+    val currentDrop by rememberUpdatedState(onDrop)
+    val currentCancel by rememberUpdatedState(onCancel)
+
+    return Modifier
+        .onGloballyPositioned { coordinates[0] = it }
+        .pointerInput(key) {
+            awaitEachGesture {
+                val down = awaitFirstDown(requireUnconsumed = false)
+                val origin = down.position
+                val heldStill = withTimeoutOrNull(holdMillis) {
+                    while (true) {
+                        val main = awaitPointerEvent()
+                        val change = main.changes.firstOrNull { it.id == down.id } ?: break
+                        if (!change.pressed) break
+                        if (main.changes.count { it.pressed } > 1) break
+                        if ((change.position - origin).getDistance() > tolerance) break
+                        // An ancestor's claim only becomes visible once the whole
+                        // main pass has run, so look again on the final pass.
+                        val final = awaitPointerEvent(PointerEventPass.Final)
+                        if (final.changes.any { it.isConsumed }) break
+                    }
+                } == null
+                if (!heldStill) return@awaitEachGesture
+
+                val layout = coordinates[0]?.takeIf { it.isAttached } ?: return@awaitEachGesture
+                val took = currentPickUp(
+                    down.position,
+                    layout.localToRoot(down.position),
+                    layout.positionInRoot(),
+                    layout.size,
+                )
+                if (!took) return@awaitEachGesture
+                var dropped = false
+                try {
+                    // Driven on the initial pass, which runs parent → child: an
+                    // ancestor that outranks us (the pinch) has already consumed
+                    // by the time we look, and descendants — the month grid's
+                    // full-bleed tap layer — see our consumption.
+                    while (true) {
+                        val event = awaitPointerEvent(PointerEventPass.Initial)
+                        val change = event.changes.firstOrNull { it.id == down.id } ?: break
+                        if (change.isConsumed) break
+                        if (!change.pressed) {
+                            change.consume()
+                            dropped = true
+                            break
+                        }
+                        if (event.changes.count { it.pressed } > 1) break
+                        change.consume()
+                        coordinates[0]?.takeIf { it.isAttached }
+                            ?.let { currentMove(it.localToRoot(change.position)) }
+                    }
+                } finally {
+                    // Also reached when the pointer node is disposed mid-drag —
+                    // a cancel, not a drop, and must never write.
+                    if (dropped) currentDrop() else currentCancel()
+                }
+            }
+        }
+}
+
+/** A lift on pickup, then a tick every time the drop target snaps to a new slot. */
+@Composable
+fun DragSnapHaptics(slot: Any?) {
+    val haptics = LocalHapticFeedback.current
+    val previous = remember { arrayOfNulls<Any>(1) }
+    LaunchedEffect(slot) {
+        val had = previous[0]
+        previous[0] = slot
+        when {
+            slot == null -> Unit
+            had == null -> haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+            had != slot -> haptics.performHapticFeedback(HapticFeedbackType.SegmentTick)
+        }
+    }
+}

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

@@ -0,0 +1,144 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.SnackChip
+import de.jeanlucmakiola.floret.components.SnackChipHeight
+import de.jeanlucmakiola.floret.components.SnackChipMargin
+import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import kotlinx.coroutines.delay
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.util.Locale
+
+/** How long the confirmation chip stays up, matching a short snackbar. */
+private const val CHIP_MILLIS = 4_000L
+
+/** How long an *undone* move stays up — shorter, since it offers nothing to act on. */
+private const val UNDONE_CHIP_MILLIS = 1_600L
+
+/** What the chip currently reads, kept past the outcome it was built from. */
+private data class ChipContent(val message: String, val undo: MoveUndo?)
+
+/** The FAB's own band at the bottom end, which the chip must not run into. */
+private val FAB_BAND = 88.dp
+
+/**
+ * The two surfaces a drag-and-drop reschedule needs on top of the calendar: the
+ * recurring-scope prompt, and the confirmation chip carrying Undo. None of the
+ * calendar screens sets a `snackbarHost`, so this hosts its own confirmation as
+ * a pill on the FAB's band, leaving the calendar visible behind it.
+ */
+@Composable
+fun EventMoveHost(viewModel: RescheduleViewModel, modifier: Modifier = Modifier) {
+    val prompt by viewModel.scopePrompt.collectAsStateWithLifecycle()
+    val outcome by viewModel.outcome.collectAsStateWithLifecycle()
+    val undoTick by viewModel.undoStarted.collectAsStateWithLifecycle()
+    val writeInFlight by viewModel.inFlight.collectAsStateWithLifecycle()
+    val locale = currentLocale()
+    val use24Hour = LocalUse24HourFormat.current
+
+    prompt?.let { pending ->
+        RecurringScopeDialog(
+            title = stringResource(R.string.event_move_recurring_title),
+            onSelect = viewModel::moveWithScope,
+            onDismiss = viewModel::cancelScope,
+            allowSeries = !pending.occurrenceOnly,
+            reason = stringResource(R.string.event_move_occurrence_only)
+                .takeIf { pending.occurrenceOnly },
+        )
+    }
+
+    val moved = outcome as? MoveOutcome.Moved
+    val movedLabel = moved?.let { formatMovedTo(it.startMillis, it.isAllDay, use24Hour, locale) }
+    val message = when (outcome) {
+        null -> null
+        is MoveOutcome.Moved -> stringResource(R.string.event_move_done, movedLabel.orEmpty())
+        MoveOutcome.Undone -> stringResource(R.string.event_move_undone)
+        MoveOutcome.WriteDenied -> stringResource(R.string.event_move_write_denied)
+        MoveOutcome.Gone -> stringResource(R.string.event_move_gone)
+        MoveOutcome.BlockedSeriesEnd -> stringResource(R.string.event_move_blocked_series_end)
+        MoveOutcome.Failed -> stringResource(R.string.event_move_failed)
+    }
+
+    // Held past the outcome being consumed so the chip has something to draw
+    // while it springs back out. Updated in composition rather than from an
+    // effect, which would land a frame late and open the chip on stale text.
+    val shown = remember { mutableStateOf(ChipContent("", null)) }
+    if (message != null && (shown.value.message != message || shown.value.undo != moved?.undo)) {
+        shown.value = ChipContent(message, moved?.undo)
+    }
+    val content = shown.value
+    // Restarted by the undo tick and held while a write is in flight: an undo
+    // tapped in the last moments of the window leaves the outcome at Moved on
+    // purpose, and this timer would otherwise fire mid-undo and close the chip
+    // just before the same chip has to say "undone".
+    LaunchedEffect(outcome, undoTick, writeInFlight) {
+        if (outcome == null || writeInFlight) return@LaunchedEffect
+        delay(if (outcome == MoveOutcome.Undone) UNDONE_CHIP_MILLIS else CHIP_MILLIS)
+        viewModel.consumeOutcome()
+    }
+
+    BoxWithConstraints(modifier = modifier.fillMaxSize()) {
+        val chipMaxWidth = maxWidth - FAB_BAND
+        // A FAB-height band at the bottom start with the FAB's own margin, so
+        // the chip lines up beside the bottom-end FAB.
+        Box(
+            modifier = Modifier
+                .align(Alignment.BottomStart)
+                .navigationBarsPadding()
+                .padding(start = SnackChipMargin, bottom = SnackChipMargin)
+                .height(SnackChipHeight),
+            contentAlignment = Alignment.CenterStart,
+        ) {
+            // The action goes away while a write runs: undo() refuses a second
+            // write anyway, so offering it would be a button that does nothing.
+            val undo = content.undo?.takeIf { !writeInFlight }
+            SnackChip(
+                visible = outcome != null,
+                message = content.message,
+                maxWidth = chipMaxWidth,
+                actionLabel = stringResource(R.string.event_move_undo).takeIf { undo != null },
+                onAction = undo?.let { { viewModel.undo(it) } },
+            )
+        }
+    }
+}
+
+/**
+ * "Fri, 7 Aug, 09:00" — the day, plus the time for a timed event. All-day events
+ * are read back on the UTC calendar day they are anchored to (#65, #82).
+ */
+private fun formatMovedTo(
+    startMillis: Long,
+    isAllDay: Boolean,
+    use24Hour: Boolean,
+    locale: Locale,
+): String {
+    val zone: ZoneId = if (isAllDay) ZoneOffset.UTC else ZoneId.systemDefault()
+    val skeleton = when {
+        isAllDay -> "EEEdMMM"
+        use24Hour -> "EEEdMMMHm"
+        else -> "EEEdMMMhm"
+    }
+    return localizedDateFormatter(locale, skeleton)
+        .format(Instant.ofEpochMilli(startMillis).atZone(zone))
+}

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

@@ -0,0 +1,126 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.CustomAccessibilityAction
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * Drag-to-reschedule wiring (#68), provided once at `CalendarHost` and read by
+ * whichever event block is being composed. Null means moving is off entirely and
+ * blocks register no drag gesture at all.
+ */
+@Immutable
+class EventMoveScope(
+    /**
+     * Calendars whose events may be moved. Nothing below the UI enforces this —
+     * the repository writes whatever it is handed — so this gate is load-bearing.
+     */
+    val movableCalendarIds: Set<Long>,
+    /**
+     * Whether the *gesture* is on (#173). Off gates the drag alone: [edit] and the
+     * TalkBack action below stay, since invoking a menu item can't cause the
+     * accidental drags the setting exists to stop.
+     */
+    val dragEnabled: Boolean,
+    /** False when the drop was refused outright, so nothing will be written. */
+    val move: (MoveRequest) -> Boolean,
+    /**
+     * True while a dropped event is being written, including the time its scope
+     * dialog is up. A flow rather than a value so this scope stays the same
+     * object across a move — every visible block reads it as a composition local.
+     */
+    val inFlight: StateFlow<Boolean>,
+    /** Ticks when an undo write begins — see `RescheduleViewModel.undoStarted`. */
+    val undoStarted: StateFlow<Int>,
+    /** Open an event in the edit form — the pointer-free route to the same change. */
+    val edit: (EventInstance) -> Unit,
+) {
+    fun allows(event: EventInstance): Boolean = event.calendarId in movableCalendarIds
+}
+
+val LocalEventMove = compositionLocalOf<EventMoveScope?> { null }
+
+private val NEVER_IN_FLIGHT = MutableStateFlow(false)
+
+private val NEVER_UNDONE = MutableStateFlow(0)
+
+/**
+ * Whether a dropped event is still being written — false wherever moving is off.
+ * The drag overlays hold a landed block on its target for this window.
+ */
+@Composable
+fun moveInFlight(): Boolean {
+    val flow = LocalEventMove.current?.inFlight ?: NEVER_IN_FLIGHT
+    return flow.collectAsStateWithLifecycle().value
+}
+
+/**
+ * Runs [onUndo] when an undo write begins, and never for one that began before
+ * this composable came on screen.
+ */
+@Composable
+fun OnUndoStarted(onUndo: () -> Unit) {
+    val flow = LocalEventMove.current?.undoStarted ?: NEVER_UNDONE
+    val tick by flow.collectAsStateWithLifecycle()
+    var seen by remember { mutableIntStateOf(tick) }
+    LaunchedEffect(tick) {
+        if (tick == seen) return@LaunchedEffect
+        seen = tick
+        onUndo()
+    }
+}
+
+/** Opacity the source block keeps while its floating copy travels. */
+const val GHOST_ALPHA: Float = 0.3f
+
+/**
+ * Opacity for a block whose copy is in flight: ghosted from the lift until the
+ * copy is handed back, then animated up rather than switched, so the block
+ * appears to travel to its new slot instead of vanishing and reappearing.
+ */
+@Composable
+fun ghostAlpha(lifted: Boolean): Float = animateFloatAsState(
+    targetValue = if (lifted) GHOST_ALPHA else 1f,
+    label = "ghost-alpha",
+).value
+
+/**
+ * Whether [event] can be picked up and dragged — its calendar allows moving and
+ * the gesture is switched on. Not the same question as [eventMoveAction], which
+ * survives the setting.
+ */
+@Composable
+fun eventDragAllowed(event: EventInstance): Boolean {
+    val move = LocalEventMove.current ?: return false
+    return move.dragEnabled && move.allows(event)
+}
+
+/**
+ * A TalkBack action that opens [event] in the edit form, so rescheduling isn't
+ * pointer-only. Null when this event can't be moved.
+ */
+@Composable
+fun eventMoveAction(event: EventInstance): CustomAccessibilityAction? {
+    val move = LocalEventMove.current ?: return null
+    if (!move.allows(event)) return null
+    val label = stringResource(R.string.event_move_action)
+    return remember(event.instanceId, label, move) {
+        CustomAccessibilityAction(label) {
+            move.edit(event)
+            true
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.LayoutDirection
+
+/** How an event chip's title should overflow: what to pass to `Text`. */
+data class EventTitleOverflow(val overflow: TextOverflow, val softWrap: Boolean)
+
+/**
+ * Overflow for an event chip's title (#164). Chips are narrow enough that the
+ * "…" costs a couple of readable characters, so the title runs to the chip's
+ * edge and clips mid-glyph instead.
+ *
+ * Two cases keep the ellipsis:
+ *
+ * - **[rtl].** With `softWrap` off Compose lays the line out at its full
+ *   intrinsic width and clips to the node's left edge, which in RTL is the *end*
+ *   of the string — an Arabic title would lose its beginning. The ellipsis
+ *   truncates at the logical end in both directions.
+ * - **More than one line** ([singleLine] false). Wrapping needs `softWrap` on,
+ *   and clipping with it on breaks the last line at the last whole word — less
+ *   title than the ellipsis showed, not more.
+ */
+fun eventTitleOverflowFor(rtl: Boolean, singleLine: Boolean): EventTitleOverflow =
+    if (rtl || !singleLine) {
+        EventTitleOverflow(TextOverflow.Ellipsis, softWrap = true)
+    } else {
+        EventTitleOverflow(TextOverflow.Clip, softWrap = false)
+    }
+
+/** [eventTitleOverflowFor] against the current layout direction. */
+@Composable
+fun eventTitleOverflow(singleLine: Boolean = true): EventTitleOverflow =
+    eventTitleOverflowFor(
+        rtl = LocalLayoutDirection.current == LayoutDirection.Rtl,
+        singleLine = singleLine,
+    )

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

@@ -0,0 +1,119 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.floret.locale.currentLocale
+
+/** Width of the hour gutter down the start edge of the day and week timelines. */
+val GUTTER_WIDTH = 48.dp
+
+/**
+ * Start inset for the gutter's content (week badge + hour labels) so it centres
+ * on the top bar's hamburger: with a 48dp gutter, 8dp lands the centre at 28dp,
+ * matching the icon button's centre.
+ */
+val GUTTER_CONTENT_START_INSET = 8.dp
+
+private val BADGE_HEIGHT = 20.dp
+
+/** How far the fixed hour labels recede while a block is being dragged. */
+private const val DIMMED_HOUR_ALPHA = 0.3f
+
+/**
+ * The timeline's hour gutter. Scrolls in sync with the day columns through the
+ * shared [scrollState], and while [dragController] holds a lifted block it dims
+ * the hour labels and floats a badge with the drag's current start time at the
+ * row the block would land on.
+ */
+@Composable
+fun HourGutter(
+    scrollState: ScrollState,
+    hourHeight: Dp,
+    dragController: TimelineDragController,
+    modifier: Modifier = Modifier,
+) {
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    // Derived: the drag is rewritten every frame, its snapped start once a slot.
+    val dragStartMin by remember(dragController) {
+        derivedStateOf { dragController.drag?.startMin }
+    }
+    val hourAlpha by animateFloatAsState(
+        targetValue = if (dragStartMin != null) DIMMED_HOUR_ALPHA else 1f,
+        label = "hourLabelAlpha",
+    )
+
+    Box(
+        modifier = modifier
+            .width(GUTTER_WIDTH)
+            .padding(start = GUTTER_CONTENT_START_INSET)
+            .fillMaxHeight()
+            .verticalScroll(scrollState),
+    ) {
+        Column {
+            (0 until 24).forEach { h ->
+                Box(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(hourHeight),
+                ) {
+                    if (h > 0) {
+                        Text(
+                            text = formatHourLabel(h, use24Hour, locale),
+                            style = MaterialTheme.typography.labelSmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                                .copy(alpha = hourAlpha),
+                            modifier = Modifier
+                                .align(Alignment.TopCenter)
+                                .offset(y = (-6).dp),
+                        )
+                    }
+                }
+            }
+        }
+        dragStartMin?.let { startMin ->
+            val top = (hourHeight * (startMin / 60f) - BADGE_HEIGHT / 2).coerceAtLeast(0.dp)
+            Box(
+                modifier = Modifier
+                    .align(Alignment.TopCenter)
+                    .offset(y = top)
+                    .height(BADGE_HEIGHT)
+                    .background(MaterialTheme.colorScheme.primary, CircleShape)
+                    .padding(horizontal = 4.dp)
+                    // The dragged block already announces this time.
+                    .clearAndSetSemantics { },
+                contentAlignment = Alignment.Center,
+            ) {
+                Text(
+                    text = formatGutterTime(startMin, use24Hour, locale),
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onPrimary,
+                    maxLines = 1,
+                    softWrap = false,
+                )
+            }
+        }
+    }
+}

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

@@ -0,0 +1,169 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atTime
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Instant
+
+/**
+ * Stand-in events for the view previews. A preview has no business querying the
+ * provider for a thumbnail, so every chooser renders the same invented week.
+ *
+ * Colours are raw ARGB on purpose: that is what the provider hands out for an
+ * event, so a theme token here would misrepresent what the views actually draw.
+ */
+private val SAMPLE_COLORS = listOf(
+    0xFF3F7BD4.toInt(),
+    0xFFCE5B4C.toInt(),
+    0xFF4E9A6A.toInt(),
+    0xFF8A63C7.toInt(),
+)
+
+private val SAMPLE_TITLES = listOf(
+    "Standup",
+    "Lunch",
+    "Review",
+    "Gym",
+    "Call",
+    "Workshop",
+    "Dentist",
+    "Trip",
+)
+
+/** Hands out [EventInstance]s with running ids and cycling sample titles/colours. */
+private class SampleEvents(private val zone: TimeZone) {
+    private var id = 0L
+
+    fun timed(
+        day: LocalDate,
+        hour: Int,
+        minute: Int = 0,
+        lengthMinutes: Int,
+        colorIndex: Int,
+    ): EventInstance {
+        val start = day.atTime(hour, minute).toInstant(zone)
+        return build(
+            start = start,
+            end = start + lengthMinutes.minutes,
+            isAllDay = false,
+            colorIndex = colorIndex,
+        )
+    }
+
+    fun allDay(from: LocalDate, days: Int, colorIndex: Int): EventInstance = build(
+        // All-day events sit at UTC midnights with an exclusive end.
+        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
+        end = from.plus(days, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
+        isAllDay = true,
+        colorIndex = colorIndex,
+    )
+
+    private fun build(
+        start: Instant,
+        end: Instant,
+        isAllDay: Boolean,
+        colorIndex: Int,
+    ): EventInstance {
+        val next = ++id
+        return EventInstance(
+            instanceId = next,
+            eventId = next,
+            calendarId = 1L,
+            title = SAMPLE_TITLES[(next.toInt() - 1) % SAMPLE_TITLES.size],
+            start = start,
+            end = end,
+            isAllDay = isAllDay,
+            color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
+            location = null,
+        )
+    }
+}
+
+/**
+ * A month's worth of stand-ins, spread so most weeks carry something, with one
+ * multi-day bar bridging cells and a busy today for the split pane.
+ */
+internal fun sampleMonthEvents(
+    firstOfMonth: LocalDate,
+    today: LocalDate,
+    zone: TimeZone,
+): List<EventInstance> {
+    val sample = SampleEvents(zone)
+    return buildList {
+        add(sample.allDay(firstOfMonth.plus(9, DateTimeUnit.DAY), days = 3, colorIndex = 2))
+        add(sample.timed(firstOfMonth.plus(1, DateTimeUnit.DAY), 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(firstOfMonth.plus(4, DateTimeUnit.DAY), 14, lengthMinutes = 120, colorIndex = 1))
+        add(sample.timed(firstOfMonth.plus(7, DateTimeUnit.DAY), 11, lengthMinutes = 60, colorIndex = 3))
+        add(sample.timed(firstOfMonth.plus(15, DateTimeUnit.DAY), 10, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(firstOfMonth.plus(18, DateTimeUnit.DAY), 16, lengthMinutes = 60, colorIndex = 2))
+        add(sample.timed(firstOfMonth.plus(22, DateTimeUnit.DAY), 8, lengthMinutes = 120, colorIndex = 1))
+        add(sample.timed(firstOfMonth.plus(25, DateTimeUnit.DAY), 13, lengthMinutes = 60, colorIndex = 3))
+        // Today, so the split pane's list and the grid's dots both have content.
+        add(sample.timed(today, 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(today, 12, lengthMinutes = 60, colorIndex = 1))
+        add(sample.timed(today, 15, lengthMinutes = 120, colorIndex = 3))
+    }
+}
+
+/**
+ * Stand-ins for a timeline preview over [days]. [anchor] — the day the preview
+ * is centred on — gets the busy set, including one overlapping pair so the
+ * side-by-side lane layout shows; the rest of the week is sparser. A multi-day
+ * all-day bar is only added when there is more than one column to span.
+ */
+internal fun sampleTimelineEvents(
+    days: List<LocalDate>,
+    anchor: LocalDate,
+    zone: TimeZone,
+): List<EventInstance> {
+    val sample = SampleEvents(zone)
+    return buildList {
+        if (days.size > 1) {
+            add(sample.allDay(days[days.size / 2], days = 2, colorIndex = 2))
+        } else {
+            add(sample.allDay(anchor, days = 1, colorIndex = 2))
+        }
+        // The anchor day: enough to fill the column, with 09:30–11:00 running
+        // under 09:00–10:00 so the overlap resolves into two lanes.
+        add(sample.timed(anchor, 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(anchor, 9, minute = 30, lengthMinutes = 90, colorIndex = 1))
+        add(sample.timed(anchor, 13, lengthMinutes = 120, colorIndex = 3))
+        days.filterNot { it == anchor }.forEachIndexed { index, day ->
+            // Skip every third day so the week doesn't read as a solid block.
+            if (index % 3 == 2) return@forEachIndexed
+            add(
+                sample.timed(
+                    day = day,
+                    hour = 8 + (index * 3) % 9,
+                    lengthMinutes = if (index % 2 == 0) 60 else 90,
+                    colorIndex = index,
+                ),
+            )
+        }
+    }
+}
+
+/**
+ * Stand-ins for the agenda preview: a forward-looking fortnight where the first
+ * days are busy and later ones thin out, so the grouped-by-day list shows both
+ * a full day and the gaps between days.
+ */
+internal fun sampleAgendaEvents(today: LocalDate, zone: TimeZone): List<EventInstance> {
+    val sample = SampleEvents(zone)
+    return buildList {
+        add(sample.timed(today, 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(today, 12, minute = 30, lengthMinutes = 60, colorIndex = 1))
+        add(sample.timed(today, 16, lengthMinutes = 90, colorIndex = 3))
+        val tomorrow = today.plus(1, DateTimeUnit.DAY)
+        add(sample.allDay(tomorrow, days = 2, colorIndex = 2))
+        add(sample.timed(tomorrow, 10, lengthMinutes = 120, colorIndex = 1))
+        add(sample.timed(today.plus(3, DateTimeUnit.DAY), 14, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(today.plus(6, DateTimeUnit.DAY), 11, lengthMinutes = 60, colorIndex = 3))
+        add(sample.timed(today.plus(10, DateTimeUnit.DAY), 18, lengthMinutes = 120, colorIndex = 2))
+    }
+}

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

@@ -0,0 +1,69 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.floret.components.OptionCard
+
+/**
+ * How far a write to a recurring event should reach: this occurrence, it and
+ * everything after (a series split), or the whole series. Shared by the edit
+ * screen's save and a drag-and-drop reschedule; one of the two carve-outs from
+ * the full-screen picker rule.
+ *
+ * [allowOccurrence] drops "only this event" (an exception row can't carry its own
+ * rule); [allowSeries] drops the two wider options, for a rule whose days can't
+ * be recalculated from one moved occurrence — [reason] then says why.
+ */
+@Composable
+fun RecurringScopeDialog(
+    title: String,
+    onSelect: (RecurringWriteScope) -> Unit,
+    onDismiss: () -> Unit,
+    allowOccurrence: Boolean = true,
+    allowSeries: Boolean = true,
+    reason: String? = null,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(title) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                if (reason != null) {
+                    Text(
+                        text = reason,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+                if (allowOccurrence) {
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_occurrence),
+                        onClick = { onSelect(RecurringWriteScope.ThisEvent) },
+                    )
+                }
+                if (allowSeries) {
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_following),
+                        onClick = { onSelect(RecurringWriteScope.ThisAndFollowing) },
+                    )
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_series),
+                        onClick = { onSelect(RecurringWriteScope.AllEvents) },
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
+        },
+    )
+}

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

@@ -0,0 +1,463 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.domain.EventDetail
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.EventFormProblem
+import de.jeanlucmakiola.calendula.domain.RecurrenceEnd
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.allowsEventMove
+import de.jeanlucmakiola.calendula.domain.parseSimpleRecurrence
+import de.jeanlucmakiola.calendula.domain.problems
+import de.jeanlucmakiola.calendula.domain.realignRecurrence
+import de.jeanlucmakiola.calendula.domain.resolvedZone
+import de.jeanlucmakiola.calendula.domain.shiftedByDays
+import de.jeanlucmakiola.calendula.domain.shiftedTo
+import de.jeanlucmakiola.calendula.domain.toEditForm
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Instant
+import javax.inject.Inject
+
+private const val MILLIS_PER_MINUTE = 60_000
+private const val MINUTES_PER_DAY = 24 * 60
+
+/** Where a dragged event should land. */
+sealed interface MoveTarget {
+    /** A new start instant — a timeline drag, which moves time and day at once. */
+    data class Start(val instant: Instant) : MoveTarget
+
+    /**
+     * A whole-day shift, keeping the time of day — a month-grid or all-day drag.
+     * A delta rather than a target date, so the screen and this view model can't
+     * disagree by a day over which zone the event's first day is resolved in.
+     */
+    data class ByDays(val days: Int) : MoveTarget
+}
+
+/**
+ * One dropped event. [beginMillis]/[endMillis] are the dragged *occurrence's*
+ * own times (`Instances.BEGIN`/`END`), as the detail and edit screens pass them.
+ */
+data class MoveRequest(
+    val eventId: Long,
+    val beginMillis: Long,
+    val endMillis: Long,
+    val target: MoveTarget,
+)
+
+/**
+ * A recurring drop waiting for the user to pick how far it reaches.
+ * [occurrenceOnly] means a wider write would leave the rule and the series
+ * anchor disagreeing — either the rule names days one moved occurrence can't
+ * re-derive (`BYDAY=MO,WE`, `2TH`, …), or the shift wouldn't carry the anchor
+ * across the same midnights the occurrence crossed.
+ */
+data class MoveScopePrompt(val occurrenceOnly: Boolean)
+
+/** The inverse of a completed move, for the undo action. */
+data class MoveUndo(
+    val eventId: Long,
+    /** The form as it now stands (the moved state). */
+    val moved: EventForm,
+    /** The form as it stood before the move. */
+    val restored: EventForm,
+)
+
+sealed interface MoveOutcome {
+    /**
+     * Written. [startMillis] is where the dragged occurrence now begins, for the
+     * confirmation message; [undo] is null when the write has no clean inverse.
+     */
+    data class Moved(
+        val startMillis: Long,
+        val isAllDay: Boolean,
+        val undo: MoveUndo?,
+    ) : MoveOutcome
+
+    data object Undone : MoveOutcome
+
+    /** `WRITE_CALENDAR` was revoked between the drop and the provider call. */
+    data object WriteDenied : MoveOutcome
+
+    /** The event vanished (sync, another device) between the read and the write. */
+    data object Gone : MoveOutcome
+
+    /** The drop would push the series past its own `UNTIL`, generating nothing. */
+    data object BlockedSeriesEnd : MoveOutcome
+
+    data object Failed : MoveOutcome
+}
+
+/**
+ * Writes a drag-and-drop reschedule (#68) through the same repository calls the
+ * edit screen's save uses, so recurring writes, reminder reconciliation and
+ * attendee preservation behave identically. Hosted at `CalendarHost` so one
+ * instance serves every calendar view and survives view switches. The full
+ * prefilled form is carried through the write — a stripped one would wipe the
+ * reminders and attendees the occurrence-exception path reconciles.
+ */
+@HiltViewModel
+class RescheduleViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val _scopePrompt = MutableStateFlow<MoveScopePrompt?>(null)
+    val scopePrompt: StateFlow<MoveScopePrompt?> = _scopePrompt.asStateFlow()
+
+    private val _outcome = MutableStateFlow<MoveOutcome?>(null)
+    val outcome: StateFlow<MoveOutcome?> = _outcome.asStateFlow()
+
+    private var pending: PreparedMove? = null
+
+    private val _inFlight = MutableStateFlow(false)
+
+    /**
+     * True from the moment a drop is accepted until its write settles — the
+     * window the dropped block holds its landing position for.
+     */
+    val inFlight: StateFlow<Boolean> = _inFlight.asStateFlow()
+
+    private val _undoStarted = MutableStateFlow(0)
+
+    /**
+     * Ticks the moment an undo write begins, before the provider has anything to
+     * re-read, so the view that drew the drop can carry its chip back rather than
+     * let it reappear on the old day.
+     */
+    val undoStarted: StateFlow<Int> = _undoStarted.asStateFlow()
+
+    /**
+     * Set from the moment a drop is accepted until its write settles. Two drops
+     * of the same recurring event inside that window would compute their shift
+     * from the same pre-move occurrence, and the shifts would compound.
+     */
+    private var busy = false
+        set(value) {
+            field = value
+            _inFlight.value = value
+        }
+
+    /**
+     * The calendars whose events may be dragged. Nothing below the UI guards
+     * this, so a block outside this set registers no drag gesture at all.
+     */
+    val movableCalendarIds: StateFlow<Set<Long>> = repository.calendars()
+        .map { calendars -> calendars.filter { it.allowsEventMove }.map { it.id }.toSet() }
+        .catch { emit(emptySet<Long>()) }
+        .flowOn(io)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = emptySet(),
+        )
+
+    /** Everything a drop needs, resolved before anything is written. */
+    private data class PreparedMove(
+        val request: MoveRequest,
+        val original: EventForm,
+        val updated: EventForm,
+        /** True for a series master with a rule — an exception row is not one. */
+        val isRecurring: Boolean,
+        /** False when the rule names days this move can't re-derive. */
+        val canRealign: Boolean,
+        /** The series row's DTSTART date after the move — what its `UNTIL` must clear. */
+        val newAnchorDate: LocalDate,
+    )
+
+    /**
+     * Take a drop, unless one is already being written. False means nothing will
+     * be written and the caller must let its held copy go now — waiting on
+     * [inFlight] would strand it until the settle timeout instead.
+     */
+    fun move(request: MoveRequest): Boolean {
+        if (busy || _scopePrompt.value != null) return false
+        busy = true
+        viewModelScope.launch {
+            val prepared = prepare(request)
+            if (prepared == null) {
+                busy = false
+                return@launch
+            }
+            if (!prepared.isRecurring) {
+                write(prepared, RecurringWriteScope.AllEvents)
+                busy = false
+            } else {
+                // Still busy: the scope dialog is now the thing in flight.
+                pending = prepared
+                _scopePrompt.value = MoveScopePrompt(occurrenceOnly = !prepared.canRealign)
+            }
+        }
+        return true
+    }
+
+    /** Answer the scope dialog. */
+    fun moveWithScope(scope: RecurringWriteScope) {
+        val prepared = pending ?: return
+        // Guard against the dialog ever offering a scope the rule can't carry.
+        if (!prepared.canRealign && scope != RecurringWriteScope.ThisEvent) return
+        pending = null
+        _scopePrompt.value = null
+        viewModelScope.launch {
+            write(prepared, scope)
+            busy = false
+        }
+    }
+
+    /** Dismiss the scope dialog without writing. */
+    fun cancelScope() {
+        pending = null
+        busy = false
+        _scopePrompt.value = null
+    }
+
+    /**
+     * Put a completed move back where it came from. The outcome stands until the
+     * inverse write reports back, so the one chip changes what it says rather
+     * than closing and reopening. False when another write is already running —
+     * the chip hides its action for that window, so this is the backstop.
+     */
+    fun undo(undo: MoveUndo): Boolean {
+        if (busy) return false
+        busy = true
+        _undoStarted.value += 1
+        viewModelScope.launch {
+            _outcome.value = try {
+                repository.updateEvent(undo.eventId, undo.moved, undo.restored)
+                MoveOutcome.Undone
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: SecurityException) {
+                MoveOutcome.WriteDenied
+            } catch (e: NoSuchEventException) {
+                MoveOutcome.Gone
+            } catch (e: Exception) {
+                MoveOutcome.Failed
+            }
+            busy = false
+        }
+        return true
+    }
+
+    /** Clear the outcome once the screen has shown it. */
+    fun consumeOutcome() {
+        _outcome.value = null
+    }
+
+    private suspend fun prepare(request: MoveRequest): PreparedMove? {
+        val detail = try {
+            repository.eventDetail(request.eventId)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: NoSuchEventException) {
+            _outcome.value = MoveOutcome.Gone
+            return null
+        } catch (e: Exception) {
+            _outcome.value = MoveOutcome.Failed
+            return null
+        }
+
+        val zone = TimeZone.currentSystemDefault()
+        val original = detail.toEditForm(request.beginMillis, request.endMillis, zone)
+        val shifted = when (val target = request.target) {
+            is MoveTarget.Start -> original.shiftedTo(target.instant, zone)
+            is MoveTarget.ByDays -> original.shiftedByDays(target.days, zone)
+        }
+        // A zero-distance drop is not a write.
+        if (shifted == original) return null
+
+        // The UNTIL check is deferred to the write, which knows how far the move
+        // reaches and so which date has to clear it.
+        if ((shifted.problems() - EventFormProblem.RecurrenceEndsBeforeStart).isNotEmpty()) {
+            _outcome.value = MoveOutcome.Failed
+            return null
+        }
+
+        // An exception row stands alone whatever rule a sync adapter left on it.
+        val isRecurring = original.rrule != null && !detail.isException
+        val movedDay = shifted.start.date != original.start.date
+        // The series anchor moves by the same *wall-clock* shift as the dragged
+        // occurrence, so only a whole-day shift carries it across the same number
+        // of midnights whatever time of day it sits at. A same-date drag has its
+        // own, narrower check — see anchorKeepsItsDay.
+        val wholeDayShift = original.isAllDay || shifted.start.time == original.start.time
+        val realigned = if (isRecurring && movedDay) {
+            if (wholeDayShift) {
+                realignRecurrence(
+                    requireNotNull(original.rrule),
+                    original.start.date,
+                    shifted.start.date,
+                )
+            } else {
+                null
+            }
+        } else {
+            original.rrule
+        }
+        return PreparedMove(
+            request = request,
+            original = original,
+            // A rule we can't re-derive stays verbatim: the only scope offered
+            // then is the single occurrence, whose exception row carries no rule.
+            updated = shifted.copy(rrule = realigned ?: original.rrule),
+            isRecurring = isRecurring,
+            canRealign = when {
+                !isRecurring -> true
+                movedDay -> realigned != null
+                else -> anchorKeepsItsDay(detail, original, shifted, zone)
+            },
+            // Where the series row's own DTSTART lands, given the anchor moves by
+            // the same shift. Only read under canRealign, which is what
+            // guarantees the anchor really does travel this many days.
+            newAnchorDate = anchorDate(detail, original, zone)
+                .plus(shifted.start.date.toEpochDays() - original.start.date.toEpochDays(), DateTimeUnit.DAY),
+        )
+    }
+
+    private suspend fun write(prepared: PreparedMove, scope: RecurringWriteScope) {
+        val request = prepared.request
+        if (endsBeforeItStarts(prepared, scope)) {
+            _outcome.value = MoveOutcome.BlockedSeriesEnd
+            return
+        }
+        _outcome.value = try {
+            when {
+                !prepared.isRecurring || scope == RecurringWriteScope.AllEvents ->
+                    repository.updateEvent(request.eventId, prepared.original, prepared.updated)
+
+                scope == RecurringWriteScope.ThisEvent ->
+                    repository.updateOccurrence(
+                        request.eventId,
+                        request.beginMillis,
+                        prepared.updated,
+                    )
+
+                else -> repository.updateEventFromOccurrence(
+                    eventId = request.eventId,
+                    beginMillis = request.beginMillis,
+                    original = prepared.original,
+                    updated = prepared.updated,
+                )
+            }
+            MoveOutcome.Moved(
+                startMillis = movedStartMillis(prepared),
+                isAllDay = prepared.updated.isAllDay,
+                undo = undoFor(prepared, scope),
+            )
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: SecurityException) {
+            MoveOutcome.WriteDenied
+        } catch (e: NoSuchEventException) {
+            MoveOutcome.Gone
+        } catch (e: Exception) {
+            MoveOutcome.Failed
+        }
+    }
+
+    /**
+     * Whether this write would leave a rule whose `UNTIL` precedes the first day
+     * it now applies to — the provider then generates nothing at all. Which date
+     * has to clear `UNTIL` depends on the scope: a whole-series move carries the
+     * series *anchor*, a split starts at the moved occurrence, and a single
+     * occurrence becomes an exception row that no `UNTIL` constrains.
+     */
+    private fun endsBeforeItStarts(prepared: PreparedMove, scope: RecurringWriteScope): Boolean {
+        if (!prepared.isRecurring || scope == RecurringWriteScope.ThisEvent) return false
+        val rule = prepared.updated.rrule ?: return false
+        val end = parseSimpleRecurrence(rule)?.end as? RecurrenceEnd.Until ?: return false
+        val firstDay = if (scope == RecurringWriteScope.AllEvents) {
+            prepared.newAnchorDate
+        } else {
+            prepared.updated.start.date
+        }
+        return end.date < firstDay
+    }
+
+    /**
+     * Whether a same-date drag leaves the series anchor on its own day too. The
+     * anchor moves by the same wall-clock delta as the occurrence, and normally
+     * shares its time of day — but a row with no `EVENT_TIMEZONE` resolves the
+     * two in zones that can sit a DST hour apart, so a near-midnight drag could
+     * carry the anchor across a midnight the occurrence never crossed and leave
+     * `BYDAY` naming the wrong weekday.
+     */
+    private fun anchorKeepsItsDay(
+        detail: EventDetail,
+        original: EventForm,
+        shifted: EventForm,
+        zone: TimeZone,
+    ): Boolean {
+        val anchorZone = if (original.isAllDay) TimeZone.UTC else original.resolvedZone(zone)
+        val anchorMinute = detail.instance.start.toLocalDateTime(anchorZone)
+            .time.toMillisecondOfDay() / MILLIS_PER_MINUTE
+        val delta = (
+            shifted.start.time.toMillisecondOfDay() - original.start.time.toMillisecondOfDay()
+            ) / MILLIS_PER_MINUTE
+        return anchorMinute + delta in 0 until MINUTES_PER_DAY
+    }
+
+    /**
+     * The series row's own start date — for a recurring master, `EventDetail`
+     * carries the row's DTSTART rather than the tapped occurrence's. Read in the
+     * same anchoring the write path uses: UTC for an all-day series.
+     */
+    private fun anchorDate(detail: EventDetail, original: EventForm, zone: TimeZone): LocalDate =
+        detail.instance.start
+            .toLocalDateTime(if (original.isAllDay) TimeZone.UTC else original.resolvedZone(zone))
+            .date
+
+    /**
+     * Undo is offered only where the inverse is one symmetric write: a
+     * non-recurring event, and a whole-series move. "This event" leaves an
+     * exception row behind and "this and following" splits the series with an
+     * UNTIL truncation — neither is undone by shifting back.
+     */
+    private fun undoFor(prepared: PreparedMove, scope: RecurringWriteScope): MoveUndo? =
+        if (!prepared.isRecurring || scope == RecurringWriteScope.AllEvents) {
+            MoveUndo(
+                eventId = prepared.request.eventId,
+                moved = prepared.updated,
+                restored = prepared.original,
+            )
+        } else {
+            null
+        }
+
+    /**
+     * Where the dragged occurrence now begins, in the same anchoring the views
+     * read dates back in: UTC midnight for an all-day event.
+     */
+    private fun movedStartMillis(prepared: PreparedMove): Long {
+        val form = prepared.updated
+        return if (form.isAllDay) {
+            form.start.date.atStartOfDayIn(TimeZone.UTC).toEpochMilliseconds()
+        } else {
+            form.start.toInstant(form.resolvedZone(TimeZone.currentSystemDefault()))
+                .toEpochMilliseconds()
+        }
+    }
+
+}

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

@@ -17,6 +17,7 @@ val LocalUse24HourFormat = staticCompositionLocalOf { true }
 private const val PATTERN_24 = "HH:mm"
 private const val PATTERN_12 = "h:mm a"
 private const val HOUR_PATTERN_12 = "h a"
+private const val HOUR_MINUTE_PATTERN_12 = "h:mm"
 
 /** A time-of-day [DateTimeFormatter] for the resolved convention and [locale]. */
 fun timeOfDayFormatter(is24Hour: Boolean, locale: Locale): DateTimeFormatter =
@@ -42,6 +43,18 @@ fun formatMinuteOfDay(minutes: Int, is24Hour: Boolean, locale: Locale): String =
     else -> formatTimeOfDay(minutes / 60, minutes % 60, is24Hour, locale)
 }
 
+/**
+ * The time shown in the timeline gutter while a block is dragged: 24h →
+ * "09:15", 12h → "9:15". The meridiem is dropped — the hour labels around it
+ * already carry it, and the gutter is too narrow.
+ */
+fun formatGutterTime(minutes: Int, is24Hour: Boolean, locale: Locale): String {
+    val clamped = minutes.coerceIn(0, MINUTES_PER_DAY - 1)
+    val pattern = if (is24Hour) PATTERN_24 else HOUR_MINUTE_PATTERN_12
+    return LocalTime.of(clamped / 60, clamped % 60)
+        .format(DateTimeFormatter.ofPattern(pattern, locale))
+}
+
 /**
  * The compact hour-only label for a timeline gutter: 24h → "13" (zero-padded,
  * the prior look); 12h → "1 PM".

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

@@ -0,0 +1,486 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.MutatePriority
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.absoluteOffset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.week.MINUTES_PER_DAY
+import de.jeanlucmakiola.calendula.ui.week.TimedBlock
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+import de.jeanlucmakiola.floret.locale.currentLocale
+import kotlinx.coroutines.delay
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.math.roundToInt
+import kotlin.time.Instant
+
+/** Start granularity a dragged block snaps to, matching the big calendar apps. */
+const val DRAG_SNAP_MINUTES: Int = 15
+
+/** How close to a timeline edge the finger must get before the view scrolls. */
+private val AUTO_SCROLL_EDGE = 64.dp
+
+/** Fastest auto-scroll step, per frame, right at the edge. */
+private val AUTO_SCROLL_STEP = 16.dp
+
+/** A block being dragged, in root coordinates so it can be drawn in an overlay. */
+data class TimelineDrag(
+    val event: EventInstance,
+    val date: LocalDate,
+    val startMin: Int,
+    val endMin: Int,
+    val topLeftInRoot: Offset,
+    val sizePx: IntSize,
+) {
+    /** What the snap haptics key off: one tick per changed slot, not per frame. */
+    val slot: Pair<LocalDate, Int> get() = date to startMin
+}
+
+/** Where a finished drag asks its event to go. */
+data class TimelineDrop(val event: EventInstance, val date: LocalDate, val startMin: Int)
+
+/**
+ * The timeline's live geometry, republished on every layout. Plain fields rather
+ * than snapshot state: it changes on every scroll frame, and the drag loop reads
+ * it per frame anyway.
+ */
+class TimelineGeometry {
+    /** The day-columns row — scrolling *content*, so its root position folds in the scroll. */
+    var grid: LayoutCoordinates? = null
+
+    /** The scroll viewport, for the edge that triggers auto-scrolling. */
+    var viewport: LayoutCoordinates? = null
+    var scroll: ScrollState? = null
+    var hourPx: Float = 0f
+
+    /** Column pitch — one column plus the gap after it. */
+    var columnWidthPx: Float = 0f
+    var columnGapPx: Float = 0f
+    var edgePx: Float = 0f
+    var stepPx: Float = 0f
+    var days: List<LocalDate> = emptyList()
+
+    /**
+     * Whether the columns are laid out right-to-left. Pointer coordinates are
+     * never mirrored but the grid is, so the mapping has to flip with it.
+     */
+    var isRtl: Boolean = false
+}
+
+/**
+ * Hoisted drag state for one timeline (#68). It lives above the per-page
+ * `AnimatedContent`, so a page change mid-drag can't strand a ghost, and the
+ * block it renders is drawn in an overlay, clear of the day column's clip.
+ */
+@Stable
+class TimelineDragController {
+    val geometry = TimelineGeometry()
+
+    var drag: TimelineDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * A dropped block, held at the slot it landed on while the write runs — the
+     * grid behind it still shows the old time until the query re-reads.
+     */
+    var settling: TimelineDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * Which block is lifted, and whether anything is. Separate snapshot state
+     * from [drag], which changes every frame, so blocks that only need "am I the
+     * ghost" don't recompose that often. Stays set through [settling].
+     */
+    var liftedInstanceId: Long? by mutableStateOf(null)
+        private set
+
+    /**
+     * Where the settled drop came from, and which event row it belongs to. The
+     * instance id alone can't identify the source block for the length of the
+     * write: the provider regenerates `Instances` rows, so a re-read carrying the
+     * *old* time can arrive under a new instance id.
+     */
+    private var settledOrigin: Triple<Long, LocalDate, Int>? by mutableStateOf(null)
+
+    /** Whether a finger is on a block right now — [settling] is not dragging. */
+    var isDragging: Boolean by mutableStateOf(false)
+        private set
+
+    /**
+     * Whether the grid itself now draws the settled drop at its landing slot.
+     * The copy may only be handed back once this is true, or the source ghost
+     * flashes back to full opacity in its old slot.
+     */
+    var settledOnGrid: Boolean by mutableStateOf(false)
+        private set
+
+    private var source: TimedBlock? = null
+    private var grab = Offset.Zero
+    private var pointer = Offset.Zero
+
+    /**
+     * The slot the block already occupied when it was picked up — not the same
+     * as its start, since the target snaps to the grid (09:07 lifts to 09:00).
+     */
+    private var originSlot: Pair<LocalDate, Int>? = null
+
+    fun begin(block: TimedBlock, pointerInRoot: Offset, blockInRoot: Offset) {
+        source = block
+        settling = null
+        isDragging = true
+        liftedInstanceId = block.event.instanceId
+        grab = pointerInRoot - blockInRoot
+        pointer = pointerInRoot
+        originSlot = null
+        recompute()
+        originSlot = drag?.slot
+    }
+
+    fun move(pointerInRoot: Offset) {
+        pointer = pointerInRoot
+        recompute()
+    }
+
+    fun cancel() {
+        source = null
+        isDragging = false
+        liftedInstanceId = null
+        originSlot = null
+        drag = null
+        settling = null
+        settledOnGrid = false
+        settledOrigin = null
+    }
+
+    /**
+     * Whether [block] is the one whose copy is in flight, and so must stay a
+     * ghost: the instance the finger picked up, or once dropped whatever now
+     * sits in the slot it left.
+     */
+    fun ghosts(block: TimedBlock, date: LocalDate): Boolean {
+        if (liftedInstanceId == null) return false
+        if (block.event.instanceId == liftedInstanceId) return true
+        val (eventId, originDate, originMin) = settledOrigin ?: return false
+        return block.event.eventId == eventId &&
+            date == originDate &&
+            block.startMin == originMin
+    }
+
+    /**
+     * What a day column now holds, so a settled drop can tell when the grid has
+     * caught up with it. Matched on the landing slot plus either the event row
+     * or its title, since a single-occurrence move writes a new `eventId`.
+     */
+    fun noteGrid(date: LocalDate, blocks: List<TimedBlock>) {
+        val landed = settling ?: return
+        if (settledOnGrid || landed.date != date) return
+        settledOnGrid = blocks.any { block ->
+            block.startMin == landed.startMin &&
+                (
+                    block.event.eventId == landed.event.eventId ||
+                        block.event.title == landed.event.title
+                    )
+        }
+    }
+
+    /**
+     * End the drag, handing back where it landed — null when it never resolved,
+     * or when it landed back on the slot it started from. A real drop keeps its
+     * copy on the target as [settling] until [release].
+     */
+    fun finish(): TimelineDrop? {
+        val landed = drag
+        val origin = originSlot
+        cancel()
+        if (landed == null || landed.slot == origin) return null
+        settling = landed
+        liftedInstanceId = landed.event.instanceId
+        settledOrigin = origin?.let { (date, min) -> Triple(landed.event.eventId, date, min) }
+        return TimelineDrop(landed.event, landed.date, landed.startMin)
+    }
+
+    /**
+     * Stop ghosting the source — the grid draws the drop itself by now — while
+     * the copy is still dissolving. Un-ghosting at [release] instead would leave
+     * the block dim under the fading copy and then brighten it: a visible dip.
+     */
+    fun handOver() {
+        liftedInstanceId = null
+        settledOrigin = null
+    }
+
+    /** Drop the copy, once it has faded into the grid's own block. */
+    fun release() {
+        settling = null
+        settledOnGrid = false
+        handOver()
+    }
+
+    /**
+     * Re-derive the target from the pointer's *root* position. Recomputed rather
+     * than accumulated from `positionChange()`, because a stationary finger emits
+     * no move events while auto-scroll walks the content underneath it.
+     */
+    fun recompute() {
+        val block = source ?: return
+        val grid = geometry.grid?.takeIf { it.isAttached } ?: return
+        val hourPx = geometry.hourPx
+        val columnPx = geometry.columnWidthPx
+        val days = geometry.days
+        if (hourPx <= 0f || columnPx <= 0f || days.isEmpty()) return
+
+        val origin = grid.positionInRoot()
+        val rawMinutes = (pointer.y - grab.y - origin.y) / hourPx * 60f
+        val snapped = (rawMinutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
+        // Clamp the start into the target day; a tail past midnight is fine.
+        val startMin = snapped.coerceIn(0, MINUTES_PER_DAY - DRAG_SNAP_MINUTES)
+        // The event's own length, not the block's: TimedBlock.endMin is clipped
+        // at midnight, which would draw a 22:00–02:00 event as a two-hour copy.
+        val span = (block.event.end - block.event.start).inWholeMinutes.toInt().coerceAtLeast(0)
+        // The column the finger is over on screen, and the day that column shows.
+        val column = ((pointer.x - origin.x) / columnPx).toInt().coerceIn(0, days.lastIndex)
+        val dayIndex = if (geometry.isRtl) days.lastIndex - column else column
+        val height = maxOf(span / 60f * hourPx, MIN_EVENT_FRACTION * hourPx)
+        drag = TimelineDrag(
+            event = block.event,
+            date = days[dayIndex],
+            startMin = startMin,
+            endMin = startMin + span,
+            topLeftInRoot = Offset(
+                x = origin.x + column * columnPx,
+                y = origin.y + startMin / 60f * hourPx,
+            ),
+            sizePx = IntSize(
+                (columnPx - geometry.columnGapPx).roundToInt(),
+                height.roundToInt(),
+            ),
+        )
+    }
+
+    /**
+     * Hold the scroll for the whole drag and nudge it once per frame while the
+     * finger sits near an edge. One `scroll` call, since a loop of
+     * `animateScrollBy` would re-acquire the mutex and cancel the last.
+     */
+    suspend fun autoScroll() {
+        val scroll = geometry.scroll ?: return
+        scroll.scroll(MutatePriority.UserInput) {
+            while (true) {
+                withFrameNanos { }
+                recompute()
+                val step = edgeStep()
+                if (step != 0f) scrollBy(step)
+            }
+        }
+    }
+
+    private fun edgeStep(): Float {
+        val viewport = geometry.viewport?.takeIf { it.isAttached } ?: return 0f
+        val edge = geometry.edgePx
+        if (edge <= 0f) return 0f
+        val bounds = viewport.boundsInRoot()
+        val fromTop = pointer.y - bounds.top
+        val fromBottom = bounds.bottom - pointer.y
+        return when {
+            fromTop < edge -> -(edge - fromTop) / edge * geometry.stepPx
+            fromBottom < edge -> (edge - fromBottom) / edge * geometry.stepPx
+            else -> 0f
+        }
+    }
+}
+
+@Composable
+fun rememberTimelineDragController(): TimelineDragController {
+    val controller = remember { TimelineDragController() }
+    val density = LocalDensity.current
+    controller.geometry.edgePx = with(density) { AUTO_SCROLL_EDGE.toPx() }
+    controller.geometry.stepPx = with(density) { AUTO_SCROLL_STEP.toPx() }
+    return controller
+}
+
+/**
+ * True when [block] actually begins on [day] rather than being the tail of an
+ * event that started earlier. A clipped block's top edge is midnight, not the
+ * event's start, so dragging it would move the event to a time it never had.
+ */
+fun TimedBlock.beginsOn(day: LocalDate, zone: TimeZone): Boolean =
+    event.start.toLocalDateTime(zone).date == day
+
+/**
+ * The instant a drop asks for, read in the zone the timeline is drawn in. A drop
+ * into a spring-forward gap has no instant of its own; `toInstant` resolves it
+ * forward by the missing hour, and the block visibly settles there.
+ */
+fun TimelineDrop.startInstant(zone: TimeZone): Instant =
+    LocalDateTime(date, LocalTime(startMin / 60, startMin % 60)).toInstant(zone)
+
+/**
+ * A beat after the grid draws the drop, so its own block is under way before the
+ * copy starts dissolving.
+ */
+const val SETTLE_GRACE_MILLIS: Long = 60L
+
+/**
+ * How long to wait for a grid that never confirms the drop — it landed on a day
+ * this timeline doesn't show, or the write failed. The copy has to go either way.
+ */
+private const val SETTLE_TIMEOUT_MILLIS = 900L
+
+/**
+ * The hand-over: the copy dissolves over this while the grid's own block slides
+ * in under it. Kept short, because a full-width copy sits over any neighbour it
+ * now shares a lane with until it is gone.
+ */
+const val SETTLE_FADE_MILLIS: Int = 250
+
+/**
+ * The floating block, drawn over the whole calendar so it is free of the day
+ * column's clip and of the scroll viewport's rounded corners.
+ */
+@Composable
+fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier = Modifier) {
+    var origin by remember { mutableStateOf(Offset.Zero) }
+    val dark = isSystemInDarkTheme()
+    val soften = LocalSoftenColors.current
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    val reduceMotion = rememberReduceMotion()
+    val density = LocalDensity.current
+    val moveInFlight = moveInFlight()
+
+    // Both live here rather than beside the controller: they read [drag], which
+    // changes every frame, and this composable is the one that is meant to.
+    DragSnapHaptics(controller.drag?.slot)
+    LaunchedEffect(controller.isDragging) {
+        if (controller.isDragging) controller.autoScroll()
+    }
+    // Hold the landed copy until the write is done — including the time a
+    // recurring drop's scope dialog is up — and then until the grid draws the
+    // drop itself.
+    var handingOver by remember(controller.settling) { mutableStateOf(false) }
+    LaunchedEffect(controller.settling, moveInFlight, controller.settledOnGrid) {
+        if (controller.settling == null || moveInFlight) return@LaunchedEffect
+        delay(if (controller.settledOnGrid) SETTLE_GRACE_MILLIS else SETTLE_TIMEOUT_MILLIS)
+        handingOver = true
+        controller.handOver()
+        delay(SETTLE_FADE_MILLIS.toLong())
+        controller.release()
+    }
+
+    Box(
+        modifier = modifier
+            .fillMaxSize()
+            // A copy of a block still in the tree behind it; announcing it again
+            // would duplicate the event for the drag's duration.
+            .clearAndSetSemantics { }
+            .onGloballyPositioned { origin = it.positionInRoot() },
+    ) {
+        val drag = controller.drag ?: controller.settling ?: return@Box
+        // Landed: the copy sinks back to the grid's own plane while the write runs.
+        val landed = controller.drag == null
+        val lift by animateFloatAsState(
+            targetValue = if (landed || reduceMotion) 0f else 1f,
+            label = "drag-lift",
+        )
+        val copyAlpha by animateFloatAsState(
+            targetValue = if (handingOver) 0f else 1f,
+            animationSpec = tween(SETTLE_FADE_MILLIS),
+            label = "drag-handover",
+        )
+        val fill = eventFill(drag.event.color, dark, soften)
+        val title = drag.event.title.ifBlank { stringResource(R.string.event_untitled) }
+        // An end past midnight wraps rather than saturating, so a four-hour
+        // event dragged to 22:00 reads "22:00–02:00" and not "22:00–24:00".
+        val endMin = if (drag.endMin > MINUTES_PER_DAY) {
+            drag.endMin % MINUTES_PER_DAY
+        } else {
+            drag.endMin
+        }
+        val label = "${formatMinuteOfDay(drag.startMin, use24Hour, locale)}–" +
+            formatMinuteOfDay(endMin, use24Hour, locale)
+        Box(
+            modifier = Modifier
+                // Absolute: these are root coordinates, and the direction-aware
+                // offset would mirror them across the screen in an RTL layout.
+                .absoluteOffset {
+                    IntOffset(
+                        (drag.topLeftInRoot.x - origin.x).roundToInt(),
+                        (drag.topLeftInRoot.y - origin.y).roundToInt(),
+                    )
+                }
+                .size(
+                    width = with(density) { drag.sizePx.width.toDp() },
+                    height = with(density) { drag.sizePx.height.toDp() },
+                )
+                .padding(horizontal = 1.dp)
+                .graphicsLayer {
+                    scaleX = 1f + 0.02f * lift
+                    scaleY = 1f + 0.02f * lift
+                    shadowElevation = 8.dp.toPx() * lift
+                    alpha = copyAlpha
+                    shape = RoundedCornerShape(4.dp)
+                    clip = false
+                }
+                .background(fill, RoundedCornerShape(4.dp))
+                .padding(horizontal = 4.dp, vertical = 2.dp),
+        ) {
+            Column {
+                val titleOverflow = eventTitleOverflow()
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.labelMedium,
+                    maxLines = 1,
+                    overflow = titleOverflow.overflow,
+                    softWrap = titleOverflow.softWrap,
+                    color = eventInk(fill, alpha = 0.85f),
+                )
+                Text(
+                    text = label,
+                    style = MaterialTheme.typography.labelSmall,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
+                )
+            }
+        }
+    }
+}

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

@@ -41,7 +41,14 @@ class TimelineZoom(
     var scale: TimelineScale by mutableStateOf(initial)
         private set
 
-    private var pinching = false
+    /**
+     * Whether fingers are rescaling the timeline right now. Snapshot state, so
+     * anything that tweens off [scale] can stand down for the gesture: the
+     * height changes every pointer frame, and a spring would spend the whole
+     * pinch chasing a target that has already moved.
+     */
+    var isPinching: Boolean by mutableStateOf(false)
+        private set
 
     /**
      * Take a value that came from the preference. Ignored mid-pinch: the stored
@@ -49,11 +56,11 @@ class TimelineZoom(
      * snap the timeline back while the user is still pinching.
      */
     fun adopt(stored: TimelineScale) {
-        if (!pinching) scale = stored
+        if (!isPinching) scale = stored
     }
 
     fun beginPinch() {
-        pinching = true
+        isPinching = true
     }
 
     fun pinchTo(hourHeight: Dp) {
@@ -61,7 +68,7 @@ class TimelineZoom(
     }
 
     fun endPinch() {
-        pinching = false
+        isPinching = false
         persist(scale)
     }
 }

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

@@ -0,0 +1,145 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.snap
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.graphics.TransformOrigin
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.layout
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.floret.components.GroupedListInset
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+import kotlin.math.roundToInt
+
+/**
+ * The viewport a view preview pretends to be: a phone's width by the height a
+ * calendar view gets under the top bar. Scaling every preview from one fixed
+ * height keeps them comparable — each shows the same slice of screen.
+ */
+internal val PREVIEW_VIEWPORT_HEIGHT = 440.dp
+
+/**
+ * Renders [content] at a full phone viewport and shrinks the finished layout
+ * into a box [height] tall, for the settings and onboarding choosers. Callers
+ * pass the *real* view composables, so a preview cannot drift from what it
+ * depicts.
+ *
+ * The [layout] below ignores the incoming constraints so the view measures at a
+ * phone viewport, and a [graphicsLayer] scale shrinks the result.
+ * `Modifier.requiredSize` is the obvious alternative but *centres* content that
+ * overflows its constraints, leaving only the bottom-right corner in the clip.
+ */
+@Composable
+internal fun ScaledViewPreview(
+    height: Dp,
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    val screenWidth = LocalConfiguration.current.screenWidthDp.dp
+    val scale = height.value / PREVIEW_VIEWPORT_HEIGHT.value
+
+    Box(
+        modifier = modifier
+            .clipToBounds()
+            .background(MaterialTheme.colorScheme.surface)
+            // A preview is a picture, not a control: swallow touches before the
+            // view's own clickables see them, and give screen readers one label
+            // instead of six weeks of day cells.
+            .pointerInput(Unit) {
+                awaitPointerEventScope {
+                    while (true) {
+                        awaitPointerEvent(PointerEventPass.Initial).changes
+                            .forEach { it.consume() }
+                    }
+                }
+            }
+            .clearAndSetSemantics { }
+            // Measure at a full phone viewport but report the scaled size, so the
+            // node occupies exactly what it draws.
+            .layout { measurable, _ ->
+                val fullWidth = screenWidth.roundToPx()
+                val fullHeight = PREVIEW_VIEWPORT_HEIGHT.roundToPx()
+                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
+                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
+                    placeable.place(0, 0)
+                }
+            }
+            .graphicsLayer {
+                scaleX = scale
+                scaleY = scale
+                transformOrigin = TransformOrigin(0f, 0f)
+            },
+    ) {
+        Column(Modifier.fillMaxSize()) { content() }
+    }
+}
+
+/**
+ * The stage every preview picker sets its preview on, cross-fading as [selected]
+ * changes. A preview draws the app's own surface, so a tonal plate gives it the
+ * edge it would otherwise lack on a chooser screen; the plate takes the width
+ * and outer radius of the grouped rows underneath so the two read as one stack.
+ *
+ * Only vertical spacing is the caller's to pass — the horizontal inset is the
+ * rows' own, and the alignment is the point.
+ */
+@Composable
+internal fun <T> ViewPreviewFrame(
+    selected: T,
+    label: String,
+    modifier: Modifier = Modifier,
+    content: @Composable (T) -> Unit,
+) {
+    val reduceMotion = rememberReduceMotion()
+    Box(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(horizontal = GroupedListInset)
+            .clip(FRAME_SHAPE)
+            .background(MaterialTheme.colorScheme.surfaceContainerHigh)
+            .padding(FRAME_INSET),
+        contentAlignment = Alignment.Center,
+    ) {
+        Crossfade(
+            targetState = selected,
+            animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+            label = label,
+        ) { shown ->
+            // Each preview renders the real view at phone size and scales it
+            // down, so its own corners are square — the plate rounds them.
+            Box(
+                modifier = Modifier
+                    .clip(PREVIEW_SHAPE)
+                    .background(MaterialTheme.colorScheme.surface)
+                    .clipToBounds(),
+            ) {
+                content(shown)
+            }
+        }
+    }
+}
+
+private val FRAME_INSET = 8.dp
+
+/** The grouped rows' own outer radius, so the stack shares one silhouette. */
+private val FRAME_SHAPE = RoundedCornerShape(22.dp)
+private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -42,6 +42,7 @@ import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -54,14 +55,18 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.customActions
 import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -75,7 +80,23 @@ import de.jeanlucmakiola.calendula.ui.common.TodayAction
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
+import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
+import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.MoveRequest
+import de.jeanlucmakiola.calendula.ui.common.MoveTarget
 import de.jeanlucmakiola.calendula.ui.common.NowLine
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
+import de.jeanlucmakiola.calendula.ui.common.TimelineDrop
+import de.jeanlucmakiola.calendula.ui.common.beginsOn
+import de.jeanlucmakiola.calendula.ui.common.eventDragAllowed
+import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
+import de.jeanlucmakiola.calendula.ui.common.eventTitleOverflow
+import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.startInstant
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
@@ -94,8 +115,9 @@ import de.jeanlucmakiola.calendula.ui.common.MIN_EVENT_FRACTION
 import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.ui.common.hourHeight
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
-import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
 import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
+import de.jeanlucmakiola.calendula.ui.common.HourGutter
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
@@ -108,16 +130,11 @@ import kotlin.time.Clock
 import java.util.Locale
 import kotlin.math.roundToInt
 
-private val GUTTER_WIDTH = 48.dp
-/** Start inset for the gutter's hour labels so they centre on the top bar's
- *  hamburger: with a 48dp gutter, 8dp lands the centre at 28dp (the app bar's
- *  4dp inset + 24dp half icon button), matching the week view. */
-private val GUTTER_CONTENT_START_INSET = 8.dp
 private val ALL_DAY_ROW_HEIGHT = 24.dp
 private val ALL_DAY_VERTICAL_PADDING = 6.dp
 
 /** Total all-day strip height for the day (0 when there are no all-day events). */
-private fun DayUiState.Success.allDayStripHeight(): Dp {
+internal fun DayUiState.Success.allDayStripHeight(): Dp {
     if (allDay.isEmpty()) return 0.dp
     val lanes = allDay.maxOf { it.lane } + 1
     return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
@@ -300,9 +317,16 @@ private fun DayContent(
     // drag is consumed by the inner scroll first — the two gestures coexist.
     val swipeModifier = rememberCalendarPageSwipe(onSwipeNext, onSwipePrev)
 
+    // Above the AnimatedContent: a page change mid-drag would strand the
+    // floating block inside the outgoing page.
+    val dragController = rememberTimelineDragController()
+    val move = LocalEventMove.current
+    val zone = remember { TimeZone.currentSystemDefault() }
+
+    Box(modifier = modifier) {
         AnimatedContent(
             targetState = state,
-        modifier = modifier.then(swipeModifier),
+            modifier = Modifier.fillMaxSize().then(swipeModifier),
             contentKey = { s ->
                 when (s) {
                     is DayUiState.Success -> "success-${s.date}"
@@ -321,21 +345,39 @@ private fun DayContent(
                     topSectionColor = topSectionColor,
                     scrollState = scrollState,
                     allDayHeight = allDayHeight,
+                    dragController = dragController,
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
+                    onDrop = { drop ->
+                        val took = move?.move(
+                            MoveRequest(
+                                eventId = drop.event.eventId,
+                                beginMillis = drop.event.start.toEpochMilliseconds(),
+                                endMillis = drop.event.end.toEpochMilliseconds(),
+                                target = MoveTarget.Start(drop.startInstant(zone)),
+                            ),
+                        )
+                        // Refused, so nothing will land: let the copy go now
+                        // rather than hold it out for a settle that never comes.
+                        if (took != true) dragController.release()
+                    },
                 )
             }
         }
+        TimelineDragOverlay(dragController)
+    }
 }
 
 @Composable
-private fun DaySuccess(
+internal fun DaySuccess(
     state: DayUiState.Success,
     topSectionColor: Color,
     scrollState: ScrollState,
     allDayHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         // All-day strip collapses to nothing when the day has no all-day events,
@@ -354,8 +396,10 @@ private fun DaySuccess(
         Timeline(
             state = state,
             scrollState = scrollState,
+            dragController = dragController,
             onEventClick = onEventClick,
             onCreateAt = onCreateAt,
+            onDrop = onDrop,
         )
     }
 }
@@ -475,11 +519,13 @@ private fun AllDayBar(
             .semantics { contentDescription = title },
         contentAlignment = Alignment.CenterStart,
     ) {
+        val titleOverflow = eventTitleOverflow()
         Text(
             text = title,
             style = MaterialTheme.typography.labelSmall,
             maxLines = 1,
-            overflow = TextOverflow.Ellipsis,
+            overflow = titleOverflow.overflow,
+            softWrap = titleOverflow.softWrap,
             color = eventInk(fill),
         )
     }
@@ -489,13 +535,15 @@ private fun AllDayBar(
 private fun Timeline(
     state: DayUiState.Success,
     scrollState: ScrollState,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     val dark = isSystemInDarkTheme()
-    val use24Hour = LocalUse24HourFormat.current
-    val locale = currentLocale()
     val zoom = LocalTimelineZoom.current
+    val density = LocalDensity.current
+    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
 
     // BoxWithConstraints rather than Box: the fit-the-whole-day scale needs the
     // timeline's own viewport height, which is only known here — below the top
@@ -514,39 +562,19 @@ private fun Timeline(
         Row(modifier = Modifier.fillMaxSize().then(pinch)) {
             // Hour gutter (scrolls in sync with the day column). Start inset so the
             // labels centre on the top bar hamburger, matching the week view.
-            Column(
-                modifier = Modifier
-                    .width(GUTTER_WIDTH)
-                    .padding(start = GUTTER_CONTENT_START_INSET)
-                    .fillMaxHeight()
-                    .verticalScroll(scrollState),
-            ) {
-                (0 until 24).forEach { h ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .height(hourHeight),
-                    ) {
-                        if (h > 0) {
-                            Text(
-                                text = formatHourLabel(h, use24Hour, locale),
-                                style = MaterialTheme.typography.labelSmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                modifier = Modifier
-                                    .align(Alignment.TopCenter)
-                                    .offset(y = (-6).dp),
+            HourGutter(
+                scrollState = scrollState,
+                hourHeight = hourHeight,
+                dragController = dragController,
             )
-                        }
-                    }
-                }
-            }
             // Day column: rounded, clipped scroll viewport (permanent corners).
             Box(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
                     .clip(RoundedCornerShape(16.dp))
-                    .verticalScroll(scrollState),
+                    .verticalScroll(scrollState)
+                    .onGloballyPositioned { dragController.geometry.viewport = it },
             ) {
                 DayColumnCard(
                     blocks = state.timed,
@@ -554,11 +582,26 @@ private fun Timeline(
                     date = state.date,
                     today = state.today,
                     hourHeight = hourHeight,
+                    dragController = dragController,
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
+                    onDrop = onDrop,
                     modifier = Modifier
                         .fillMaxWidth()
-                        .height(totalHeight),
+                        .height(totalHeight)
+                        // The scrolling content itself, so its root position
+                        // already folds in the scroll offset.
+                        .onGloballyPositioned { coords ->
+                            dragController.geometry.let {
+                                it.grid = coords
+                                it.scroll = scrollState
+                                it.hourPx = with(density) { hourHeight.toPx() }
+                                it.columnGapPx = 0f
+                                it.columnWidthPx = coords.size.width.toFloat()
+                                it.days = listOf(state.date)
+                                it.isRtl = isRtl
+                            }
+                        },
                 )
             }
         }
@@ -572,13 +615,19 @@ private fun DayColumnCard(
     date: LocalDate,
     today: LocalDate,
     hourHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val hourPx = with(LocalDensity.current) { hourHeight.toPx() }
     val showHourLines = LocalShowHourLines.current
     val hourLineColor = MaterialTheme.colorScheme.outlineVariant
+    // Tells a settled drop when this column has caught up with it.
+    LaunchedEffect(blocks, dragController.settling) {
+        dragController.noteGrid(date, blocks)
+    }
     // The tap detector outlives the composition that installed it — a pinch or a
     // Settings change moves the hour height without restarting it — so it reads
     // the height and the callback through state handles instead of capturing
@@ -614,23 +663,39 @@ private fun DayColumnCard(
         ) {
             val colWidth = maxWidth
             val minEventHeight = hourHeight * MIN_EVENT_FRACTION
+            // Keyed by event, so a block that changes time or lane is the *same*
+            // composable afterwards and tweens there. The ordinal disambiguates
+            // a column holding two occurrences of one series.
+            val ordinals = mutableMapOf<Long, Int>()
             blocks.forEach { block ->
+                val ordinal = ordinals.merge(block.event.eventId, 1, Int::plus)!! - 1
+                key(block.event.eventId, ordinal) {
                     val laneWidth = colWidth / block.laneCount
                     val top = hourHeight * (block.startMin / 60f)
                     val rawHeight = hourHeight * ((block.endMin - block.startMin) / 60f)
                     val height = if (rawHeight < minEventHeight) minEventHeight else rawHeight
+                    val place = animatedBlockPlacement(
+                        x = laneWidth * block.lane,
+                        y = top,
+                        width = laneWidth,
+                        height = height,
+                    )
                     EventBlock(
                         block = block,
                         dark = dark,
-                    height = height,
+                        height = place.height,
+                        date = date,
+                        dragController = dragController,
                         onClick = { onEventClick(block.event) },
+                        onDrop = onDrop,
                         modifier = Modifier
-                        .offset(x = laneWidth * block.lane, y = top)
-                        .width(laneWidth)
-                        .height(height)
+                            .offset(x = place.x, y = place.y)
+                            .width(place.width)
+                            .height(place.height)
                             .padding(horizontal = 1.dp),
                     )
                 }
+            }
             // Current-time line, on top of the events, only on today's column.
             if (date == today) {
                 NowLine(date = date, hourHeight = hourHeight)
@@ -644,7 +709,10 @@ private fun EventBlock(
     block: TimedBlock,
     dark: Boolean,
     height: Dp,
+    date: LocalDate,
+    dragController: TimelineDragController,
     onClick: () -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
@@ -668,29 +736,51 @@ private fun EventBlock(
     val showTitle = available >= titleLineHeight
     val soften = LocalSoftenColors.current
     val fill = eventFill(block.event.color, dark, soften)
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val moveAction = eventMoveAction(block.event)
+    // A block clipped at the top continues from the previous day: its top edge
+    // is midnight, not the event's start, so dragging it would invent a time.
+    val draggable = eventDragAllowed(block.event) && block.beginsOn(date, zone)
+    val dragModifier = rememberEventDragSource(
+        enabled = draggable,
+        key = block.event.instanceId,
+        onPickUp = { pointer, blockRoot, _ -> dragController.begin(block, pointer, blockRoot) },
+        onMove = dragController::move,
+        onDrop = { dragController.finish()?.let(onDrop) },
+        onCancel = dragController::cancel,
+    )
+    val lifted = draggable && dragController.ghosts(block, date)
+    val ghost = ghostAlpha(lifted)
     Box(
         modifier = modifier
+            // The source stays put as a ghost while its floating copy travels.
+            .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
             .background(fill, RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
+            // After clickable, so it is the inner node and wins the main pass;
+            // the tap still works, since a drag consumes the up.
+            .then(dragModifier)
             .padding(horizontal = 4.dp, vertical = 2.dp)
-            .semantics { contentDescription = "$title, $timeLabel" },
+            .semantics {
+                contentDescription = "$title, $timeLabel"
+                if (moveAction != null) customActions = listOf(moveAction)
+            },
     ) {
         Column {
             if (showTitle) {
+                val titleOverflow = eventTitleOverflow(singleLine = showTime)
                 Text(
                     text = title,
                     style = MaterialTheme.typography.labelMedium,
                     maxLines = if (showTime) 1 else 2,
-                    overflow = TextOverflow.Ellipsis,
+                    overflow = titleOverflow.overflow,
+                    softWrap = titleOverflow.softWrap,
                     color = eventInk(fill, alpha = 0.85f),
                 )
             }
             if (showTime) {
-                Text(
-                    text = timeLabel,
-                    style = MaterialTheme.typography.labelSmall,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
+                BlockTimeLabel(
+                    label = timeLabel,
                     color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
                 )
             }

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

@@ -0,0 +1,65 @@
+package de.jeanlucmakiola.calendula.ui.day
+
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.sampleTimelineEvents
+import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
+import de.jeanlucmakiola.calendula.ui.week.layoutDay
+import kotlinx.coroutines.flow.first
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+
+/**
+ * A live, scaled-down Day view for the onboarding view chooser. Today's date is
+ * real; only the events are stand-ins.
+ */
+@Composable
+internal fun DayViewPreview(
+    height: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
+    val state = remember(today, zone) { sampleDayState(today, zone) }
+    val scrollState = rememberScrollState()
+    LaunchedEffect(Unit) {
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        // Half the scroll range is noon — the same centring the live view does.
+        scrollState.scrollTo(scrollState.maxValue / 2)
+    }
+
+    ScaledViewPreview(height = height, modifier = modifier) {
+        DaySuccess(
+            state = state,
+            topSectionColor = MaterialTheme.colorScheme.surface,
+            scrollState = scrollState,
+            allDayHeight = state.allDayStripHeight(),
+            dragController = rememberTimelineDragController(),
+            onEventClick = {},
+            onCreateAt = { _, _ -> },
+            onDrop = {},
+        )
+    }
+}
+
+/** Sample day state, laid out through the same helpers the live view uses. */
+private fun sampleDayState(today: LocalDate, zone: TimeZone): DayUiState.Success {
+    val days = listOf(today)
+    val events = sampleTimelineEvents(days, today, zone)
+    return DayUiState.Success(
+        date = today,
+        today = today,
+        allDay = layoutAllDay(events.filter { it.isAllDay }, days, zone),
+        timed = layoutDay(events, today, zone),
+    )
+}

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

@@ -127,6 +127,7 @@ import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.calendula.data.calendar.CalendarColorPalette
+import de.jeanlucmakiola.calendula.ui.common.RecurringScopeDialog
 import de.jeanlucmakiola.calendula.ui.common.CalendarPickerGroups
 import de.jeanlucmakiola.calendula.ui.common.CalendarDatePickerDialog
 import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
@@ -452,30 +453,11 @@ private fun SaveScopeDialog(
     onSelect: (RecurringWriteScope) -> Unit,
     onDismiss: () -> Unit,
 ) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text(stringResource(R.string.event_edit_recurring_title)) },
-        text = {
-            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                if (!recurrenceChanged) {
-                    OptionCard(
-                        label = stringResource(R.string.event_delete_option_occurrence),
-                        onClick = { onSelect(RecurringWriteScope.ThisEvent) },
-                    )
-                }
-                OptionCard(
-                    label = stringResource(R.string.event_delete_option_following),
-                    onClick = { onSelect(RecurringWriteScope.ThisAndFollowing) },
-                )
-                OptionCard(
-                    label = stringResource(R.string.event_delete_option_series),
-                    onClick = { onSelect(RecurringWriteScope.AllEvents) },
-                )
-            }
-        },
-        confirmButton = {
-            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
-        },
+    RecurringScopeDialog(
+        title = stringResource(R.string.event_edit_recurring_title),
+        onSelect = onSelect,
+        onDismiss = onDismiss,
+        allowOccurrence = !recurrenceChanged,
     )
 }
 

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

@@ -0,0 +1,303 @@
+package de.jeanlucmakiola.calendula.ui.month
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.unit.IntSize
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.LocalDate
+import kotlin.math.abs
+
+/** One week row's live geometry, republished on every layout while it is on screen. */
+class MonthRowGeometry(
+    val days: List<LocalDate>,
+    /** The row's day-column box — the space chip offsets are measured in. */
+    val cell: LayoutCoordinates,
+    /** The lane band inside that box, where the chips themselves are seated. */
+    val band: LayoutCoordinates?,
+    val columnWidthPx: Float,
+    val laneHeightPx: Float,
+    val laneCount: Int,
+    /**
+     * Whether the columns are laid out right-to-left. Pointer coordinates are
+     * never mirrored but the grid is, so the mapping has to flip with it.
+     */
+    val isRtl: Boolean,
+    /** What this row currently draws in [lane] of column `col`, or null. */
+    val chipAt: (col: Int, lane: Int) -> EventInstance?,
+) {
+    /** Root top-left of the chip seated in [lane] of column [col]. */
+    fun seat(col: Int, lane: Int): Offset? {
+        val band = band?.takeIf { it.isAttached } ?: return null
+        val origin = band.positionInRoot()
+        val column = if (isRtl) days.lastIndex - col else col
+        return Offset(origin.x + column * columnWidthPx, origin.y + lane * laneHeightPx)
+    }
+
+    /**
+     * Where this row seats [event] on [date], or null when it doesn't hold it —
+     * the day isn't in this week, or the chip went into the day's "+N" overflow.
+     */
+    fun seatOf(event: EventInstance, date: LocalDate): Offset? {
+        val col = days.indexOf(date).takeIf { it >= 0 } ?: return null
+        val lane = (0 until laneCount).firstOrNull { lane ->
+            chipAt(col, lane)?.let { isSameEvent(it, event) } == true
+        } ?: return null
+        return seat(col, lane)
+    }
+}
+
+/**
+ * Whether [chip] is the moved event [moved] as the grid now holds it. Neither id
+ * alone will do: re-read instances get new instance ids, and a single-occurrence
+ * move writes a new event id — the title survives both.
+ */
+private fun isSameEvent(chip: EventInstance, moved: EventInstance): Boolean =
+    chip.eventId == moved.eventId || chip.title == moved.title
+
+/** A chip in flight, in root coordinates so it can be drawn in an overlay. */
+data class MonthChipDrag(
+    val event: EventInstance,
+    /** The day whose column the chip was grabbed in — the drag is a delta from it. */
+    val grabDate: LocalDate,
+    val targetDate: LocalDate?,
+    val topLeftInRoot: Offset,
+    val sizePx: IntSize,
+)
+
+/** Where a finished chip drag asks its event to go, as a whole-day shift. */
+data class MonthChipDrop(
+    val event: EventInstance,
+    val grabDate: LocalDate,
+    val targetDate: LocalDate,
+)
+
+/**
+ * Hoisted drag state for the month grid (#68). Every visible week row registers
+ * itself so a chip can be carried across rows, the target resolved against
+ * whichever registered row the finger is over. Rows are keyed by an identity
+ * token rather than a date: the continuous style can show the same week twice.
+ */
+@Stable
+class MonthDragController {
+    private val rows = LinkedHashMap<Any, MonthRowGeometry>()
+
+    var drag: MonthChipDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * A dropped chip, held on the day it landed on while the write runs — the
+     * grid behind it still shows the old day until the query re-reads.
+     */
+    var settling: MonthChipDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * Which chip is lifted, and whether anything is. Separate snapshot state from
+     * [drag], which changes every frame, so the chips and rows that only need
+     * "am I the ghost" don't recompose that often. Stays set through [settling].
+     */
+    var liftedInstanceId: Long? by mutableStateOf(null)
+        private set
+
+    /**
+     * Where the grid itself now draws the drop, in root coordinates — published
+     * by whichever week row ends up holding it. The copy is dropped wherever the
+     * finger was while the grid seats it in a lane, so without this it would
+     * cross-fade across the gap instead of gliding onto its seat.
+     */
+    var settledInRoot: Offset? by mutableStateOf(null)
+        private set
+
+    /**
+     * Whether the drop's own chip is still standing in for the copy. Cleared at
+     * [handOver] rather than [release], or the chip stays dim under a copy that
+     * has already faded and brightens afterwards: a visible dip.
+     */
+    private var settledGhost: Boolean by mutableStateOf(false)
+
+    /** Whether a finger is on a chip right now — [settling] is not dragging. */
+    var isDragging: Boolean by mutableStateOf(false)
+        private set
+
+    /**
+     * The last drop this controller made, kept past [release] for [beginUndo] —
+     * the confirmation chip carries Undo long after the copy is gone.
+     */
+    private var undoable: MonthChipDrag? = null
+
+    private var event: EventInstance? = null
+    private var grabDate: LocalDate? = null
+    private var grab = Offset.Zero
+    private var pointer = Offset.Zero
+    private var sizePx = IntSize.Zero
+
+    fun putRow(token: Any, geometry: MonthRowGeometry) {
+        rows[token] = geometry
+    }
+
+    fun removeRow(token: Any) {
+        rows.remove(token)
+    }
+
+    fun begin(
+        event: EventInstance,
+        grabDate: LocalDate,
+        pointerInRoot: Offset,
+        chipInRoot: Offset,
+        size: IntSize,
+    ) {
+        this.event = event
+        this.grabDate = grabDate
+        settling = null
+        isDragging = true
+        liftedInstanceId = event.instanceId
+        grab = pointerInRoot - chipInRoot
+        pointer = pointerInRoot
+        sizePx = size
+        recompute()
+    }
+
+    fun move(pointerInRoot: Offset) {
+        pointer = pointerInRoot
+        recompute()
+    }
+
+    fun cancel() {
+        event = null
+        grabDate = null
+        isDragging = false
+        liftedInstanceId = null
+        drag = null
+        settling = null
+        settledInRoot = null
+        settledGhost = false
+    }
+
+    /**
+     * Whether [days] holds the chip the grid has drawn for the settled drop —
+     * the seat the copy is on its way to, which must ghost until it gets there.
+     */
+    fun isSettledChip(event: EventInstance, days: List<LocalDate>?): Boolean {
+        val landed = settling?.takeIf { settledGhost } ?: return false
+        if (days == null || landed.targetDate !in days) return false
+        return isSameEvent(event, landed.event)
+    }
+
+    /**
+     * Ask the row keyed [token] whether it now seats the settled chip. Both
+     * copies of a week the continuous style shows twice will answer; the seat
+     * nearest where the chip was let go is the one the finger was over.
+     */
+    fun noteSettled(token: Any) {
+        val landed = settling ?: return
+        val target = landed.targetDate ?: return
+        val at = rows[token]?.seatOf(landed.event, target) ?: return
+        val current = settledInRoot
+        val closer = current == null ||
+            abs(at.y - landed.topLeftInRoot.y) < abs(current.y - landed.topLeftInRoot.y)
+        if (closer) settledInRoot = at
+    }
+
+    /**
+     * Put a chip on the journey an undo's inverse write is about to make, so it
+     * travels back rather than teleporting. Writes nothing itself. False when
+     * there is no drop of this controller's left to undo, or the grid doesn't
+     * seat the moved event where the chip would have to start from.
+     */
+    fun beginUndo(): Boolean {
+        val last = undoable ?: return false
+        undoable = null
+        val from = last.targetDate ?: return false
+        val at = rows.values.firstNotNullOfOrNull { it.seatOf(last.event, from) } ?: return false
+        settling = last.copy(grabDate = from, targetDate = last.grabDate, topLeftInRoot = at)
+        liftedInstanceId = last.event.instanceId
+        settledGhost = true
+        settledInRoot = null
+        return true
+    }
+
+    /**
+     * End the drag, handing back where it landed — null when it never resolved,
+     * or when it landed back on the day it came from. A real drop keeps its chip
+     * on the target day as [settling] until [release], slid over to that day's
+     * column so it lands where the grid is about to draw it.
+     */
+    fun finish(): MonthChipDrop? {
+        val landed = drag
+        val left = landed?.targetDate?.let(::columnLeft)
+        cancel()
+        val target = landed?.targetDate?.takeIf { it != landed.grabDate } ?: return null
+        settling = landed.copy(
+            topLeftInRoot = Offset(left ?: landed.topLeftInRoot.x, landed.topLeftInRoot.y),
+        )
+        liftedInstanceId = landed.event.instanceId
+        settledGhost = true
+        undoable = settling
+        return MonthChipDrop(landed.event, landed.grabDate, target)
+    }
+
+    /**
+     * Stop ghosting the source while the copy is still dissolving — un-ghosting
+     * at [release] instead leaves the chip dim and then brightens it.
+     */
+    fun handOver() {
+        liftedInstanceId = null
+        settledGhost = false
+    }
+
+    /** Drop the copy, once it has faded into the grid's own chip. */
+    fun release() {
+        settling = null
+        settledInRoot = null
+        handOver()
+    }
+
+    /** Root x of [date]'s column, in whichever visible row shows that day. */
+    private fun columnLeft(date: LocalDate): Float? = rows.values.firstNotNullOfOrNull { row ->
+        val index = row.days.indexOf(date).takeIf { it >= 0 } ?: return@firstNotNullOfOrNull null
+        val bounds = row.cell.takeIf { it.isAttached }?.boundsInRoot()
+            ?: return@firstNotNullOfOrNull null
+        val column = if (row.isRtl) row.days.lastIndex - index else index
+        bounds.left + column * row.columnWidthPx
+    }
+
+    private fun recompute() {
+        val event = event ?: return
+        val grabbed = grabDate ?: return
+        val resolved = rows.values.firstNotNullOfOrNull { row ->
+            val bounds = row.cell.takeIf { it.isAttached }?.boundsInRoot()
+                ?: return@firstNotNullOfOrNull null
+            if (!bounds.contains(pointer) || row.columnWidthPx <= 0f) {
+                null
+            } else {
+                val column = ((pointer.x - bounds.left) / row.columnWidthPx)
+                    .toInt()
+                    .coerceIn(0, row.days.lastIndex)
+                row.days[if (row.isRtl) row.days.lastIndex - column else column]
+            }
+        }
+        drag = MonthChipDrag(
+            event = event,
+            grabDate = grabbed,
+            // Off the grid entirely: keep the last cell it was over, so a
+            // wobble past the edge doesn't drop the target.
+            targetDate = resolved ?: drag?.targetDate,
+            topLeftInRoot = pointer - grab,
+            sizePx = sizePx,
+        )
+    }
+}
+
+@Composable
+fun rememberMonthDragController(): MonthDragController = remember { MonthDragController() }
+
+val LocalMonthDrag = compositionLocalOf<MonthDragController?> { null }

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

@@ -4,7 +4,9 @@ import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.ExperimentalSharedTransitionApi
 import androidx.compose.animation.SharedTransitionLayout
+import androidx.compose.animation.core.Animatable
 import androidx.compose.animation.core.RepeatMode
+import androidx.compose.animation.core.VectorConverter
 import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.animation.core.snap
 import androidx.compose.animation.core.animateFloat
@@ -59,9 +61,11 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.key
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.mutableIntStateOf
@@ -77,7 +81,33 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.draw.drawBehind
 import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.foundation.layout.absoluteOffset
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.geometry.Offset
+import kotlin.math.roundToInt
+import de.jeanlucmakiola.calendula.ui.common.rememberDragSurface
+import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
+import de.jeanlucmakiola.calendula.ui.common.eventTitleOverflow
+import de.jeanlucmakiola.calendula.ui.common.MoveTarget
+import de.jeanlucmakiola.calendula.ui.common.MoveRequest
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.moveInFlight
+import de.jeanlucmakiola.calendula.ui.common.OnUndoStarted
+import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
+import de.jeanlucmakiola.calendula.ui.common.DragSnapHaptics
+import de.jeanlucmakiola.calendula.ui.common.SETTLE_FADE_MILLIS
+import de.jeanlucmakiola.calendula.ui.common.SETTLE_GRACE_MILLIS
+import de.jeanlucmakiola.calendula.ui.common.EventMoveScope
+import de.jeanlucmakiola.calendula.domain.spanFirstDay
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.semantics.customActions
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.drawscope.Stroke
@@ -126,6 +156,7 @@ import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.time.isoWeekNumber
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.launch
@@ -384,13 +415,23 @@ fun MonthScreen(
                 )
             },
         ) { innerPadding ->
-            Column(
+            // Hoisted above every style's grid: a dragged chip is drawn in an
+            // overlay, clear of the week row's and the list viewport's clips.
+            val chipDrag = rememberMonthDragController()
+            // Undo moves the event back, so the chip travels back too. The
+            // signal comes from the write, not from the chip that offers it.
+            OnUndoStarted { chipDrag.beginUndo() }
+            Box(
                 modifier = Modifier
                     .padding(innerPadding)
                     .fillMaxSize(),
             ) {
+            Column(modifier = Modifier.fillMaxSize()) {
                 WeekdayHeader(weekStart = weekStart, showWeekNumbers = showWeekNumbers)
-                CompositionLocalProvider(LocalDimCutoff provides dimCutoff) {
+                CompositionLocalProvider(
+                    LocalDimCutoff provides dimCutoff,
+                    LocalMonthDrag provides chipDrag,
+                ) {
                     if (scrolling) {
                         ContinuousMonthContent(
                             state = continuousState,
@@ -427,9 +468,102 @@ fun MonthScreen(
                     }
                 }
             }
+            MonthDragOverlay(chipDrag)
             }
         }
     }
+}
+
+/**
+ * How long to wait for a grid that never seats the drop — it landed in a day's
+ * "+N" overflow or on a day this month doesn't show, or the write failed.
+ */
+private const val MONTH_SETTLE_TIMEOUT_MILLIS = 450L
+
+/** The chip in flight, drawn over the grid and following the finger. */
+@Composable
+private fun MonthDragOverlay(controller: MonthDragController) {
+    var origin by remember { mutableStateOf(Offset.Zero) }
+    val dark = isSystemInDarkTheme()
+    val density = LocalDensity.current
+    val reduceMotion = rememberReduceMotion()
+    val moveInFlight = moveInFlight()
+    // Here rather than beside the controller: this reads [drag], which changes
+    // every frame, and this composable is the one that is meant to.
+    DragSnapHaptics(controller.drag?.targetDate)
+    // Hold the landed chip until the write is done — including the time a
+    // recurring drop's scope dialog is up — and then, unlike the timeline, carry
+    // it to its seat: it was dropped at whatever height the finger was at, while
+    // the grid seats it in a lane.
+    var handingOver by remember(controller.settling) { mutableStateOf(false) }
+    var gliding by remember(controller.settling) { mutableStateOf(false) }
+    val glide = remember { Animatable(Offset.Zero, Offset.VectorConverter) }
+    val glideSpec = MaterialTheme.motionScheme.fastSpatialSpec<Offset>()
+    val seat = controller.settledInRoot
+    LaunchedEffect(controller.settling, moveInFlight, seat) {
+        val landed = controller.settling
+        if (landed == null || moveInFlight) return@LaunchedEffect
+        if (seat == null) {
+            delay(MONTH_SETTLE_TIMEOUT_MILLIS)
+        } else {
+            if (!gliding) glide.snapTo(landed.topLeftInRoot)
+            gliding = true
+            if (reduceMotion) glide.snapTo(seat) else glide.animateTo(seat, glideSpec)
+            delay(SETTLE_GRACE_MILLIS)
+        }
+        handingOver = true
+        controller.handOver()
+        delay(SETTLE_FADE_MILLIS.toLong())
+        controller.release()
+    }
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            // A copy of a chip still in the tree behind it; announcing it again
+            // would duplicate the event for the drag's duration.
+            .clearAndSetSemantics { }
+            .onGloballyPositioned { origin = it.positionInRoot() },
+    ) {
+        val drag = controller.drag ?: controller.settling ?: return@Box
+        // Landed: the copy sinks back to the grid's own plane while the write runs.
+        val lift by animateFloatAsState(
+            targetValue = if (controller.drag == null || reduceMotion) 0f else 1f,
+            label = "chip-lift",
+        )
+        val copyAlpha by animateFloatAsState(
+            targetValue = if (handingOver) 0f else 1f,
+            animationSpec = tween(SETTLE_FADE_MILLIS),
+            label = "chip-handover",
+        )
+        MonthBar(
+            event = drag.event,
+            dark = dark,
+            continuesLeft = false,
+            continuesRight = false,
+            modifier = Modifier
+                // Absolute: these are root coordinates, and the direction-aware
+                // offset would mirror them across the screen in an RTL layout.
+                .absoluteOffset {
+                    val at = if (gliding) glide.value else drag.topLeftInRoot
+                    IntOffset(
+                        (at.x - origin.x).roundToInt(),
+                        (at.y - origin.y).roundToInt(),
+                    )
+                }
+                .width(with(density) { drag.sizePx.width.toDp() })
+                .height(with(density) { drag.sizePx.height.toDp() })
+                .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp)
+                .graphicsLayer {
+                    scaleX = 1f + 0.04f * lift
+                    scaleY = 1f + 0.04f * lift
+                    shadowElevation = 8.dp.toPx() * lift
+                    alpha = copyAlpha
+                    shape = RoundedCornerShape(4.dp)
+                    clip = false
+                },
+        )
+    }
+}
 
 @Composable
 private fun MonthContent(
@@ -1720,6 +1854,50 @@ private fun MonthWeekRow(
     val shownLanes = laneCount.coerceAtMost(MAX_EVENT_ROWS)
     val morphing = morphInFlight()
 
+    // Drag to reschedule (#68). The chips can take no pointer input of their own
+    // — the full-bleed tap layer sits on top of them — so one detector on the
+    // row's day-column box hit-tests them geometrically instead.
+    val moveScope = LocalEventMove.current
+    val dragController = LocalMonthDrag.current
+    val rowToken = remember { Any() }
+    val bandCoordinates = remember { arrayOfNulls<LayoutCoordinates>(1) }
+    val cellCoordinates = remember { arrayOfNulls<LayoutCoordinates>(1) }
+    val density = LocalDensity.current
+    val rowHeightPx = with(density) { EVENT_ROW_HEIGHT.toPx() }
+    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
+    val dragging = dragController?.isDragging == true
+    DisposableEffect(rowToken, dragController) {
+        onDispose { dragController?.removeRow(rowToken) }
+    }
+    // Republished on layout *and* on every recomposition: the coordinates change
+    // only on the former, but what the row draws — which the controller reads to
+    // find a moved chip's seat — changes on the latter.
+    val publish = {
+        val cell = cellCoordinates[0]?.takeIf { it.isAttached }
+        if (dragController != null && cell != null) {
+            dragController.putRow(
+                rowToken,
+                MonthRowGeometry(
+                    days = week.days,
+                    cell = cell,
+                    band = bandCoordinates[0],
+                    columnWidthPx = cell.size.width / 7f,
+                    laneHeightPx = rowHeightPx,
+                    laneCount = MAX_EVENT_ROWS,
+                    isRtl = isRtl,
+                    chipAt = { col, lane -> week.chipAt(col, lane, MAX_EVENT_ROWS) },
+                ),
+            )
+        }
+    }
+    SideEffect { publish() }
+    // Once the grid holds the settled chip, tell the controller where this row
+    // has seated it, so the copy in flight can glide onto it. Keyed on the week,
+    // which is what changes when the re-read lands.
+    LaunchedEffect(week, dragController?.settling) {
+        dragController?.noteSettled(rowToken)
+    }
+
     Row(modifier) {
         // Optional calendar-week gutter, sized so the seven day columns below
         // divide the remaining width — the absolute bar offsets stay correct
@@ -1735,7 +1913,21 @@ private fun MonthWeekRow(
         BoxWithConstraints(
             Modifier
                 .weight(1f)
-                .fillMaxHeight(),
+                .fillMaxHeight()
+                .onGloballyPositioned { coords ->
+                    cellCoordinates[0] = coords
+                    publish()
+                }
+                .then(
+                    monthChipDragModifier(
+                        week = week,
+                        moveScope = moveScope,
+                        controller = dragController,
+                        band = bandCoordinates,
+                        rowHeightPx = rowHeightPx,
+                        isRtl = isRtl,
+                    ),
+                ),
         ) {
             val colW = maxWidth / 7
 
@@ -1800,7 +1992,13 @@ private fun MonthWeekRow(
                     modifier = Modifier
                         .fillMaxWidth()
                         .weight(1f)
-                        .then(if (morphing) Modifier else Modifier.clipToBounds()),
+                        .onGloballyPositioned {
+                            bandCoordinates[0] = it
+                            publish()
+                        }
+                        // A dragged chip travels to another row, so the clip
+                        // yields for it as it does for a morph.
+                        .then(if (morphing || dragging) Modifier else Modifier.clipToBounds()),
                 ) {
                     // Spanning bars on their shared lanes.
                     week.spans.filter { it.lane < shownLanes }.forEach { span ->
@@ -1810,6 +2008,7 @@ private fun MonthWeekRow(
                             dark = dark,
                             continuesLeft = span.continuesLeft,
                             continuesRight = span.continuesRight,
+                            days = week.days.subList(span.startCol, span.endCol + 1),
                             modifier = Modifier
                                 .offset(
                                     x = colW * span.startCol,
@@ -1879,6 +2078,7 @@ private fun MonthWeekRow(
                                 dark = dark,
                                 continuesLeft = false,
                                 continuesRight = false,
+                                days = listOf(d),
                                 modifier = Modifier
                                     .offset(
                                         x = colW * col,
@@ -1959,6 +2159,73 @@ private fun MonthWeekRow(
     }
 }
 
+/**
+ * The row-level pickup for month chips: resolves which chip the press landed on
+ * from the geometry the row just laid out, and abandons the gesture on empty
+ * space (or an unmovable calendar) so tapping a day still opens it.
+ */
+@Composable
+private fun monthChipDragModifier(
+    week: MonthWeek,
+    moveScope: EventMoveScope?,
+    controller: MonthDragController?,
+    band: Array<LayoutCoordinates?>,
+    rowHeightPx: Float,
+    isRtl: Boolean,
+): Modifier = rememberDragSurface(
+    enabled = moveScope?.dragEnabled == true && controller != null,
+    key = week.days.first(),
+    onPickUp = { local, pointerInRoot, nodeInRoot, size ->
+        val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y
+        val columnPx = size.width / 7f
+        val bandY = if (bandTop == null) -1f else local.y - (bandTop - nodeInRoot.y)
+        val lane = (bandY / rowHeightPx).toInt()
+        // The column under the finger on screen, and the day that column shows.
+        val column = (local.x / columnPx).toInt()
+        val dayIndex = if (isRtl) week.days.lastIndex - column else column
+        val event = if (bandY < 0f || columnPx <= 0f) {
+            null
+        } else {
+            week.chipAt(dayIndex, lane, MAX_EVENT_ROWS)
+        }
+        if (event == null || moveScope?.allows(event) != true) {
+            false
+        } else {
+            controller?.begin(
+                event = event,
+                grabDate = week.days[dayIndex],
+                pointerInRoot = pointerInRoot,
+                chipInRoot = Offset(
+                    x = nodeInRoot.x + column * columnPx,
+                    y = requireNotNull(bandTop) + lane * rowHeightPx,
+                ),
+                size = IntSize(columnPx.toInt(), rowHeightPx.toInt()),
+            )
+            true
+        }
+    },
+    onMove = { controller?.move(it) },
+    onDrop = {
+        controller?.finish()?.let { drop ->
+            // How many columns the finger crossed — grabbing the middle of a
+            // multi-day bar shifts by what it travelled, not to where it landed.
+            val delta = (drop.targetDate.toEpochDays() - drop.grabDate.toEpochDays()).toInt()
+            val took = moveScope?.move(
+                MoveRequest(
+                    eventId = drop.event.eventId,
+                    beginMillis = drop.event.start.toEpochMilliseconds(),
+                    endMillis = drop.event.end.toEpochMilliseconds(),
+                    target = MoveTarget.ByDays(delta),
+                ),
+            )
+            // Refused, so nothing will land: let the copy go now rather than
+            // hold the chip out for a settle that can never arrive.
+            if (took != true) controller?.release()
+        }
+    },
+    onCancel = { controller?.cancel() },
+)
+
 /**
  * Left-gutter calendar-week cell (#25): a full-height tonal pill mirroring the
  * day cells' geometry, set apart by the secondaryContainer tint (matching the
@@ -2051,12 +2318,24 @@ private fun MonthBar(
     continuesLeft: Boolean,
     continuesRight: Boolean,
     modifier: Modifier = Modifier,
+    /**
+     * The days this chip covers in its row, for the drag (#68). A drop's own chip
+     * has to ghost until the copy lands on it, and the instance id can't find it:
+     * the provider hands the re-read instance a new one.
+     */
+    days: List<LocalDate>? = null,
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     val dimCutoff = LocalDimCutoff.current
     val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
     val soften = LocalSoftenColors.current
     val fill = eventFill(event.color, dark, soften)
+    val moveAction = eventMoveAction(event)
+    // The source stays put as a ghost while its floating copy travels.
+    val monthDrag = LocalMonthDrag.current
+    val lifted = monthDrag?.liftedInstanceId == event.instanceId ||
+        monthDrag?.isSettledChip(event, days) == true
+    val ghost = ghostAlpha(lifted)
     val shape = RoundedCornerShape(
         topStart = if (continuesLeft) 0.dp else 4.dp,
         bottomStart = if (continuesLeft) 0.dp else 4.dp,
@@ -2065,16 +2344,22 @@ private fun MonthBar(
     )
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
+            .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
             .background(fill, shape)
             .padding(horizontal = 4.dp)
-            .semantics { contentDescription = title },
+            .semantics {
+                contentDescription = title
+                if (moveAction != null) customActions = listOf(moveAction)
+            },
         contentAlignment = Alignment.CenterStart,
     ) {
+        val titleOverflow = eventTitleOverflow()
         Text(
             text = title,
             style = MaterialTheme.typography.labelSmall,
             maxLines = 1,
-            overflow = TextOverflow.Ellipsis,
+            overflow = titleOverflow.overflow,
+            softWrap = titleOverflow.softWrap,
             color = eventInk(fill),
         )
     }

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

@@ -1,54 +1,31 @@
 package de.jeanlucmakiola.calendula.ui.month
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.layout.layout
-import androidx.compose.ui.unit.Constraints
-import androidx.compose.ui.graphics.TransformOrigin
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.input.pointer.PointerEventPass
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalConfiguration
-import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.sampleMonthEvents
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.YearMonth
-import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
-import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
-import kotlin.math.roundToInt
 
 /**
  * A live, scaled-down Month view in a given [MonthViewStyle], for the settings
- * chooser.
- *
- * It renders the *real* grid composables rather than a drawing of them, so the
- * preview cannot drift from the thing it depicts: change a cell's shape or an
- * event bar's colour and every preview follows automatically. The trick is
- * [requiredSize] — it ignores the incoming constraints, so the grid lays itself
- * out at a full phone width and a plausible viewport height, and a
- * [graphicsLayer] scale shrinks the finished layout into the card.
+ * and onboarding choosers.
  *
  * The month, today's position and the week start are all real; only the events
- * are stand-ins, since the settings screen has no business querying the
- * provider for a thumbnail.
+ * are stand-ins. See [ScaledViewPreview] for how the real grid composables get
+ * measured at phone size and shrunk into the card.
  */
 @Composable
 internal fun MonthStylePreview(
@@ -57,50 +34,11 @@ internal fun MonthStylePreview(
     height: Dp,
     modifier: Modifier = Modifier,
 ) {
-    val screenWidth = LocalConfiguration.current.screenWidthDp.dp
-    val scale = height.value / VIRTUAL_HEIGHT.value
     val zone = remember { TimeZone.currentSystemDefault() }
     val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
     val sample = remember(today, weekStart, zone) { sampleMonthState(today, weekStart, zone) }
 
-    Box(
-        modifier = modifier
-            .clipToBounds()
-            .background(MaterialTheme.colorScheme.surface)
-            // A preview is a picture, not a control: swallow touches before the
-            // grid's own clickables see them, and give screen readers one label
-            // instead of six weeks of day cells.
-            .pointerInput(Unit) {
-                awaitPointerEventScope {
-                    while (true) {
-                        awaitPointerEvent(PointerEventPass.Initial).changes
-                            .forEach { it.consume() }
-                    }
-                }
-            }
-            .clearAndSetSemantics { }
-            // Measure the grid at a full phone viewport but report the scaled
-            // size, so the node occupies exactly what it draws.
-            //
-            // Modifier.requiredSize would be the obvious way to force the larger
-            // measurement, but it *centres* content that overflows the incoming
-            // constraints — which pushed the grid to a negative offset and left
-            // only its bottom-right corner inside the clip.
-            .layout { measurable, _ ->
-                val fullWidth = screenWidth.roundToPx()
-                val fullHeight = VIRTUAL_HEIGHT.roundToPx()
-                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
-                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
-                    placeable.place(0, 0)
-                }
-            }
-            .graphicsLayer {
-                scaleX = scale
-                scaleY = scale
-                transformOrigin = TransformOrigin(0f, 0f)
-            },
-    ) {
-        Column(Modifier.fillMaxSize()) {
+    ScaledViewPreview(height = height, modifier = modifier) {
         WeekdayHeader(weekStart = weekStart, showWeekNumbers = false)
         when (style) {
             MonthViewStyle.Paged -> MonthGrid(
@@ -121,11 +59,10 @@ internal fun MonthStylePreview(
             MonthViewStyle.Dense -> DenseMonthGrid(
                 state = sample.continuous,
                 listState = rememberLazyListState(
-                            // Start a week above today's, so the preview shows a
-                            // stream running past the viewport rather than one
-                            // beginning at its top edge.
-                            initialFirstVisibleItemIndex =
-                                weekIndexOf(today, weekStart) - 1,
+                    // Start a week above today's, so the preview shows a stream
+                    // running past the viewport rather than one beginning at its
+                    // top edge.
+                    initialFirstVisibleItemIndex = weekIndexOf(today, weekStart) - 1,
                 ),
                 showWeekNumbers = false,
                 onOpenDay = {},
@@ -151,14 +88,7 @@ internal fun MonthStylePreview(
         }
     }
 }
-}
 
-/**
- * The viewport the preview pretends to be: a phone's width by the height a
- * calendar view gets under the top bar. Scaling from a fixed height keeps the
- * three styles comparable — each shows the same slice of screen.
- */
-private val VIRTUAL_HEIGHT = 440.dp
 private val SPLIT_PANE_HEIGHT = 170.dp
 
 private class SampleMonth(
@@ -170,9 +100,6 @@ private class SampleMonth(
  * A month's worth of stand-in events, laid out through the same
  * [layoutMonthWeeks] / [clipWeekToMonth] the live views use — so the preview
  * exercises the real span, lane and overflow logic rather than approximating it.
- *
- * Colours are raw ARGB on purpose: that is what the provider hands out for an
- * event, so a token here would misrepresent what the grid actually renders.
  */
 private fun sampleMonthState(
     today: LocalDate,
@@ -181,7 +108,7 @@ private fun sampleMonthState(
 ): SampleMonth {
     val ym = YearMonth(today.year, today.month)
     val first = LocalDate(ym.year, ym.month, 1)
-    val events = sampleEvents(first, today, zone)
+    val events = sampleMonthEvents(first, today, zone)
 
     val weeks = layoutMonthWeeks(ym, weekStart, events, zone)
     val month = MonthUiState.Success(
@@ -213,72 +140,3 @@ private fun sampleMonthState(
     )
     return SampleMonth(month, continuous)
 }
-
-private val SAMPLE_COLORS = listOf(
-    0xFF3F7BD4.toInt(),
-    0xFFCE5B4C.toInt(),
-    0xFF4E9A6A.toInt(),
-    0xFF8A63C7.toInt(),
-)
-
-private fun sampleEvents(
-    firstOfMonth: LocalDate,
-    today: LocalDate,
-    zone: TimeZone,
-): List<EventInstance> {
-    var id = 0L
-    fun next() = ++id
-
-    fun timed(day: LocalDate, hour: Int, length: Int, colorIndex: Int) = EventInstance(
-        instanceId = next(),
-        eventId = id,
-        calendarId = 1L,
-        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
-        start = day.atTime(hour, 0).toInstant(zone),
-        end = day.atTime(hour + length, 0).toInstant(zone),
-        isAllDay = false,
-        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
-        location = null,
-    )
-
-    fun allDay(from: LocalDate, days: Int, colorIndex: Int) = EventInstance(
-        instanceId = next(),
-        eventId = id,
-        calendarId = 1L,
-        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
-        // All-day events sit at UTC midnights with an exclusive end.
-        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
-        end = from.plus(days, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
-        isAllDay = true,
-        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
-        location = null,
-    )
-
-    // Spread across the month so most weeks carry something, with one multi-day
-    // bar to show a span bridging cells and a busy today for the split pane.
-    return buildList {
-        add(allDay(firstOfMonth.plus(9, DateTimeUnit.DAY), days = 3, colorIndex = 2))
-        add(timed(firstOfMonth.plus(1, DateTimeUnit.DAY), 9, 1, 0))
-        add(timed(firstOfMonth.plus(4, DateTimeUnit.DAY), 14, 2, 1))
-        add(timed(firstOfMonth.plus(7, DateTimeUnit.DAY), 11, 1, 3))
-        add(timed(firstOfMonth.plus(15, DateTimeUnit.DAY), 10, 1, 0))
-        add(timed(firstOfMonth.plus(18, DateTimeUnit.DAY), 16, 1, 2))
-        add(timed(firstOfMonth.plus(22, DateTimeUnit.DAY), 8, 2, 1))
-        add(timed(firstOfMonth.plus(25, DateTimeUnit.DAY), 13, 1, 3))
-        // Today, so the split pane's list and the grid's dots both have content.
-        add(timed(today, 9, 1, 0))
-        add(timed(today, 12, 1, 1))
-        add(timed(today, 15, 2, 3))
-    }
-}
-
-private val SAMPLE_TITLES = listOf(
-    "Standup",
-    "Lunch",
-    "Review",
-    "Gym",
-    "Call",
-    "Workshop",
-    "Dentist",
-    "Trip",
-)

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

@@ -67,6 +67,23 @@ fun MonthWeek.laneEvents(col: Int, day: LocalDate, laneCap: Int): List<EventInst
     return byLane.filterNotNull()
 }
 
+/**
+ * The event drawn in lane [lane] of column [col], or null for an empty slot.
+ * Unlike [laneEvents] the lanes are *not* compacted — this answers "what is under
+ * this point", so an empty lane above a seated bar has to stay empty (#68).
+ */
+fun MonthWeek.chipAt(col: Int, lane: Int, laneCap: Int): EventInstance? {
+    if (col !in days.indices || lane !in 0 until laneCap) return null
+    spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }?.let { return it.event }
+    val occupied = spans
+        .filter { it.lane < laneCap && col in it.startCol..it.endCol }
+        .map { it.lane }
+        .toSet()
+    val free = (0 until laneCap).filter { it !in occupied }
+    val index = free.indexOf(lane).takeIf { it >= 0 } ?: return null
+    return timedByDay[days[col]].orEmpty().take(free.size).getOrNull(index)
+}
+
 /**
  * The events on [day] that [laneEvents] had no lane left for — its exact
  * complement, in the same bars-then-pills order. Returned as events rather than

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/BackupStep.kt

@@ -0,0 +1,100 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CloudOff
+import androidx.compose.material.icons.filled.FolderOpen
+import androidx.compose.material.icons.filled.Schedule
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.BenefitRow
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+
+/**
+ * Wizard step shown only when everything you write to is a device-only calendar
+ * (#163): the events exist nowhere but this phone, so losing it loses them.
+ *
+ * The primary action picks a folder and switches automatic backup on in one go.
+ * Everything it sets is a normal Backup setting, adjustable afterwards.
+ */
+@Composable
+internal fun BackupStep(
+    onEnable: (Uri) -> Unit,
+    onSkip: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    val pickFolder = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.OpenDocumentTree(),
+    ) { uri ->
+        // Cancelling the picker decides nothing and leaves the step open.
+        uri?.let(onEnable)
+    }
+
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { IconHero(Icons.Filled.CloudOff) },
+        actions = {
+            Button(
+                onClick = { runCatching { pickFolder.launch(null) } },
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_backup_enable_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+            TextButton(
+                onClick = onSkip,
+                modifier = Modifier.fillMaxWidth(),
+            ) {
+                Text(stringResource(R.string.onboarding_backup_skip_button))
+            }
+        },
+    ) {
+        Text(
+            text = stringResource(R.string.onboarding_backup_title),
+            style = MaterialTheme.typography.headlineMedium,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.onboarding_backup_body),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+
+        Spacer(Modifier.height(OnboardingSpace.lg))
+
+        BenefitRow(
+            icon = Icons.Filled.FolderOpen,
+            title = stringResource(R.string.onboarding_backup_benefit_folder_title),
+            body = stringResource(R.string.onboarding_backup_benefit_folder_body),
+        )
+        Spacer(Modifier.height(OnboardingSpace.sm))
+        BenefitRow(
+            icon = Icons.Filled.Schedule,
+            title = stringResource(R.string.onboarding_backup_benefit_daily_title),
+            body = stringResource(R.string.onboarding_backup_benefit_daily_body),
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/BrandHero.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
@@ -9,6 +9,7 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -16,20 +17,25 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.colorResource
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 
+/** What, if anything, the brand mark is wearing in its corner. */
+internal enum class HeroBadge { Denied, Done }
+
 /**
  * The app's adaptive launcher mark, reconstructed as a large branded squircle —
  * the hero of the onboarding screens (floret-kit's OnboardingScaffold supplies
  * the shell; the mark stays app-local so each sibling keeps its own identity).
- * A lock badge overlays the corner when permission has been [denied].
+ * A [badge] overlays the corner where the screen has a verdict to give: blocked,
+ * or finished.
  */
 @Composable
-internal fun BrandHero(denied: Boolean) {
+internal fun BrandHero(badge: HeroBadge? = null) {
     Box(contentAlignment = Alignment.Center) {
         Box(
             modifier = Modifier
@@ -43,24 +49,56 @@ internal fun BrandHero(denied: Boolean) {
                 modifier = Modifier.fillMaxSize(),
             )
         }
-        if (denied) {
-            // A small lock badge sits over the corner to signal "blocked".
+        if (badge != null) {
+            val container = when (badge) {
+                HeroBadge.Denied -> MaterialTheme.colorScheme.errorContainer
+                HeroBadge.Done -> MaterialTheme.colorScheme.primaryContainer
+            }
+            val onContainer = when (badge) {
+                HeroBadge.Denied -> MaterialTheme.colorScheme.onErrorContainer
+                HeroBadge.Done -> MaterialTheme.colorScheme.onPrimaryContainer
+            }
             Box(
                 modifier = Modifier
                     .align(Alignment.BottomEnd)
                     .offset(x = 10.dp, y = 10.dp)
                     .size(44.dp)
                     .clip(CircleShape)
-                    .background(MaterialTheme.colorScheme.errorContainer),
+                    .background(container),
                 contentAlignment = Alignment.Center,
             ) {
                 Icon(
-                    imageVector = Icons.Filled.Lock,
+                    imageVector = when (badge) {
+                        HeroBadge.Denied -> Icons.Filled.Lock
+                        HeroBadge.Done -> Icons.Filled.Check
+                    },
                     contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onErrorContainer,
+                    tint = onContainer,
                     modifier = Modifier.size(24.dp),
                 )
             }
         }
     }
 }
+
+/**
+ * A single [icon] in the brand squircle — the same silhouette as [BrandHero],
+ * for the wizard steps that stand for a feature rather than for the app itself.
+ */
+@Composable
+internal fun IconHero(icon: ImageVector) {
+    Box(
+        modifier = Modifier
+            .size(128.dp)
+            .clip(RoundedCornerShape(34.dp))
+            .background(MaterialTheme.colorScheme.primaryContainer),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onPrimaryContainer,
+            modifier = Modifier.size(56.dp),
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/DoneStep.kt

@@ -0,0 +1,61 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+
+/**
+ * The wizard's closing screen (#163): the flow ends on a full screen saying so
+ * rather than dropping into the calendar mid-gesture, and the brand mark wears
+ * the check that the last step earned.
+ */
+@Composable
+internal fun DoneStep(
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { BrandHero(HeroBadge.Done) },
+        actions = {
+            Button(
+                onClick = onFinished,
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_done_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+        },
+    ) {
+        Text(
+            text = stringResource(R.string.onboarding_done_title),
+            style = MaterialTheme.typography.headlineMedium,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.onboarding_done_body),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingMotion.kt

@@ -0,0 +1,58 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.animation.ContentTransform
+import androidx.compose.animation.SizeTransform
+import androidx.compose.animation.core.FiniteAnimationSpec
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.IntOffset
+
+/**
+ * The M3 Expressive spatial spring the wizard's steps travel on. Read in
+ * composable scope so it can be captured by `AnimatedContent`'s non-composable
+ * transitionSpec lambda.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+internal fun rememberOnboardingSlideSpec(): FiniteAnimationSpec<IntOffset> =
+    MaterialTheme.motionScheme.defaultSpatialSpec()
+
+/**
+ * Moving between wizard steps (#163): the steps sit side by side and the whole
+ * width swipes across, position on a spring so the arriving step settles with a
+ * little give rather than stopping dead.
+ *
+ * No cross-fade, unlike the calendar's shared-axis paging: two steps have
+ * nothing in common, so fading one through the other smears. Both are opaque and
+ * travel in lockstep, showing one screen pushing the other off.
+ *
+ * @param slideDir     +1 = forward (incoming from the right), -1 = back.
+ * @param spec         spatial spec, typically [rememberOnboardingSlideSpec].
+ * @param fadeSpec     effects spec used for the whole transition under reduced
+ *                     motion.
+ * @param reduceMotion when true, drop the movement and cross-fade alone.
+ */
+internal fun onboardingSlideTransition(
+    slideDir: Int,
+    spec: FiniteAnimationSpec<IntOffset>,
+    fadeSpec: FiniteAnimationSpec<Float>,
+    reduceMotion: Boolean,
+): ContentTransform {
+    if (reduceMotion) {
+        return fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
+    }
+    val dir = if (slideDir == 0) 1 else slideDir
+    return ContentTransform(
+        targetContentEnter = slideInHorizontally(spec) { w -> dir * w },
+        initialContentExit = slideOutHorizontally(spec) { w -> -dir * w },
+        // Clipping to the animating container would shear both steps against the
+        // viewport edge as they pass; there is no size change here to contain.
+        sizeTransform = SizeTransform(clip = false),
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingPlan.kt

@@ -0,0 +1,116 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+/** One screen of the first-launch wizard (#163), in the order they are shown. */
+enum class OnboardingStep {
+    /** Required: nothing works without the calendar grant. */
+    Permission,
+
+    /** Whether Calendula delivers reminder notifications itself. */
+    Reminders,
+
+    /** Only when nothing you write to is synced anywhere — offers a backup. */
+    Backup,
+
+    /** Which view the app opens on, chosen from a live preview. */
+    View,
+
+    /** How the Month view lays itself out, chosen from a live preview. */
+    MonthStyle,
+
+    /** Only on an install that has calendars the device is hiding (#75). */
+    Visibility,
+
+    /** The closing screen: everything is answered and the app is ready. */
+    Done,
+}
+
+/**
+ * Which steps this install owes and where it has got to. [steps] is the whole
+ * flow — completed steps included — so the counter doesn't renumber as steps
+ * are finished; [current] is null once nothing is left and the app opens.
+ */
+data class OnboardingPlan(
+    val steps: List<OnboardingStep>,
+    val current: OnboardingStep?,
+) {
+    /** 1-based position of [current] in [steps], or 0 when the flow is done. */
+    val index: Int get() = steps.indexOf(current) + 1
+
+    val total: Int get() = steps.size
+
+    /** A one-step flow is not a wizard: there is nothing to count down. */
+    val showsProgress: Boolean get() = total > 1
+
+    /** The step before [current], or null at the start (and once finished). */
+    val previous: OnboardingStep? get() = steps.getOrNull(index - 2).takeIf { current != null }
+
+    /**
+     * Whether the wizard can step back. Everything is re-askable except the
+     * calendar grant, which belongs to the system — once given there is nothing
+     * for a back press to return to.
+     */
+    val canGoBack: Boolean get() = previous != null && previous != OnboardingStep.Permission
+}
+
+/**
+ * Work out the flow from what is stored.
+ *
+ * The optional steps belong to installs still working through their first run.
+ * Before the grant that can only be guessed, so one that has not answered the
+ * reminder step either counts as fresh — the same condition
+ * [de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs.armOnboardingWizard]
+ * commits to storage a moment later, and clears again on the closing screen so
+ * a later re-grant is only the permission step.
+ *
+ * [backupApplies] is null until the calendar list can be read, i.e. for the
+ * whole permission step; the backup step is assumed to apply until proven
+ * otherwise, so the flow can only ever get shorter — never sprout a step the
+ * counter had not accounted for.
+ *
+ * The month-style step is *not* conditional on Month being the chosen view:
+ * Month is reachable from the drawer whatever opens first, and a step that came
+ * and went as the view is picked would move the counter under the user on the
+ * step right before it.
+ *
+ * [visibilityArmed] carries the one-time notice that the device is hiding some
+ * calendars (#75) — the only optional step an *existing* install can be given,
+ * which is why it is not gated on `fresh`, and on its own it earns no closing
+ * screen.
+ */
+fun onboardingPlan(
+    hasPermission: Boolean,
+    remindersDone: Boolean,
+    wizardArmed: Boolean,
+    backupDone: Boolean,
+    viewDone: Boolean,
+    monthStyleDone: Boolean,
+    backupApplies: Boolean?,
+    visibilityArmed: Boolean = false,
+    visibilityDone: Boolean = false,
+    doneShown: Boolean = false,
+): OnboardingPlan {
+    val fresh = wizardArmed || (!hasPermission && !remindersDone)
+    val steps = buildList {
+        if (!hasPermission || fresh) add(OnboardingStep.Permission)
+        if (!remindersDone || fresh) add(OnboardingStep.Reminders)
+        if (fresh && backupApplies != false) add(OnboardingStep.Backup)
+        if (fresh) {
+            add(OnboardingStep.View)
+            add(OnboardingStep.MonthStyle)
+        }
+        if (visibilityArmed) add(OnboardingStep.Visibility)
+        if (fresh) add(OnboardingStep.Done)
+    }
+    val current = steps.firstOrNull { step ->
+        when (step) {
+            OnboardingStep.Permission -> !hasPermission
+            OnboardingStep.Reminders -> !remindersDone
+            OnboardingStep.Backup -> !backupDone
+            OnboardingStep.View -> !viewDone
+            OnboardingStep.MonthStyle -> !monthStyleDone
+            OnboardingStep.Visibility -> !visibilityDone
+            OnboardingStep.Done -> !doneShown
+        }
+    }
+    return OnboardingPlan(steps, current)
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingSteps.kt

@@ -0,0 +1,118 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.OnboardingProgress
+
+/**
+ * Renders the wizard's current [step] (#163). Each step commits its own answer
+ * through [viewModel], which then hands the host the next one.
+ */
+@Composable
+fun OnboardingSteps(
+    step: OnboardingStep,
+    plan: OnboardingPlan,
+    viewModel: OnboardingViewModel,
+    onPermissionGranted: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    // Collected for every step, not just the two that draw a preview: starting
+    // it when the picker composes would leave that step blank as it slides in.
+    val choice by viewModel.viewChoice.collectAsStateWithLifecycle()
+
+    // Coerced because the outgoing half of a transition may be a step the live
+    // plan has since dropped — the backup step goes once the calendars say it
+    // does not apply — and a "Step 0 of 3" flash is worse than a stale number.
+    val index = (plan.steps.indexOf(step) + 1).coerceAtLeast(1)
+    val progress: (@Composable () -> Unit)? = if (!plan.showsProgress) {
+        null
+    } else {
+        {
+            OnboardingProgress(
+                step = index,
+                total = plan.total,
+                label = stringResource(R.string.onboarding_step_counter, index, plan.total),
+            )
+        }
+    }
+
+    // The system back gesture does the same thing as the button, and stays off
+    // on the first step so back still leaves the app.
+    BackHandler(enabled = plan.canGoBack) { viewModel.goBack() }
+    val navigationIcon: (@Composable () -> Unit)? = if (!plan.canGoBack) {
+        null
+    } else {
+        {
+            IconButton(onClick = viewModel::goBack) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                    contentDescription = stringResource(R.string.onboarding_back),
+                )
+            }
+        }
+    }
+
+    when (step) {
+        OnboardingStep.Permission -> PermissionScreen(
+            onGranted = onPermissionGranted,
+            modifier = modifier,
+            progress = progress,
+        )
+        OnboardingStep.Reminders -> ReminderStep(
+            onFinished = viewModel::finishReminders,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+        OnboardingStep.Backup -> BackupStep(
+            onEnable = viewModel::enableAutoBackup,
+            onSkip = viewModel::skipBackup,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+        // The choice is null only until DataStore's first emission; rendering
+        // nothing for that frame beats a preview built on the wrong defaults.
+        OnboardingStep.View -> choice?.let {
+            ViewStep(
+                choice = it,
+                onSelect = viewModel::setDefaultView,
+                onFinished = viewModel::finishView,
+                modifier = modifier,
+                progress = progress,
+                navigationIcon = navigationIcon,
+            )
+        }
+        OnboardingStep.MonthStyle -> choice?.let {
+            MonthStyleStep(
+                choice = it,
+                onSelect = viewModel::setMonthViewStyle,
+                onFinished = viewModel::finishMonthStyle,
+                modifier = modifier,
+                progress = progress,
+                navigationIcon = navigationIcon,
+            )
+        }
+        OnboardingStep.Visibility -> VisibilityStep(
+            onFinished = viewModel::finishVisibility,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+        OnboardingStep.Done -> DoneStep(
+            onFinished = viewModel::finishOnboarding,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingViewModel.kt

@@ -0,0 +1,321 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import de.jeanlucmakiola.calendula.data.backup.BackupScheduler
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.calendar.CalendarVisibilityReconciler
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
+import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapLatest
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * Drives the first-launch wizard (#163): decides which steps this install owes
+ * (see [onboardingPlan]) and commits each answer.
+ *
+ * [plan] is null until the first stored emission, so the host renders nothing
+ * for that frame rather than flashing a step the user has already answered.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+class OnboardingViewModel @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val prefs: SettingsPrefs,
+    private val calendarPrefs: CalendarPrefs,
+    private val repository: CalendarRepository,
+    private val scanner: ReminderScanner,
+    private val visibilityReconciler: CalendarVisibilityReconciler,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    /** Null until the host reports it — assuming either way would flash a screen. */
+    private val permissionReported = MutableStateFlow<Boolean?>(null)
+
+    /**
+     * The grant as the rest of the flow sees it: published only once the wizard
+     * has been armed for it, since arming is a stored write and the frames
+     * before it lands would collapse the plan to its one-step form.
+     */
+    private val hasPermission: StateFlow<Boolean?> = permissionReported
+        .mapLatest { granted ->
+            if (granted == true) armWizardIfFresh()
+            granted
+        }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.Eagerly,
+            initialValue = null,
+        )
+
+    /**
+     * Whether the backup step applies: something of yours is worth exporting and
+     * nothing you write to is synced anywhere. Null while the calendar list
+     * cannot be read: every frame before the grant, and any read that fails —
+     * an empty list is also how a null cursor arrives, and guessing false there
+     * would drop the step for the whole session.
+     */
+    private val backupApplies: Flow<Boolean?> = hasPermission.flatMapLatest { granted ->
+        if (granted != true) {
+            flowOf(null)
+        } else {
+            repository.calendars()
+                .map { calendars -> if (calendars.isEmpty()) null else calendars.backupApplies() }
+                .catch { emit(null) }
+                .flowOn(io)
+        }
+    }
+
+    private val flags: Flow<OnboardingFlags> = combine(
+        prefs.reminderOnboardingDone,
+        prefs.onboardingWizardArmed,
+        prefs.onboardingBackupDone,
+        prefs.onboardingViewDone,
+        prefs.onboardingMonthStyleDone,
+        ::OnboardingFlags,
+    )
+
+    /** The closing steps' own flags, and whether the notice applies at all. */
+    private val closingFlags: Flow<ClosingFlags> = combine(
+        calendarPrefs.visibilityNoticePending.map { it == true },
+        prefs.onboardingVisibilityDone,
+        prefs.onboardingDoneShown,
+        ::ClosingFlags,
+    )
+
+    val plan: StateFlow<OnboardingPlan?> =
+        combine(hasPermission, flags, closingFlags, backupApplies) { granted, stored, closing, backup ->
+            granted?.let {
+                onboardingPlan(
+                    hasPermission = it,
+                    remindersDone = stored.remindersDone,
+                    wizardArmed = stored.wizardArmed,
+                    backupDone = stored.backupDone,
+                    viewDone = stored.viewDone,
+                    monthStyleDone = stored.monthStyleDone,
+                    backupApplies = backup,
+                    visibilityArmed = closing.visibilityArmed,
+                    visibilityDone = closing.visibilityDone,
+                    doneShown = closing.doneShown,
+                )
+            }
+        }.stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = null,
+        )
+
+    /** The current view preferences, for the view step's initial selection. */
+    val viewChoice: StateFlow<ViewChoice?> = combine(
+        prefs.defaultView,
+        prefs.monthViewStyle,
+        prefs.weekStart,
+        ::ViewChoice,
+    ).stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000L),
+        initialValue = null,
+    )
+
+    fun setHasPermission(granted: Boolean) {
+        permissionReported.value = granted
+    }
+
+    /**
+     * Arm the wizard for an install that has yet to answer the reminder step,
+     * whatever route the grant took. Gating this on the in-app grant would
+     * strand anyone who granted on Android's own settings screen and came back
+     * to a restarted process, leaving them the reminder step alone.
+     */
+    private suspend fun armWizardIfFresh() {
+        if (!prefs.reminderOnboardingDone.first()) prefs.armOnboardingWizard()
+    }
+
+    /**
+     * Record the in-app grant. The launch scan ran before it and bailed out
+     * without arming anything, so the first alarm would otherwise wait on the
+     * daily worker.
+     */
+    fun onPermissionGranted() {
+        scanner.scanInBackground()
+    }
+
+    /** Close the reminder step, recording whether notifications stay on. */
+    fun finishReminders(remindersEnabled: Boolean) {
+        viewModelScope.launch {
+            prefs.setRemindersEnabled(remindersEnabled)
+            prefs.setReminderOnboardingDone()
+            // Nothing else re-arms the scan: turning reminders off cancels the
+            // alarm (#75).
+            scanner.scan()
+        }
+    }
+
+    /**
+     * Re-ask the step before the current one, by clearing its answer. The plan
+     * derives the position from those answers, so un-setting one *is* the back
+     * navigation. The calendar grant belongs to the system and cannot be
+     * returned to, which [OnboardingPlan.canGoBack] already refuses.
+     */
+    fun goBack() {
+        viewModelScope.launch {
+            when (plan.value?.previous) {
+                OnboardingStep.Reminders -> prefs.setReminderOnboardingDone(false)
+                OnboardingStep.Backup -> prefs.setOnboardingBackupDone(false)
+                OnboardingStep.View -> prefs.setOnboardingViewDone(false)
+                OnboardingStep.MonthStyle -> prefs.setOnboardingMonthStyleDone(false)
+                OnboardingStep.Visibility -> prefs.setOnboardingVisibilityDone(false)
+                OnboardingStep.Done -> prefs.setOnboardingDoneShown(false)
+                OnboardingStep.Permission, null -> Unit
+            }
+        }
+    }
+
+    /** Close the backup step without setting anything up. */
+    fun skipBackup() {
+        viewModelScope.launch { prefs.setOnboardingBackupDone() }
+    }
+
+    /**
+     * Turn automatic backup on, writing to the folder the user just picked
+     * (taking a durable write grant so background runs can keep writing), and
+     * close the step.
+     */
+    fun enableAutoBackup(folder: Uri) {
+        viewModelScope.launch {
+            runCatching {
+                context.contentResolver.takePersistableUriPermission(
+                    folder,
+                    Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
+                )
+            }
+            prefs.setAutoBackupFolderUri(folder.toString())
+            prefs.setAutoBackupEnabled(true)
+            BackupScheduler.apply(
+                context = context,
+                enabled = true,
+                intervalMinutes = prefs.autoBackupIntervalMinutes.first(),
+                hasFolder = true,
+            )
+            // Immediate feedback: the first backup lands while onboarding runs.
+            BackupScheduler.runNow(context)
+            prefs.setOnboardingBackupDone()
+        }
+    }
+
+    fun setDefaultView(view: CalendarView) {
+        viewModelScope.launch { prefs.setDefaultView(view) }
+    }
+
+    fun setMonthViewStyle(style: MonthViewStyle) {
+        viewModelScope.launch { prefs.setMonthViewStyle(style) }
+    }
+
+    /** Close a picker step — the choice itself is saved as it is made. */
+    fun finishView() {
+        viewModelScope.launch { prefs.setOnboardingViewDone() }
+    }
+
+    fun finishMonthStyle() {
+        viewModelScope.launch { prefs.setOnboardingMonthStyleDone() }
+    }
+
+    /** Acknowledge the calendar-visibility notice (#75). */
+    fun finishVisibility() {
+        viewModelScope.launch {
+            prefs.setOnboardingVisibilityDone()
+            // Retiring the notice drops its step, so it waits until nothing
+            // follows — the count must not fall on the way to a later screen.
+            if (plan.value?.steps?.last() == OnboardingStep.Visibility) retireVisibilityNotice()
+        }
+    }
+
+    /** Close the wizard from its last screen. */
+    fun finishOnboarding() {
+        viewModelScope.launch {
+            prefs.finishOnboardingWizard()
+            retireVisibilityNotice()
+        }
+    }
+
+    /**
+     * Put the one-time visibility notice away for good — nothing else clears it
+     * now that the wizard owns it, and left standing it would keep its step in
+     * every later plan.
+     */
+    private suspend fun retireVisibilityNotice() {
+        if (calendarPrefs.visibilityNoticePending.first() == true) {
+            calendarPrefs.setVisibilityNoticePending(false)
+        }
+    }
+
+    /**
+     * Fold the retired app-local calendar visibility into the device's own, and
+     * arm the notice if this install has anything to announce. Runs whenever the
+     * app comes up holding the permission, however it was granted — one taken on
+     * Android's app-settings screen never reaches the permission step's callback.
+     */
+    fun reconcileCalendarVisibility() {
+        viewModelScope.launch { visibilityReconciler.run() }
+    }
+}
+
+/** The stored answers the plan is derived from. */
+private data class OnboardingFlags(
+    val remindersDone: Boolean,
+    val wizardArmed: Boolean,
+    val backupDone: Boolean,
+    val viewDone: Boolean,
+    val monthStyleDone: Boolean,
+)
+
+/** The tail of the flow: the visibility notice and the closing screen. */
+private data class ClosingFlags(
+    val visibilityArmed: Boolean,
+    val visibilityDone: Boolean,
+    val doneShown: Boolean,
+)
+
+/** What the view step starts from, and renders its previews with. */
+data class ViewChoice(
+    val defaultView: CalendarView,
+    val monthViewStyle: MonthViewStyle,
+    val weekStart: WeekStartPref,
+)
+
+/**
+ * True when this device holds events that live nowhere else: at least one local
+ * calendar worth exporting, and no writable synced calendar to carry them.
+ * A read-only subscription is not a backup, so it does not count.
+ */
+private fun List<CalendarSource>.backupApplies(): Boolean {
+    val exportable = any { it.isLocal && it.canModifyContents && !it.isManaged }
+    val syncedTarget = any { !it.isLocal && it.canModifyContents }
+    return exportable && !syncedTarget
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/PermissionScreen.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import de.jeanlucmakiola.floret.components.BenefitRow
 import de.jeanlucmakiola.floret.components.OnboardingScaffold
@@ -10,19 +10,15 @@ import android.net.Uri
 import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Arrangement
-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.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowForward
 import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.Lock
-import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
@@ -32,13 +28,11 @@ import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
@@ -52,6 +46,7 @@ private val CALENDAR_PERMISSIONS = arrayOf(
 fun PermissionScreen(
     onGranted: () -> Unit,
     modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
     viewModel: PermissionViewModel = hiltViewModel(),
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
@@ -76,6 +71,7 @@ fun PermissionScreen(
     when (state) {
         is PermissionUiState.Rationale -> RationaleContent(
             onRequest = { launcher.launch(CALENDAR_PERMISSIONS) },
+            progress = progress,
             modifier = modifier,
         )
         is PermissionUiState.Denied -> DeniedContent(
@@ -83,6 +79,7 @@ fun PermissionScreen(
                 viewModel.onRetry()
                 launcher.launch(CALENDAR_PERMISSIONS)
             },
+            progress = progress,
             modifier = modifier,
         )
         is PermissionUiState.Granted -> {
@@ -94,11 +91,14 @@ fun PermissionScreen(
 @Composable
 private fun RationaleContent(
     onRequest: () -> Unit,
+    progress: (@Composable () -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
     OnboardingScaffold(
         modifier = modifier,
-        hero = { BrandHero(denied = false) },
+        progress = progress,
+        topSpacing = OnboardingSpace.lg,
+        hero = { BrandHero() },
         actions = {
             Button(
                 onClick = onRequest,
@@ -116,16 +116,8 @@ private fun RationaleContent(
                     modifier = Modifier.size(20.dp),
                 )
             }
-            PrivacyFootnote()
         },
     ) {
-        Text(
-            text = stringResource(R.string.app_name).uppercase(),
-            style = MaterialTheme.typography.labelLarge,
-            color = MaterialTheme.colorScheme.primary,
-            letterSpacing = 2.sp,
-        )
-        Spacer(Modifier.height(OnboardingSpace.xs))
         Text(
             text = stringResource(R.string.permission_rationale_title),
             style = MaterialTheme.typography.headlineMedium,
@@ -139,14 +131,8 @@ private fun RationaleContent(
             textAlign = TextAlign.Center,
         )
 
-        Spacer(Modifier.height(OnboardingSpace.xl))
+        Spacer(Modifier.height(OnboardingSpace.lg))
 
-        BenefitRow(
-            icon = Icons.Filled.Lock,
-            title = stringResource(R.string.permission_benefit_private_title),
-            body = stringResource(R.string.permission_benefit_private_body),
-        )
-        Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
             icon = Icons.Filled.CalendarMonth,
             title = stringResource(R.string.permission_benefit_sync_title),
@@ -154,9 +140,9 @@ private fun RationaleContent(
         )
         Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
-            icon = Icons.Filled.VisibilityOff,
-            title = stringResource(R.string.permission_benefit_privacy_title),
-            body = stringResource(R.string.permission_benefit_privacy_body),
+            icon = Icons.Filled.Lock,
+            title = stringResource(R.string.permission_benefit_private_title),
+            body = stringResource(R.string.permission_benefit_private_body),
         )
     }
 }
@@ -164,12 +150,14 @@ private fun RationaleContent(
 @Composable
 private fun DeniedContent(
     onRetry: () -> Unit,
+    progress: (@Composable () -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
     val context = LocalContext.current
     OnboardingScaffold(
         modifier = modifier,
-        hero = { BrandHero(denied = true) },
+        progress = progress,
+        hero = { BrandHero(HeroBadge.Denied) },
         actions = {
             Button(
                 onClick = {
@@ -208,25 +196,3 @@ private fun DeniedContent(
         )
     }
 }
-
-@Composable
-private fun PrivacyFootnote() {
-    Row(
-        modifier = Modifier.fillMaxWidth().padding(top = 4.dp),
-        horizontalArrangement = Arrangement.Center,
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Icon(
-            imageVector = Icons.Filled.Lock,
-            contentDescription = null,
-            tint = MaterialTheme.colorScheme.onSurfaceVariant,
-            modifier = Modifier.size(14.dp),
-        )
-        Spacer(Modifier.width(6.dp))
-        Text(
-            text = stringResource(R.string.permission_privacy_footnote),
-            style = MaterialTheme.typography.labelMedium,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-        )
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/PermissionUiState.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 sealed interface PermissionUiState {
     data object Rationale : PermissionUiState

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/PermissionViewModel.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import androidx.lifecycle.ViewModel
 import dagger.hilt.android.lifecycle.HiltViewModel

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/ReminderStep.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import de.jeanlucmakiola.floret.components.BenefitRow
 import de.jeanlucmakiola.floret.components.OnboardingScaffold
@@ -8,34 +8,25 @@ import android.Manifest
 import android.os.Build
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.NotificationsActive
 import androidx.compose.material.icons.filled.ContentCopy
-import androidx.compose.material.icons.filled.Tune
 import androidx.compose.material3.Button
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import de.jeanlucmakiola.calendula.R
 
 /**
- * One-time onboarding step after the calendar grant (v1.4): explains that
+ * Wizard step after the calendar grant (v1.4): explains that
  * Calendula delivers reminder notifications itself, warns about duplicates
  * when a second calendar app has notifications on, and requests
  * `POST_NOTIFICATIONS` (a system dialog on API 33+ only; minSdk is 29).
@@ -45,9 +36,11 @@ import de.jeanlucmakiola.calendula.R
  * the Settings toggle re-requests it. "Not now" turns the in-app toggle off.
  */
 @Composable
-fun ReminderOnboardingScreen(
+fun ReminderStep(
     onFinished: (remindersEnabled: Boolean) -> Unit,
     modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
 ) {
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission(),
@@ -55,7 +48,10 @@ fun ReminderOnboardingScreen(
 
     OnboardingScaffold(
         modifier = modifier,
-        hero = { BellHero() },
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { IconHero(Icons.Filled.NotificationsActive) },
         actions = {
             Button(
                 onClick = {
@@ -80,13 +76,6 @@ fun ReminderOnboardingScreen(
             }
         },
     ) {
-        Text(
-            text = stringResource(R.string.app_name).uppercase(),
-            style = MaterialTheme.typography.labelLarge,
-            color = MaterialTheme.colorScheme.primary,
-            letterSpacing = 2.sp,
-        )
-        Spacer(Modifier.height(OnboardingSpace.xs))
         Text(
             text = stringResource(R.string.reminder_onboarding_title),
             style = MaterialTheme.typography.headlineMedium,
@@ -100,7 +89,7 @@ fun ReminderOnboardingScreen(
             textAlign = TextAlign.Center,
         )
 
-        Spacer(Modifier.height(OnboardingSpace.xl))
+        Spacer(Modifier.height(OnboardingSpace.lg))
 
         BenefitRow(
             icon = Icons.Filled.NotificationsActive,
@@ -113,30 +102,5 @@ fun ReminderOnboardingScreen(
             title = stringResource(R.string.reminder_benefit_duplicates_title),
             body = stringResource(R.string.reminder_benefit_duplicates_body),
         )
-        Spacer(Modifier.height(OnboardingSpace.sm))
-        BenefitRow(
-            icon = Icons.Filled.Tune,
-            title = stringResource(R.string.reminder_benefit_reversible_title),
-            body = stringResource(R.string.reminder_benefit_reversible_body),
-        )
-    }
-}
-
-/** A bell in the brand squircle — same silhouette as the permission hero. */
-@Composable
-private fun BellHero() {
-    Box(
-        modifier = Modifier
-            .size(128.dp)
-            .clip(RoundedCornerShape(34.dp))
-            .background(MaterialTheme.colorScheme.primaryContainer),
-        contentAlignment = Alignment.Center,
-    ) {
-        Icon(
-            imageVector = Icons.Filled.NotificationsActive,
-            contentDescription = null,
-            tint = MaterialTheme.colorScheme.onPrimaryContainer,
-            modifier = Modifier.size(56.dp),
-        )
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/ViewStep.kt

@@ -0,0 +1,209 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaViewPreview
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.calendula.ui.common.PickerDescription
+import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
+import de.jeanlucmakiola.calendula.ui.common.icon
+import de.jeanlucmakiola.calendula.ui.common.labelRes
+import de.jeanlucmakiola.calendula.ui.day.DayViewPreview
+import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
+import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
+import de.jeanlucmakiola.calendula.ui.month.descriptionRes
+import de.jeanlucmakiola.calendula.ui.month.labelRes
+import de.jeanlucmakiola.calendula.ui.week.WeekViewPreview
+import de.jeanlucmakiola.floret.components.GroupedListInset
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+import de.jeanlucmakiola.floret.components.GroupedRow
+import de.jeanlucmakiola.floret.components.SelectedCheck
+import de.jeanlucmakiola.floret.components.positionOf
+import de.jeanlucmakiola.floret.locale.currentLocale
+
+/**
+ * Wizard step: which view the app opens on (#163). Built like the Settings
+ * picker it mirrors — a live preview over connected grouped rows. Selecting
+ * applies immediately and leaves the step open; the preview is the confirmation.
+ */
+@Composable
+internal fun ViewStep(
+    choice: ViewChoice,
+    onSelect: (CalendarView) -> Unit,
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    val weekStart = choice.weekStart.resolveFirstDay(currentLocale())
+
+    StepPickerScaffold(
+        title = stringResource(R.string.onboarding_view_title),
+        onFinished = onFinished,
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+    ) {
+        StepPreview(selected = choice.defaultView) { view ->
+            when (view) {
+                CalendarView.Month -> MonthStylePreview(
+                    style = choice.monthViewStyle,
+                    weekStart = weekStart,
+                    height = PREVIEW_HEIGHT,
+                )
+                CalendarView.Week -> WeekViewPreview(weekStart = weekStart, height = PREVIEW_HEIGHT)
+                CalendarView.Day -> DayViewPreview(height = PREVIEW_HEIGHT)
+                CalendarView.Agenda -> AgendaViewPreview(height = PREVIEW_HEIGHT)
+            }
+        }
+        IMPLEMENTED_VIEWS.forEachIndexed { index, view ->
+            val isSelected = view == choice.defaultView
+            GroupedRow(
+                title = stringResource(view.labelRes),
+                position = positionOf(index, IMPLEMENTED_VIEWS.size),
+                selected = isSelected,
+                leading = {
+                    Icon(
+                        imageVector = view.icon,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                },
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = { onSelect(view) },
+            )
+        }
+    }
+}
+
+/**
+ * Wizard step: how the Month view lays itself out (#163). The same shape as
+ * [ViewStep] and as the Settings chooser this duplicates, down to the selected
+ * style's own blurb sitting under its preview rather than on every row.
+ */
+@Composable
+internal fun MonthStyleStep(
+    choice: ViewChoice,
+    onSelect: (MonthViewStyle) -> Unit,
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    val weekStart = choice.weekStart.resolveFirstDay(currentLocale())
+    val options = MonthViewStyle.entries
+
+    StepPickerScaffold(
+        title = stringResource(R.string.onboarding_month_style_title),
+        onFinished = onFinished,
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+    ) {
+        StepPreview(selected = choice.monthViewStyle) { style ->
+            MonthStylePreview(style = style, weekStart = weekStart, height = PREVIEW_HEIGHT)
+        }
+        PickerDescription(stringResource(choice.monthViewStyle.descriptionRes))
+        options.forEachIndexed { index, style ->
+            val isSelected = style == choice.monthViewStyle
+            GroupedRow(
+                title = stringResource(style.labelRes),
+                position = positionOf(index, options.size),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = { onSelect(style) },
+            )
+        }
+    }
+}
+
+/**
+ * The shell both picker steps share: the wizard chrome around a title and a
+ * full-bleed column, since grouped rows carry their own inset.
+ */
+@Composable
+private fun StepPickerScaffold(
+    title: String,
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+    body: @Composable ColumnScope.() -> Unit,
+) {
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.xs,
+        contentPadding = 0.dp,
+        // The preview gets the room it needs; Continue scrolls in under the
+        // options rather than pinning to the bottom.
+        scrollingActions = true,
+        hero = {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.headlineSmall,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = GroupedListInset),
+            )
+        },
+        actions = {
+            Button(
+                onClick = onFinished,
+                // Full-bleed step: the button takes the grouped rows' own inset
+                // and ends up as wide as the options above it.
+                modifier = Modifier
+                    .padding(horizontal = GroupedListInset)
+                    .fillMaxWidth()
+                    .height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_view_continue_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+        },
+        body = body,
+    )
+}
+
+/**
+ * The live preview, framed like the picker's. The wider gap below keeps the rows
+ * reading as a group of their own rather than as the preview's caption.
+ */
+@Composable
+private fun <T> StepPreview(selected: T, content: @Composable (T) -> Unit) {
+    ViewPreviewFrame(
+        selected = selected,
+        label = "step-preview",
+        modifier = Modifier.padding(top = OnboardingSpace.xs, bottom = OnboardingSpace.md),
+        content = content,
+    )
+}
+
+/** The same size the Settings chooser gives it. */
+private val PREVIEW_HEIGHT: Dp = 280.dp

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/VisibilityStep.kt

@@ -0,0 +1,65 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.VisibilityOff
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+
+/**
+ * Wizard step for the one-time notice that Calendula now follows the device's
+ * own per-calendar visibility and some of yours are switched off (#75, #163).
+ *
+ * Nothing to decide here — the app does not switch those calendars back on,
+ * since that would un-hide them everywhere else too.
+ */
+@Composable
+internal fun VisibilityStep(
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { IconHero(Icons.Filled.VisibilityOff) },
+        actions = {
+            Button(
+                onClick = onFinished,
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_visibility_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+        },
+    ) {
+        Text(
+            text = stringResource(R.string.calendars_visibility_notice_title),
+            style = MaterialTheme.typography.headlineMedium,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.calendars_visibility_notice_message),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/ReminderOnboardingViewModel.kt

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.permission
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * Gates the one-time reminder onboarding step (v1.4) shown after the calendar
- * grant. [onboardingDone] is null until DataStore's first emission so the
- * step neither flashes for users who completed it nor gets skipped.
- */
-@HiltViewModel
-class ReminderOnboardingViewModel @Inject constructor(
-    private val prefs: SettingsPrefs,
-    private val scanner: ReminderScanner,
-) : ViewModel() {
-
-    val onboardingDone: StateFlow<Boolean?> = prefs.reminderOnboardingDone
-        .map { done -> done as Boolean? }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = null,
-        )
-
-    /** Close the step, recording whether reminder notifications stay on. */
-    fun finish(remindersEnabled: Boolean) {
-        viewModelScope.launch {
-            prefs.setRemindersEnabled(remindersEnabled)
-            prefs.setReminderOnboardingDone()
-            // Nothing else re-arms the scan: turning reminders off cancels the
-            // alarm (#75).
-            scanner.scan()
-        }
-    }
-
-    /**
-     * Re-scan after the calendar permission is granted. The launch scan runs
-     * before the grant and bails out without arming anything, so without this
-     * the first alarm waits on the daily worker.
-     */
-    fun rearmAfterGrant() {
-        scanner.scanInBackground()
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchScreen.kt

@@ -1,67 +1,108 @@
 package de.jeanlucmakiola.calendula.ui.search
 
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.activity.compose.BackHandler
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.animateColorAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListScope
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.SearchOff
+import androidx.compose.material.icons.filled.SelectAll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Checkbox
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.MatchSpan
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.SearchHit
+import de.jeanlucmakiola.calendula.domain.SearchMonth
 import de.jeanlucmakiola.floret.identity.animateItemMotion
+import de.jeanlucmakiola.floret.identity.fadeThrough
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.components.SnackChip
+import de.jeanlucmakiola.floret.components.SnackChipHeight
+import de.jeanlucmakiola.floret.components.SnackChipMargin
 import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.RecurringScopeDialog
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.domain.spanFirstDay
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.floret.components.positionOf
+import kotlinx.coroutines.delay
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toJavaLocalDate
 import java.time.Instant as JavaInstant
@@ -69,11 +110,13 @@ import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
 
+/** How long the delete confirmation chip stays up, matching a short snackbar. */
+private const val CHIP_MILLIS = 4_000L
+
 /**
- * Full-text event search (top-bar entry). Type a query → matching events
- * (title / location / description) across the whole calendar, newest-relevant
- * first; tap a result to open its detail. A full-screen overlay hosted by
- * [de.jeanlucmakiola.calendula.ui.CalendarHost].
+ * Full-text event search over title / location / description: tap a result to
+ * open its detail, long-press to select several and delete them at once (#80).
+ * A full-screen overlay hosted by [de.jeanlucmakiola.calendula.ui.CalendarHost].
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -85,63 +128,79 @@ fun SearchScreen(
 ) {
     val query by viewModel.query.collectAsStateWithLifecycle()
     val state by viewModel.state.collectAsStateWithLifecycle()
+    val selection by viewModel.selection.collectAsStateWithLifecycle()
+    val deleteState by viewModel.deleteState.collectAsStateWithLifecycle()
     val focusRequester = remember { FocusRequester() }
     val keyboard = LocalSoftwareKeyboardController.current
+    val context = LocalContext.current
+    val inSelection = selection.isNotEmpty()
+    var showDeleteDialog by remember { mutableStateOf(false) }
 
-    // Each fresh open starts blank and straight into typing. The ViewModel is
-    // activity-scoped so it outlives the overlay; clearing on (re)enter is what
-    // resets a previous search. Peeking a result doesn't re-run this (the screen
-    // stays composed under the detail), so backing out keeps the query.
+    // The ViewModel is activity-scoped, so a re-enter is what resets the last
+    // search, its selection and any delete receipt still up. Peeking a result
+    // doesn't re-run this — the screen stays composed under the detail.
     LaunchedEffect(Unit) {
         viewModel.setQuery("")
+        viewModel.clearSelection()
+        viewModel.consumeDeleteResult()
+    }
+    // The field only exists out of selection mode, so a recreation that lands
+    // mid-selection has to wait for the clear above before it can be focused.
+    var focusPending by remember { mutableStateOf(true) }
+    LaunchedEffect(inSelection) {
+        if (inSelection || !focusPending) return@LaunchedEffect
+        focusPending = false
         focusRequester.requestFocus()
         keyboard?.show()
     }
+
+    // Same in-place WRITE_CALENDAR upgrade the detail screen does: a v1.0 install
+    // holds only READ_CALENDAR, and granting continues into the held delete.
+    var pendingWrite by remember { mutableStateOf<(() -> Unit)?>(null) }
+    val writePermissionLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.RequestPermission(),
+    ) { granted ->
+        if (granted) pendingWrite?.invoke()
+        pendingWrite = null
+    }
+    val requireWrite: (() -> Unit) -> Unit = { action ->
+        val granted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.WRITE_CALENDAR,
+        ) == PackageManager.PERMISSION_GRANTED
+        if (granted) {
+            action()
+        } else {
+            pendingWrite = action
+            writePermissionLauncher.launch(Manifest.permission.WRITE_CALENDAR)
+        }
+    }
+
+    // Back leaves selection mode before it leaves the screen, and without the
+    // predictive-back scale-out — that would read as search closing and snapping
+    // back. The two handlers are mutually exclusive on [inSelection].
+    BackHandler(enabled = inSelection) { viewModel.clearSelection() }
+
     Scaffold(
-        modifier = modifier.predictiveBack(onBack = onBack),
+        modifier = modifier.predictiveBack(onBack = onBack, enabled = !inSelection),
         containerColor = MaterialTheme.colorScheme.surface,
         topBar = {
-            TopAppBar(
-                title = {
-                    InlineTextField(
-                        value = query,
-                        onValueChange = viewModel::setQuery,
-                        placeholder = stringResource(R.string.search_hint),
-                        capitalization = KeyboardCapitalization.None,
-                        imeAction = ImeAction.Search,
+            SearchTopBar(
+                inSelection = inSelection,
+                query = query,
+                selectedCount = selection.size,
+                focusRequester = focusRequester,
+                onQueryChange = viewModel::setQuery,
                 onImeAction = { keyboard?.hide() },
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .focusRequester(focusRequester),
-                    )
-                },
-                navigationIcon = {
-                    IconButton(onClick = onBack) {
-                        Icon(
-                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
-                            contentDescription = stringResource(R.string.search_back),
-                        )
-                    }
-                },
-                actions = {
-                    if (query.isNotEmpty()) {
-                        IconButton(onClick = { viewModel.setQuery("") }) {
-                            Icon(
-                                imageVector = Icons.Default.Close,
-                                contentDescription = stringResource(R.string.search_clear),
-                            )
-                        }
-                    }
-                },
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.surface,
-                ),
+                onBack = onBack,
+                onCloseSelection = viewModel::clearSelection,
+                onSelectAll = viewModel::selectAll,
+                onDelete = { requireWrite { showDeleteDialog = true } },
             )
         },
     ) { padding ->
-        // imePadding shrinks the content by the keyboard, so the centered
-        // idle/empty message re-centres in the space above it (and the results
-        // list lifts clear of the keyboard too).
+        // imePadding so the idle/empty message re-centres above the keyboard and
+        // the results list lifts clear of it.
         Box(
             modifier = Modifier
                 .fillMaxSize()
@@ -158,52 +217,314 @@ fun SearchScreen(
                     text = stringResource(R.string.search_empty, s.query),
                 )
                 is SearchUiState.Results -> SearchResults(
-                    events = s.events,
+                    results = s,
+                    selection = selection,
+                    inSelection = inSelection,
                     onEventClick = onEventClick,
+                    onToggle = viewModel::toggleSelection,
                 )
             }
+            DeleteOutcomeChip(
+                deleteState = deleteState,
+                onConsume = viewModel::consumeDeleteResult,
+                modifier = Modifier.align(Alignment.BottomStart),
+            )
+        }
+    }
+
+    if (showDeleteDialog) {
+        val count = selection.size
+        // One decision for the whole batch: the scope question is only asked when
+        // a recurring event is in it, and one-offs ignore whatever comes back.
+        if (viewModel.selectionHasRecurring()) {
+            RecurringScopeDialog(
+                title = stringResource(R.string.event_delete_recurring_title),
+                onSelect = { scope ->
+                    showDeleteDialog = false
+                    viewModel.deleteSelected(scope)
+                },
+                onDismiss = { showDeleteDialog = false },
+            )
+        } else {
+            AlertDialog(
+                onDismissRequest = { showDeleteDialog = false },
+                title = {
+                    Text(pluralStringResource(R.plurals.search_delete_title, count, count))
+                },
+                text = { Text(stringResource(R.string.event_delete_body)) },
+                confirmButton = {
+                    TextButton(
+                        onClick = {
+                            showDeleteDialog = false
+                            viewModel.deleteSelected(RecurringWriteScope.AllEvents)
+                        },
+                    ) {
+                        Text(
+                            text = stringResource(R.string.event_detail_delete),
+                            color = MaterialTheme.colorScheme.error,
+                        )
+                    }
+                },
+                dismissButton = {
+                    TextButton(onClick = { showDeleteDialog = false }) {
+                        Text(stringResource(R.string.dialog_cancel))
+                    }
+                },
+            )
         }
     }
 }
 
+/**
+ * The search field and the contextual selection bar as one bar: the bar stays
+ * in place across the swap, easing its colour and fading its slots through.
+ */
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun SearchTopBar(
+    inSelection: Boolean,
+    query: String,
+    selectedCount: Int,
+    focusRequester: FocusRequester,
+    onQueryChange: (String) -> Unit,
+    onImeAction: () -> Unit,
+    onBack: () -> Unit,
+    onCloseSelection: () -> Unit,
+    onSelectAll: () -> Unit,
+    onDelete: () -> Unit,
+) {
+    val container by animateColorAsState(
+        targetValue = if (inSelection) {
+            MaterialTheme.colorScheme.surfaceContainerHigh
+        } else {
+            MaterialTheme.colorScheme.surface
+        },
+        animationSpec = MaterialTheme.motionScheme.fastEffectsSpec(),
+        label = "search-top-bar-color",
+    )
+    // Held past the selection emptying, so the count has something to draw while
+    // it fades out.
+    var lastCount by remember { mutableIntStateOf(0) }
+    if (selectedCount > 0) lastCount = selectedCount
+
+    // Read here so the non-composable transitionSpec lambdas can capture it.
+    val slotSwap = fadeThrough()
+
+    TopAppBar(
+        title = {
+            AnimatedContent(
+                targetState = inSelection,
+                transitionSpec = { slotSwap },
+                label = "search-top-bar-title",
+            ) { selecting ->
+                if (selecting) {
+                    Text(
+                        pluralStringResource(
+                            R.plurals.search_selected_count,
+                            lastCount,
+                            lastCount,
+                        ),
+                    )
+                } else {
+                    InlineTextField(
+                        value = query,
+                        onValueChange = onQueryChange,
+                        placeholder = stringResource(R.string.search_hint),
+                        capitalization = KeyboardCapitalization.None,
+                        imeAction = ImeAction.Search,
+                        onImeAction = onImeAction,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .focusRequester(focusRequester),
+                    )
+                }
+            }
+        },
+        navigationIcon = {
+            AnimatedContent(
+                targetState = inSelection,
+                transitionSpec = { slotSwap },
+                label = "search-top-bar-navigation",
+            ) { selecting ->
+                if (selecting) {
+                    IconButton(onClick = onCloseSelection) {
+                        Icon(
+                            imageVector = Icons.Default.Close,
+                            contentDescription = stringResource(R.string.search_selection_close),
+                        )
+                    }
+                } else {
+                    IconButton(onClick = onBack) {
+                        Icon(
+                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.search_back),
+                        )
+                    }
+                }
+            }
+        },
+        actions = {
+            AnimatedContent(
+                targetState = inSelection,
+                transitionSpec = { slotSwap },
+                label = "search-top-bar-actions",
+            ) { selecting ->
+                Row {
+                    if (selecting) {
+                        IconButton(onClick = onSelectAll) {
+                            Icon(
+                                imageVector = Icons.Default.SelectAll,
+                                contentDescription = stringResource(R.string.search_select_all),
+                            )
+                        }
+                        IconButton(onClick = onDelete) {
+                            Icon(
+                                imageVector = Icons.Default.Delete,
+                                contentDescription = stringResource(
+                                    R.string.search_delete_selected,
+                                ),
+                                tint = MaterialTheme.colorScheme.error,
+                            )
+                        }
+                    } else if (query.isNotEmpty()) {
+                        IconButton(onClick = { onQueryChange("") }) {
+                            Icon(
+                                imageVector = Icons.Default.Close,
+                                contentDescription = stringResource(R.string.search_clear),
+                            )
+                        }
+                    }
+                }
+            }
+        },
+        colors = TopAppBarDefaults.topAppBarColors(containerColor = container),
+    )
+}
+
+@OptIn(ExperimentalFoundationApi::class)
 @Composable
 private fun SearchResults(
-    events: List<EventInstance>,
+    results: SearchUiState.Results,
+    selection: Set<Long>,
+    inSelection: Boolean,
     onEventClick: (EventInstance) -> Unit,
+    onToggle: (Long) -> Unit,
 ) {
     LazyColumn(
         modifier = Modifier.fillMaxSize(),
-        contentPadding = PaddingValues(start = 16.dp, end = 16.dp, top = 8.dp, bottom = 96.dp),
+        // No horizontal inset: GroupedRow already insets itself.
+        contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
     ) {
-        itemsIndexed(
-            items = events,
-            key = { _, event -> event.eventId },
-        ) { index, event ->
-            SearchResultRow(
-                event = event,
-                position = positionOf(index, events.size),
-                modifier = animateItemMotion(),
-                onClick = { onEventClick(event) },
+        results.results.months.forEach { month ->
+            stickyHeader(key = "month-${month.year}-${month.monthNumber}") {
+                SearchSectionHeader(text = monthLabel(month))
+            }
+            hitRows(month.hits, results, selection, inSelection, onEventClick, onToggle)
+        }
+        // Held back from the calendar above: matched only in the notes.
+        if (results.results.inDescriptions.isNotEmpty()) {
+            stickyHeader(key = "in-descriptions") {
+                SearchSectionHeader(text = stringResource(R.string.search_in_descriptions))
+            }
+            hitRows(
+                results.results.inDescriptions,
+                results,
+                selection,
+                inSelection,
+                onEventClick,
+                onToggle,
             )
         }
     }
 }
 
+/** One section's rows, sharing a grouped-card run. */
+private fun LazyListScope.hitRows(
+    hits: List<SearchHit>,
+    results: SearchUiState.Results,
+    selection: Set<Long>,
+    inSelection: Boolean,
+    onEventClick: (EventInstance) -> Unit,
+    onToggle: (Long) -> Unit,
+) {
+    itemsIndexed(
+        items = hits,
+        key = { _, hit -> hit.event.eventId },
+    ) { index, hit ->
+        val event = hit.event
+        val deletable = results.isDeletable(event)
+        SearchResultRow(
+            hit = hit,
+            position = positionOf(index, hits.size),
+            modifier = animateItemMotion(),
+            selected = event.eventId in selection,
+            // A read-only calendar's row can't join a batch, so in selection
+            // mode it goes quiet rather than offering a checkbox that fails.
+            inSelection = inSelection,
+            selectable = deletable,
+            onClick = when {
+                inSelection && deletable -> ({ onToggle(event.eventId) })
+                inSelection -> null
+                else -> ({ onEventClick(event) })
+            },
+            onLongClick = { onToggle(event.eventId) }.takeIf { deletable && !inSelection },
+        )
+    }
+}
+
+/** Pinned section label, styled like the agenda's day headers. */
+@Composable
+private fun SearchSectionHeader(text: String) {
+    Surface(color = MaterialTheme.colorScheme.surface, modifier = Modifier.fillMaxWidth()) {
+        Text(
+            text = text,
+            style = MaterialTheme.typography.titleSmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 16.dp, bottom = 8.dp),
+        )
+    }
+}
+
+/** "August 2026" in the locale's own field order. */
+@Composable
+private fun monthLabel(month: SearchMonth): String {
+    val locale = currentLocale()
+    return remember(month.year, month.monthNumber, locale) {
+        localizedDateFormatter(locale, "LLLLy")
+            .format(java.time.LocalDate.of(month.year, month.monthNumber, 1))
+    }
+}
+
 @Composable
 private fun SearchResultRow(
-    event: EventInstance,
+    hit: SearchHit,
     position: Position,
     modifier: Modifier = Modifier,
-    onClick: () -> Unit,
+    selected: Boolean = false,
+    inSelection: Boolean = false,
+    selectable: Boolean = true,
+    onClick: (() -> Unit)?,
+    onLongClick: (() -> Unit)? = null,
 ) {
+    val event = hit.event
     val dark = isSystemInDarkTheme()
     val soften = LocalSoftenColors.current
+    // On a picked row the headline is already recoloured for the secondary
+    // container, so the match is carried by weight alone there.
+    val highlight = SpanStyle(
+        fontWeight = FontWeight.Bold,
+        color = if (selected) Color.Unspecified else MaterialTheme.colorScheme.primary,
+    )
     GroupedRow(
-        modifier = modifier,
-        title = event.title,
-        summary = searchSummary(event),
+        // Faded like a past event anywhere else in the app — search reaches back
+        // through the whole history.
+        modifier = if (hit.isPast) modifier.alpha(EventDimAlpha) else modifier,
+        title = marked(event.title, hit.titleSpans, highlight),
+        summary = searchSummary(hit, highlight),
         position = position,
         minHeight = 64.dp,
+        selected = selected,
+        dimmed = inSelection && !selectable,
         leading = {
             Box(
                 modifier = Modifier
@@ -212,21 +533,97 @@ private fun SearchResultRow(
                     .background(eventAccent(event.color, dark, soften)),
             )
         },
+        trailing = if (inSelection && selectable) {
+            {
+                Checkbox(
+                    checked = selected,
+                    onCheckedChange = null,
+                )
+            }
+        } else {
+            null
+        },
         onClick = onClick,
+        onLongClick = onLongClick,
     )
 }
 
-/** "Wed, 17 Jun 2026 · 09:00 · Office" — date, then time (or All day), then location. */
+/**
+ * The batch's receipt: how many went, and whether any refused. No Undo — the
+ * provider can't put a deleted event back.
+ */
 @Composable
-private fun searchSummary(event: EventInstance): String {
+private fun DeleteOutcomeChip(
+    deleteState: BulkDeleteUiState,
+    onConsume: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val message = when (deleteState) {
+        is BulkDeleteUiState.Done -> when {
+            deleteState.failed > 0 -> stringResource(
+                R.string.search_delete_partial,
+                deleteState.deleted,
+                deleteState.failed,
+            )
+            else -> pluralStringResource(
+                R.plurals.search_delete_done,
+                deleteState.deleted,
+                deleteState.deleted,
+            )
+        }
+        is BulkDeleteUiState.NeedsPermission -> if (deleteState.deleted > 0) {
+            stringResource(R.string.search_delete_denied_partial, deleteState.deleted)
+        } else {
+            stringResource(R.string.event_delete_write_denied)
+        }
+        else -> null
+    }
+    // Held past the state being consumed so the chip has something to draw while
+    // it springs back out.
+    val shown = remember { mutableStateOf("") }
+    if (message != null && shown.value != message) shown.value = message
+
+    LaunchedEffect(deleteState) {
+        if (message == null) return@LaunchedEffect
+        delay(CHIP_MILLIS)
+        onConsume()
+    }
+    Box(
+        modifier = modifier
+            .navigationBarsPadding()
+            .padding(start = SnackChipMargin, bottom = SnackChipMargin)
+            .height(SnackChipHeight),
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        SnackChip(visible = message != null, message = shown.value)
+    }
+}
+
+/** [text] with every matched run emphasised. */
+private fun marked(text: String, spans: List<MatchSpan>, style: SpanStyle): AnnotatedString =
+    if (spans.isEmpty()) {
+        AnnotatedString(text)
+    } else {
+        buildAnnotatedString {
+            append(text)
+            spans.forEach { addStyle(style, it.start, it.end) }
+        }
+    }
+
+/**
+ * "Wed, 17 Jun 2026 · 09:00 · Office", with a second line excerpting the
+ * description when that is where the query matched.
+ */
+@Composable
+private fun searchSummary(hit: SearchHit, highlight: SpanStyle): AnnotatedString {
+    val event = hit.event
     val locale = currentLocale()
     val zone = remember { ZoneId.systemDefault() }
     val start = remember(event.start, zone) {
         JavaInstant.ofEpochMilli(event.start.toEpochMilliseconds()).atZone(zone)
     }
-    // From the shared span rule, not [start]: an all-day event sits at UTC
-    // midnight and would name the day before west of UTC (#82). The clock time
-    // below stays device-zone — it is only rendered for timed events.
+    // From the span rule, not [start]: an all-day event sits at UTC midnight and
+    // would name the day before west of UTC (#82).
     val dateText = remember(event.start, event.end, event.isAllDay, locale) {
         DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
             .format(event.spanFirstDay(TimeZone.currentSystemDefault()).toJavaLocalDate())
@@ -237,8 +634,23 @@ private fun searchSummary(event: EventInstance): String {
     } else {
         remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }.format(start)
     }
-    val base = "$dateText · $timeText"
-    return event.location?.takeIf { it.isNotBlank() }?.let { "$base · $it" } ?: base
+    return buildAnnotatedString {
+        append("$dateText · $timeText")
+        event.location?.takeIf { it.isNotBlank() }?.let { location ->
+            append(" · ")
+            val offset = length
+            append(location)
+            hit.locationSpans.forEach {
+                addStyle(highlight, offset + it.start, offset + it.end)
+            }
+        }
+        hit.descriptionSnippet?.let { snippet ->
+            append("\n")
+            val offset = length
+            append(snippet.text)
+            snippet.spans.forEach { addStyle(highlight, offset + it.start, offset + it.end) }
+        }
+    }
 }
 
 @Composable

app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchViewModel.kt

@@ -6,6 +6,10 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.EventSearch
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.SearchResults
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.FlowPreview
@@ -14,12 +18,19 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
 import javax.inject.Inject
 
@@ -33,8 +44,30 @@ sealed interface SearchUiState {
     /** A query ran but matched nothing. */
     data class Empty(val query: String) : SearchUiState
 
-    /** Matches, ordered nearest-to-today first (upcoming ascending, then past descending). */
-    data class Results(val events: List<EventInstance>) : SearchUiState
+    /** Matches by month — see [de.jeanlucmakiola.calendula.domain.EventSearch]. */
+    data class Results(
+        val results: SearchResults,
+        /** Rows from these are kept out of selection rather than failing later. */
+        val readOnlyCalendarIds: Set<Long> = emptySet(),
+    ) : SearchUiState {
+        val events: List<EventInstance> get() = results.allHits.map { it.event }
+
+        fun isDeletable(event: EventInstance): Boolean =
+            event.calendarId !in readOnlyCalendarIds
+    }
+}
+
+/** Outcome of deleting the selected results (#80). */
+sealed interface BulkDeleteUiState {
+    data object Idle : BulkDeleteUiState
+
+    data object Deleting : BulkDeleteUiState
+
+    /** Terminal: [deleted] events went, [failed] wouldn't. */
+    data class Done(val deleted: Int, val failed: Int) : BulkDeleteUiState
+
+    /** WRITE_CALENDAR was revoked after [deleted] went; the rest wasn't tried. */
+    data class NeedsPermission(val deleted: Int) : BulkDeleteUiState
 }
 
 @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
@@ -47,17 +80,42 @@ class SearchViewModel @Inject constructor(
     private val _query = MutableStateFlow("")
     val query: StateFlow<String> = _query.asStateFlow()
 
-    val state: StateFlow<SearchUiState> = _query
-        .debounce(250L)
-        .map { it.trim() }
-        .distinctUntilChanged()
+    /** Bumped after a delete so the same query re-runs against the changed provider. */
+    private val _reload = MutableStateFlow(0)
+
+    private val _selection = MutableStateFlow<Set<Long>>(emptySet())
+
+    /** Event ids picked in selection mode; empty means the mode is off. */
+    val selection: StateFlow<Set<Long>> = _selection.asStateFlow()
+
+    private val _deleteState = MutableStateFlow<BulkDeleteUiState>(BulkDeleteUiState.Idle)
+    val deleteState: StateFlow<BulkDeleteUiState> = _deleteState.asStateFlow()
+
+    val state: StateFlow<SearchUiState> = combine(
+        _query.debounce(250L).map { it.trim() }.distinctUntilChanged(),
+        _reload,
+    ) { q, _ -> q }
         .mapLatest { q ->
             if (q.length < MIN_QUERY_LENGTH) {
                 SearchUiState.Idle
             } else {
-                val results = repository.searchEvents(q)
-                if (results.isEmpty()) SearchUiState.Empty(q)
-                else SearchUiState.Results(sortNearestFirst(results))
+                val now = Clock.System.now()
+                val zone = TimeZone.currentSystemDefault()
+                val results = EventSearch.search(
+                    candidates = repository.searchEvents(q),
+                    query = q,
+                    now = now,
+                    todayStart = now.toLocalDateTime(zone).date.atStartOfDayIn(zone),
+                    zone = zone,
+                )
+                if (results.isEmpty) {
+                    SearchUiState.Empty(q)
+                } else {
+                    SearchUiState.Results(
+                        results = results,
+                        readOnlyCalendarIds = readOnlyCalendarIds(),
+                    )
+                }
             }
         }
         .catch { emit(SearchUiState.Idle) }
@@ -65,13 +123,94 @@ class SearchViewModel @Inject constructor(
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000L), SearchUiState.Idle)
 
     fun setQuery(value: String) {
+        if (value != _query.value) _selection.value = emptySet()
         _query.value = value
     }
 
-    /** Soonest upcoming (and ongoing) first, then the most recent past. */
-    private fun sortNearestFirst(events: List<EventInstance>): List<EventInstance> {
-        val now = Clock.System.now()
-        val (upcoming, past) = events.partition { it.end >= now }
-        return upcoming.sortedBy { it.start } + past.sortedByDescending { it.start }
+    /** Toggle one result; the first pick is what turns selection mode on. */
+    fun toggleSelection(eventId: Long) {
+        val current = _selection.value
+        _selection.value = if (eventId in current) current - eventId else current + eventId
+    }
+
+    /** Pick every result that lives in a writable calendar. */
+    fun selectAll() {
+        val results = state.value as? SearchUiState.Results ?: return
+        _selection.value = results.events.filter(results::isDeletable).map { it.eventId }.toSet()
+    }
+
+    /** Leave selection mode. */
+    fun clearSelection() {
+        _selection.value = emptySet()
+    }
+
+    /** Whether the batch needs a [RecurringWriteScope] decision before it runs. */
+    fun selectionHasRecurring(): Boolean {
+        val results = state.value as? SearchUiState.Results ?: return false
+        val picked = _selection.value
+        return results.events.any { it.eventId in picked && it.isRecurring }
+    }
+
+    /**
+     * Delete every selected event. [scope] reaches the recurring ones only; a
+     * one-off always goes whole. One at a time, so a single failure doesn't take
+     * the rest with it — the tally lands in [deleteState].
+     */
+    fun deleteSelected(scope: RecurringWriteScope) {
+        if (_deleteState.value == BulkDeleteUiState.Deleting) return
+        val results = state.value as? SearchUiState.Results ?: return
+        val picked = _selection.value
+        val targets = results.events.filter { it.eventId in picked && results.isDeletable(it) }
+        if (targets.isEmpty()) return
+
+        viewModelScope.launch {
+            _deleteState.value = BulkDeleteUiState.Deleting
+            var deleted = 0
+            var failed = 0
+            var denied = false
+            for (event in targets) {
+                try {
+                    withContext(io) { deleteOne(event, scope) }
+                    deleted++
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: SecurityException) {
+                    denied = true
+                    break
+                } catch (e: Exception) {
+                    failed++
                 }
             }
+            _selection.value = emptySet()
+            _reload.value += 1
+            _deleteState.value = if (denied) {
+                BulkDeleteUiState.NeedsPermission(deleted = deleted)
+            } else {
+                BulkDeleteUiState.Done(deleted = deleted, failed = failed)
+            }
+        }
+    }
+
+    /** Reset [deleteState] after the screen showed the outcome. */
+    fun consumeDeleteResult() {
+        _deleteState.value = BulkDeleteUiState.Idle
+    }
+
+    private suspend fun deleteOne(event: EventInstance, scope: RecurringWriteScope) {
+        val begin = event.start.toEpochMilliseconds()
+        when {
+            !event.isRecurring -> repository.deleteEvent(event.eventId)
+            scope == RecurringWriteScope.ThisEvent ->
+                repository.deleteOccurrence(event.eventId, begin)
+            scope == RecurringWriteScope.ThisAndFollowing ->
+                repository.deleteEventFromOccurrence(event.eventId, begin)
+            else -> repository.deleteEvent(event.eventId)
+        }
+    }
+
+    private suspend fun readOnlyCalendarIds(): Set<Long> =
+        repository.calendars().first()
+            .filterNot { it.canModifyContents }
+            .map { it.id }
+            .toSet()
+}

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

@@ -1,24 +1,13 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
-import androidx.compose.animation.Crossfade
-import androidx.compose.animation.core.snap
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
+import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
 import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.calendula.ui.month.descriptionRes
@@ -27,7 +16,6 @@ import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import kotlinx.datetime.DayOfWeek
 
 /**
@@ -51,40 +39,22 @@ internal fun MonthViewStylePicker(
     onDismiss: () -> Unit,
 ) {
     val options = MonthViewStyle.entries
-    val reduceMotion = rememberReduceMotion()
     FullScreenPicker(
         title = stringResource(R.string.settings_month_view_style),
         onDismiss = onDismiss,
         predictiveBack = true,
     ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 12.dp, vertical = 8.dp)
-                .height(PREVIEW_HEIGHT),
-            contentAlignment = Alignment.Center,
-        ) {
-            Crossfade(
-                targetState = selected,
-                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+        ViewPreviewFrame(
+            selected = selected,
             label = "month-style-preview",
+            modifier = Modifier.padding(vertical = 8.dp),
         ) { shown ->
-                // The preview renders the real grid at phone size and scales it
-                // down, so its own corners are square — the frame rounds it.
-                Box(
-                    modifier = Modifier
-                        .clip(PREVIEW_SHAPE)
-                        .background(MaterialTheme.colorScheme.surface)
-                        .clipToBounds(),
-                ) {
             MonthStylePreview(
                 style = shown,
                 weekStart = weekStart,
                 height = PREVIEW_HEIGHT,
             )
         }
-            }
-        }
         // The selected style's own blurb lives here, under its preview, rather
         // than on every row — the rows stay single-line and dense, and the words
         // describe exactly what is being shown above.
@@ -109,4 +79,3 @@ internal fun MonthViewStylePicker(
 }
 
 private val PREVIEW_HEIGHT = 280.dp
-private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -302,13 +302,14 @@ private fun ReportProblemRow(position: Position) {
 @Composable
 private fun LanguageRow(position: Position) {
     val context = LocalContext.current
+    val supported = remember { AppLanguage.supportedTags(context, R.xml.locales_config) }
     // Setting a locale recreates the activity; mirror the choice locally so the
     // row updates instantly even before the recreation lands.
-    var current by remember { mutableStateOf(AppLanguage.currentTag()) }
+    var current by remember { mutableStateOf(AppLanguage.currentTag(supported)) }
     var showDialog by remember { mutableStateOf(false) }
 
     // null = follow the system; the rest are BCP-47 tags from locales_config.xml.
-    val options = remember { listOf<String?>(null) + AppLanguage.supportedTags(context, R.xml.locales_config) }
+    val options = remember(supported) { listOf<String?>(null) + supported }
 
     GroupedRow(
         title = stringResource(R.string.settings_language),

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

@@ -42,6 +42,8 @@ data class SettingsUiState(
     val showWeekNumbers: Boolean = false,
     /** Whether the jump-to-today control sits in the top bar instead of the FAB (#60). */
     val todayButtonInToolbar: Boolean = false,
+    /** Whether events can be dragged to another slot to reschedule them (#68, #173). */
+    val dragToReschedule: Boolean = true,
     /** How far ahead the in-app Agenda screen shows events (v2.11). */
     val agendaScreenRange: AgendaRange = AgendaRange.Month,
     /** How far ahead the agenda widget shows events (v2.11). */

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

@@ -145,9 +145,15 @@ class SettingsViewModel @Inject constructor(
                     prefs.showWeekNumbers,
                     prefs.agendaShowToday,
                     prefs.softenCalendarColors,
+                    combine(
                         prefs.todayButtonInToolbar,
-                ) { hourLines, weekNumbers, showToday, soften, todayInToolbar ->
-                    DisplayToggles(hourLines, weekNumbers, showToday, soften, todayInToolbar)
+                        prefs.dragToReschedule,
+                        ::Pair,
+                    ),
+                ) { hourLines, weekNumbers, showToday, soften, (todayInToolbar, dragToMove) ->
+                    DisplayToggles(
+                        hourLines, weekNumbers, showToday, soften, todayInToolbar, dragToMove,
+                    )
                 },
             ) { view, screenRange, widgetRange, timeFormat, toggles ->
                 ViewSettings(
@@ -157,6 +163,7 @@ class SettingsViewModel @Inject constructor(
                     agendaShowToday = toggles.agendaShowToday,
                     softenColors = toggles.softenColors,
                     todayButtonInToolbar = toggles.todayButtonInToolbar,
+                    dragToReschedule = toggles.dragToReschedule,
                 )
             },
             combine(
@@ -189,6 +196,7 @@ class SettingsViewModel @Inject constructor(
                 agendaShowToday = views.agendaShowToday,
                 softenColors = views.softenColors,
                 todayButtonInToolbar = views.todayButtonInToolbar,
+                dragToReschedule = views.dragToReschedule,
                 agendaShowRangeBar = misc.showRangeBar,
                 autofocusEventTitle = misc.autofocusEventTitle,
                 pastEventDisplay = misc.pastEventDisplay,
@@ -289,6 +297,7 @@ class SettingsViewModel @Inject constructor(
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
+        val dragToReschedule: Boolean,
     )
 
     private data class DisplayToggles(
@@ -297,6 +306,7 @@ class SettingsViewModel @Inject constructor(
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
+        val dragToReschedule: Boolean,
     )
 
     private data class MiscSettings(
@@ -534,6 +544,10 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setTodayButtonInToolbar(enabled) }
     }
 
+    fun setDragToReschedule(enabled: Boolean) {
+        viewModelScope.launch { prefs.setDragToReschedule(enabled) }
+    }
+
     /**
      * Switch the launcher label (#44). The card highlights at once, then settles
      * on what the component state reports; the writes are binder round-trips and

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

@@ -114,7 +114,7 @@ internal fun ViewsScreen(
         GroupedRow(
             title = stringResource(R.string.settings_dim_completed),
             summary = stringResource(R.string.settings_dim_completed_summary),
-            position = Position.Bottom,
+            position = Position.Middle,
             trailing = {
                 Switch(
                     checked = state.dimCompletedEvents,
@@ -123,6 +123,18 @@ internal fun ViewsScreen(
             },
             onClick = { viewModel.setDimCompletedEvents(!state.dimCompletedEvents) },
         )
+        GroupedRow(
+            title = stringResource(R.string.settings_drag_to_reschedule),
+            summary = stringResource(R.string.settings_drag_to_reschedule_summary),
+            position = Position.Bottom,
+            trailing = {
+                Switch(
+                    checked = state.dragToReschedule,
+                    onCheckedChange = viewModel::setDragToReschedule,
+                )
+            },
+            onClick = { viewModel.setDragToReschedule(!state.dragToReschedule) },
+        )
 
         Spacer(Modifier.height(8.dp))
         SectionHeader(stringResource(R.string.settings_month_header))

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

@@ -1,33 +1,21 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
-import androidx.compose.animation.Crossfade
-import androidx.compose.animation.core.snap
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
+import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
 import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 
 /**
@@ -46,39 +34,23 @@ internal fun WeekStartPicker(
     onDismiss: () -> Unit,
 ) {
     val locale = currentLocale()
-    val reduceMotion = rememberReduceMotion()
     val resolved = selected.resolveFirstDay(locale)
     FullScreenPicker(
         title = stringResource(R.string.settings_week_start),
         onDismiss = onDismiss,
         predictiveBack = true,
     ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 12.dp, vertical = 8.dp)
-                .height(PREVIEW_HEIGHT),
-            contentAlignment = Alignment.Center,
-        ) {
-            Crossfade(
-                targetState = resolved,
-                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+        ViewPreviewFrame(
+            selected = resolved,
             label = "week-start-preview",
+            modifier = Modifier.padding(vertical = 8.dp),
         ) { day ->
-                Box(
-                    modifier = Modifier
-                        .clip(PREVIEW_SHAPE)
-                        .background(MaterialTheme.colorScheme.surface)
-                        .clipToBounds(),
-                ) {
             MonthStylePreview(
                 style = monthStyle,
                 weekStart = day,
                 height = PREVIEW_HEIGHT,
             )
         }
-            }
-        }
         PickerDescription(stringResource(R.string.settings_week_start_hint))
         options.forEachIndexed { index, option ->
             val isSelected = option == selected
@@ -107,4 +79,3 @@ internal fun WeekStartPicker(
 
 /** Short enough to leave the first options on screen under it. */
 private val PREVIEW_HEIGHT = 200.dp
-private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -47,6 +47,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.key
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
@@ -63,13 +64,16 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.RectangleShape
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.customActions
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -85,6 +89,22 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
+import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
+import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
+import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.MoveRequest
+import de.jeanlucmakiola.calendula.ui.common.MoveTarget
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
+import de.jeanlucmakiola.calendula.ui.common.TimelineDrop
+import de.jeanlucmakiola.calendula.ui.common.beginsOn
+import de.jeanlucmakiola.calendula.ui.common.eventDragAllowed
+import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
+import de.jeanlucmakiola.calendula.ui.common.eventTitleOverflow
+import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.startInstant
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
@@ -105,8 +125,10 @@ import de.jeanlucmakiola.calendula.ui.common.MIN_TITLE_WRAP_WIDTH
 import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.ui.common.hourHeight
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
-import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
 import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.GUTTER_CONTENT_START_INSET
+import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
+import de.jeanlucmakiola.calendula.ui.common.HourGutter
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
@@ -123,16 +145,13 @@ import kotlin.time.Clock
 import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 
-private val GUTTER_WIDTH = 48.dp
-/** Start inset for the gutter's content (week badge + hour labels) so it centres
- *  on the top bar's hamburger: with a 48dp gutter, 8dp lands the centre at 28dp
- *  (the app bar's 4dp inset + 24dp half icon button). */
-private val GUTTER_CONTENT_START_INSET = 8.dp
 private val ALL_DAY_ROW_HEIGHT = 24.dp
 private val ALL_DAY_VERTICAL_PADDING = 6.dp
+/** Gap between day columns; part of the column pitch a drag maps positions through. */
+private val COLUMN_GAP = 2.dp
 
 /** Total all-day strip height for a week (0 when there are no all-day events). */
-private fun WeekUiState.Success.allDayStripHeight(): Dp {
+internal fun WeekUiState.Success.allDayStripHeight(): Dp {
     if (allDaySpans.isEmpty()) return 0.dp
     val lanes = allDaySpans.maxOf { it.lane } + 1
     return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
@@ -333,9 +352,16 @@ private fun WeekContent(
     // gestures coexist without fighting.
     val swipeModifier = rememberCalendarPageSwipe(onSwipeNext, onSwipePrev)
 
+    // Above the AnimatedContent: a page change mid-drag would strand the
+    // floating block inside the outgoing page.
+    val dragController = rememberTimelineDragController()
+    val move = LocalEventMove.current
+    val zone = remember { TimeZone.currentSystemDefault() }
+
+    Box(modifier = modifier) {
         AnimatedContent(
             targetState = state,
-        modifier = modifier.then(swipeModifier),
+            modifier = Modifier.fillMaxSize().then(swipeModifier),
             contentKey = { s ->
                 when (s) {
                     is WeekUiState.Success -> "success-${s.weekStart}"
@@ -354,23 +380,41 @@ private fun WeekContent(
                     topSectionColor = topSectionColor,
                     scrollState = scrollState,
                     allDayHeight = allDayHeight,
+                    dragController = dragController,
                     onEventClick = onEventClick,
                     onOpenDay = onOpenDay,
                     onCreateAt = onCreateAt,
+                    onDrop = { drop ->
+                        val took = move?.move(
+                            MoveRequest(
+                                eventId = drop.event.eventId,
+                                beginMillis = drop.event.start.toEpochMilliseconds(),
+                                endMillis = drop.event.end.toEpochMilliseconds(),
+                                target = MoveTarget.Start(drop.startInstant(zone)),
+                            ),
+                        )
+                        // Refused, so nothing will land: let the copy go now
+                        // rather than hold it out for a settle that never comes.
+                        if (took != true) dragController.release()
+                    },
                 )
             }
         }
+        TimelineDragOverlay(dragController)
+    }
 }
 
 @Composable
-private fun WeekSuccess(
+internal fun WeekSuccess(
     state: WeekUiState.Success,
     topSectionColor: Color,
     scrollState: ScrollState,
     allDayHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         Column(
@@ -387,8 +431,10 @@ private fun WeekSuccess(
         Timeline(
             state = state,
             scrollState = scrollState,
+            dragController = dragController,
             onEventClick = onEventClick,
             onCreateAt = onCreateAt,
+            onDrop = onDrop,
         )
     }
 }
@@ -610,11 +656,13 @@ private fun AllDayBar(
             .semantics { contentDescription = title },
         contentAlignment = Alignment.CenterStart,
     ) {
+        val titleOverflow = eventTitleOverflow()
         Text(
             text = title,
             style = MaterialTheme.typography.labelSmall,
             maxLines = 1,
-            overflow = TextOverflow.Ellipsis,
+            overflow = titleOverflow.overflow,
+            softWrap = titleOverflow.softWrap,
             color = eventInk(fill),
         )
     }
@@ -624,13 +672,15 @@ private fun AllDayBar(
 private fun Timeline(
     state: WeekUiState.Success,
     scrollState: ScrollState,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     val dark = isSystemInDarkTheme()
-    val use24Hour = LocalUse24HourFormat.current
-    val locale = currentLocale()
     val zoom = LocalTimelineZoom.current
+    val density = LocalDensity.current
+    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
 
     // BoxWithConstraints rather than Box: the fit-the-whole-day scale needs the
     // timeline's own viewport height, which is only known here — below the top
@@ -650,45 +700,39 @@ private fun Timeline(
         Row(modifier = Modifier.fillMaxSize().then(pinch)) {
             // Hour gutter (scrolls in sync with the day columns). Same start inset
             // as the header badge so the labels sit under it and on the hamburger.
-            Column(
-                modifier = Modifier
-                    .width(GUTTER_WIDTH)
-                    .padding(start = GUTTER_CONTENT_START_INSET)
-                    .fillMaxHeight()
-                    .verticalScroll(scrollState),
-            ) {
-                (0 until 24).forEach { h ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .height(hourHeight),
-                    ) {
-                        if (h > 0) {
-                            Text(
-                                text = formatHourLabel(h, use24Hour, locale),
-                                style = MaterialTheme.typography.labelSmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                modifier = Modifier
-                                    .align(Alignment.TopCenter)
-                                    .offset(y = (-6).dp),
+            HourGutter(
+                scrollState = scrollState,
+                hourHeight = hourHeight,
+                dragController = dragController,
             )
-                        }
-                    }
-                }
-            }
             // Day columns: rounded, clipped scroll viewport (permanent corners).
             Box(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
                     .clip(RoundedCornerShape(16.dp))
-                    .verticalScroll(scrollState),
+                    .verticalScroll(scrollState)
+                    .onGloballyPositioned { dragController.geometry.viewport = it },
             ) {
                 Row(
                     modifier = Modifier
                         .fillMaxWidth()
-                        .height(totalHeight),
-                    horizontalArrangement = Arrangement.spacedBy(2.dp),
+                        .height(totalHeight)
+                        // The scrolling content itself, so its root position
+                        // already folds in the scroll offset.
+                        .onGloballyPositioned { coords ->
+                            val gap = with(density) { COLUMN_GAP.toPx() }
+                            dragController.geometry.let {
+                                it.grid = coords
+                                it.scroll = scrollState
+                                it.hourPx = with(density) { hourHeight.toPx() }
+                                it.columnGapPx = gap
+                                it.columnWidthPx = (coords.size.width + gap) / state.days.size
+                                it.days = state.days
+                                it.isRtl = isRtl
+                            }
+                        },
+                    horizontalArrangement = Arrangement.spacedBy(COLUMN_GAP),
                 ) {
                     state.days.forEach { day ->
                         DayColumnCard(
@@ -697,8 +741,10 @@ private fun Timeline(
                             date = day,
                             today = state.today,
                             hourHeight = hourHeight,
+                            dragController = dragController,
                             onEventClick = onEventClick,
                             onCreateAt = onCreateAt,
+                            onDrop = onDrop,
                             modifier = Modifier
                                 .weight(1f)
                                 .fillMaxHeight(),
@@ -717,13 +763,19 @@ private fun DayColumnCard(
     date: LocalDate,
     today: LocalDate,
     hourHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val hourPx = with(LocalDensity.current) { hourHeight.toPx() }
     val showHourLines = LocalShowHourLines.current
     val hourLineColor = MaterialTheme.colorScheme.outlineVariant
+    // Tells a settled drop when this column has caught up with it.
+    LaunchedEffect(blocks, dragController.settling) {
+        dragController.noteGrid(date, blocks)
+    }
     // The tap detector outlives the composition that installed it — a pinch or a
     // Settings change moves the hour height without restarting it — so it reads
     // the height and the callback through state handles instead of capturing
@@ -758,24 +810,40 @@ private fun DayColumnCard(
         ) {
             val colWidth = maxWidth
             val minEventHeight = hourHeight * MIN_EVENT_FRACTION
+            // Keyed by event, so a block that changes time or lane is the *same*
+            // composable afterwards and tweens there. The ordinal disambiguates
+            // a column holding two occurrences of one series.
+            val ordinals = mutableMapOf<Long, Int>()
             blocks.forEach { block ->
+                val ordinal = ordinals.merge(block.event.eventId, 1, Int::plus)!! - 1
+                key(block.event.eventId, ordinal) {
                     val laneWidth = colWidth / block.laneCount
                     val top = hourHeight * (block.startMin / 60f)
                     val rawHeight = hourHeight * ((block.endMin - block.startMin) / 60f)
                     val height = if (rawHeight < minEventHeight) minEventHeight else rawHeight
+                    val place = animatedBlockPlacement(
+                        x = laneWidth * block.lane,
+                        y = top,
+                        width = laneWidth,
+                        height = height,
+                    )
                     EventBlock(
                         block = block,
                         dark = dark,
-                    height = height,
-                    width = laneWidth,
+                        height = place.height,
+                        width = place.width,
+                        date = date,
+                        dragController = dragController,
                         onClick = { onEventClick(block.event) },
+                        onDrop = onDrop,
                         modifier = Modifier
-                        .offset(x = laneWidth * block.lane, y = top)
-                        .width(laneWidth)
-                        .height(height)
+                            .offset(x = place.x, y = place.y)
+                            .width(place.width)
+                            .height(place.height)
                             .padding(horizontal = 1.dp),
                     )
                 }
+            }
             // Current-time line, on top of the events, only on today's column.
             if (date == today) {
                 NowLine(date = date, hourHeight = hourHeight)
@@ -790,7 +858,10 @@ private fun EventBlock(
     dark: Boolean,
     height: Dp,
     width: Dp,
+    date: LocalDate,
+    dragController: TimelineDragController,
     onClick: () -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
@@ -833,29 +904,51 @@ private fun EventBlock(
     val dimmed = dimCutoff != null && block.event.hasEnded(dimCutoff)
     val soften = LocalSoftenColors.current
     val fill = eventFill(block.event.color, dark, soften)
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val moveAction = eventMoveAction(block.event)
+    // A block clipped at the top continues from the previous day: its top edge
+    // is midnight, not the event's start, so dragging it would invent a time.
+    val draggable = eventDragAllowed(block.event) && block.beginsOn(date, zone)
+    val dragModifier = rememberEventDragSource(
+        enabled = draggable,
+        key = block.event.instanceId,
+        onPickUp = { pointer, blockRoot, _ -> dragController.begin(block, pointer, blockRoot) },
+        onMove = dragController::move,
+        onDrop = { dragController.finish()?.let(onDrop) },
+        onCancel = dragController::cancel,
+    )
+    val lifted = draggable && dragController.ghosts(block, date)
+    val ghost = ghostAlpha(lifted)
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
+            // The source stays put as a ghost while its floating copy travels.
+            .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
             .background(fill, RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
+            // After clickable, so it is the inner node and wins the main pass;
+            // the tap still works, since a drag consumes the up.
+            .then(dragModifier)
             .padding(horizontal = 4.dp, vertical = 2.dp)
-            .semantics { contentDescription = "$title, $timeLabel" },
+            .semantics {
+                contentDescription = "$title, $timeLabel"
+                if (moveAction != null) customActions = listOf(moveAction)
+            },
     ) {
         Column {
             if (showTitle) {
+                val titleOverflow = eventTitleOverflow(singleLine = titleMaxLines == 1)
                 Text(
                     text = title,
                     style = MaterialTheme.typography.labelMedium,
                     maxLines = titleMaxLines,
-                    overflow = TextOverflow.Ellipsis,
+                    overflow = titleOverflow.overflow,
+                    softWrap = titleOverflow.softWrap,
                     color = eventInk(fill, alpha = 0.85f),
                 )
             }
             if (showTime) {
-                Text(
-                    text = timeLabel,
-                    style = MaterialTheme.typography.labelSmall,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
+                BlockTimeLabel(
+                    label = timeLabel,
                     color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
                 )
             }

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

@@ -0,0 +1,78 @@
+package de.jeanlucmakiola.calendula.ui.week
+
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.sampleTimelineEvents
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.coroutines.flow.first
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+
+/**
+ * A live, scaled-down Week view for the onboarding view chooser. The week and
+ * today's column are real; only the events are stand-ins.
+ *
+ * The timeline is scrolled to the working day rather than to midnight — the
+ * live view centres on noon once it knows its own scroll range, which a preview
+ * that is never interacted with would otherwise never do.
+ */
+@Composable
+internal fun WeekViewPreview(
+    weekStart: DayOfWeek,
+    height: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
+    val state = remember(today, weekStart, zone) { sampleWeekState(today, weekStart, zone) }
+    val scrollState = rememberScrollState()
+    LaunchedEffect(Unit) {
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        // Half the scroll range is noon — the same centring the live view does.
+        scrollState.scrollTo(scrollState.maxValue / 2)
+    }
+
+    ScaledViewPreview(height = height, modifier = modifier) {
+        WeekSuccess(
+            state = state,
+            topSectionColor = MaterialTheme.colorScheme.surface,
+            scrollState = scrollState,
+            allDayHeight = state.allDayStripHeight(),
+            dragController = rememberTimelineDragController(),
+            onEventClick = {},
+            onOpenDay = {},
+            onCreateAt = { _, _ -> },
+            onDrop = {},
+        )
+    }
+}
+
+/** Sample week state, laid out through the same helpers the live view uses. */
+private fun sampleWeekState(
+    today: LocalDate,
+    weekStart: DayOfWeek,
+    zone: TimeZone,
+): WeekUiState.Success {
+    val start = today.startOfWeek(weekStart)
+    val days = (0 until 7).map { start.plus(it, DateTimeUnit.DAY) }
+    val events = sampleTimelineEvents(days, today, zone)
+    return WeekUiState.Success(
+        weekStart = start,
+        today = today,
+        days = days,
+        allDaySpans = layoutAllDay(events.filter { it.isAllDay }, days, zone),
+        timedByDay = days.associateWith { layoutDay(events, it, zone) },
+    )
+}

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

@@ -12,14 +12,14 @@
     <string name="state_failure_provider">Kalender konnte nicht gelesen werden.</string>
     <!-- Permission-Flow (F1) -->
     <string name="permission_rationale_title">Alle Termine, schön im Blick</string>
-    <string name="permission_rationale_body">Calendula braucht Zugriff auf deinen Kalender, um deine Termine zu zeigen und zu verwalten. Mehr braucht sie nicht um zu funktionieren — und nichts verlässt dein Gerät.</string>
+    <string name="permission_rationale_body">Calendula braucht Zugriff auf deinen Kalender, um deine Termine zu zeigen und zu verwalten.</string>
     <string name="permission_request_button">Kalender-Zugriff erlauben</string>
     <string name="permission_denied_title">Kalender-Zugriff abgelehnt</string>
     <string name="permission_denied_body">Ohne Kalender-Zugriff kann Calendula keine Termine anzeigen. Du kannst den Zugriff in den System-Einstellungen wieder erlauben.</string>
     <string name="permission_open_settings_button">System-Einstellungen öffnen</string>
     <string name="permission_retry_button">Erneut versuchen</string>
-    <string name="permission_benefit_private_title">Bleibt auf deinem Gerät</string>
-    <string name="permission_benefit_private_body">Deine Kalender werden lokal gelesen und verlassen das Telefon nie.</string>
+    <string name="permission_benefit_private_title">Datenschutz by Design</string>
+    <string name="permission_benefit_private_body">Keine Internetberechtigung, keine Telemetrie — nichts verlässt dein Telefon.</string>
     <string name="permission_benefit_sync_title">Alle Kalender vereint</string>
     <string name="permission_benefit_sync_body">Google, CalDAV, lokal — alles, was synchronisiert ist, erscheint automatisch.</string>
     <string name="permission_benefit_privacy_title">Kein Tracking, niemals</string>
@@ -310,9 +310,9 @@
     <string name="settings_language">App-Sprache</string>
     <string name="settings_language_auto">Systemstandard</string>
     <!-- Hub category subtitles -->
-    <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_appearance_subtitle">Theme, Farben, Schriftarten</string>
+    <string name="settings_event_form_subtitle">Standardfelder und Verhalten</string>
+    <string name="settings_notifications_subtitle">Erinnerungen und Zustellung</string>
     <string name="settings_section_about">Über</string>
     <string name="settings_license">Lizenz</string>
     <string name="settings_license_value">MIT</string>
@@ -424,7 +424,7 @@
     <string name="settings_calendar_reminders_title">Erinnerungen pro Kalender</string>
     <string name="settings_translate">Hilf beim Übersetzen</string>
     <string name="settings_translate_hint">Füge eine Sprache auf Weblate hinzu oder verbessere sie</string>
-    <string name="settings_views_subtitle">Schnellwechsellnopf und Menüreihenfolge</string>
+    <string name="settings_views_subtitle">Standartansicht, Anordnung, Menüreihenfolge</string>
     <string name="settings_special_dates_subtitle">Kontakte-Geburtstage und Jubiläen</string>
     <string name="settings_section_special_dates">Besondere Termine von Kontakten</string>
     <string name="settings_special_dates_enable">Kontakttermine anzeigen</string>
@@ -498,4 +498,154 @@
     <string name="event_edit_timezone_none">Keine Zeitzone passt zu “%1$s”</string>
     <string name="event_edit_timezone_local_time">%1$s deiner Zeit</string>
     <string name="import_reminder_prompt_title">Deine Standarterinnerung anwenden?</string>
+    <plurals name="import_reminder_prompt_body_existing">
+        <item quantity="one">Dieses Event wurde mit %1$d Erinnerung importiert.</item>
+        <item quantity="other">Dieses Event wurde mit %1$d Erinnerungen importiert.</item>
+    </plurals>
+    <string name="settings_widget_size">Agenda-Widget-Größe</string>
+    <string name="import_reminder_prompt_body_none">Dieser Termin wurde ohne eine Erinnerung importiert.</string>
+    <string name="import_reminder_prompt_apply">Standart anwenden</string>
+    <string name="settings_widgets_subtitle">Agenda-Widget, Schnelleinstellungen-Kachel</string>
+    <string name="import_reminder_prompt_keep">unverändert lassen</string>
+    <string name="event_access_public_summary">Jeder mit Zugriff sieht jedes Detail</string>
+    <string name="event_access_private_summary">Andere sehen nur das du beschäftigt bist</string>
+    <string name="event_edit_recurrence_next">Als nächstes: %1$s</string>
+    <string name="event_edit_recurrence_incomplete">Gebe eine Zahl zwischen 1 und 999 ein</string>
+    <string name="timeline_scale_custom">Benutzerdefiniert</string>
+    <string name="settings_calendar_duration_inherits">Standard (%1$s)</string>
+    <string name="settings_group_about">Über</string>
+    <string name="event_move_gone">Dieser Termin existiert nicht mehr</string>
+    <string name="duration_custom_max">Maximal %1$s</string>
+    <string name="reminder_day_yesterday">Gestern</string>
+    <string name="agenda_no_more_today">Keine Events mehr heute</string>
+    <string name="agenda_span_starts">Beginnt %1$s</string>
+    <string name="agenda_span_ends">Endet %1$s</string>
+    <string name="today_jump_action">Zu Heute springen</string>
+    <string name="event_move_action">Verschieben…</string>
+    <string name="event_move_recurring_title">Wiederkehrenden Termin verschieben</string>
+    <string name="event_move_occurrence_only">Die ganze Serie zu verschieben würde ändern, auf welche Tage sie fällt, deshalb kann nur dieser Termin verschoben werden.</string>
+    <string name="event_move_done">Verschoben auf %1$s</string>
+    <string name="event_move_undo">Rückgängig</string>
+    <string name="event_move_undone">Verschieben rückgängig gemacht</string>
+    <string name="event_move_failed">Termin konnte nicht verschoben werden</string>
+    <string name="event_move_write_denied">Calendula braucht Schreibzugriff, um Termine zu verschieben</string>
+    <string name="event_move_blocked_series_end">Ein Termin kann nicht über das Ende seiner Serie hinaus verschoben werden</string>
+    <string name="event_edit_recurrence_next_none">Diese Regel wiederholt sich nie</string>
+    <string name="event_access_default_summary">Was dieser Kalender normalerweise macht</string>
+    <string name="event_access_confidential_summary">Als vertraulich markiert; was das bedeutet, entscheidet das Kalenderkonto</string>
+    <string name="onboarding_step_counter">Schritt %1$d von %2$d</string>
+    <string name="onboarding_backup_title">Deine Termine liegen nur hier</string>
+    <string name="onboarding_backup_body">Nichts auf diesem Telefon wird mit einem Konto synchronisiert – geht es verloren, ist auch dein Kalender weg. Calendula kann eine Sicherung für dich schreiben.</string>
+    <string name="onboarding_backup_benefit_folder_title">Ein Ordner deiner Wahl</string>
+    <string name="onboarding_backup_benefit_folder_body">Sicherungen sind einfache .ics-Dateien – lege sie irgendwohin, wo synchronisiert wird, oder auf eine SD-Karte.</string>
+    <string name="onboarding_backup_benefit_daily_title">Einmal am Tag, von selbst</string>
+    <string name="onboarding_backup_benefit_daily_body">Calendula exportiert deine lokalen Kalender im Hintergrund. Wie oft, änderst du in den Einstellungen.</string>
+    <string name="onboarding_backup_enable_button">Ordner wählen und sichern</string>
+    <string name="onboarding_view_title">Was soll zuerst geöffnet werden?</string>
+    <string name="onboarding_month_style_title">Wie soll Monat aussehen?</string>
+    <string name="onboarding_view_continue_button">Weiter</string>
+    <string name="onboarding_visibility_button">Alles klar</string>
+    <string name="onboarding_done_title">Alles bereit</string>
+    <string name="onboarding_done_body">Deine Kalender sind eingerichtet. Alles, was du gerade gewählt hast, lässt sich später in den Einstellungen ändern.</string>
+    <string name="onboarding_done_button">Meinen Kalender öffnen</string>
+    <plurals name="search_selected_count">
+        <item quantity="one">%d ausgewählt</item>
+        <item quantity="other">%d ausgewählt</item>
+    </plurals>
+    <string name="search_in_descriptions">In Beschreibungen gefunden</string>
+    <string name="search_selection_close">Auswahl abbrechen</string>
+    <string name="search_select_all">Alle auswählen</string>
+    <string name="search_delete_selected">Ausgewählte löschen</string>
+    <string name="search_delete_partial">%1$d gelöscht, %2$d nicht</string>
+    <string name="search_delete_denied_partial">%1$d gelöscht, dann wurde der Schreibzugriff entzogen</string>
+    <string name="settings_theme_hint">Ob die App hell oder dunkel ist. Die Auswahl gilt sofort.</string>
+    <string name="settings_theme_system_summary">Aktuell %1$s</string>
+    <string name="settings_soften_colors">Kalenderfarben harmonisieren</string>
+    <string name="settings_soften_colors_summary">Behält den Farbton jedes Kalenders, gleicht aber seine Helligkeit an, damit jeder Termin lesbar bleibt und die Farben zusammenpassen. Ausschalten, um die Originalfarben aus der Kalenderquelle zu zeigen.</string>
+    <string name="settings_font_specimen_heading">Donnerstag, 14. Mai</string>
+    <string name="settings_font_specimen_body">Team-Besprechung um 10:00, danach Mittagessen mit Robin im Café am Marktplatz.</string>
+    <string name="settings_week_start_auto_summary">Aktuell %1$s</string>
+    <string name="settings_today_toolbar">Heute-Schaltfläche in der Symbolleiste</string>
+    <string name="settings_today_toolbar_summary">Zeigt die Schaltfläche für den Sprung zu heute in der Symbolleiste statt als schwebende Schaltfläche</string>
+    <string name="settings_app_name">App-Name</string>
+    <string name="settings_app_name_summary">Zeigt Calendula in deinem Launcher als „Kalender“. Nur der Name im Launcher ändert sich; das Symbol kann nach dem Wechsel an einer neuen Stelle liegen.</string>
+    <string name="settings_time_format_auto_summary">Folgt dem System: %1$s</string>
+    <string name="settings_timeline_scale">Stundenhöhe</string>
+    <string name="settings_timeline_scale_hint">Wie viel senkrechten Platz eine Stunde in der Wochen- und Tagesansicht einnimmt. Beide Ansichten teilen sich diese Einstellung. Du kannst die Zeitleiste auch mit zwei Fingern aufziehen, um jede Höhe dazwischen einzustellen.</string>
+    <string name="timeline_scale_fit_day">Ganzer Tag</string>
+    <string name="timeline_scale_fit_day_summary">Alle 24 Stunden auf einem Bildschirm, ohne Scrollen</string>
+    <string name="timeline_scale_compact">Kompakt</string>
+    <string name="timeline_scale_compact_summary">Mehr Stunden pro Bildschirm, kleinere Blöcke</string>
+    <string name="timeline_scale_regular">Normal</string>
+    <string name="timeline_scale_regular_summary">Der Standardabstand</string>
+    <string name="timeline_scale_comfortable">Komfortabel</string>
+    <string name="timeline_scale_comfortable_summary">Größere Blöcke, mehr Scrollen</string>
+    <string name="timeline_scale_custom_summary">Die Höhe, auf die du die Zeitleiste gezogen hast</string>
+    <string name="settings_past_events_sample_morning">Team-Besprechung</string>
+    <string name="settings_past_events_sample_midday">Mittagessen mit Robin</string>
+    <string name="settings_past_events_sample_evening">Chorprobe</string>
+    <string name="settings_widget_size_hint">Wie groß das Agenda-Widget auf dem Startbildschirm seinen Text zeichnet. Für das Monats-Widget gibt es keine Einstellung – sein Raster passt sich immer dem Platz an, den du ihm gibst.</string>
+    <string name="settings_widget_size_small">Klein</string>
+    <string name="settings_widget_size_medium">Mittel</string>
+    <string name="settings_widget_size_large">Groß</string>
+    <string name="settings_widget_size_extra_large">Sehr groß</string>
+    <string name="settings_widget_size_summary">Termintext %1$d%%</string>
+    <string name="settings_agenda_show_today">Heute immer zeigen</string>
+    <string name="settings_agenda_show_today_hint">Behält Heute oben in der Agenda und ihrem Widget, auch wenn für heute nichts mehr ansteht.</string>
+    <string name="settings_month_header">Monatsansicht</string>
+    <string name="settings_month_view_style">Stil der Monatsansicht</string>
+    <string name="month_style_paged">Seiten</string>
+    <string name="month_style_paged_summary">Ein Monat füllt den Bildschirm. Wische nach links oder rechts, um den Monat zu wechseln.</string>
+    <string name="month_style_continuous">Fortlaufende Monate</string>
+    <string name="month_style_continuous_summary">Jeder Monat steht unter seiner eigenen Überschrift, mit etwas Abstand zum nächsten.</string>
+    <string name="month_style_dense">Nahtlose Wochen</string>
+    <string name="month_style_dense_summary">Die Wochen laufen ohne Unterbrechung weiter, jeder Monat geht ohne Lücke direkt in den nächsten über.</string>
+    <string name="month_style_split">Geteilt</string>
+    <string name="month_style_split_summary">Ein kompaktes Raster markiert die Tage mit Terminen, und der angetippte Tag wird darunter aufgelistet.</string>
+    <string name="month_split_no_events">Nichts geplant</string>
+    <string name="month_split_expand">Ganzen Monat zeigen</string>
+    <string name="month_split_collapse">Termine des Tages zeigen</string>
+    <string name="settings_event_duration">Standarddauer</string>
+    <string name="settings_event_duration_hint">Wie lange ein neuer Termin dauert, bis du seine Endzeit änderst. Ganztägige Termine sind nicht betroffen.</string>
+    <string name="settings_calendar_durations_title">Dauer pro Kalender</string>
+    <string name="settings_calendar_durations_hint">Gib einem Kalender seine eigene Standarddauer – z. B. 8 Stunden für Arbeitsschichten.</string>
+    <string name="settings_calendar_duration_use_default">Standarddauer verwenden (%1$s)</string>
+    <string name="settings_allday_reminder_fires_at">Benachrichtigt um %1$s</string>
+    <string name="settings_group_look">Aussehen &amp; Verhalten</string>
+    <string name="settings_group_data">Daten</string>
+    <string name="settings_group_app">App</string>
+    <string name="settings_backup_subtitle">Export, Import, automatische Sicherung</string>
+    <string name="settings_section_widgets">Widgets &amp; Kacheln</string>
+    <string name="settings_widgets_hint">Einstellungen für die Widgets auf dem Startbildschirm und die Schnelleinstellungen-Kachel. Füge ein Widget hinzu, indem du lange auf den Startbildschirm drückst.</string>
+    <string name="settings_section_backup">Sicherung &amp; Wiederherstellung</string>
+    <string name="settings_views_all_header">Alle Ansichten</string>
+    <string name="settings_week_day_header">Woche &amp; Tag</string>
+    <string name="settings_default_view_hint">Die Ansicht, mit der Calendula startet.</string>
+    <string name="settings_week_start_hint">Der Tag, mit dem jede Woche beginnt – in allen Ansichten und Widgets.</string>
+    <string name="settings_time_format_hint">Wie Zeiten in der App geschrieben werden. Automatisch folgt deiner Systemeinstellung.</string>
+    <string name="settings_past_events_hint">Was die Agenda mit Terminen macht, die bereits vorbei sind.</string>
+    <string name="settings_dynamic_color_summary">Nimmt die Farben der App von deinem Hintergrundbild.</string>
+    <string name="settings_about_privacy">Datenschutzerklärung</string>
+    <string name="calendars_visibility_hint">Schalte einen Kalender aus, um ihn auf diesem Gerät zu verbergen – seine Termine verschwinden aus der App und er erinnert dich nicht mehr. Es ist derselbe Schalter, den deine anderen Kalender-Apps verwenden, sie verbergen ihn also ebenfalls. Nichts wird gelöscht, kein anderes Gerät ist betroffen, und du kannst ihn hier jederzeit wieder einschalten.</string>
+    <string name="calendars_visibility_a11y">„%1$s“ anzeigen</string>
+    <string name="calendars_visibility_notice_title">Einige Kalender sind ausgeschaltet</string>
+    <string name="calendars_visibility_notice_message">Calendula zeigt die Kalender, die für dieses Gerät eingeschaltet sind, und einige von deinen sind aus. Schalte sie unter Einstellungen → Kalender ein, um ihre Termine zu sehen.</string>
+    <string name="calendar_picker_missing_title">Fehlt ein Kalender?</string>
+    <string name="calendar_picker_missing_summary">Er kann ausgeschaltet, schreibgeschützt oder aus deinen Kontakten gefüllt sein – verwalte deine Kalender hier.</string>
+    <string name="calendars_state_read_only">Schreibgeschützt</string>
+    <string name="calendars_state_not_synced">Nicht auf dieses Gerät synchronisiert</string>
+    <string name="calendars_state_managed">Aus deinen Kontakten gefüllt</string>
+    <string name="calendars_managed_delete_locked">Dieser Kalender wird aus deinen Kontakten gefüllt, Calendula würde ihn bei der nächsten Synchronisierung neu anlegen. Schalte die besonderen Termine unter Einstellungen → Besondere Termine aus, um ihn zu löschen.</string>
+    <string name="calendars_account_from_source">%1$s (%2$s)</string>
+    <string name="duration_hours_minutes">%1$s %2$s</string>
+    <string name="onboarding_backup_skip_button">Nicht jetzt</string>
+    <string name="onboarding_back">Zurück</string>
+    <plurals name="search_delete_title">
+        <item quantity="one">%d Termin löschen?</item>
+        <item quantity="other">%d Termine löschen?</item>
+    </plurals>
+    <plurals name="search_delete_done">
+        <item quantity="one">%d Termin gelöscht</item>
+        <item quantity="other">%d Termine gelöscht</item>
+    </plurals>
 </resources>

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

@@ -0,0 +1,8 @@
+<resources>
+    <!-- Dark backdrop needs light status-bar icons; the base theme's `true` is
+         only right for the light window background. -->
+    <style name="Theme.Calendula" parent="Theme.AppCompat.DayNight.NoActionBar">
+        <item name="android:windowBackground">@color/window_background</item>
+        <item name="android:windowLightStatusBar">false</item>
+    </style>
+</resources>

app/src/main/res/values-pt-rBR/strings.xml

@@ -0,0 +1,210 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="backup_interval_units">
+        <item>Minutes</item>
+        <item>Hours</item>
+        <item>Days</item>
+        <item>Weeks</item>
+    </string-array>
+    <string name="state_loading">Carregando…</string>
+    <string name="app_name">Calendula</string>
+    <string name="state_failure_permission">O acesso ao calendário é necessário.</string>
+    <string name="state_failure_no_calendars">Nenhum calendário configurado.</string>
+    <string name="state_failure_no_calendars_action">Abrir configurações do calendário do sistema</string>
+    <string name="state_retry">Tentar novamente</string>
+    <string name="state_failure_permission_action">Conceder acesso</string>
+    <string name="app_tagline">Um calendário moderno.</string>
+    <string name="state_failure_unknown">Algo deu errado.</string>
+    <string name="state_failure_provider">Não foi possível ler o calendário.</string>
+    <string name="permission_rationale_title">Veja todos os seus eventos, lindamente</string>
+    <string name="permission_rationale_body">Calendula precisa acessar seu calendário para mostrar e gerenciar eventos. É tudo que ele pede — e nada sai do seu dispositivo.</string>
+    <string name="permission_request_button">Conceder acesso ao calendário</string>
+    <string name="permission_denied_title">Acesso ao calendário negado</string>
+    <string name="permission_denied_body">Calendula não consegue mostrar eventos sem acesso ao calendário. Você pode conceder novamente nas configurações do sistema.</string>
+    <string name="permission_open_settings_button">Abrir configurações do sistema</string>
+    <string name="permission_retry_button">Tentar novamente</string>
+    <string name="permission_benefit_private_title">Fica no seu dispositivo</string>
+    <string name="permission_benefit_private_body">Seus calendários são lidos localmente e nunca saem do celular.</string>
+    <string name="permission_benefit_sync_title">Todos os seus calendários, juntos</string>
+    <string name="permission_benefit_sync_body">Google, CalDAV, local — tudo sincronizado ao dispositivo apenas aparece.</string>
+    <string name="permission_benefit_privacy_title">Nenhum rastreamento, jamais</string>
+    <string name="permission_benefit_privacy_body">Zero telemetria, zero dados para análise, sem anúncios.</string>
+    <string name="permission_privacy_footnote">Fica no seu dispositivo · sem permissão de internet</string>
+    <string name="month_prev">Mês anterior</string>
+    <string name="month_next">Próximo mês</string>
+    <string name="month_today_action">Hoje</string>
+    <string name="month_more_actions">Mais ações</string>
+    <string name="month_open_menu">Abrir menu</string>
+    <string name="month_action_settings">Configurações</string>
+    <string name="month_a11y_today_prefix">Hoje</string>
+    <string name="week_today_action">Esta semana</string>
+    <string name="week_number_label">Sem</string>
+    <string name="day_today_action">Hoje</string>
+    <string name="event_detail_back">Voltar</string>
+    <string name="event_detail_edit">Editar</string>
+    <string name="event_detail_delete">Excluir</string>
+    <string name="event_detail_share">Compartilhar</string>
+    <string name="event_detail_duplicate">Duplicar</string>
+    <string name="event_share_chooser_title">Compartilhar evento</string>
+    <string name="event_share_failed">Não foi possível compartilhar este evento.</string>
+    <string name="event_delete_title">Excluir evento?</string>
+    <string name="event_delete_body">O evento sairá do calendário e de todos os aparelhos que o sincronizam.</string>
+    <string name="event_delete_recurring_title">Excluir evento recorrente</string>
+    <string name="event_delete_option_occurrence">Apenas este evento</string>
+    <string name="event_delete_option_following">Este evento e todos os próximos</string>
+    <string name="event_delete_option_series">Todos os eventos nesta série</string>
+    <string name="event_edit_recurring_title">Editar evento recorrente</string>
+    <string name="event_delete_failed">Não foi possível excluir o evento</string>
+    <string name="event_delete_write_denied">Calendula requer permissão de escrita para excluir eventos</string>
+    <string name="dialog_cancel">Cancelar</string>
+    <string name="dialog_ok">OK</string>
+    <string name="event_edit_new_title">Novo evento</string>
+    <string name="event_edit_close">Fechar</string>
+    <string name="event_edit_save">Salvar</string>
+    <string name="event_edit_title_hint">Adicionar título</string>
+    <string name="event_edit_managed_hint">Gerenciado por “%1$s” — o título, data e frequência são sincronizados dos seus contatos. Lembretes, locais e notas são seus para editar.</string>
+    <string name="event_edit_starts">Inicia</string>
+    <string name="event_edit_ends">Termina</string>
+    <string name="event_edit_error_end_before_start">Termina antes de iniciar</string>
+    <string name="event_edit_error_no_calendar">Nenhum calendário disponível para escrita</string>
+    <string name="event_edit_save_failed">Não foi possível salvar o evento</string>
+    <string name="event_edit_write_denied">Calendula requer permissão de escrita para criar eventos</string>
+    <string name="event_edit_more_fields">Mais campos</string>
+    <string name="event_edit_add">Adicionar</string>
+    <string name="event_edit_add_reminder">Adicionar lembrete</string>
+    <string name="event_edit_remove_reminder">Remover lembrete</string>
+    <string name="event_edit_attendees">Convidados</string>
+    <string name="event_edit_add_guest">Adicionar convidado</string>
+    <string name="event_edit_add_guest_hint">Adicionar convidado via e-mail…</string>
+    <string name="event_edit_add_guest_from_contacts">Adicionar dos contatos</string>
+    <string name="event_edit_location_from_contacts">Escolher endereço dos contatos</string>
+    <string name="event_edit_remove_guest">Remover convidado</string>
+    <string name="event_edit_attendee_required">Obrigatório</string>
+    <string name="event_edit_attendee_optional">Opcional</string>
+    <string name="event_edit_attendees_note_synced">Calendula não manda convites. Sua conta de calendário poderá enviar e-mails para os convidados quando sincronizar.</string>
+    <string name="event_edit_attendees_note_local">Armazenado neste dispositivo. Ninguém é notificado.</string>
+    <string name="event_edit_reminder_custom">Personalizado</string>
+    <string name="reminder_unit_minutes">minutos</string>
+    <string name="reminder_unit_hours">horas</string>
+    <string name="reminder_unit_days">dias</string>
+    <string name="reminder_unit_weeks">semanas</string>
+    <string name="event_edit_availability">Disponibilidade</string>
+    <string name="event_edit_visibility">Visibilidade</string>
+    <string name="event_edit_timezone_device">Fuso horário do dispositivo</string>
+    <string name="event_edit_timezone_device_summary">Segue onde você estiver</string>
+    <string name="event_edit_timezone_search">Buscar fusos</string>
+    <string name="event_edit_timezone_recent">Recente</string>
+    <string name="event_edit_timezone_all">Todos os fusos</string>
+    <string name="event_edit_timezone_none">Nenhum fuso horário encontrado com “%1$s”</string>
+    <string name="event_edit_timezone_local_time">%1$s seu horário</string>
+    <string name="event_edit_color">Cor</string>
+    <string name="event_edit_color_default">Cor do calendário</string>
+    <string name="event_edit_color_custom">Cor personalizada</string>
+    <string name="event_edit_color_reset">Redefinir</string>
+    <string name="event_edit_color_unsupported">Não disponível neste calendário</string>
+    <string name="event_edit_color_unsupported_hint">Este calendário não publica um esquema de cores. Você pode permitir cores personalizadas nas Configurações.</string>
+    <string name="event_edit_color_sync_warning">Este calendário pode remover ou sobrescrever a cor na próxima sincronização.</string>
+    <string name="event_edit_conflict_title">Evento alterado em outro lugar</string>
+    <string name="event_edit_conflict_body">Enquanto estava editando, este evento foi alterado — por sincronia ou por outro app. O que deve acontecer com suas mudanças?</string>
+    <string name="event_edit_conflict_overwrite">Salvar mudanças</string>
+    <string name="event_edit_conflict_overwrite_hint">Apenas campos editados sobrescrevem a mudança externa</string>
+    <string name="event_edit_conflict_discard">Descartar mudanças</string>
+    <string name="event_edit_conflict_discard_hint">Evento fica como está agora</string>
+    <string name="event_edit_gone_title">Evento excluído</string>
+    <string name="event_edit_gone_body">Este evento foi excluído enquanto isso, por exemplo, em outro aparelho. Suas mudanças não podem mais ser salvas.</string>
+    <string name="import_reminder_prompt_title">Aplicar seu lembrete padrão?</string>
+    <string name="import_reminder_prompt_body_none">Este evento foi importado sem lembretes.</string>
+    <plurals name="import_reminder_prompt_body_existing">
+        <item quantity="one">Este evento foi importado com %1$d lembrete.</item>
+        <item quantity="many">Este evento foi importado com %1$d lembretes.</item>
+        <item quantity="other">Este evento foi importado com %1$d lembretes.</item>
+    </plurals>
+    <string name="import_reminder_prompt_apply">Aplicar padrão</string>
+    <string name="import_reminder_prompt_keep">Manter assim</string>
+    <string name="event_edit_recurrence_none">Não se repete</string>
+    <string name="event_edit_recurrence_custom">Personalizado</string>
+    <string name="event_edit_recurrence_every">A cada</string>
+    <string name="recurrence_unit_days">dias</string>
+    <string name="recurrence_unit_weeks">semanas</string>
+    <string name="recurrence_unit_months">meses</string>
+    <string name="recurrence_unit_years">anos</string>
+    <string name="event_edit_recurrence_incomplete">Insira um número de 1 a 999</string>
+    <string name="event_edit_recurrence_next">Próximo: %1$s</string>
+    <string name="event_edit_recurrence_next_none">Esta regra nunca se repete</string>
+    <string name="event_edit_recurrence_ends">Termina</string>
+    <string name="event_edit_recurrence_end_never">Nunca</string>
+    <string name="event_edit_recurrence_end_until">Em uma data</string>
+    <string name="event_edit_recurrence_end_count">Após um número de vezes</string>
+    <string name="event_edit_recurrence_times">vezes</string>
+    <string name="event_edit_error_recurrence_ends_before_start">Repetições terminam antes do evento começar</string>
+    <string name="event_availability_busy">Ocupado</string>
+    <string name="event_access_default">Padrão</string>
+    <string name="event_access_public">Público</string>
+    <string name="event_detail_all_day">O dia todo</string>
+    <string name="event_detail_calendar">Calendário</string>
+    <string name="event_detail_calendar_unknown">Calendário desconhecido</string>
+    <string name="event_detail_location">Local</string>
+    <string name="event_detail_description">Descrição</string>
+    <string name="event_detail_attendees">Participantes</string>
+    <string name="event_detail_recurrence">Recorrência</string>
+    <string name="event_detail_recurring">Evento recorrente</string>
+    <string name="recurrence_daily">Todo dia</string>
+    <string name="recurrence_weekly">Toda semana</string>
+    <string name="recurrence_monthly">Todo mês</string>
+    <string name="recurrence_yearly">Todo ano</string>
+    <string name="recurrence_every_n_days">A cada %1$d dias</string>
+    <string name="recurrence_every_n_weeks">A cada %1$d semanas</string>
+    <string name="recurrence_every_n_months">A cada %1$d meses</string>
+    <string name="recurrence_every_n_years">A cada %1$d anos</string>
+    <string name="recurrence_on_days">%1$s em %2$s</string>
+    <string name="recurrence_with_until">%1$s até %2$s</string>
+    <string name="recurrence_with_count">%1$s, %2$d vezes</string>
+    <string name="event_detail_not_found">Este evento não existe mais.</string>
+    <string name="event_attendee_accepted">Aceitou</string>
+    <string name="event_attendee_declined">Rejeitou</string>
+    <string name="event_attendee_tentative">Não decidiu</string>
+    <string name="event_attendee_needs_action">Sem resposta</string>
+    <string name="event_attendee_unknown">—</string>
+    <string name="event_detail_reminders">Lembretes</string>
+    <string name="event_detail_timezone">Fuso horário</string>
+    <string name="event_status_cancelled">Cancelado</string>
+    <string name="event_availability_free">Disponível</string>
+    <string name="event_access_private">Privado</string>
+    <string name="event_access_confidential">Confidencial</string>
+    <string name="event_access_default_summary">O que este calendário normalmente faz</string>
+    <string name="event_access_public_summary">Todos com acesso veem tudo</string>
+    <string name="event_access_private_summary">Outros veem apenas que está ocupado</string>
+    <string name="event_access_confidential_summary">Marcado como confidencial; o que significa depende da conta</string>
+    <string name="event_attendee_organizer">Organizador</string>
+    <string name="event_attendee_optional">Opcional</string>
+    <string name="event_attendee_resource">Recurso</string>
+    <string name="event_detail_self_response">Sua resposta: %1$s</string>
+    <string name="reminder_at_time">Na hora do evento</string>
+    <string name="reminder_default">Lembrete padrão</string>
+    <plurals name="reminder_minutes">
+        <item quantity="one">%d minuto antes</item>
+        <item quantity="many">%d minutos antes</item>
+        <item quantity="other">%d minutos antes</item>
+    </plurals>
+    <plurals name="reminder_hours">
+        <item quantity="one">%d hora antes</item>
+        <item quantity="many">%d horas antes</item>
+        <item quantity="other">%d horas antes</item>
+    </plurals>
+    <plurals name="reminder_days">
+        <item quantity="one">%d dia antes</item>
+        <item quantity="many">%d dias antes</item>
+        <item quantity="other">%d dias antes</item>
+    </plurals>
+    <plurals name="reminder_weeks">
+        <item quantity="one">%d semana antes</item>
+        <item quantity="many">%d semanas antes</item>
+        <item quantity="other">%d semanas antes</item>
+    </plurals>
+    <plurals name="duration_minutes">
+        <item quantity="one">%d minuto</item>
+        <item quantity="many">%d minutos</item>
+        <item quantity="other">%d minutos</item>
+    </plurals>
+    <string name="settings_special_dates_grant">Conceder acesso</string>
+</resources>

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

@@ -18,16 +18,20 @@
 
     <!-- Permission flow (F1) -->
     <string name="permission_rationale_title">See all your events, beautifully</string>
-    <string name="permission_rationale_body">Calendula needs access to your calendar to show and manage your events. That\'s all it asks for up front — and nothing ever leaves your device.</string>
+    <string name="permission_rationale_body">Calendula needs access to your calendar to show and manage your events.</string>
     <string name="permission_request_button">Grant calendar access</string>
     <string name="permission_denied_title">Calendar access denied</string>
     <string name="permission_denied_body">Calendula cannot show events without calendar access. You can grant it again in the system settings.</string>
     <string name="permission_open_settings_button">Open system settings</string>
     <string name="permission_retry_button">Try again</string>
-    <string name="permission_benefit_private_title">Stays on your device</string>
-    <string name="permission_benefit_private_body">Your calendars are read locally and never leave the phone.</string>
+    <string name="permission_benefit_private_title">Private by design</string>
+    <string name="permission_benefit_private_body">No internet permission, no telemetry — nothing ever leaves your phone.</string>
     <string name="permission_benefit_sync_title">All your calendars, together</string>
     <string name="permission_benefit_sync_body">Google, CalDAV, local — anything synced to the device just appears.</string>
+    <!-- Unused since the wizard trim (#163) — the privacy point is now
+         permission_benefit_private_*. Kept until Weblate drops them from the
+         translations: removing a base key a translation still carries is a
+         fatal ExtraTranslation. -->
     <string name="permission_benefit_privacy_title">No tracking, ever</string>
     <string name="permission_benefit_privacy_body">Zero telemetry, zero analytics, no ads.</string>
     <string name="permission_privacy_footnote">Stays on your device · no internet permission</string>
@@ -65,6 +69,20 @@
     <string name="event_edit_recurring_title">Edit recurring event</string>
     <string name="event_delete_failed">Couldn\'t delete the event</string>
     <string name="event_delete_write_denied">Calendula needs write access to delete events</string>
+
+    <!-- Drag an event to another time or day (#68) -->
+    <string name="event_move_action">Move…</string>
+    <string name="event_move_recurring_title">Move recurring event</string>
+    <string name="event_move_occurrence_only">Moving the whole series would change which days it falls on, so only this event can move.</string>
+    <!-- %1$s is the new date and time, e.g. "Fri, 7 Aug, 09:00". -->
+    <string name="event_move_done">Moved to %1$s</string>
+    <string name="event_move_undo">Undo</string>
+    <string name="event_move_undone">Move undone</string>
+    <string name="event_move_failed">Couldn\'t move the event</string>
+    <string name="event_move_write_denied">Calendula needs write access to move events</string>
+    <string name="event_move_gone">That event no longer exists</string>
+    <string name="event_move_blocked_series_end">Can\'t move an event past the end of its series</string>
+
     <string name="dialog_cancel">Cancel</string>
     <string name="dialog_ok">OK</string>
 
@@ -254,6 +272,25 @@
     <!-- Shared event strings -->
     <string name="event_untitled">(No title)</string>
 
+    <!-- First-launch wizard (#163) -->
+    <string name="onboarding_step_counter">Step %1$d of %2$d</string>
+    <string name="onboarding_backup_title">Your events live only here</string>
+    <string name="onboarding_backup_body">Nothing on this phone syncs to an account, so losing it would lose your calendar. Calendula can write a backup for you.</string>
+    <string name="onboarding_backup_benefit_folder_title">A folder you choose</string>
+    <string name="onboarding_backup_benefit_folder_body">Backups are plain .ics files — put them somewhere that syncs, or on an SD card.</string>
+    <string name="onboarding_backup_benefit_daily_title">Once a day, by itself</string>
+    <string name="onboarding_backup_benefit_daily_body">Calendula exports your local calendars in the background. Change how often in Settings.</string>
+    <string name="onboarding_backup_enable_button">Choose folder and back up</string>
+    <string name="onboarding_backup_skip_button">Not now</string>
+    <string name="onboarding_view_title">What should open first?</string>
+    <string name="onboarding_month_style_title">How should Month look?</string>
+    <string name="onboarding_view_continue_button">Continue</string>
+    <string name="onboarding_back">Back</string>
+    <string name="onboarding_visibility_button">Got it</string>
+    <string name="onboarding_done_title">You\'re all set</string>
+    <string name="onboarding_done_body">Your calendars are ready. Everything you just chose can be changed later in Settings.</string>
+    <string name="onboarding_done_button">Open my calendar</string>
+
     <!-- Reminder notifications (v1.4) -->
     <string name="reminder_channel_name">Event reminders</string>
     <string name="reminder_channel_description">Notifications at the reminder times of your events</string>
@@ -263,6 +300,7 @@
     <string name="reminder_benefit_delivery_body">Every reminder on your events arrives as a notification, right on time.</string>
     <string name="reminder_benefit_duplicates_title">Using a second calendar app?</string>
     <string name="reminder_benefit_duplicates_body">If another app also posts reminders, you\'ll see them twice — turn them off there or here.</string>
+    <!-- Unused since the wizard trim (#163); see the note above. -->
     <string name="reminder_benefit_reversible_title">Change it anytime</string>
     <string name="reminder_benefit_reversible_body">The switch lives in Settings, under Notifications.</string>
     <string name="reminder_onboarding_enable_button">Turn on reminders</string>
@@ -304,6 +342,26 @@
     <string name="search_idle_hint">Search your events by title, location or notes.</string>
     <string name="search_empty">No events match “%1$s”.</string>
 
+    <!-- Selecting search results to delete several at once (#80) -->
+    <plurals name="search_selected_count">
+        <item quantity="one">%d selected</item>
+        <item quantity="other">%d selected</item>
+    </plurals>
+    <string name="search_in_descriptions">Found in descriptions</string>
+    <string name="search_selection_close">Cancel selection</string>
+    <string name="search_select_all">Select all</string>
+    <string name="search_delete_selected">Delete selected</string>
+    <plurals name="search_delete_title">
+        <item quantity="one">Delete %d event?</item>
+        <item quantity="other">Delete %d events?</item>
+    </plurals>
+    <plurals name="search_delete_done">
+        <item quantity="one">%d event deleted</item>
+        <item quantity="other">%d events deleted</item>
+    </plurals>
+    <string name="search_delete_partial">%1$d deleted, %2$d couldn\'t be</string>
+    <string name="search_delete_denied_partial">%1$d deleted, then write access was withdrawn</string>
+
     <!-- Home-screen widgets -->
     <string name="widget_agenda_title">Upcoming</string>
     <string name="widget_agenda_label">Calendula agenda</string>
@@ -381,6 +439,8 @@
     <string name="timeline_scale_custom_summary">The height you pinched the timeline to</string>
     <string name="settings_dim_completed">Dim completed events</string>
     <string name="settings_dim_completed_summary">Fade events that have already ended in month and week view</string>
+    <string name="settings_drag_to_reschedule">Drag to reschedule</string>
+    <string name="settings_drag_to_reschedule_summary">Move an event by dragging it to another day or time</string>
     <string name="settings_past_events">Past events</string>
     <string name="settings_past_events_show">Show</string>
     <string name="settings_past_events_dim">Dim</string>
@@ -563,7 +623,7 @@
     <string name="calendars_visibility_hint">Turn a calendar off to hide it on this device — its events disappear from the app and it stops reminding you. This is the same switch your other calendar apps use, so they hide it too. Nothing is deleted, no other device is affected, and you can turn it back on here anytime.</string>
     <string name="calendars_visibility_a11y">Show \"%1$s\"</string>
     <string name="calendars_visibility_notice_title">Some calendars are switched off</string>
-    <string name="calendars_visibility_notice_message">Calendula now shows the calendars that are switched on for this device, so what you see and what reminds you can no longer disagree. Some of yours are currently off — they were switched off here or in another calendar app. Turn any of them back on in Settings → Calendars.</string>
+    <string name="calendars_visibility_notice_message">Calendula shows the calendars that are switched on for this device, and some of yours are off. To see their events, switch them on under Settings → Calendars.</string>
     <!-- Footer row under the event-form and .ics import calendar pickers. -->
     <string name="calendar_picker_missing_title">Missing a calendar?</string>
     <string name="calendar_picker_missing_summary">It may be switched off, read-only, or filled from your contacts — manage your calendars here.</string>

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

@@ -5,8 +5,6 @@
          Compose theme; this is essentially the launch/backdrop theme. -->
     <style name="Theme.Calendula" parent="Theme.AppCompat.DayNight.NoActionBar">
         <item name="android:windowBackground">@color/window_background</item>
-        <item name="android:statusBarColor">@android:color/transparent</item>
-        <item name="android:navigationBarColor">@android:color/transparent</item>
         <item name="android:windowLightStatusBar">true</item>
     </style>
 </resources>

app/src/main/res/xml/locales_config.xml

@@ -15,5 +15,6 @@
     <locale android:name="fr" />
     <locale android:name="it" />
     <locale android:name="pl" />
+    <locale android:name="pt-BR" />
     <locale android:name="zh-CN" />
 </locale-config>

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt

@@ -11,6 +11,7 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
 import kotlinx.datetime.LocalDate
@@ -451,15 +452,15 @@ class CalendarRepositoryImplTest {
             calendarsResult = listOf(makeCal(1L), makeCal(2L, visible = false), makeCal(3L))
             searchResult = {
                 listOf(
-                    makeEvent(10L, "Shown", calendarId = 1L),
-                    makeEvent(11L, "Switched off", calendarId = 2L),
-                    makeEvent(12L, "Hidden", calendarId = 3L),
+                    SearchCandidate(makeEvent(10L, "Shown", calendarId = 1L)),
+                    SearchCandidate(makeEvent(11L, "Switched off", calendarId = 2L)),
+                    SearchCandidate(makeEvent(12L, "Hidden", calendarId = 3L)),
                 )
             }
         }
         val repo = CalendarRepositoryImpl(fake, prefs, newSettings(tempDir), Dispatchers.Unconfined)
 
-        assertThat(repo.searchEvents("e").map { it.title }).containsExactly("Shown")
+        assertThat(repo.searchEvents("e").map { it.event.title }).containsExactly("Shown")
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt

@@ -5,6 +5,7 @@ import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.realignRecurrence
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
@@ -285,6 +286,88 @@ class EventWriteMapperTest {
             .isEqualTo(instantAt("2026-01-09T14:30", "Europe/Berlin"))
     }
 
+    @Test
+    fun `a weekday move must carry the rule with the anchor, or the series stays put`() {
+        // The anchor moves by the same shift as the occurrence, while RRULE is
+        // written verbatim: without realignRecurrence nothing moves.
+        val series = instantAt("2026-01-05T09:00", "Europe/Berlin")
+        val original = form(
+            start = LocalDateTime(LocalDate(2026, 6, 8), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 8), LocalTime(10, 0)),
+        ).copy(rrule = "FREQ=WEEKLY;BYDAY=MO")
+        val moved = original.copy(
+            start = LocalDateTime(LocalDate(2026, 6, 10), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 10), LocalTime(10, 0)),
+            rrule = realignRecurrence("FREQ=WEEKLY;BYDAY=MO", LocalDate(2026, 6, 8), LocalDate(2026, 6, 10)),
+        )
+
+        val values = update(original, moved, series)
+
+        val anchor = java.time.Instant.ofEpochMilli(values[CalendarContract.Events.DTSTART] as Long)
+            .atZone(java.time.ZoneId.of("Europe/Berlin"))
+        assertThat(anchor.dayOfWeek).isEqualTo(java.time.DayOfWeek.WEDNESDAY)
+        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=WEEKLY;BYDAY=WE")
+    }
+
+    @Test
+    fun `a recurring move keeps the series' length across a DST boundary`() {
+        // The occurrence being dragged is in CET; the series anchor is in CEST.
+        val series = instantAt("2026-07-15T09:00", "Europe/Berlin")
+        val original = form(
+            start = LocalDateTime(LocalDate(2026, 1, 7), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 1, 7), LocalTime(10, 30)),
+        ).copy(rrule = "FREQ=WEEKLY")
+        val moved = original.copy(
+            start = LocalDateTime(LocalDate(2026, 1, 8), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 1, 8), LocalTime(10, 30)),
+        )
+
+        assertThat(update(original, moved, series)[CalendarContract.Events.DURATION])
+            .isEqualTo("P5400S")
+    }
+
+    @Test
+    fun `shifting a one-off event and back again restores the original values`() {
+        val original = form()
+        val moved = original.copy(
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(14, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(15, 0)),
+        )
+
+        val forward = update(original, moved)
+        val back = update(moved, original)
+
+        assertThat(back[CalendarContract.Events.DTSTART])
+            .isEqualTo(original.toWriteTimes(berlin).dtStartMillis)
+        assertThat(back[CalendarContract.Events.DTEND])
+            .isEqualTo(original.toWriteTimes(berlin).dtEndMillis)
+        assertThat(forward[CalendarContract.Events.DTSTART])
+            .isNotEqualTo(back[CalendarContract.Events.DTSTART])
+    }
+
+    @Test
+    fun `undoing a whole-series move lands the anchor back where it started`() {
+        // What makes undo safe for "all events": the shift is applied to the
+        // anchor the provider currently holds, so re-issuing it with the two
+        // forms swapped applies the exact inverse to the moved anchor.
+        val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
+        val original = form(
+            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
+        ).copy(rrule = "FREQ=WEEKLY")
+        val moved = original.copy(
+            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 30)),
+            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 30)),
+        )
+
+        val movedAnchor = update(original, moved, series)[CalendarContract.Events.DTSTART] as Long
+        assertThat(movedAnchor).isNotEqualTo(series)
+
+        val restored = update(moved, original, movedAnchor)
+        assertThat(restored[CalendarContract.Events.DTSTART]).isEqualTo(series)
+        assertThat(restored[CalendarContract.Events.DURATION]).isEqualTo("P3600S")
+    }
+
     @Test
     fun `switching a recurring event to all-day anchors the series on a UTC midnight`() {
         val series = instantAt("2026-01-07T09:00", "Europe/Berlin")

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt

@@ -6,6 +6,7 @@ import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
@@ -19,7 +20,7 @@ internal class FakeCalendarDataSource : CalendarDataSource {
 
     var calendarsResult: List<CalendarSource> = emptyList()
     var instancesResult: (Long, Long) -> List<EventInstance> = { _, _ -> emptyList() }
-    var searchResult: (String) -> List<EventInstance> = { _ -> emptyList() }
+    var searchResult: (String) -> List<SearchCandidate> = { _ -> emptyList() }
     var eventDetailResult: (Long) -> EventDetail? = { null }
     var eventColorPaletteResult: (Long) -> List<EventColorOption> = { emptyList() }
     var exportableEventsResult: List<IcsEvent> = emptyList()
@@ -29,6 +30,10 @@ internal class FakeCalendarDataSource : CalendarDataSource {
     var existingUidsResult: Set<String> = emptySet()
     /** Set to make the next write call throw. */
     var writeError: Exception? = null
+
+    /** Deletes let through before [writeError] applies, for part-way failures. */
+    var deletesBeforeError: Int = 0
+    private var deletes = 0
     /** Id returned by the next [insertEvent]. */
     var nextInsertId: Long = 100L
 
@@ -71,7 +76,7 @@ internal class FakeCalendarDataSource : CalendarDataSource {
     }
     override fun instances(beginMillis: Long, endMillis: Long): List<EventInstance> =
         instancesResult(beginMillis, endMillis)
-    override fun searchEvents(query: String): List<EventInstance> = searchResult(query)
+    override fun searchEvents(query: String): List<SearchCandidate> = searchResult(query)
     override fun eventDetail(eventId: Long, allDayReminderTimeMinutes: Int): EventDetail? =
         eventDetailResult(eventId)
     override fun eventColorPalette(calendarId: Long): List<EventColorOption> =
@@ -196,7 +201,7 @@ internal class FakeCalendarDataSource : CalendarDataSource {
     }
 
     override fun deleteEvent(eventId: Long) {
-        writeError?.let { throw it }
+        writeError?.let { if (deletes++ >= deletesBeforeError) throw it }
         deletedEventIds += eventId
         managedEvents.values.forEach { rows -> rows.removeAll { it.eventId == eventId } }
     }

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/SearchMapperTest.kt

@@ -16,7 +16,11 @@ class SearchMapperTest {
         eventColor: Any? = null,
         calendarColor: Int = 0xFFAABBCC.toInt(),
         location: String? = null,
+        rrule: String? = null,
+        rdate: String? = null,
     ): MapColumnReader = MapColumnReader(
+        SearchProjection.IDX_RRULE to rrule,
+        SearchProjection.IDX_RDATE to rdate,
         SearchProjection.IDX_ID to id,
         SearchProjection.IDX_CALENDAR_ID to calendarId,
         SearchProjection.IDX_TITLE to title,
@@ -42,4 +46,16 @@ class SearchMapperTest {
     fun `absent dtstart drops the search hit`() {
         assertThat(searchReader(dtstart = null).toSearchResult()).isNull()
     }
+
+    @Test
+    fun `a rule or an rdate marks the hit recurring (issue #80)`() {
+        assertThat(searchReader().toSearchResult()!!.isRecurring).isFalse()
+        assertThat(searchReader(rrule = "").toSearchResult()!!.isRecurring).isFalse()
+        assertThat(
+            searchReader(rrule = "FREQ=WEEKLY").toSearchResult()!!.isRecurring,
+        ).isTrue()
+        assertThat(
+            searchReader(rdate = "20260101T000000Z").toSearchResult()!!.isRecurring,
+        ).isTrue()
+    }
 }

app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt

@@ -337,6 +337,32 @@ class SettingsPrefsTest {
         assertThat(prefs.reminderOnboardingDone.first()).isTrue()
     }
 
+    @Test
+    fun `the wizard arms on a first run`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.armOnboardingWizard()
+        assertThat(prefs.onboardingWizardArmed.first()).isTrue()
+    }
+
+    @Test
+    fun `the wizard does not arm once the reminder step is answered`(@TempDir tempDir: Path) = runTest {
+        // An existing install re-granting the permission is not re-onboarded.
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setReminderOnboardingDone()
+        prefs.armOnboardingWizard()
+        assertThat(prefs.onboardingWizardArmed.first()).isFalse()
+    }
+
+    @Test
+    fun `closing the wizard disarms it`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.armOnboardingWizard()
+
+        prefs.finishOnboardingWizard()
+        assertThat(prefs.onboardingDoneShown.first()).isTrue()
+        assertThat(prefs.onboardingWizardArmed.first()).isFalse()
+    }
+
     @Test
     fun `default reminder is empty until set`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))

app/src/test/java/de/jeanlucmakiola/calendula/domain/CalendarRowStateTest.kt

@@ -94,6 +94,26 @@ class CalendarRowStateTest {
         assertThat(calendar.isEventTarget).isFalse()
     }
 
+    @Test
+    fun `a managed calendar's events are editable but never movable`() {
+        // Their date is owned by the contacts sync, so a drag would be undone.
+        val managed = cal().copy(isManaged = true)
+        assertThat(managed.allowsEventMove).isFalse()
+    }
+
+    @Test
+    fun `a read-only calendar's events are not movable`() {
+        assertThat(cal().copy(canModifyContents = false).allowsEventMove).isFalse()
+    }
+
+    @Test
+    fun `a switched-off calendar's events stay movable, unlike a new-event target`() {
+        // The predicate is deliberately not isEventTarget.
+        val hidden = cal().copy(isVisibleInSystem = false)
+        assertThat(hidden.isEventTarget).isFalse()
+        assertThat(hidden.allowsEventMove).isTrue()
+    }
+
     @Test
     fun `manager order puts non-syncing calendars last and is otherwise stable`() {
         val ordered = listOf(

app/src/test/java/de/jeanlucmakiola/calendula/domain/EventSearchTest.kt

@@ -0,0 +1,315 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.TimeZone
+import org.junit.jupiter.api.Test
+import kotlin.time.Instant
+
+/**
+ * Search matching and how the results are laid out (#80 follow-up): a calendar
+ * of months rather than a ranking, with description-only hits held back.
+ */
+class EventSearchTest {
+
+    private val zone = TimeZone.UTC
+
+    /** 2027-01-15T08:00Z — mid-month and mid-day, so both sides of each are testable. */
+    private val now = Instant.parse("2027-01-15T08:00:00Z")
+    private val todayStart = Instant.parse("2027-01-15T00:00:00Z")
+
+    private var nextId = 1L
+
+    private fun candidate(
+        title: String,
+        start: String = "2027-01-20T09:00:00Z",
+        location: String? = null,
+        description: String? = null,
+    ): SearchCandidate {
+        val begin = Instant.parse(start)
+        return SearchCandidate(
+            event = EventInstance(
+                instanceId = nextId,
+                eventId = nextId++,
+                calendarId = 1L,
+                title = title,
+                start = begin,
+                end = begin.plus(kotlin.time.Duration.parse("1h")),
+                isAllDay = false,
+                color = 0,
+                location = location,
+            ),
+            description = description,
+        )
+    }
+
+    /** [day] is the event's own date; all-day events sit at UTC midnight. */
+    private fun allDayCandidate(title: String, day: String): SearchCandidate {
+        val begin = Instant.parse("${day}T00:00:00Z")
+        return SearchCandidate(
+            event = EventInstance(
+                instanceId = nextId,
+                eventId = nextId++,
+                calendarId = 1L,
+                title = title,
+                start = begin,
+                end = begin.plus(kotlin.time.Duration.parse("24h")),
+                isAllDay = true,
+                color = 0,
+                location = null,
+            ),
+        )
+    }
+
+    private fun search(vararg candidates: SearchCandidate, query: String): SearchResults =
+        EventSearch.search(candidates.toList(), query, now, todayStart, zone)
+
+    private fun datedTitles(results: SearchResults): List<String> =
+        results.months.flatMap { month -> month.hits.map { it.event.title } }
+
+    @Test
+    fun `hits are grouped into months, this one first, then ahead, then back`() {
+        val thisMonth = candidate("Test A", start = "2027-01-20T09:00:00Z")
+        val nextMonth = candidate("Test B", start = "2027-02-03T09:00:00Z")
+        val lastMonth = candidate("Test C", start = "2026-12-10T09:00:00Z")
+        val yearBefore = candidate("Test D", start = "2026-03-10T09:00:00Z")
+
+        val results = search(yearBefore, nextMonth, lastMonth, thisMonth, query = "test")
+
+        assertThat(results.months.map { it.year to it.monthNumber })
+            .containsExactly(2027 to 1, 2027 to 2, 2026 to 12, 2026 to 3)
+            .inOrder()
+        assertThat(datedTitles(results)).containsExactly("Test A", "Test B", "Test C", "Test D")
+            .inOrder()
+    }
+
+    @Test
+    fun `inside a month what is still to come comes before what has passed`() {
+        // Both sides of today share one January card rather than two headers.
+        val earlierThisMonth = candidate("Test past", start = "2027-01-05T09:00:00Z")
+        val laterThisMonth = candidate("Test soon", start = "2027-01-20T09:00:00Z")
+
+        val results = search(earlierThisMonth, laterThisMonth, query = "test")
+
+        assertThat(results.months).hasSize(1)
+        assertThat(datedTitles(results)).containsExactly("Test soon", "Test past").inOrder()
+    }
+
+    @Test
+    fun `an event still running today keeps its place among the upcoming ones`() {
+        // Reported: "test" at 19:00 having passed must not fall behind "test2" at
+        // 23:00 — the day is the boundary, not the moment.
+        val earlierToday = candidate("test", start = "2027-01-15T05:00:00Z")
+        val laterToday = candidate("test2", start = "2027-01-15T20:00:00Z")
+
+        val results = search(laterToday, earlierToday, query = "test")
+
+        assertThat(datedTitles(results)).containsExactly("test", "test2").inOrder()
+    }
+
+    @Test
+    fun `a match tomorrow comes before one from yesterday`() {
+        val yesterday = candidate("test", start = "2027-01-14T09:00:00Z")
+        val tomorrow = candidate("test2", start = "2027-01-16T09:00:00Z")
+
+        val results = search(yesterday, tomorrow, query = "test")
+
+        assertThat(datedTitles(results)).containsExactly("test2", "test").inOrder()
+    }
+
+    @Test
+    fun `a description-only hit is held back from the dated months`() {
+        // The original complaint: "protestantischer" in a holiday's notes landed
+        // among the events actually named Test.
+        val holiday = candidate(
+            "Reformationstag",
+            start = "2027-01-16T09:00:00Z",
+            description = "Feiertag der protestantischer Kirchen",
+        )
+        val real = candidate("Test", start = "2027-06-01T09:00:00Z")
+
+        val results = search(holiday, real, query = "test")
+
+        assertThat(datedTitles(results)).containsExactly("Test")
+        assertThat(results.inDescriptions.map { it.event.title }).containsExactly("Reformationstag")
+    }
+
+    @Test
+    fun `a location match stays in the dated months`() {
+        val located = candidate("Frühstück", location = "Büro")
+
+        val results = search(located, query = "büro")
+
+        assertThat(datedTitles(results)).containsExactly("Frühstück")
+        assertThat(results.inDescriptions).isEmpty()
+    }
+
+    @Test
+    fun `an event named for one token stays dated even if another is in the notes`() {
+        val mixed = candidate("Zahnarzt", description = "Termin bestätigen")
+
+        val results = search(mixed, query = "zahnarzt termin")
+
+        assertThat(datedTitles(results)).containsExactly("Zahnarzt")
+        assertThat(results.inDescriptions).isEmpty()
+    }
+
+    @Test
+    fun `every token has to match, in any field and any order`() {
+        val both = candidate("Zahnarzt", description = "Termin bestätigen")
+        val onlyOne = candidate("Zahnarzt")
+
+        val results = search(both, onlyOne, query = "termin zahnarzt")
+
+        assertThat(results.allHits.map { it.event.eventId }).containsExactly(both.event.eventId)
+    }
+
+    @Test
+    fun `a mid-word match is still found, so compounds keep working`() {
+        val compound = candidate("Zahnarzttermin")
+
+        assertThat(datedTitles(search(compound, query = "termin"))).containsExactly("Zahnarzttermin")
+    }
+
+    @Test
+    fun `case folds beyond ASCII`() {
+        assertThat(datedTitles(search(candidate("ÄRZTE Termin"), query = "ärzte")))
+            .containsExactly("ÄRZTE Termin")
+        assertThat(datedTitles(search(candidate("ärzte"), query = "ÄRZTE")))
+            .containsExactly("ärzte")
+    }
+
+    @Test
+    fun `an all-day event is filed by its own day, not by UTC`() {
+        // Behind UTC an all-day event sits at midnight UTC, which is the previous
+        // month locally (#82) — the month has to come from the span's first day.
+        val newYear = SearchCandidate(
+            event = EventInstance(
+                instanceId = 99L,
+                eventId = 99L,
+                calendarId = 1L,
+                title = "Test holiday",
+                start = Instant.parse("2027-02-01T00:00:00Z"),
+                end = Instant.parse("2027-02-02T00:00:00Z"),
+                isAllDay = true,
+                color = 0,
+                location = null,
+            ),
+        )
+
+        val results = EventSearch.search(
+            listOf(newYear),
+            "test",
+            now,
+            todayStart,
+            TimeZone.of("America/New_York"),
+        )
+
+        assertThat(results.months.single().let { it.year to it.monthNumber }).isEqualTo(2027 to 2)
+    }
+
+    @Test
+    fun `an all-day event that has passed does not rank as still to come`() {
+        // Ahead of UTC its UTC-midnight end lands after the local day started, so
+        // comparing raw instants floated yesterday's holiday above today's events.
+        val berlin = TimeZone.of("Europe/Berlin")
+        val yesterday = allDayCandidate("Test holiday", "2027-01-14")
+        val tomorrow = candidate("Test soon", start = "2027-01-16T09:00:00Z")
+
+        val results = EventSearch.search(
+            listOf(yesterday, tomorrow),
+            "test",
+            Instant.parse("2027-01-15T07:00:00Z"),
+            Instant.parse("2027-01-14T23:00:00Z"),
+            berlin,
+        )
+
+        assertThat(datedTitles(results)).containsExactly("Test soon", "Test holiday").inOrder()
+        assertThat(results.allHits.last().isPast).isTrue()
+    }
+
+    @Test
+    fun `an all-day event is not past until its own day is over`() {
+        // 21:00 in Los Angeles, where the event's UTC-midnight end is already gone.
+        val results = EventSearch.search(
+            listOf(allDayCandidate("Test holiday", "2027-01-15")),
+            "test",
+            Instant.parse("2027-01-16T05:00:00Z"),
+            Instant.parse("2027-01-15T08:00:00Z"),
+            TimeZone.of("America/Los_Angeles"),
+        )
+
+        assertThat(results.allHits.single().isPast).isFalse()
+    }
+
+    @Test
+    fun `an untitled event's placeholder is not something the query can match`() {
+        val untitled = candidate("(Ohne Titel)", description = "Titel folgt noch").copy(title = null)
+
+        val results = search(untitled, query = "titel")
+
+        assertThat(datedTitles(results)).isEmpty()
+        assertThat(results.inDescriptions.single().titleSpans).isEmpty()
+    }
+
+    @Test
+    fun `a hit that has already finished is marked past, including earlier today`() {
+        val earlierToday = candidate("test", start = "2027-01-15T05:00:00Z")
+        val laterToday = candidate("test", start = "2027-01-15T20:00:00Z")
+
+        val hits = search(earlierToday, laterToday, query = "test")
+            .allHits
+            .associateBy { it.event.eventId }
+
+        assertThat(hits.getValue(earlierToday.event.eventId).isPast).isTrue()
+        assertThat(hits.getValue(laterToday.event.eventId).isPast).isFalse()
+    }
+
+    @Test
+    fun `the title carries the spans to highlight, merged where they overlap`() {
+        val hit = search(candidate("Test the tester"), query = "test").allHits.single()
+
+        assertThat(hit.titleSpans).containsExactly(MatchSpan(0, 4), MatchSpan(9, 13)).inOrder()
+    }
+
+    @Test
+    fun `a description snippet is excerpted around its match`() {
+        val long = "x".repeat(300) + " geheimwort " + "y".repeat(300)
+
+        val snippet = search(candidate("Notiz", description = long), query = "geheimwort")
+            .allHits
+            .single()
+            .descriptionSnippet
+
+        requireNotNull(snippet)
+        assertThat(snippet.text).contains("geheimwort")
+        assertThat(snippet.text.length).isLessThan(long.length)
+        assertThat(snippet.text).startsWith("…")
+        val span = snippet.spans.single()
+        assertThat(snippet.text.substring(span.start, span.end)).isEqualTo("geheimwort")
+    }
+
+    @Test
+    fun `a title-only match carries no description snippet`() {
+        val hit = search(candidate("Test", description = "nothing relevant here"), query = "test")
+            .allHits
+            .single()
+
+        assertThat(hit.descriptionSnippet).isNull()
+    }
+
+    @Test
+    fun `a multi-line description matches and snippets as one line`() {
+        val snippet = search(
+            candidate("Notiz", description = "erste Zeile\n\n  zweite Zeile"),
+            query = "zweite",
+        ).allHits.single().descriptionSnippet
+
+        requireNotNull(snippet)
+        assertThat(snippet.text).isEqualTo("erste Zeile zweite Zeile")
+    }
+
+    @Test
+    fun `a blank query matches nothing`() {
+        assertThat(search(candidate("Test"), query = "   ").isEmpty).isTrue()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/domain/EventShiftTest.kt

@@ -0,0 +1,155 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+import org.junit.jupiter.api.Test
+
+class EventShiftTest {
+
+    private val berlin = TimeZone.of("Europe/Berlin")
+    private val newYork = TimeZone.of("America/New_York")
+
+    private fun form(
+        start: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)),
+        end: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
+        timezone: String? = null,
+        isAllDay: Boolean = false,
+    ) = EventForm(
+        calendarId = 1L,
+        title = "Standup",
+        isAllDay = isAllDay,
+        start = start,
+        end = end,
+        timezone = timezone,
+    )
+
+    @Test
+    fun `shifting to a new start keeps the length`() {
+        val original = form()
+        val target = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(14, 30)).toInstant(berlin)
+
+        val moved = original.shiftedTo(target, berlin)
+
+        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(14, 30)))
+        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(15, 30)))
+    }
+
+    @Test
+    fun `a pinned event is re-derived in its own zone, not the device's`() {
+        // 09:00 in New York, opened on a Berlin device.
+        val original = form(
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)),
+            timezone = "America/New_York",
+        )
+        // The grid says "15:30 Berlin", which is 09:30 in New York.
+        val target = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(15, 30)).toInstant(berlin)
+
+        val moved = original.shiftedTo(target, berlin)
+
+        assertThat(moved.timezone).isEqualTo("America/New_York")
+        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 30)))
+        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 30)))
+    }
+
+    @Test
+    fun `the instant duration survives a shift across spring forward`() {
+        // 2026-03-29 02:00 CET is when Berlin skips to 03:00.
+        val original = form(
+            start = LocalDateTime(LocalDate(2026, 3, 28), LocalTime(23, 0)),
+            end = LocalDateTime(LocalDate(2026, 3, 29), LocalTime(1, 0)),
+        )
+        val target = LocalDateTime(LocalDate(2026, 3, 29), LocalTime(1, 0)).toInstant(berlin)
+
+        val moved = original.shiftedTo(target, berlin)
+
+        // Two real hours from 01:00 CET lands at 04:00 CEST: the hour in
+        // between does not exist.
+        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(1, 0)))
+        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(4, 0)))
+        assertThat(moved.end.toInstant(berlin) - moved.start.toInstant(berlin))
+            .isEqualTo(original.end.toInstant(berlin) - original.start.toInstant(berlin))
+    }
+
+    @Test
+    fun `a drop into the spring-forward gap resolves forward by the missing hour`() {
+        val original = form()
+        // 02:30 does not exist on 2026-03-29 in Berlin.
+        val target = LocalDateTime(LocalDate(2026, 3, 29), LocalTime(2, 30)).toInstant(berlin)
+
+        val moved = original.shiftedTo(target, berlin)
+
+        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(3, 30)))
+    }
+
+    @Test
+    fun `a zero-distance drop leaves the form untouched`() {
+        val original = form()
+        assertThat(original.shiftedTo(original.start.toInstant(berlin), berlin)).isEqualTo(original)
+    }
+
+    @Test
+    fun `an unparseable pinned zone falls back to the device, like the write path`() {
+        val original = form(timezone = "Mars/Olympus")
+        val target = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0)).toInstant(newYork)
+
+        val moved = original.shiftedTo(target, newYork)
+
+        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0)))
+    }
+
+    @Test
+    fun `an all-day event ignores shiftedTo and moves by whole days instead`() {
+        val allDay = form(isAllDay = true)
+        val target = LocalDateTime(LocalDate(2026, 7, 1), LocalTime(3, 0)).toInstant(berlin)
+
+        assertThat(allDay.shiftedTo(target, berlin)).isEqualTo(allDay)
+
+        val moved = allDay.shiftedByDays(3, berlin)
+        assertThat(moved.start.date).isEqualTo(LocalDate(2026, 6, 14))
+        assertThat(moved.end.date).isEqualTo(LocalDate(2026, 6, 14))
+        // The placeholder times exist only for a switch back to timed; untouched.
+        assertThat(moved.start.time).isEqualTo(allDay.start.time)
+    }
+
+    @Test
+    fun `a multi-day event keeps its span when shifted by days`() {
+        val multiDay = form(
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(22, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 13), LocalTime(2, 0)),
+        )
+
+        val moved = multiDay.shiftedByDays(-2, berlin)
+
+        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 9), LocalTime(22, 0)))
+        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(2, 0)))
+    }
+
+    @Test
+    fun `a timed shift onto a DST changeover keeps the real length, not the wall clock`() {
+        // 22:00 Sat -> 04:00 Sun is six real hours, onto the Sunday Berlin
+        // springs forward on. Keeping wall clock would write five.
+        val overnight = form(
+            start = LocalDateTime(LocalDate(2026, 3, 21), LocalTime(22, 0)),
+            end = LocalDateTime(LocalDate(2026, 3, 22), LocalTime(4, 0)),
+        )
+
+        val moved = overnight.shiftedByDays(7, berlin)
+
+        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 3, 28), LocalTime(22, 0)))
+        assertThat(moved.end.toInstant(berlin) - moved.start.toInstant(berlin))
+            .isEqualTo(overnight.end.toInstant(berlin) - overnight.start.toInstant(berlin))
+        // The wall-clock end therefore lands an hour later than a naive +7 days.
+        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(5, 0)))
+    }
+
+    @Test
+    fun `shifting by no days is a no-op`() {
+        val original = form()
+        assertThat(original.shiftedByDays(0, berlin)).isEqualTo(original)
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/domain/RecurrenceRealignTest.kt

@@ -0,0 +1,111 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.LocalDate
+import org.junit.jupiter.api.Test
+
+class RecurrenceRealignTest {
+
+    private val monday = LocalDate(2026, 6, 8)
+    private val wednesday = LocalDate(2026, 6, 10)
+
+    @Test
+    fun `a weekly BYDAY rule follows the occurrence to its new weekday`() {
+        assertThat(realignRecurrence("FREQ=WEEKLY;BYDAY=MO", monday, wednesday))
+            .isEqualTo("FREQ=WEEKLY;BYDAY=WE")
+    }
+
+    @Test
+    fun `unrelated parts survive the rewrite`() {
+        assertThat(
+            realignRecurrence("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO;COUNT=10", monday, wednesday),
+        ).isEqualTo("FREQ=WEEKLY;INTERVAL=2;BYDAY=WE;COUNT=10")
+    }
+
+    @Test
+    fun `a day-of-month rule is refused, because the anchor moves by days not dates`() {
+        // BYMONTHDAY=28 with a January anchor, occurrence Feb 28 dragged to Mar 1:
+        // the rebuilt rule would say the 1st while the anchor became Jan 29 — a
+        // DTSTART that is not an instance of its own rule.
+        assertThat(realignRecurrence("FREQ=MONTHLY;BYMONTHDAY=8", monday, wednesday)).isNull()
+        assertThat(
+            realignRecurrence("FREQ=YEARLY;BYMONTH=6;BYMONTHDAY=8", monday, LocalDate(2026, 7, 20)),
+        ).isNull()
+    }
+
+    @Test
+    fun `BYDAY on a non-weekly rule is refused`() {
+        // parseSimpleRecurrence can't read it either, so the UNTIL guard
+        // downstream would be blind to it.
+        assertThat(realignRecurrence("FREQ=MONTHLY;BYDAY=MO", monday, wednesday)).isNull()
+    }
+
+    @Test
+    fun `a rule with no FREQ is refused`() {
+        assertThat(realignRecurrence("INTERVAL=2;BYDAY=MO", monday, wednesday)).isNull()
+    }
+
+    @Test
+    fun `a rule with no day-selecting part needs no rewrite`() {
+        assertThat(realignRecurrence("FREQ=DAILY;INTERVAL=3", monday, wednesday))
+            .isEqualTo("FREQ=DAILY;INTERVAL=3")
+        assertThat(realignRecurrence("FREQ=WEEKLY", monday, wednesday)).isEqualTo("FREQ=WEEKLY")
+    }
+
+    @Test
+    fun `a rule the move does not disturb comes back verbatim`() {
+        val rule = "FREQ=WEEKLY;BYDAY=MO,WE,FR"
+        assertThat(realignRecurrence(rule, monday, monday)).isEqualTo(rule)
+    }
+
+    @Test
+    fun `a multi-day BYDAY cannot be resolved from one moved occurrence`() {
+        assertThat(realignRecurrence("FREQ=WEEKLY;BYDAY=MO,WE", monday, wednesday)).isNull()
+    }
+
+    @Test
+    fun `an ordinal BYDAY cannot be resolved`() {
+        assertThat(realignRecurrence("FREQ=MONTHLY;BYDAY=2MO", monday, wednesday)).isNull()
+    }
+
+    @Test
+    fun `a BYDAY that does not name the occurrence's own weekday is refused`() {
+        // The rule and DTSTART already disagree; guessing would make it worse.
+        assertThat(realignRecurrence("FREQ=WEEKLY;BYDAY=TU", monday, wednesday)).isNull()
+    }
+
+    @Test
+    fun `parts we cannot reason about are refused rather than guessed`() {
+        assertThat(realignRecurrence("FREQ=WEEKLY;BYDAY=MO;BYSETPOS=1", monday, wednesday))
+            .isNull()
+        assertThat(realignRecurrence("FREQ=YEARLY;BYYEARDAY=159", monday, wednesday)).isNull()
+    }
+
+    @Test
+    fun `everything realignable is also a rule the UNTIL guard can read`() {
+        // problems() checks UNTIL through parseSimpleRecurrence; a rule this
+        // realigns but that parser rejects would go unchecked.
+        val realignable = listOf(
+            "FREQ=WEEKLY;BYDAY=MO",
+            "FREQ=WEEKLY;INTERVAL=2;BYDAY=MO;UNTIL=20261231T225959Z",
+            "FREQ=DAILY;COUNT=5",
+        )
+        realignable.forEach { rule ->
+            assertThat(realignRecurrence(rule, monday, wednesday)).isNotNull()
+            assertThat(parseSimpleRecurrence(realignRecurrence(rule, monday, wednesday)!!))
+                .isNotNull()
+        }
+    }
+
+    @Test
+    fun `a leading RRULE prefix is preserved`() {
+        assertThat(realignRecurrence("RRULE:FREQ=WEEKLY;BYDAY=MO", monday, wednesday))
+            .isEqualTo("RRULE:FREQ=WEEKLY;BYDAY=WE")
+    }
+
+    @Test
+    fun `a malformed rule is refused`() {
+        assertThat(realignRecurrence("FREQ=WEEKLY;GARBAGE", monday, wednesday)).isNull()
+        assertThat(realignRecurrence("", monday, wednesday)).isNull()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/EventTitleOverflowTest.kt

@@ -0,0 +1,40 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.ui.text.style.TextOverflow
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class EventTitleOverflowTest {
+
+    @Test
+    fun `a single LTR line clips, so the title runs to the chip's edge`() {
+        val result = eventTitleOverflowFor(rtl = false, singleLine = true)
+        assertThat(result.overflow).isEqualTo(TextOverflow.Clip)
+        // Load-bearing: with softWrap on, a clipped line breaks at the last
+        // whole word and shows less title than the ellipsis did (#164).
+        assertThat(result.softWrap).isFalse()
+    }
+
+    @Test
+    fun `RTL keeps the ellipsis, which truncates at the logical end`() {
+        // Clipping with softWrap off cuts at the node's left edge, which in RTL
+        // is the end of the string — the title would lose its beginning.
+        val result = eventTitleOverflowFor(rtl = true, singleLine = true)
+        assertThat(result.overflow).isEqualTo(TextOverflow.Ellipsis)
+        assertThat(result.softWrap).isTrue()
+    }
+
+    @Test
+    fun `a multi-line block keeps the ellipsis, since wrapping needs softWrap`() {
+        val result = eventTitleOverflowFor(rtl = false, singleLine = false)
+        assertThat(result.overflow).isEqualTo(TextOverflow.Ellipsis)
+        assertThat(result.softWrap).isTrue()
+    }
+
+    @Test
+    fun `multi-line in RTL keeps the ellipsis too`() {
+        val result = eventTitleOverflowFor(rtl = true, singleLine = false)
+        assertThat(result.overflow).isEqualTo(TextOverflow.Ellipsis)
+        assertThat(result.softWrap).isTrue()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/RescheduleViewModelTest.kt

@@ -0,0 +1,497 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+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 de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+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.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+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
+
+/**
+ * The drop pipeline: which repository call a scope maps to, when a recurring drop
+ * has to ask first, and every case that must refuse to write.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class RescheduleViewModelTest {
+
+    private val dispatcher = UnconfinedTestDispatcher()
+
+    @BeforeEach fun setUp() = Dispatchers.setMain(dispatcher)
+    @AfterEach fun tearDown() = Dispatchers.resetMain()
+
+    // Monday 2026-06-08, midday in the device zone — the zone the drop path
+    // reads dates back in. The BYDAY assertions depend on it being a Monday.
+    private val monday = LocalDate(2026, 6, 8)
+    private val beginMillis = LocalDateTime(monday, LocalTime(12, 0))
+        .toInstant(TimeZone.currentSystemDefault())
+        .toEpochMilliseconds()
+    private val endMillis = beginMillis + 3_600_000L
+
+    private fun cal(
+        id: Long,
+        canModify: Boolean = true,
+        managed: Boolean = false,
+    ): CalendarSource = CalendarSource(
+        id = id, displayName = "Cal $id", accountName = "acc@local", accountType = "LOCAL",
+        color = 0xFF112233.toInt(), isVisibleInSystem = true, canModifyContents = canModify,
+        isManaged = managed,
+    )
+
+    private fun detail(
+        rrule: String? = null,
+        isAllDay: Boolean = false,
+        isException: Boolean = false,
+        anchorMillis: Long = beginMillis,
+    ): EventDetail = EventDetail(
+        instance = EventInstance(
+            instanceId = 42L, eventId = 42L, calendarId = 1L, title = "Standup",
+            start = Instant.fromEpochMilliseconds(anchorMillis),
+            end = Instant.fromEpochMilliseconds(anchorMillis + (endMillis - beginMillis)),
+            isAllDay = isAllDay, color = 0xFF000000.toInt(), location = null,
+        ),
+        description = null, organizer = null, attendees = emptyList(), rrule = rrule,
+        isException = isException,
+    )
+
+    private fun viewModel(tempDir: Path, fake: FakeCalendarDataSource): RescheduleViewModel {
+        val prefs = CalendarPrefs(
+            PreferenceDataStoreFactory.create(
+                scope = CoroutineScope(dispatcher),
+                produceFile = { tempDir.resolve("move_prefs.preferences_pb").toFile() },
+            ),
+        )
+        val settings = SettingsPrefs(
+            PreferenceDataStoreFactory.create(
+                scope = CoroutineScope(dispatcher),
+                produceFile = { tempDir.resolve("move_settings.preferences_pb").toFile() },
+            ),
+        )
+        val repo = CalendarRepositoryImpl(fake, prefs, settings, dispatcher as CoroutineDispatcher)
+        return RescheduleViewModel(repo, dispatcher)
+    }
+
+    private fun CoroutineScope.activate(vm: RescheduleViewModel): Job =
+        launch { vm.movableCalendarIds.collect {} }
+
+    /** A drop two days later, expressed the way the month grid expresses one. */
+    private fun toWednesday() = MoveRequest(
+        eventId = 42L,
+        beginMillis = beginMillis,
+        endMillis = endMillis,
+        target = MoveTarget.ByDays(2),
+    )
+
+    /** A drop an hour later, expressed the way a timeline drag expresses one. */
+    private fun oneHourLater() = MoveRequest(
+        eventId = 42L,
+        beginMillis = beginMillis,
+        endMillis = endMillis,
+        target = MoveTarget.Start(Instant.fromEpochMilliseconds(beginMillis + 3_600_000L)),
+    )
+
+    @Test
+    fun `a one-off drop writes straight through with no scope prompt`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isNull()
+        assertThat(fake.updatedEvents).hasSize(1)
+        val (id, original, updated) = fake.updatedEvents.single()
+        assertThat(id).isEqualTo(42L)
+        assertThat(updated.start).isNotEqualTo(original.start)
+        assertThat(vm.outcome.value).isInstanceOf(MoveOutcome.Moved::class.java)
+    }
+
+    @Test
+    fun `a recurring drop parks for the scope instead of writing`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isEqualTo(MoveScopePrompt(occurrenceOnly = false))
+        assertThat(fake.updatedEvents).isEmpty()
+        assertThat(fake.updatedOccurrences).isEmpty()
+    }
+
+    @Test
+    fun `each scope maps to its own repository call`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val occurrence = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY") }
+        }
+        viewModel(tempDir.resolve("a").also { it.toFile().mkdirs() }, occurrence).run {
+            move(oneHourLater())
+            moveWithScope(RecurringWriteScope.ThisEvent)
+        }
+        advanceUntilIdle()
+        assertThat(occurrence.updatedOccurrences).hasSize(1)
+        assertThat(occurrence.updatedOccurrences.single().second).isEqualTo(beginMillis)
+
+        val following = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY") }
+        }
+        viewModel(tempDir.resolve("b").also { it.toFile().mkdirs() }, following).run {
+            move(oneHourLater())
+            moveWithScope(RecurringWriteScope.ThisAndFollowing)
+        }
+        advanceUntilIdle()
+        assertThat(following.updatedFromOccurrences).hasSize(1)
+
+        val series = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY") }
+        }
+        viewModel(tempDir.resolve("c").also { it.toFile().mkdirs() }, series).run {
+            move(oneHourLater())
+            moveWithScope(RecurringWriteScope.AllEvents)
+        }
+        advanceUntilIdle()
+        assertThat(series.updatedEvents).hasSize(1)
+    }
+
+    @Test
+    fun `a weekly BYDAY rule is realigned when the whole series moves weekday`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(toWednesday())
+        vm.moveWithScope(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+
+        // Without this the anchor becomes a Wednesday while the rule still says
+        // Monday, and the series does not move at all.
+        assertThat(fake.updatedEvents.single().third.rrule).isEqualTo("FREQ=WEEKLY;BYDAY=WE")
+    }
+
+    @Test
+    fun `a rule that cannot be realigned offers only the single occurrence`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO,WE") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(toWednesday())
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isEqualTo(MoveScopePrompt(occurrenceOnly = true))
+    }
+
+    @Test
+    fun `a same-time drop within one day still needs no realignment`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO,WE") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        // The weekday is unchanged, so the ambiguous BYDAY is not in the way.
+        assertThat(vm.scopePrompt.value).isEqualTo(MoveScopePrompt(occurrenceOnly = false))
+    }
+
+    @Test
+    fun `a time-only drop that would carry the anchor past midnight offers only the occurrence`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        // The anchor sits at 23:30 while the dragged occurrence is at midday —
+        // only possible when the row pins no zone, so the two resolve an hour
+        // apart. +1h leaves the occurrence on its day but rolls the anchor onto
+        // the next one, which would leave BYDAY naming the wrong weekday.
+        val anchor = LocalDateTime(LocalDate(2026, 6, 1), LocalTime(23, 30))
+            .toInstant(TimeZone.currentSystemDefault())
+            .toEpochMilliseconds()
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO", anchorMillis = anchor) }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isEqualTo(MoveScopePrompt(occurrenceOnly = true))
+    }
+
+    @Test
+    fun `a second drop is refused while the first is still in flight`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        assertThat(vm.move(toWednesday())).isTrue()
+        advanceUntilIdle()
+
+        // Parked on the scope dialog, so the first drop still owns the pipeline.
+        assertThat(vm.move(oneHourLater())).isFalse()
+        advanceUntilIdle()
+        assertThat(fake.updatedEvents).isEmpty()
+    }
+
+    @Test
+    fun `undo is refused while a write is running`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = viewModel(tempDir, fake)
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+        val undo = (vm.outcome.value as MoveOutcome.Moved).undo!!
+
+        // A second drop parks on its scope dialog, which holds the pipeline.
+        fake.eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
+        vm.move(toWednesday())
+        advanceUntilIdle()
+
+        assertThat(vm.undo(undo)).isFalse()
+        advanceUntilIdle()
+        assertThat(fake.updatedEvents).hasSize(1)
+    }
+
+    @Test
+    fun `an exception row is written as a plain event, never as a nested exception`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            // A sync adapter that left the series' rule on the override row.
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY", isException = true) }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isNull()
+        assertThat(fake.updatedEvents).hasSize(1)
+        assertThat(fake.updatedOccurrences).isEmpty()
+    }
+
+    @Test
+    fun `a drop past the series' own UNTIL is refused, not written`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            // Midday UTC, so the device zone can't push the UNTIL date onto the
+            // day the event is being dragged to.
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;UNTIL=20260608T120000Z") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(toWednesday())
+        vm.moveWithScope(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.BlockedSeriesEnd)
+        assertThat(fake.updatedEvents).isEmpty()
+    }
+
+    @Test
+    fun `dragging a bounded series' last occurrence still allows moving just it`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;UNTIL=20260608T120000Z") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(toWednesday())
+        advanceUntilIdle()
+        // An exception row is constrained by no UNTIL, so the scope stays on offer.
+        assertThat(vm.scopePrompt.value).isNotNull()
+
+        vm.moveWithScope(RecurringWriteScope.ThisEvent)
+        advanceUntilIdle()
+
+        assertThat(fake.updatedOccurrences).hasSize(1)
+        assertThat(vm.outcome.value).isInstanceOf(MoveOutcome.Moved::class.java)
+    }
+
+    @Test
+    fun `a drag that changes both the day and the time cannot move the series`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        // Onto the next day *and* two hours later: a late enough anchor would
+        // cross two midnights under the same wall-clock shift.
+        vm.move(
+            MoveRequest(
+                eventId = 42L,
+                beginMillis = beginMillis,
+                endMillis = endMillis,
+                target = MoveTarget.Start(
+                    Instant.fromEpochMilliseconds(beginMillis + 26 * 3_600_000L),
+                ),
+            ),
+        )
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isEqualTo(MoveScopePrompt(occurrenceOnly = true))
+    }
+
+    @Test
+    fun `a zero-distance drop writes nothing and says nothing`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(
+            MoveRequest(
+                eventId = 42L,
+                beginMillis = beginMillis,
+                endMillis = endMillis,
+                target = MoveTarget.Start(Instant.fromEpochMilliseconds(beginMillis)),
+            ),
+        )
+        advanceUntilIdle()
+
+        assertThat(fake.updatedEvents).isEmpty()
+        assertThat(vm.outcome.value).isNull()
+    }
+
+    @Test
+    fun `a vanished event reports itself as gone`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { null } }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.Gone)
+    }
+
+    @Test
+    fun `a revoked write permission is reported apart from a plain failure`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail() }
+            writeError = SecurityException("revoked")
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.WriteDenied)
+    }
+
+    @Test
+    fun `undo writes the move back the other way`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+        val undo = (vm.outcome.value as MoveOutcome.Moved).undo
+        assertThat(undo).isNotNull()
+
+        vm.undo(undo!!)
+        advanceUntilIdle()
+
+        assertThat(fake.updatedEvents).hasSize(2)
+        val forward = fake.updatedEvents[0]
+        val back = fake.updatedEvents[1]
+        assertThat(back.second).isEqualTo(forward.third)
+        assertThat(back.third).isEqualTo(forward.second)
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.Undone)
+    }
+
+    @Test
+    fun `an occurrence write offers no undo, since shifting back cannot restore it`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        vm.moveWithScope(RecurringWriteScope.ThisEvent)
+        advanceUntilIdle()
+
+        assertThat((vm.outcome.value as MoveOutcome.Moved).undo).isNull()
+    }
+
+    @Test
+    fun `only writable, unmanaged calendars can be dragged from`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(
+                cal(1L),
+                cal(2L, canModify = false),
+                cal(3L, managed = true),
+            )
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+        advanceUntilIdle()
+
+        assertThat(vm.movableCalendarIds.value).containsExactly(1L)
+        job.cancel()
+    }
+
+    @Test
+    fun `cancelling the scope dialog writes nothing`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        vm.cancelScope()
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isNull()
+        assertThat(fake.updatedEvents).isEmpty()
+        assertThat(fake.updatedOccurrences).isEmpty()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/TimeFormatTest.kt

@@ -27,6 +27,14 @@ class TimeFormatTest {
         assertThat(formatMinuteOfDay(13 * 60 + 15, is24Hour = true, Locale.US)).isEqualTo("13:15")
     }
 
+    @Test
+    fun `gutter time drops the meridiem and clamps to the day`() {
+        assertThat(formatGutterTime(9 * 60 + 15, is24Hour = true, Locale.US)).isEqualTo("09:15")
+        assertThat(formatGutterTime(13 * 60 + 45, is24Hour = false, Locale.US)).isEqualTo("1:45")
+        assertThat(formatGutterTime(0, is24Hour = false, Locale.US)).isEqualTo("12:00")
+        assertThat(formatGutterTime(1_440, is24Hour = true, Locale.US)).isEqualTo("23:59")
+    }
+
     @Test
     fun `hour label is zero-padded in 24h and compact am-pm in 12h`() {
         assertThat(formatHourLabel(13, is24Hour = true, Locale.US)).isEqualTo("13")

app/src/test/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingPlanTest.kt

@@ -0,0 +1,246 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+/**
+ * The wizard's step plan (#163). Two invariants carry the whole feature: an
+ * existing install must never be re-onboarded, and the counter must not
+ * renumber under the user as steps are completed.
+ */
+class OnboardingPlanTest {
+
+    private fun plan(
+        hasPermission: Boolean = false,
+        remindersDone: Boolean = false,
+        wizardArmed: Boolean = false,
+        backupDone: Boolean = false,
+        viewDone: Boolean = false,
+        monthStyleDone: Boolean = false,
+        backupApplies: Boolean? = null,
+        visibilityArmed: Boolean = false,
+        visibilityDone: Boolean = false,
+        doneShown: Boolean = false,
+    ) = onboardingPlan(
+        hasPermission = hasPermission,
+        remindersDone = remindersDone,
+        wizardArmed = wizardArmed,
+        backupDone = backupDone,
+        viewDone = viewDone,
+        monthStyleDone = monthStyleDone,
+        backupApplies = backupApplies,
+        visibilityArmed = visibilityArmed,
+        visibilityDone = visibilityDone,
+        doneShown = doneShown,
+    )
+
+    @Test
+    fun `fresh install starts on the permission step`() {
+        val fresh = plan()
+        assertThat(fresh.current).isEqualTo(OnboardingStep.Permission)
+        assertThat(fresh.index).isEqualTo(1)
+        assertThat(fresh.showsProgress).isTrue()
+    }
+
+    @Test
+    fun `granting the permission does not renumber the steps behind it`() {
+        // The plan keeps completed steps, so the reminder step stays step 2 of
+        // the same flow rather than becoming step 1 of a shorter one.
+        val granted = plan(hasPermission = true, wizardArmed = true, backupApplies = true)
+        assertThat(granted.steps).containsExactly(
+            OnboardingStep.Permission,
+            OnboardingStep.Reminders,
+            OnboardingStep.Backup,
+            OnboardingStep.View,
+            OnboardingStep.MonthStyle,
+            OnboardingStep.Done,
+        ).inOrder()
+        assertThat(granted.current).isEqualTo(OnboardingStep.Reminders)
+        assertThat(granted.index).isEqualTo(2)
+    }
+
+    @Test
+    fun `a synced calendar drops the backup step`() {
+        val synced = plan(
+            hasPermission = true,
+            wizardArmed = true,
+            remindersDone = true,
+            backupApplies = false,
+        )
+        assertThat(synced.steps).doesNotContain(OnboardingStep.Backup)
+        assertThat(synced.current).isEqualTo(OnboardingStep.View)
+        assertThat(synced.total).isEqualTo(5)
+    }
+
+    @Test
+    fun `the backup step is assumed until the calendars can be read`() {
+        // Before the grant the answer is unknowable, so the flow is planned at
+        // its longest — it may shrink afterwards, never grow.
+        assertThat(plan(backupApplies = null).steps).contains(OnboardingStep.Backup)
+    }
+
+    @Test
+    fun `an existing install is not re-onboarded`() {
+        val existing = plan(hasPermission = true, remindersDone = true)
+        assertThat(existing.steps).isEmpty()
+        assertThat(existing.current).isNull()
+    }
+
+    @Test
+    fun `an existing install owing only the reminder step gets no counter`() {
+        val existing = plan(hasPermission = true)
+        assertThat(existing.steps).containsExactly(OnboardingStep.Reminders)
+        assertThat(existing.current).isEqualTo(OnboardingStep.Reminders)
+        assertThat(existing.showsProgress).isFalse()
+    }
+
+    @Test
+    fun `re-granting the permission on an onboarded install skips the extra steps`() {
+        // Revoked and granted again: the reminder step is already answered, so
+        // this is not a fresh install and only the permission is owed.
+        val revoked = plan(remindersDone = true)
+        assertThat(revoked.steps).containsExactly(OnboardingStep.Permission)
+        assertThat(revoked.showsProgress).isFalse()
+    }
+
+    @Test
+    fun `re-granting after the wizard itself ran does not re-enter it`() {
+        // The closing screen clears the armed flag, so someone the wizard did
+        // onboard ends up where any other revoker does: one screen, no counter.
+        val revoked = plan(remindersDone = true, wizardArmed = false, doneShown = true)
+        assertThat(revoked.steps).containsExactly(OnboardingStep.Permission)
+        assertThat(revoked.showsProgress).isFalse()
+    }
+
+    @Test
+    fun `a read notice leaves nothing behind in a later plan`() {
+        // The notice is retired once read, so its step stops padding the count
+        // on a later re-grant.
+        val later = plan(remindersDone = true, visibilityArmed = false, visibilityDone = true)
+        assertThat(later.steps).containsExactly(OnboardingStep.Permission)
+        assertThat(later.showsProgress).isFalse()
+    }
+
+    @Test
+    fun `answering every step ends the flow`() {
+        val done = plan(
+            hasPermission = true,
+            remindersDone = true,
+            wizardArmed = true,
+            backupDone = true,
+            viewDone = true,
+            monthStyleDone = true,
+            backupApplies = true,
+            doneShown = true,
+        )
+        assertThat(done.current).isNull()
+        assertThat(done.index).isEqualTo(0)
+    }
+
+    @Test
+    fun `the month style is asked whatever view was chosen`() {
+        // Month is reachable from the drawer whatever opens first, and making
+        // the step conditional would move the counter on the step before it.
+        val afterView = plan(
+            hasPermission = true,
+            wizardArmed = true,
+            remindersDone = true,
+            backupDone = true,
+            viewDone = true,
+            backupApplies = true,
+        )
+        assertThat(afterView.current).isEqualTo(OnboardingStep.MonthStyle)
+    }
+
+    @Test
+    fun `back steps to the previous answered step`() {
+        val onView = plan(
+            hasPermission = true,
+            wizardArmed = true,
+            remindersDone = true,
+            backupDone = true,
+            backupApplies = true,
+        )
+        assertThat(onView.current).isEqualTo(OnboardingStep.View)
+        assertThat(onView.previous).isEqualTo(OnboardingStep.Backup)
+        assertThat(onView.canGoBack).isTrue()
+    }
+
+    @Test
+    fun `back is refused where the previous step is the system grant`() {
+        // The permission is the system's to give; there is nothing to return to.
+        val onReminders = plan(hasPermission = true, wizardArmed = true, backupApplies = true)
+        assertThat(onReminders.previous).isEqualTo(OnboardingStep.Permission)
+        assertThat(onReminders.canGoBack).isFalse()
+    }
+
+    @Test
+    fun `back is refused on the first step and once the flow is done`() {
+        assertThat(plan().canGoBack).isFalse()
+        val done = plan(
+            hasPermission = true,
+            remindersDone = true,
+            wizardArmed = true,
+            backupDone = true,
+            viewDone = true,
+            monthStyleDone = true,
+            backupApplies = true,
+            doneShown = true,
+        )
+        assertThat(done.previous).isNull()
+        assertThat(done.canGoBack).isFalse()
+    }
+
+    @Test
+    fun `the wizard ends on its closing screen`() {
+        val lastAnswer = plan(
+            hasPermission = true,
+            remindersDone = true,
+            wizardArmed = true,
+            backupDone = true,
+            viewDone = true,
+            monthStyleDone = true,
+            backupApplies = true,
+        )
+        assertThat(lastAnswer.current).isEqualTo(OnboardingStep.Done)
+        assertThat(lastAnswer.index).isEqualTo(lastAnswer.total)
+    }
+
+    @Test
+    fun `the visibility notice is asked before the closing screen`() {
+        val armed = plan(
+            hasPermission = true,
+            remindersDone = true,
+            wizardArmed = true,
+            backupDone = true,
+            viewDone = true,
+            monthStyleDone = true,
+            backupApplies = true,
+            visibilityArmed = true,
+        )
+        assertThat(armed.current).isEqualTo(OnboardingStep.Visibility)
+        assertThat(armed.steps.last()).isEqualTo(OnboardingStep.Done)
+    }
+
+    @Test
+    fun `an onboarded install owing only the notice gets one screen and no counter`() {
+        // The notice is the one step an existing install can still be given —
+        // and on its own it is not a wizard, so there is nothing to conclude.
+        val notice = plan(hasPermission = true, remindersDone = true, visibilityArmed = true)
+        assertThat(notice.steps).containsExactly(OnboardingStep.Visibility)
+        assertThat(notice.current).isEqualTo(OnboardingStep.Visibility)
+        assertThat(notice.showsProgress).isFalse()
+        assertThat(notice.canGoBack).isFalse()
+    }
+
+    @Test
+    fun `reading the notice ends an otherwise onboarded flow`() {
+        val read = plan(
+            hasPermission = true,
+            remindersDone = true,
+            visibilityArmed = true,
+            visibilityDone = true,
+        )
+        assertThat(read.current).isNull()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/search/SearchViewModelTest.kt

@@ -0,0 +1,247 @@
+package de.jeanlucmakiola.calendula.ui.search
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+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.EventInstance
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+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 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
+
+/**
+ * Selecting search results and deleting the batch (#80): which repository call
+ * each kind of hit routes to, and what a read-only calendar is allowed to join.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class SearchViewModelTest {
+
+    private val dispatcher = UnconfinedTestDispatcher()
+
+    @BeforeEach fun setUp() = Dispatchers.setMain(dispatcher)
+    @AfterEach fun tearDown() = Dispatchers.resetMain()
+
+    private val begin = 1_800_000_000_000L
+
+    private fun cal(id: Long, canModify: Boolean = true) = CalendarSource(
+        id = id, displayName = "Cal $id", accountName = "acc@local", accountType = "LOCAL",
+        color = 0xFF112233.toInt(), isVisibleInSystem = true, canModifyContents = canModify,
+    )
+
+    private fun hit(
+        id: Long,
+        calendarId: Long = 1L,
+        recurring: Boolean = false,
+        startMillis: Long = begin,
+    ) = SearchCandidate(
+        EventInstance(
+            instanceId = id, eventId = id, calendarId = calendarId, title = "Standup $id",
+            start = Instant.fromEpochMilliseconds(startMillis),
+            end = Instant.fromEpochMilliseconds(startMillis + 3_600_000L),
+            isAllDay = false, color = 0xFF000000.toInt(), location = null, isRecurring = recurring,
+        ),
+    )
+
+    private fun viewModel(tempDir: Path, fake: FakeCalendarDataSource): SearchViewModel {
+        val prefs = CalendarPrefs(
+            PreferenceDataStoreFactory.create(
+                scope = CoroutineScope(dispatcher),
+                produceFile = { tempDir.resolve("search_prefs.preferences_pb").toFile() },
+            ),
+        )
+        val settings = SettingsPrefs(
+            PreferenceDataStoreFactory.create(
+                scope = CoroutineScope(dispatcher),
+                produceFile = { tempDir.resolve("search_settings.preferences_pb").toFile() },
+            ),
+        )
+        val repo = CalendarRepositoryImpl(fake, prefs, settings, dispatcher as CoroutineDispatcher)
+        return SearchViewModel(repo, dispatcher)
+    }
+
+    private fun CoroutineScope.activate(vm: SearchViewModel): Job = launch { vm.state.collect {} }
+
+    @Test
+    fun `a batch of one-offs deletes each event whole`(@TempDir tempDir: Path) =
+        runTest(dispatcher) {
+            val fake = FakeCalendarDataSource().apply {
+                calendarsResult = listOf(cal(1L))
+                searchResult = { listOf(hit(1L), hit(2L), hit(3L)) }
+            }
+            val vm = viewModel(tempDir, fake)
+            val job = activate(vm)
+
+            vm.setQuery("standup")
+            advanceUntilIdle()
+            vm.toggleSelection(1L)
+            vm.toggleSelection(3L)
+            assertThat(vm.selectionHasRecurring()).isFalse()
+
+            vm.deleteSelected(RecurringWriteScope.AllEvents)
+            advanceUntilIdle()
+
+            assertThat(fake.deletedEventIds).containsExactly(1L, 3L)
+            assertThat(fake.deletedOccurrences).isEmpty()
+            assertThat(vm.selection.value).isEmpty()
+            assertThat(vm.deleteState.value).isEqualTo(BulkDeleteUiState.Done(deleted = 2, failed = 0))
+            job.cancel()
+        }
+
+    @Test
+    fun `the batch scope reaches the recurring hits only`(@TempDir tempDir: Path) =
+        runTest(dispatcher) {
+            val fake = FakeCalendarDataSource().apply {
+                calendarsResult = listOf(cal(1L))
+                searchResult = { listOf(hit(1L), hit(2L, recurring = true)) }
+            }
+            val vm = viewModel(tempDir, fake)
+            val job = activate(vm)
+
+            vm.setQuery("standup")
+            advanceUntilIdle()
+            vm.selectAll()
+            assertThat(vm.selectionHasRecurring()).isTrue()
+
+            vm.deleteSelected(RecurringWriteScope.ThisEvent)
+            advanceUntilIdle()
+
+            // The one-off goes whole whatever the batch decided; only the series
+            // sees the scope, cancelling the occurrence the result row stands for.
+            assertThat(fake.deletedEventIds).containsExactly(1L)
+            assertThat(fake.deletedOccurrences).containsExactly(2L to begin)
+            job.cancel()
+        }
+
+    @Test
+    fun `this-and-following truncates the recurring hit from its shown occurrence`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            searchResult = { listOf(hit(9L, recurring = true)) }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.setQuery("standup")
+        advanceUntilIdle()
+        vm.toggleSelection(9L)
+        vm.deleteSelected(RecurringWriteScope.ThisAndFollowing)
+        advanceUntilIdle()
+
+        assertThat(fake.deletedFromOccurrences).containsExactly(9L to begin)
+        job.cancel()
+    }
+
+    @Test
+    fun `a read-only calendar's hit cannot be selected or deleted`(@TempDir tempDir: Path) =
+        runTest(dispatcher) {
+            val fake = FakeCalendarDataSource().apply {
+                calendarsResult = listOf(cal(1L), cal(2L, canModify = false))
+                searchResult = { listOf(hit(1L, calendarId = 1L), hit(2L, calendarId = 2L)) }
+            }
+            val vm = viewModel(tempDir, fake)
+            val job = activate(vm)
+
+            vm.setQuery("standup")
+            advanceUntilIdle()
+
+            val results = vm.state.value as SearchUiState.Results
+            assertThat(results.isDeletable(results.events.single { it.eventId == 2L })).isFalse()
+
+            vm.selectAll()
+            assertThat(vm.selection.value).containsExactly(1L)
+
+            // Even a hand-toggled read-only row is dropped before the write.
+            vm.toggleSelection(2L)
+            vm.deleteSelected(RecurringWriteScope.AllEvents)
+            advanceUntilIdle()
+
+            assertThat(fake.deletedEventIds).containsExactly(1L)
+            job.cancel()
+        }
+
+    @Test
+    fun `a failing delete leaves the rest of the batch alone`(@TempDir tempDir: Path) =
+        runTest(dispatcher) {
+            val fake = FakeCalendarDataSource().apply {
+                calendarsResult = listOf(cal(1L))
+                searchResult = { listOf(hit(1L), hit(2L)) }
+                writeError = IllegalStateException("provider said no")
+            }
+            val vm = viewModel(tempDir, fake)
+            val job = activate(vm)
+
+            vm.setQuery("standup")
+            advanceUntilIdle()
+            vm.selectAll()
+            vm.deleteSelected(RecurringWriteScope.AllEvents)
+            advanceUntilIdle()
+
+            assertThat(vm.deleteState.value)
+                .isEqualTo(BulkDeleteUiState.Done(deleted = 0, failed = 2))
+            job.cancel()
+        }
+
+    @Test
+    fun `a permission revoked mid-batch still reports what already went`(@TempDir tempDir: Path) =
+        runTest(dispatcher) {
+            val fake = FakeCalendarDataSource().apply {
+                calendarsResult = listOf(cal(1L))
+                searchResult = { listOf(hit(1L), hit(2L), hit(3L)) }
+                writeError = SecurityException("revoked")
+                deletesBeforeError = 1
+            }
+            val vm = viewModel(tempDir, fake)
+            val job = activate(vm)
+
+            vm.setQuery("standup")
+            advanceUntilIdle()
+            vm.selectAll()
+            vm.deleteSelected(RecurringWriteScope.AllEvents)
+            advanceUntilIdle()
+
+            assertThat(fake.deletedEventIds).hasSize(1)
+            assertThat(vm.deleteState.value)
+                .isEqualTo(BulkDeleteUiState.NeedsPermission(deleted = 1))
+            job.cancel()
+        }
+
+    @Test
+    fun `changing the query drops the selection`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            searchResult = { listOf(hit(1L)) }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.setQuery("standup")
+        advanceUntilIdle()
+        vm.toggleSelection(1L)
+        assertThat(vm.selection.value).isNotEmpty()
+
+        vm.setQuery("retro")
+        assertThat(vm.selection.value).isEmpty()
+        job.cancel()
+    }
+}

docs/ARCHITECTURE.md

@@ -27,7 +27,7 @@ the package list (recurring writes, save conflicts, reminder delivery).
 ```mermaid
 flowchart TD
     subgraph UI ["ui/ — Compose screens + ViewModels"]
-        Screens["Month / Week / Day\nDetail / Edit / Settings\nPermission + Reminder onboarding"]
+        Screens["Month / Week / Day\nDetail / Edit / Settings\nOnboarding wizard"]
     end
     subgraph Data ["data/"]
         Repo["CalendarRepository\n(interface + impl, Flow-based, io-dispatched)"]
@@ -78,8 +78,8 @@ flowchart TD
 ## Navigation
 
 There is no navigation library. `MainActivity` hosts `RootScreen`, which
-gates on the calendar permission and the one-time reminder onboarding, then
-shows `CalendarHost`. `CalendarHost` holds the active view (month/week/day)
+gates on the first-launch wizard (`ui/onboarding/`), then shows
+`CalendarHost`. `CalendarHost` holds the active view (month/week/day)
 plus overlay state for detail, edit, and settings — full-screen overlays
 driven by `AnimatedVisibility` with a *held-key* pattern: the last shown
 key stays alive through the slide-out so content never flashes empty.
@@ -87,6 +87,32 @@ A tapped reminder notification routes through `MainActivity` (`singleTop` +
 `onNewIntent`) as an external detail key that `CalendarHost` consumes
 exactly like an event tap.
 
+### First-launch wizard
+
+`ui/onboarding/` is a plan, not a navigation graph: `onboardingPlan()` is a
+pure function of the stored answers that returns the whole flow *plus* the
+step it is on, and `RootScreen` renders that step. Two rules make it work:
+
+- The plan keeps **completed** steps, so finishing one never renumbers the
+  counter under the user, and stepping *back* is just clearing the previous
+  step's answer — there is no separate back stack. The calendar grant is the
+  one step with nothing to return to, so back stops there.
+- The optional steps (backup, view) only exist for an install still on its
+  first run — `armOnboardingWizard()` arms on any launch holding the calendar
+  permission but refuses if the reminder step was already answered, and the
+  closing screen clears the flag again, so revoking and re-granting the
+  permission later never re-onboards anyone.
+
+Whether the backup step applies (nothing writable is synced anywhere) cannot
+be known before the grant, so it is assumed until the calendar list can be
+read: the flow may shrink after the grant, never sprout a step the counter
+had not accounted for.
+
+The flow closes on an "all set" screen, and the one-time calendar-visibility
+notice (#75) is a step in front of it rather than a dialog over the app — it
+is the only optional step an *already onboarded* install can be given, which
+is why it alone is not gated on the wizard being armed.
+
 ## Recurring writes
 
 The provider's invariants drive the design (learned the hard way, verified
@@ -108,6 +134,83 @@ on-device):
   UTC, so zones ahead of UTC can't leak an extra occurrence.
 - All-day events are normalised to UTC midnights with an exclusive end.
 
+### Drag to reschedule
+
+Dropping an event on another slot (#68) is not a second write path: the drop
+loads the event, prefills the **same** `toEditForm` the edit screen uses, shifts
+it (`EventShift.kt`), and dispatches through the same three repository calls a
+save does — so recurring writes, reminder reconciliation and attendee
+preservation behave identically. The full form is carried through, never a
+stripped one: `updateOccurrence` reconciles reminders *and* attendees onto the
+new exception row, and a partial form would wipe them.
+
+Two things the drag has to get right that the edit screen sidesteps:
+
+- **`RRULE` day parts go stale.** `buildEventUpdateValues` writes the rule
+  verbatim while `DTSTART` moves, so dragging a `FREQ=WEEKLY;BYDAY=MO` occurrence
+  onto a Wednesday under *All events* leaves a Wednesday anchor under a Monday
+  rule and the series does not move. `realignRecurrence` re-derives `BYDAY`, and
+  returns **null** for everything else — the drop then offers only *this event*,
+  whose exception row carries no rule at all. The same staleness is reachable
+  from the edit screen; wiring it there too is a separate change.
+
+  What the rule has to agree with is the **series anchor**, not the occurrence
+  being dragged, and `buildEventUpdateValues` moves that anchor by the same
+  *wall-clock* shift. So the realigner only touches weekday, which is uniform mod
+  7 and therefore survives that shift whatever time of day the anchor sits at.
+  Day-of-month is not uniform — `BYMONTHDAY=28` with a January anchor, occurrence
+  Feb 28 dragged to Mar 1, would leave a Jan 29 anchor under a `BYMONTHDAY=1`
+  rule, a DTSTART that is not an instance of its own rule and a phantom
+  occurrence on any client that trusts it.
+
+  Uniform mod 7 is not enough on its own: the anchor also has to cross the *same
+  number of midnights* as the occurrence did, or the rebuilt weekday is off by a
+  day. `RescheduleViewModel` requires that of every write wider than one
+  occurrence, in the two shapes a drag comes in:
+
+  - a drag that **changes the day** must be a whole number of days, so the two
+    move in step whatever the anchor's time of day;
+  - a **time-only** drag must leave the anchor on its own day. That is normally
+    free, since the anchor shares the occurrence's time of day — but a row with
+    no `EVENT_TIMEZONE` resolves anchor and occurrence in zones that can sit a
+    DST hour apart, and a near-midnight drag would then carry the anchor across a
+    midnight the occurrence never crossed.
+
+  Whatever falls outside — a rule the realigner won't rebuild, or a shift that
+  would move rule and anchor out of step — may only move the one occurrence.
+
+  The accepted parts are deliberately a **subset** of what `parseSimpleRecurrence`
+  understands, so anything realignable is also a rule whose `UNTIL` the guard
+  below can actually read.
+- **The eligibility gate is load-bearing.** Nothing below the UI refuses a
+  write, so `CalendarSource.allowsEventMove` is what keeps read-only and
+  contact-managed events from being dragged. It is deliberately *not*
+  `isEventTarget`: a managed event is editable (reminders, notes) yet must never
+  move, while a switched-off calendar renders nothing to grab anyway.
+
+A drop that would push a series past its own `UNTIL` — the provider then
+generates zero occurrences and the event vanishes from every view — is refused
+rather than written. The check happens at **write** time, not at drop time,
+because which date has to clear `UNTIL` depends on how far the write reaches: a
+whole-series move carries the *anchor*, a split starts a new series at the moved
+occurrence, and a single occurrence becomes an exception row that no `UNTIL`
+constrains. Testing the occurrence in every case would refuse the perfectly
+ordinary drag of a bounded series' last occurrence.
+
+**One drop is written at a time.** Two drops of the same recurring event landing
+inside one write window would each compute their shift from the same pre-move
+occurrence, while the data layer applies both to the re-read anchor — so the
+shifts would compound. `RescheduleViewModel.move` therefore refuses while a write
+(or its scope dialog) is outstanding, and says so in its return value: the view
+that took the drop releases the block it was holding on the target instead of
+waiting out a settle that will never arrive.
+
+Two known limitations of a whole-series move, both shared with the edit screen's
+own *All events* time save rather than introduced here — a drag just makes them
+one gesture away: the series' `EXDATE` stamps and its exception rows are **not**
+re-anchored, so previously deleted occurrences can reappear and previously
+modified ones stay behind while the rest of the series moves.
+
 ### Event time zones
 
 `EventForm.timezone` is the zone its wall-clock times mean, and **null means
@@ -144,6 +247,22 @@ changes to untouched fields survive either way. Fields the form cannot
 write (attendees, status, reminder methods) are excluded so sync noise
 can't fake a conflict.
 
+A **dropped** event gets no conflict dialog, deliberately. Its blast radius is
+already bounded by the same dirty check — only `ALL_DAY`, `EVENT_TIMEZONE`,
+`DTSTART` and `DTEND`/`DURATION`/`RRULE` are written — so a concurrent remote
+edit to the title, notes or guests survives untouched. What a drop *can* clobber
+is a concurrent remote **time** change, and parking a one-gesture action behind a
+modal would cost more than that case is worth; the undo on the confirmation chip
+is the answer instead. Undo restores semantics, not the row's byte
+shape (`DURATION` normalises to `P<n>S`/`P<n>D`, `EVENT_TIMEZONE` is stamped
+concrete), and it is offered only where the inverse is one symmetric write — a
+one-off event or a whole-series shift. *This event* leaves an exception row
+behind and *this and following* splits the series; neither is undone by shifting
+back, so both get a plain confirmation. Two further gaps, both narrow and
+accepted: a shift whose *anchor* crosses a DST gap is not invertible in wall
+clock (the −Δ normalises back to where it started), and an undo after a
+concurrent remote time change overwrites it, exactly as the forward move would.
+
 ## Reminder delivery
 
 Calendula plans and fires its own reminders. It reads the offsets in

fastlane/metadata/android/ar/changelogs/21900.txt

@@ -0,0 +1,6 @@
+جديد
+• اسحب الحدث لتغيير وقته أو يومه: اضغط عليه مطولاً في عرض الشهر أو الأسبوع أو اليوم ثم أفلته في المكان الجديد. في الأحداث المتكررة يُسأل عن نطاق النقل.
+• احذف عدة نتائج بحث دفعة واحدة: اضغط مطولاً على نتيجة لبدء التحديد، ثم احذفها معاً.
+
+تغييرات
+• أصبح التشغيل الأول معالجاً قصيراً. يمكنه أيضاً تفعيل النسخ الاحتياطي التلقائي واختيار العرض الافتتاحي، وكلاهما مع معاينة.

fastlane/metadata/android/ar/changelogs/21901.txt

@@ -0,0 +1,3 @@
+جديد
+• صار بالإمكان إيقاف السحب لتغيير الموعد: الإعدادات ← العروض ← «السحب لتغيير الموعد». يبقى مفعّلاً افتراضياً؛ وعند إيقافه لا يمكن سحب الأحداث في عرض الشهر أو الأسبوع أو اليوم.
+• صار Calendula يتحدّث البرتغالية البرازيلية بفضل ترجمة من المجتمع. اخترها من الإعدادات ← اللغة.

fastlane/metadata/android/de-DE/changelogs/21900.txt

@@ -0,0 +1,6 @@
+Neu
+• Termine per Drag & Drop verschieben: in der Monats-, Wochen- oder Tagesansicht lange gedrückt halten und zu einer anderen Zeit oder einem anderen Tag ablegen. Bei Serienterminen wird nachgefragt, wofür sie gilt.
+• Mehrere Suchergebnisse auf einmal löschen: langer Druck auf einen Treffer startet die Auswahl.
+
+Geändert
+• Der erste Start ist jetzt ein kurzer Assistent. Er kann auch die automatische Sicherung einrichten und dich die Startansicht wählen lassen – beides mit Vorschau.

fastlane/metadata/android/de-DE/changelogs/21901.txt

@@ -0,0 +1,3 @@
+Neu
+• Verschieben per Drag & Drop lässt sich abschalten: Einstellungen → Ansichten → „Per Ziehen verschieben“. Standardmäßig bleibt es an; abgeschaltet lassen sich Termine in der Monats-, Wochen- und Tagesansicht nicht mehr aufnehmen.
+• Calendula spricht jetzt brasilianisches Portugiesisch – dank einer Community-Übersetzung. Auswählbar unter Einstellungen → Sprache.

fastlane/metadata/android/en-GB/changelogs/21900.txt

@@ -0,0 +1,6 @@
+New
+• Drag an event to reschedule it — press and hold it in month, week or day view and drop it on another time or day. Recurring events ask what the move applies to.
+• Delete several search results at once: long-press a hit to start selecting, then delete them in one action.
+
+Changed
+• First launch is now a short wizard. It can also set up automatic backup and let you pick the view Calendula opens on, both with previews.

fastlane/metadata/android/en-GB/changelogs/21901.txt

@@ -0,0 +1,3 @@
+Added
+• Drag to reschedule can now be turned off: Settings → Views → “Drag to reschedule”. It stays on by default; switched off, events can no longer be picked up in the month, week or day view.
+• Calendula now speaks Brazilian Portuguese, thanks to a community translation. Pick it under Settings → Language.

fastlane/metadata/android/en-US/changelogs/21900.txt

@@ -0,0 +1,6 @@
+New
+• Drag an event to reschedule it — press and hold it in month, week or day view and drop it on another time or day. Recurring events ask what the move applies to.
+• Delete several search results at once: long-press a hit to start selecting, then delete them in one action.
+
+Changed
+• First launch is now a short wizard. It can also set up automatic backup and let you pick the view Calendula opens on, both with previews.

fastlane/metadata/android/en-US/changelogs/21901.txt

@@ -0,0 +1,3 @@
+Added
+• Drag to reschedule can now be turned off: Settings → Views → “Drag to reschedule”. It stays on by default; switched off, events can no longer be picked up in the month, week or day view.
+• Calendula now speaks Brazilian Portuguese, thanks to a community translation. Pick it under Settings → Language.

fastlane/metadata/android/es-ES/changelogs/21900.txt

@@ -0,0 +1,6 @@
+Novedades
+• Arrastra un evento para cambiarlo de hora o de día: mantenlo pulsado en la vista de mes, semana o día y suéltalo donde quieras. En los eventos periódicos se pregunta a qué afecta el cambio.
+• Elimina varios resultados de búsqueda a la vez: mantén pulsado un resultado para empezar a seleccionar.
+
+Cambios
+• El primer inicio es ahora un breve asistente. También puede activar la copia de seguridad automática y dejarte elegir la vista inicial, ambas con vista previa.

fastlane/metadata/android/es-ES/changelogs/21901.txt

@@ -0,0 +1,3 @@
+Novedades
+• Ahora se puede desactivar el mover eventos arrastrando: Ajustes → Vistas → «Arrastrar para reprogramar». Sigue activado por defecto; desactivado, los eventos ya no se pueden arrastrar en las vistas de mes, semana y día.
+• Calendula ya habla portugués de Brasil, gracias a una traducción de la comunidad. Elígelo en Ajustes → Idioma.

fastlane/metadata/android/fr-FR/changelogs/21900.txt

@@ -0,0 +1,6 @@
+Nouveautés
+• Déplacez un événement par glisser-déposer : appuyez longuement dessus en vue mois, semaine ou jour, puis déposez-le à une autre heure ou un autre jour. Pour un événement récurrent, la portée du déplacement est demandée.
+• Supprimez plusieurs résultats de recherche d'un coup : un appui long lance la sélection.
+
+Modifié
+• Le premier lancement est désormais un court assistant. Il peut aussi activer la sauvegarde automatique et vous laisser choisir la vue d'ouverture, avec aperçu.

fastlane/metadata/android/fr-FR/changelogs/21901.txt

@@ -0,0 +1,3 @@
+Nouveautés
+• Le déplacement par glisser-déposer peut désormais être désactivé : Réglages → Vues → « Glisser pour déplacer ». Il reste activé par défaut ; désactivé, les événements ne peuvent plus être saisis en vue mois, semaine ou jour.
+• Calendula parle désormais le portugais brésilien, grâce à une traduction de la communauté. À choisir dans Réglages → Langue.

fastlane/metadata/android/it-IT/changelogs/21900.txt

@@ -0,0 +1,6 @@
+Novità
+• Trascina un evento per spostarlo a un altro orario o giorno: tienilo premuto nella vista mese, settimana o giorno e rilascialo. Per gli eventi ricorrenti viene chiesto a cosa si applica lo spostamento.
+• Elimina più risultati di ricerca in una volta: tieni premuto un risultato per iniziare a selezionare.
+
+Modifiche
+• Il primo avvio è ora una breve procedura guidata. Può anche attivare il backup automatico e farti scegliere la vista iniziale, entrambi con anteprima.