Keep SizeMode.Exact: Single and Responsive never reflow on resize (#214)

GlanceAppWidget.resize returns early for both, so the grid was never recomposed
for a new size and a resized widget clipped instead of reflowing. Exact costs one
serialised copy per host size, which the view cuts have made affordable again.

Drops the options-derived width that went with Single; LocalSize is exact here.

CHANGELOG.md

@@ -7,6 +7,91 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+- Tapping an empty slot in week or day view creates the event at the hour you
+  tapped, after the timeline has been zoomed. Pinching the day taller or shorter
+  — or changing **Hour height** in Settings — left the tap still being measured
+  against the old spacing, so the new event landed at some other hour entirely
+  ([#148]).
+
 ## [2.18.0] — 2026-07-31
 
 ### Added
@@ -1323,3 +1408,9 @@ automatically, with zero telemetry and no internet permission.
 [#57]: https://codeberg.org/jlmakiola/calendula/issues/57
 [#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

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 = 21800
+        versionCode = 21902
-        versionName = "2.18.0"
+        versionName = "2.19.2"
 
         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
+     * Master/one-off events that may match [query], across all calendars: every
-     * [query] (case-insensitive), across all calendars, newest first. Reads the
+     * whitespace-separated token has to appear in the title, description or
-     * Events table directly so the search is unbounded in time; exception rows
+     * location. Reads the Events table directly so the search is unbounded in
-     * are excluded (see [SearchProjection]). [query] is assumed non-blank.
+     * 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()
+        val tokens = EventSearch.tokenize(query).take(MAX_SEARCH_TOKENS)
-        if (trimmed.isEmpty()) return emptyList()
+        if (tokens.isEmpty()) return emptyList()
-        // Escape the SQL LIKE wildcards so a literal % or _ in the query matches
+        // Only a pre-filter: EventSearch re-checks every token, including the
-        // itself instead of acting as a wildcard.
+        // ones the cap above dropped.
-        val escaped = trimmed
+        val patterns = tokens.map { likePatterns(it) }
-            .replace("\\", "\\\\")
+        val match = patterns.joinToString(" AND ") { variants ->
-            .replace("%", "\\%")
+            variants.joinToString(" OR ", prefix = "(", postfix = ")") {
-            .replace("_", "\\_")
+                "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
-        val like = "%$escaped%"
+                    "${CalendarContract.Events.DESCRIPTION} LIKE ? ESCAPE '\\' OR " +
-        val match = "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
+                    "${CalendarContract.Events.EVENT_LOCATION} LIKE ? ESCAPE '\\'"
-            "${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,17 +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
+                // A recurring master's DTSTART is the series start; date the row
-                // nearest occurrence instead so the date is the one the user
+                // by its nearest occurrence instead.
-                // actually cares about (and sorting reflects it).
+                val event = if (base.isRecurring) {
-                out += if (base.isRecurring) {
                     nearestOccurrenceMillis(base.eventId)?.let { (begin, end) ->
                         base.copy(
                             start = begin.toKotlinInstantFromEpochMillis(),
@@ -626,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
@@ -1591,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
+     * Candidate matches for [query] with hidden calendars removed; empty when
-     * calendars removed and newest first. Empty when [query] is blank. Searches
+     * [query] is blank. Searches the whole history/future and leaves matching
-     * the whole history/future (see [CalendarDataSource.searchEvents]).
+     * 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/InstanceMapper.kt

@@ -1,6 +1,7 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
+import android.provider.CalendarContract
 import android.util.Log
 import de.jeanlucmakiola.calendula.domain.EventInstance
 
@@ -38,5 +39,7 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
         isAllDay = getInt(InstanceProjection.IDX_ALL_DAY) != 0,
         color = color,
         location = getString(InstanceProjection.IDX_LOCATION),
+        isDeclined = getInt(InstanceProjection.IDX_SELF_ATTENDEE_STATUS) ==
+            CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED,
     )
 }

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

@@ -52,6 +52,7 @@ internal object InstanceProjection {
         CalendarContract.Instances.EVENT_COLOR,
         CalendarContract.Instances.CALENDAR_COLOR,
         CalendarContract.Instances.EVENT_LOCATION,
+        CalendarContract.Instances.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_INSTANCE_ID = 0
@@ -64,6 +65,7 @@ internal object InstanceProjection {
     const val IDX_EVENT_COLOR = 7
     const val IDX_CALENDAR_COLOR = 8
     const val IDX_LOCATION = 9
+    const val IDX_SELF_ATTENDEE_STATUS = 10
 }
 
 internal object EventDetailProjection {
@@ -180,6 +182,9 @@ 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,
+        CalendarContract.Events.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_ID = 0
@@ -194,6 +199,8 @@ internal object SearchProjection {
     const val IDX_LOCATION = 9
     const val IDX_RRULE = 10
     const val IDX_RDATE = 11
+    const val IDX_DESCRIPTION = 12
+    const val IDX_SELF_ATTENDEE_STATUS = 13
 }
 
 /**

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import android.provider.CalendarContract
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
@@ -42,5 +43,7 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
         location = getString(SearchProjection.IDX_LOCATION),
         isRecurring = !getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
             !getString(SearchProjection.IDX_RDATE).isNullOrEmpty(),
+        isDeclined = getInt(SearchProjection.IDX_SELF_ATTENDEE_STATUS) ==
+            CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED,
     )
 }

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() {
+    /** Cleared, not just set: the wizard's back button re-asks a step (#163). */
-        store.edit { it[REMINDER_ONBOARDING_KEY] = true }
+    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/data/reminders/ReminderInstanceSource.kt

@@ -44,9 +44,16 @@ class ProviderReminderInstanceSource @Inject constructor(
         // `visible` is the flag the app's one visibility model writes (#75).
         // The status clause mirrors CalendarDataSource.instances: NULL means
         // "normal", so a bare `!= CANCELED` would drop every ordinary event.
+        // An invitation the user declined is answered — it stays on the calendar
+        // struck through, but it plans nothing (#180). NULL again means "no
+        // answer recorded", which is not a "no".
         val selection = "${CalendarContract.Calendars.VISIBLE} = 1 AND " +
             "(${CalendarContract.Instances.STATUS} IS NULL OR " +
-            "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED})"
+            "${CalendarContract.Instances.STATUS} != " +
+            "${CalendarContract.Events.STATUS_CANCELED}) AND " +
+            "(${CalendarContract.Instances.SELF_ATTENDEE_STATUS} IS NULL OR " +
+            "${CalendarContract.Instances.SELF_ATTENDEE_STATUS} != " +
+            "${CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED})"
         return context.contentResolver.query(
             uri, OCCURRENCE_PROJECTION, selection, null, null,
         )?.use { c ->

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/Models.kt

@@ -63,11 +63,17 @@ data class EventInstance(
     val color: Int,
     val location: String?,
     /**
-     * Whether this row's event carries a recurrence rule. Only search results
+     * Only search results, which read the series master, fill this in — the
-     * (which read the series master) fill this in — the Instances query already
+     * Instances query already yields one row per occurrence.
-     * yields one row per occurrence, so it stays false there.
      */
     val isRecurring: Boolean = false,
+    /**
+     * This device user answered "no" to the invitation
+     * (`Events.SELF_ATTENDEE_STATUS`). The event stays on the calendar — it is
+     * still an appointment someone expects an answer about — but every surface
+     * strikes it through, and it plans no reminders (#180).
+     */
+    val isDeclined: Boolean = false,
 )
 
 /**

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

@@ -312,9 +312,13 @@ fun CalendarHost(
         heldEditKey = key
         editKey = key
     }
-    val moveScope = remember(movableCalendarIds, reschedule) {
+    // 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,

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.animation.AnimatedContent
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.animation.fadeIn
-import androidx.compose.material3.MaterialTheme
+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.common.rememberCalendarFadeSpec
-import de.jeanlucmakiola.calendula.ui.calendars.CalendarVisibilityNoticeViewModel
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingStep
-import de.jeanlucmakiola.calendula.ui.permission.PermissionScreen
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingSteps
-import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingScreen
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingViewModel
-import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingViewModel
+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,58 +88,87 @@ fun RootScreen(
         onDispose { lifecycle.removeObserver(obs) }
     }
 
-    // Cross-fade the one-time onboarding gates so granting permission / finishing
+    val onboarding: OnboardingViewModel = hiltViewModel()
-    // onboarding eases into the next screen instead of snapping. A fade carries no
+    val plan by onboarding.plan.collectAsStateWithLifecycle()
-    // spatial motion, so it stays appropriate under "remove animations" too.
+    // The grant is reported however it was taken, including via Android's
-    val gateSpec = MaterialTheme.motionScheme.fastEffectsSpec<Float>()
+    // app-settings screen (caught by the ON_RESUME above); arming the wizard
-    Crossfade(targetState = hasPermission, animationSpec = gateSpec, label = "permissionGate") { granted ->
+    // hangs off that, not off the in-app callback.
-        if (granted) {
+    LaunchedEffect(hasPermission) {
-            // Second onboarding gate (v1.4, one-time): reminder notifications.
+        onboarding.setHasPermission(hasPermission)
-            // Null until DataStore's first emission — render nothing for that
+        if (hasPermission && !grantedAtLaunch) onboarding.onPermissionGranted()
-            // frame instead of flashing the wrong screen.
+    }
-            val reminderOnboarding: ReminderOnboardingViewModel = hiltViewModel()
+
-            val onboardingDone by reminderOnboarding.onboardingDone.collectAsStateWithLifecycle()
+    // Arms the one-time explainer for the switch to the device's own calendar
-            // 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.
-            // visibility (#75), armed by the reconciler.
+    LaunchedEffect(hasPermission) {
-            val visibilityNotice: CalendarVisibilityNoticeViewModel = hiltViewModel()
+        if (hasPermission) onboarding.reconcileCalendarVisibility()
-            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).
+    val current = plan
-            LaunchedEffect(Unit) {
+    val target: RootTarget = when {
-                visibilityNotice.reconcile()
+        current == null -> RootTarget.Loading
-                if (!grantedAtLaunch) reminderOnboarding.rearmAfterGrant()
+        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,
+                )
             }
-            if (onboardingDone == true && noticePending) {
+        },
-                CalendarVisibilityNoticeDialog(onDismiss = visibilityNotice::dismiss)
+        label = "onboardingGate",
-            }
+    ) { shown ->
-            Crossfade(targetState = onboardingDone, animationSpec = gateSpec, label = "onboardingGate") { done ->
+        when (shown) {
-                when (done) {
+            RootTarget.Loading -> Unit
-                    true -> CalendarHost(
+            RootTarget.App -> CalendarHost(
-                        modifier = modifier,
-                        requestedDetailKey = requestedDetailKey,
-                        onDetailKeyConsumed = onDetailKeyConsumed,
-                        widgetNavRequest = widgetNavRequest,
-                        onWidgetNavConsumed = onWidgetNavConsumed,
-                        requestedImportUri = requestedImportUri,
-                        onImportConsumed = onImportConsumed,
-                        requestedInsertForm = requestedInsertForm,
-                        requestedInsertSource = requestedInsertSource,
-                        onInsertConsumed = onInsertConsumed,
-                        requestedEditKey = requestedEditKey,
-                        onEditKeyConsumed = onEditKeyConsumed,
-                    )
-                    false -> ReminderOnboardingScreen(
-                        onFinished = reminderOnboarding::finish,
-                        modifier = modifier,
-                    )
-                    null -> {}
-                }
-            }
-        } else {
-            PermissionScreen(
-                onGranted = { hasPermission = true },
                 modifier = modifier,
+                requestedDetailKey = requestedDetailKey,
+                onDetailKeyConsumed = onDetailKeyConsumed,
+                widgetNavRequest = widgetNavRequest,
+                onWidgetNavConsumed = onWidgetNavConsumed,
+                requestedImportUri = requestedImportUri,
+                onImportConsumed = onImportConsumed,
+                requestedInsertForm = requestedInsertForm,
+                requestedInsertSource = requestedInsertSource,
+                onInsertConsumed = onInsertConsumed,
+                requestedEditKey = requestedEditKey,
+                onEditKeyConsumed = onEditKeyConsumed,
             )
+            // 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/AgendaRows.kt

@@ -24,11 +24,13 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
+import de.jeanlucmakiola.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
@@ -129,8 +131,8 @@ internal fun AgendaEventRow(
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     GroupedRow(
         modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
-        title = title,
+        title = declinedTitle(title, event.isDeclined),
-        summary = agendaTimeSummary(event, day, zone),
+        summary = AnnotatedString(agendaTimeSummary(event, day, zone)),
         position = position,
         minHeight = 64.dp,
         leading = {

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/EventMoveScope.kt

@@ -29,6 +29,12 @@ class EventMoveScope(
      * 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,
     /**
@@ -91,6 +97,17 @@ fun ghostAlpha(lifted: Boolean): Float = animateFloatAsState(
     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.

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

@@ -36,6 +36,14 @@ val GUTTER_WIDTH = 48.dp
  */
 val GUTTER_CONTENT_START_INSET = 8.dp
 
+/**
+ * End inset for everything that lines up with the day columns — the week's day
+ * header, the all-day strip and the timeline itself. Without it the last column
+ * runs flush into the screen edge while the gutter gives the other side room
+ * (#192); 8dp mirrors [GUTTER_CONTENT_START_INSET].
+ */
+val TIMELINE_CONTENT_END_INSET = 8.dp
+
 private val BADGE_HEIGHT = 20.dp
 
 /** How far the fixed hour labels recede while a block is being dragged. */

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

@@ -1,6 +1,10 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.style.TextDecoration
 import kotlin.time.Instant
 
 /**
@@ -14,3 +18,30 @@ val LocalDimCutoff = compositionLocalOf<Instant?> { null }
 
 /** Opacity applied to a completed/past event chip when it is dimmed. */
 const val EventDimAlpha = 0.4f
+
+/**
+ * How a declined invitation's title is struck through (#180) — the mark every
+ * surface uses to say "you answered no", chosen over hiding the event because it
+ * is still something the organiser expects you at. Null for everything else, so
+ * it drops straight into a `Text`'s `textDecoration`.
+ */
+fun declinedDecoration(isDeclined: Boolean): TextDecoration? =
+    if (isDeclined) TextDecoration.LineThrough else null
+
+/** [declinedDecoration] for the rows that take styled text rather than a `String`. */
+fun declinedTitle(title: String, isDeclined: Boolean): AnnotatedString = if (isDeclined) {
+    AnnotatedString(title, SpanStyle(textDecoration = TextDecoration.LineThrough))
+} else {
+    AnnotatedString(title)
+}
+
+/** [declinedTitle] over already-styled text, e.g. a search hit's marked runs. */
+fun declinedTitle(title: AnnotatedString, isDeclined: Boolean): AnnotatedString =
+    if (!isDeclined) {
+        title
+    } else {
+        buildAnnotatedString {
+            append(title)
+            addStyle(SpanStyle(textDecoration = TextDecoration.LineThrough), 0, title.length)
+        }
+    }

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/TimelineScale.kt

@@ -76,6 +76,18 @@ fun TimelineScale.hourHeight(viewportHeight: Dp): Dp = when (this) {
         .coerceAtLeast(fillHourHeight(viewportHeight))
 }
 
+/**
+ * The minute of the day a tap [offsetY] px down a timeline column means, snapped
+ * to the hour it landed in.
+ *
+ * [hourPx] must be the hour height the column is drawing at *now* — a tap
+ * detector that captured it when it was installed maps taps to a pre-pinch grid
+ * (#148). A zero or negative height (a viewport measured at nothing) has no grid
+ * to read, so it answers midnight rather than dividing by it.
+ */
+fun tappedMinuteOfDay(offsetY: Float, hourPx: Float): Int =
+    if (hourPx <= 0f) 0 else (offsetY / hourPx).toInt().coerceIn(0, 23) * 60
+
 /**
  * Shortest an event block may render, as a fraction of an hour. Blocks keep a
  * floor so a 15-minute event stays tappable, but the floor scales with the hour

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

@@ -46,6 +46,7 @@ import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -91,6 +92,7 @@ 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.rememberEventDragSource
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
@@ -104,6 +106,7 @@ import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.eventInk
+import de.jeanlucmakiola.calendula.ui.common.declinedDecoration
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
@@ -116,7 +119,9 @@ import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
 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.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
+import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
@@ -131,7 +136,7 @@ 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
@@ -366,7 +371,7 @@ private fun DayContent(
 }
 
 @Composable
-private fun DaySuccess(
+internal fun DaySuccess(
     state: DayUiState.Success,
     topSectionColor: Color,
     scrollState: ScrollState,
@@ -468,7 +473,11 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it resizes smoothly; padding sits
             // inside it so the content area is lanes * row height.
             .height(height)
-            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+            .padding(
+                top = ALL_DAY_VERTICAL_PADDING,
+                bottom = ALL_DAY_VERTICAL_PADDING,
+                end = TIMELINE_CONTENT_END_INSET,
+            ),
     ) {
         // Keep the gutter-width offset so the bars line up with the day column.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -522,6 +531,7 @@ private fun AllDayBar(
             maxLines = 1,
             overflow = TextOverflow.Ellipsis,
             color = eventInk(fill),
+            textDecoration = declinedDecoration(event.isDeclined),
         )
     }
 }
@@ -567,6 +577,7 @@ private fun Timeline(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
                     .verticalScroll(scrollState)
                     .onGloballyPositioned { dragController.geometry.viewport = it },
@@ -623,6 +634,12 @@ private fun DayColumnCard(
     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
+    // them, or taps land on the scale the column had before the zoom (#148).
+    val currentHourPx = rememberUpdatedState(hourPx)
+    val currentOnCreateAt = rememberUpdatedState(onCreateAt)
     Card(
         // Plain rectangular column — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -643,8 +660,10 @@ private fun DayColumnCard(
                 // only fires on the column background. Snaps to the tapped hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
-                        val hour = (offset.y / hourPx).toInt().coerceIn(0, 23)
+                        currentOnCreateAt.value(
-                        onCreateAt(date, hour * 60)
+                            date,
+                            tappedMinuteOfDay(offset.y, currentHourPx.value),
+                        )
                     }
                 },
         ) {
@@ -727,7 +746,7 @@ private fun EventBlock(
     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 = moveAction != null && block.beginsOn(date, zone)
+    val draggable = eventDragAllowed(block.event) && block.beginsOn(date, zone)
     val dragModifier = rememberEventDragSource(
         enabled = draggable,
         key = block.event.instanceId,
@@ -761,6 +780,7 @@ private fun EventBlock(
                     maxLines = if (showTime) 1 else 2,
                     overflow = TextOverflow.Ellipsis,
                     color = eventInk(fill, alpha = 0.85f),
+                    textDecoration = declinedDecoration(block.event.isDeclined),
                 )
             }
             if (showTime) {
@@ -781,7 +801,12 @@ private fun DayLoading() {
         // Same scale resolution as the loaded timeline, so the skeleton's column
         // doesn't resize the moment the real day arrives.
         val totalHeight = scale.hourHeight(maxHeight) * 24
-        Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+        Row(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(end = TIMELINE_CONTENT_END_INSET)
+                .verticalScroll(scrollState),
+        ) {
             Spacer(Modifier.width(GUTTER_WIDTH))
             Box(
                 modifier = Modifier

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/detail/EventDetailViewModel.kt

@@ -78,9 +78,15 @@ class EventDetailViewModel @Inject constructor(
      * the occurrence's own times (from `CalendarContract.Instances`); they
      * override the series DTSTART/DTEND so recurring events show the correct
      * date instead of the first occurrence.
+     *
+     * Re-opening the *same* occurrence always re-reads it. The view model
+     * outlives the sheet, and a `StateFlow` conflates an identical value away,
+     * so assigning the target alone would leave an edit that changed no time —
+     * adding a description, say (#196) — showing the state from before the save.
      */
     fun open(eventId: Long, beginMillis: Long, endMillis: Long) {
-        _target.value = Target(eventId, beginMillis, endMillis)
+        val target = Target(eventId, beginMillis, endMillis)
+        if (_target.value == target) _reload.value += 1 else _target.value = target
     }
 
     /** Re-run the current load after a failure. */

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

@@ -19,6 +19,8 @@ import androidx.compose.animation.togetherWith
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.foundation.gestures.detectDragGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -111,6 +113,7 @@ import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
@@ -138,6 +141,7 @@ import de.jeanlucmakiola.calendula.ui.common.CALENDAR_SWIPE_THRESHOLD
 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.declinedDecoration
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
@@ -439,6 +443,7 @@ fun MonthScreen(
                             showWeekNumbers = showWeekNumbers,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
+                            onEventClick = onEventClick,
                         )
                     } else if (viewStyle == MonthViewStyle.Split) {
                         SplitMonthContent(
@@ -463,6 +468,7 @@ fun MonthScreen(
                             onSwipePrev = goPrev,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
+                            onEventClick = onEventClick,
                         )
                     }
                 }
@@ -573,6 +579,7 @@ private fun MonthContent(
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
     val fadeSpec = rememberCalendarFadeSpec()
@@ -599,6 +606,7 @@ private fun MonthContent(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         }
     }
@@ -617,6 +625,7 @@ private fun ContinuousMonthContent(
     showWeekNumbers: Boolean,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     when (state) {
         // The scrolling styles get their own skeleton rather than the paged
@@ -631,6 +640,7 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         } else {
             ContinuousMonthGrid(
@@ -638,6 +648,7 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         }
     }
@@ -736,7 +747,8 @@ private val CELL_SHAPE = RoundedCornerShape(CELL_CORNER)
 
 /** Width of the split style's selected-day outline. */
 private val SPLIT_SELECTION_STROKE = 1.5.dp
-private const val MAX_EVENT_ROWS = 3
+/** Lanes of bars/pills a day cell draws before the rest become overflow dots. */
+internal const val MAX_EVENT_ROWS = 3
 
 /**
  * Row height in the continuous grid. The paged grid divides the viewport between
@@ -754,11 +766,15 @@ private val CONTINUOUS_ROW_HEIGHT = 112.dp
  */
 private val CONTINUOUS_MONTH_GAP = 20.dp
 
+/** Gap between the weekday header and the seamless stream's first week row. */
+private val DENSE_HEADER_GAP = 4.dp
+
 @Composable
 internal fun MonthGrid(
     state: MonthUiState.Success,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     /** See [MonthWeekRow]'s `selected`: an anchor for the morph, never a mark. */
     selected: LocalDate? = null,
 ) {
@@ -779,6 +795,7 @@ internal fun MonthGrid(
                 inMonth = { it.month == month.month && it.year == month.year },
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
                 selected = selected,
                 modifier = Modifier
                     .fillMaxWidth()
@@ -809,6 +826,7 @@ internal fun ContinuousMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val monthCount = remember { continuousMonthCount() }
@@ -836,6 +854,7 @@ internal fun ContinuousMonthGrid(
                     today = state.today,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                 )
             }
         }
@@ -855,6 +874,7 @@ private fun ContinuousMonthBlock(
     today: LocalDate,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     val rowCount = remember(month, weekStart) { weekRowsInMonth(month, weekStart) }
     Column(
@@ -877,6 +897,7 @@ private fun ContinuousMonthBlock(
                     blankOutside = true,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                     modifier = Modifier
                         .fillMaxWidth()
                         .height(CONTINUOUS_ROW_HEIGHT),
@@ -935,6 +956,7 @@ internal fun DenseMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val weekCount = remember(state.weekStart) { continuousWeekCount(state.weekStart) }
@@ -942,10 +964,15 @@ internal fun DenseMonthGrid(
         state = listState,
         modifier = modifier
             .fillMaxSize()
-            .padding(horizontal = 8.dp),
+            // The gap under the weekday header is a real margin, not content
+            // padding: a lazy list scrolls its rows *through* the before-content
+            // padding, so scrolling to a week landed its row that far down with
+            // the tail of the previous one showing above it (#191).
+            .padding(horizontal = 8.dp)
+            .padding(top = DENSE_HEADER_GAP),
         verticalArrangement = Arrangement.spacedBy(2.dp),
         // Bottom inset clears the FAB stack so the last row stays tappable.
-        contentPadding = PaddingValues(top = 4.dp, bottom = 96.dp),
+        contentPadding = PaddingValues(bottom = 96.dp),
     ) {
         items(count = weekCount, key = { it }) { index ->
             val week = state.weeksByIndex[index]
@@ -960,6 +987,7 @@ internal fun DenseMonthGrid(
                     inMonth = { true },
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                     labelMonthOnFirst = true,
                     modifier = Modifier
                         .fillMaxWidth()
@@ -1187,6 +1215,9 @@ private fun SplitMonthBody(
                 onSelectDay(it)
                 onSetExpanded(false)
             },
+            // A tapped chip is asking for that event, not for its day, so it
+            // opens the detail from here too rather than collapsing (#187).
+            onEventClick = onEventClick,
             onCollapse = { onSetExpanded(false) },
         )
     } else {
@@ -1287,6 +1318,7 @@ private fun SplitMonthExpanded(
     showWeekNumbers: Boolean,
     swipeModifier: Modifier,
     onPickDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     onCollapse: () -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
@@ -1309,6 +1341,7 @@ private fun SplitMonthExpanded(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onPickDay,
+                onEventClick = onEventClick,
                 selected = sel,
             )
         }
@@ -1789,7 +1822,7 @@ private fun ContinuousMonthSkeleton(dense: Boolean) {
                 modifier = Modifier.padding(bottom = 8.dp),
             )
         } else {
-            Spacer(Modifier.height(4.dp))
+            Spacer(Modifier.height(DENSE_HEADER_GAP))
         }
         // More rows than a viewport holds; the clip takes the overflow.
         repeat(6) {
@@ -1837,6 +1870,7 @@ private fun MonthWeekRow(
     inMonth: (LocalDate) -> Boolean,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
     blankOutside: Boolean = false,
     labelMonthOnFirst: Boolean = false,
@@ -2135,11 +2169,17 @@ private fun MonthWeekRow(
                 }
             }
 
-            // Tap layer: in month view a tap on any day opens that day. Padded and
+            // Tap layer: a tap on a chip opens that event, anything else opens the
+            // day (#187). The chips take no pointer input of their own — this
+            // layer covers them — so the lane under the finger is resolved
+            // geometrically, exactly as the drag pickup above does it; the down
+            // position is read on the initial pass, which consumes nothing and so
+            // leaves both the click and a pickup in flight untouched. Padded and
             // clipped to the background pill so the ripple matches it. A blanked
             // cell isn't part of this month, so it takes no taps either.
+            val downY = remember(week.days.size) { FloatArray(week.days.size) }
             Row(Modifier.matchParentSize()) {
-                week.days.forEach { d ->
+                week.days.forEachIndexed { col, d ->
                     if (blankOutside && !inMonth(d)) {
                         Spacer(Modifier.weight(1f).fillMaxHeight())
                     } else {
@@ -2147,9 +2187,28 @@ private fun MonthWeekRow(
                             Modifier
                                 .weight(1f)
                                 .fillMaxHeight()
+                                .pointerInput(col) {
+                                    awaitEachGesture {
+                                        downY[col] = awaitFirstDown(
+                                            requireUnconsumed = false,
+                                            pass = PointerEventPass.Initial,
+                                        ).position.y
+                                    }
+                                }
                                 .padding(horizontal = CELL_GAP, vertical = 1.dp)
                                 .clip(CELL_SHAPE)
-                                .clickable { onOpenDay(d) },
+                                .clickable {
+                                    val chip = week.chipAtCellY(
+                                        col = col,
+                                        cellY = downY[col],
+                                        bandTopInCell = bandTopInCell(
+                                            cellCoordinates,
+                                            bandCoordinates,
+                                        ),
+                                        rowHeightPx = rowHeightPx,
+                                    )
+                                    if (chip != null) onEventClick(chip) else onOpenDay(d)
+                                },
                         )
                     }
                 }
@@ -2158,6 +2217,38 @@ private fun MonthWeekRow(
     }
 }
 
+/**
+ * How far the event band sits below the top of the row's day-column box, or null
+ * while either is unmeasured. Read off the live coordinates rather than summed
+ * from the padding constants, so it can't drift from what the row actually drew.
+ */
+private fun bandTopInCell(
+    cell: Array<LayoutCoordinates?>,
+    band: Array<LayoutCoordinates?>,
+): Float? {
+    val cellTop = cell[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
+    val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
+    return bandTop - cellTop
+}
+
+/**
+ * The chip at [cellY] in column [col], where [cellY] is measured from the top of
+ * the row's day-column box. Null for a tap above the band (the day number), on an
+ * empty lane, or on the overflow dots — all of which mean "open the day", the
+ * dots included: their point is that the day holds more than fits.
+ */
+internal fun MonthWeek.chipAtCellY(
+    col: Int,
+    cellY: Float,
+    bandTopInCell: Float?,
+    rowHeightPx: Float,
+): EventInstance? {
+    if (bandTopInCell == null || rowHeightPx <= 0f) return null
+    val bandY = cellY - bandTopInCell
+    if (bandY < 0f) return null
+    return chipAt(col, (bandY / rowHeightPx).toInt(), MAX_EVENT_ROWS)
+}
+
 /**
  * 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
@@ -2172,7 +2263,7 @@ private fun monthChipDragModifier(
     rowHeightPx: Float,
     isRtl: Boolean,
 ): Modifier = rememberDragSurface(
-    enabled = moveScope != null && controller != null,
+    enabled = moveScope?.dragEnabled == true && controller != null,
     key = week.days.first(),
     onPickUp = { local, pointerInRoot, nodeInRoot, size ->
         val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y
@@ -2358,6 +2449,7 @@ private fun MonthBar(
             maxLines = 1,
             overflow = TextOverflow.Ellipsis,
             color = eventInk(fill),
+            textDecoration = declinedDecoration(event.isDeclined),
         )
     }
 }

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.
+ * and onboarding choosers.
- *
- * 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.
  *
  * 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
+ * are stand-ins. See [ScaledViewPreview] for how the real grid composables get
- * provider for a thumbnail.
+ * measured at phone size and shrunk into the card.
  */
 @Composable
 internal fun MonthStylePreview(
@@ -57,108 +34,64 @@ 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(
+    ScaledViewPreview(height = height, modifier = modifier) {
-        modifier = modifier
+        WeekdayHeader(weekStart = weekStart, showWeekNumbers = false)
-            .clipToBounds()
+        when (style) {
-            .background(MaterialTheme.colorScheme.surface)
+            MonthViewStyle.Paged -> MonthGrid(
-            // A preview is a picture, not a control: swallow touches before the
+                state = sample.month,
-            // grid's own clickables see them, and give screen readers one label
+                showWeekNumbers = false,
-            // instead of six weeks of day cells.
+                onOpenDay = {},
-            .pointerInput(Unit) {
+                onEventClick = {},
-                awaitPointerEventScope {
+            )
-                    while (true) {
+            MonthViewStyle.Continuous -> ContinuousMonthGrid(
-                        awaitPointerEvent(PointerEventPass.Initial).changes
+                state = sample.continuous,
-                            .forEach { it.consume() }
+                listState = rememberLazyListState(
-                    }
+                    initialFirstVisibleItemIndex = itemIndexForMonth(
-                }
+                        monthIndexOf(YearMonth(today.year, today.month)),
-            }
+                    ),
-            .clearAndSetSemantics { }
+                ),
-            // Measure the grid at a full phone viewport but report the scaled
+                showWeekNumbers = false,
-            // size, so the node occupies exactly what it draws.
+                onOpenDay = {},
-            //
+                onEventClick = {},
-            // Modifier.requiredSize would be the obvious way to force the larger
+            )
-            // measurement, but it *centres* content that overflows the incoming
+            MonthViewStyle.Dense -> DenseMonthGrid(
-            // constraints — which pushed the grid to a negative offset and left
+                state = sample.continuous,
-            // only its bottom-right corner inside the clip.
+                listState = rememberLazyListState(
-            .layout { measurable, _ ->
+                    // Start a week above today's, so the preview shows a stream
-                val fullWidth = screenWidth.roundToPx()
+                    // running past the viewport rather than one beginning at its
-                val fullHeight = VIRTUAL_HEIGHT.roundToPx()
+                    // top edge.
-                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
+                    initialFirstVisibleItemIndex = weekIndexOf(today, weekStart) - 1,
-                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
+                ),
-                    placeable.place(0, 0)
+                showWeekNumbers = false,
-                }
+                onOpenDay = {},
-            }
+                onEventClick = {},
-            .graphicsLayer {
+            )
-                scaleX = scale
+            MonthViewStyle.Split -> {
-                scaleY = scale
+                SplitMonthGrid(
-                transformOrigin = TransformOrigin(0f, 0f)
+                    state = sample.month,
-            },
+                    selected = today,
-    ) {
+                    showWeekNumbers = false,
-        Column(Modifier.fillMaxSize()) {
+                    onSelectDay = {},
-            WeekdayHeader(weekStart = weekStart, showWeekNumbers = false)
+                )
-                when (style) {
+                SplitDayPane(
-                    MonthViewStyle.Paged -> MonthGrid(
+                    date = today,
-                        state = sample.month,
+                    today = today,
-                        showWeekNumbers = false,
+                    events = sample.month.instancesByDay[today].orEmpty(),
-                        onOpenDay = {},
+                    zone = zone,
-                    )
+                    onOpenDay = {},
-                    MonthViewStyle.Continuous -> ContinuousMonthGrid(
+                    onEventClick = {},
-                        state = sample.continuous,
+                    onCreateEvent = {},
-                        listState = rememberLazyListState(
+                    modifier = Modifier.fillMaxWidth().height(SPLIT_PANE_HEIGHT),
-                            initialFirstVisibleItemIndex = itemIndexForMonth(
+                )
-                                monthIndexOf(YearMonth(today.year, today.month)),
-                            ),
-                        ),
-                        showWeekNumbers = false,
-                        onOpenDay = {},
-                    )
-                    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,
-                        ),
-                        showWeekNumbers = false,
-                        onOpenDay = {},
-                    )
-                    MonthViewStyle.Split -> {
-                        SplitMonthGrid(
-                            state = sample.month,
-                            selected = today,
-                            showWeekNumbers = false,
-                            onSelectDay = {},
-                        )
-                        SplitDayPane(
-                            date = today,
-                            today = today,
-                            events = sample.month.instancesByDay[today].orEmpty(),
-                            zone = zone,
-                            onOpenDay = {},
-                            onEventClick = {},
-                            onCreateEvent = {},
-                            modifier = Modifier.fillMaxWidth().height(SPLIT_PANE_HEIGHT),
-                        )
-                    }
-                }
             }
+        }
     }
 }
 
-/**
- * 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 +103,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 +111,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 +143,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/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) {
+        if (badge != null) {
-            // A small lock badge sits over the corner to signal "blocked".
+            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,
+            icon = Icons.Filled.Lock,
-            title = stringResource(R.string.permission_benefit_privacy_title),
+            title = stringResource(R.string.permission_benefit_private_title),
-            body = stringResource(R.string.permission_benefit_privacy_body),
+            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

@@ -5,12 +5,15 @@ 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
@@ -19,7 +22,9 @@ 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
@@ -31,6 +36,7 @@ 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
@@ -43,19 +49,26 @@ 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
@@ -65,9 +78,14 @@ 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.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
@@ -75,6 +93,8 @@ 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
@@ -95,11 +115,9 @@ import java.time.format.FormatStyle
 private const val CHIP_MILLIS = 4_000L
 
 /**
- * Full-text event search (top-bar entry). Type a query → matching events
+ * Full-text event search over title / location / description: tap a result to
- * (title / location / description) across the whole calendar, newest-relevant
+ * open its detail, long-press to select several and delete them at once (#80).
- * first; tap a result to open its detail. Long-press a result to enter selection
+ * A full-screen overlay hosted by [de.jeanlucmakiola.calendula.ui.CalendarHost].
- * mode and delete several at once (#80). A full-screen overlay hosted by
- * [de.jeanlucmakiola.calendula.ui.CalendarHost].
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -119,12 +137,20 @@ fun SearchScreen(
     val inSelection = selection.isNotEmpty()
     var showDeleteDialog by remember { mutableStateOf(false) }
 
-    // Each fresh open starts blank and straight into typing. The ViewModel is
+    // The ViewModel is activity-scoped, so a re-enter is what resets the last
-    // activity-scoped so it outlives the overlay; clearing on (re)enter is what
+    // search, its selection and any delete receipt still up. Peeking a result
-    // resets a previous search. Peeking a result doesn't re-run this (the screen
+    // doesn't re-run this — the screen stays composed under the detail.
-    // stays composed under the detail), so backing out keeps the query.
     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()
     }
@@ -151,65 +177,31 @@ fun SearchScreen(
         }
     }
 
-    // Back leaves selection mode before it leaves the screen — and without the
+    // Back leaves selection mode before it leaves the screen, and without the
-    // predictive-back scale-out, which would read as closing search only to have
+    // predictive-back scale-out — that would read as search closing and snapping
-    // it snap back. The two handlers are mutually exclusive on [inSelection].
+    // back. The two handlers are mutually exclusive on [inSelection].
     BackHandler(enabled = inSelection) { viewModel.clearSelection() }
 
     Scaffold(
         modifier = modifier.predictiveBack(onBack = onBack, enabled = !inSelection),
         containerColor = MaterialTheme.colorScheme.surface,
         topBar = {
-            if (inSelection) {
+            SearchTopBar(
-                SelectionTopBar(
+                inSelection = inSelection,
-                    count = selection.size,
+                query = query,
-                    onClose = viewModel::clearSelection,
+                selectedCount = selection.size,
-                    onSelectAll = viewModel::selectAll,
+                focusRequester = focusRequester,
-                    onDelete = { requireWrite { showDeleteDialog = true } },
+                onQueryChange = viewModel::setQuery,
-                )
+                onImeAction = { keyboard?.hide() },
-            } else {
+                onBack = onBack,
-                TopAppBar(
+                onCloseSelection = viewModel::clearSelection,
-                    title = {
+                onSelectAll = viewModel::selectAll,
-                        InlineTextField(
+                onDelete = { requireWrite { showDeleteDialog = true } },
-                            value = query,
+            )
-                            onValueChange = viewModel::setQuery,
-                            placeholder = stringResource(R.string.search_hint),
-                            capitalization = KeyboardCapitalization.None,
-                            imeAction = ImeAction.Search,
-                            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,
-                    ),
-                )
-            }
         },
     ) { padding ->
-        // imePadding shrinks the content by the keyboard, so the centered
+        // imePadding so the idle/empty message re-centres above the keyboard and
-        // idle/empty message re-centres in the space above it (and the results
+        // the results list lifts clear of it.
-        // list lifts clear of the keyboard too).
         Box(
             modifier = Modifier
                 .fillMaxSize()
@@ -284,46 +276,133 @@ fun SearchScreen(
     }
 }
 
-/** Contextual bar replacing the search field while results are picked. */
+/**
-@OptIn(ExperimentalMaterial3Api::class)
+ * 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 SelectionTopBar(
+private fun SearchTopBar(
-    count: Int,
+    inSelection: Boolean,
-    onClose: () -> Unit,
+    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 = { Text(pluralStringResource(R.plurals.search_selected_count, count, count)) },
+        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 = {
-            IconButton(onClick = onClose) {
+            AnimatedContent(
-                Icon(
+                targetState = inSelection,
-                    imageVector = Icons.Default.Close,
+                transitionSpec = { slotSwap },
-                    contentDescription = stringResource(R.string.search_selection_close),
+                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 = {
-            IconButton(onClick = onSelectAll) {
+            AnimatedContent(
-                Icon(
+                targetState = inSelection,
-                    imageVector = Icons.Default.SelectAll,
+                transitionSpec = { slotSwap },
-                    contentDescription = stringResource(R.string.search_select_all),
+                label = "search-top-bar-actions",
-                )
+            ) { selecting ->
-            }
+                Row {
-            IconButton(onClick = onDelete) {
+                    if (selecting) {
-                Icon(
+                        IconButton(onClick = onSelectAll) {
-                    imageVector = Icons.Default.Delete,
+                            Icon(
-                    contentDescription = stringResource(R.string.search_delete_selected),
+                                imageVector = Icons.Default.SelectAll,
-                    tint = MaterialTheme.colorScheme.error,
+                                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(
+        colors = TopAppBarDefaults.topAppBarColors(containerColor = container),
-            containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
-        ),
     )
 }
 
+@OptIn(ExperimentalFoundationApi::class)
 @Composable
 private fun SearchResults(
     results: SearchUiState.Results,
@@ -332,39 +411,94 @@ private fun SearchResults(
     onEventClick: (EventInstance) -> Unit,
     onToggle: (Long) -> Unit,
 ) {
-    val events = results.events
     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(
+        results.results.months.forEach { month ->
-            items = events,
+            stickyHeader(key = "month-${month.year}-${month.monthNumber}") {
-            key = { _, event -> event.eventId },
+                SearchSectionHeader(text = monthLabel(month))
-        ) { index, event ->
+            }
-            val deletable = results.isDeletable(event)
+            hitRows(month.hits, results, selection, inSelection, onEventClick, onToggle)
-            SearchResultRow(
+        }
-                event = event,
+        // Held back from the calendar above: matched only in the notes.
-                position = positionOf(index, events.size),
+        if (results.results.inDescriptions.isNotEmpty()) {
-                modifier = animateItemMotion(),
+            stickyHeader(key = "in-descriptions") {
-                selected = event.eventId in selection,
+                SearchSectionHeader(text = stringResource(R.string.search_in_descriptions))
-                // 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.
+            hitRows(
-                inSelection = inSelection,
+                results.results.inDescriptions,
-                selectable = deletable,
+                results,
-                onClick = when {
+                selection,
-                    inSelection && deletable -> ({ onToggle(event.eventId) })
+                inSelection,
-                    inSelection -> null
+                onEventClick,
-                    else -> ({ onEventClick(event) })
+                onToggle,
-                },
-                onLongClick = { onToggle(event.eventId) }.takeIf { deletable && !inSelection },
             )
         }
     }
 }
 
+/** 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,
     selected: Boolean = false,
@@ -373,12 +507,21 @@ private fun SearchResultRow(
     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,
+        // Faded like a past event anywhere else in the app — search reaches back
-        title = event.title,
+        // through the whole history.
-        summary = searchSummary(event),
+        modifier = if (hit.isPast) modifier.alpha(EventDimAlpha) else modifier,
+        title = declinedTitle(marked(event.title, hit.titleSpans, highlight), event.isDeclined),
+        summary = searchSummary(hit, highlight),
         position = position,
         minHeight = 64.dp,
         selected = selected,
@@ -407,9 +550,8 @@ private fun SearchResultRow(
 }
 
 /**
- * The batch's receipt: how many events went, and whether any refused. Sits on
+ * The batch's receipt: how many went, and whether any refused. No Undo — the
- * the FAB band so the shortened list stays visible behind it. Deletes aren't
+ * provider can't put a deleted event back.
- * reversible through the provider, so this carries no Undo.
  */
 @Composable
 private fun DeleteOutcomeChip(
@@ -430,7 +572,11 @@ private fun DeleteOutcomeChip(
                 deleteState.deleted,
             )
         }
-        BulkDeleteUiState.NeedsPermission -> stringResource(R.string.event_delete_write_denied)
+        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
@@ -454,17 +600,31 @@ private fun DeleteOutcomeChip(
     }
 }
 
-/** "Wed, 17 Jun 2026 · 09:00 · Office" — date, then time (or All day), then location. */
+/** [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(event: EventInstance): String {
+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
+    // From the span rule, not [start]: an all-day event sits at UTC midnight and
-    // midnight and would name the day before west of UTC (#82). The clock time
+    // would name the day before west of UTC (#82).
-    // below stays device-zone — it is only rendered for timed events.
     val dateText = remember(event.start, event.end, event.isAllDay, locale) {
         DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
             .format(event.spanFirstDay(TimeZone.currentSystemDefault()).toJavaLocalDate())
@@ -475,8 +635,23 @@ private fun searchSummary(event: EventInstance): String {
     } else {
         remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }.format(start)
     }
-    val base = "$dateText · $timeText"
+    return buildAnnotatedString {
-    return event.location?.takeIf { it.isNotBlank() }?.let { "$base · $it" } ?: base
+        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,7 +6,9 @@ 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
@@ -26,6 +28,9 @@ 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
 
@@ -39,16 +44,14 @@ 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). */
+    /** Matches by month — see [de.jeanlucmakiola.calendula.domain.EventSearch]. */
     data class Results(
-        val events: List<EventInstance>,
+        val results: SearchResults,
-        /**
+        /** Rows from these are kept out of selection rather than failing later. */
-         * Calendars among the results that can't be written to (WebCal, birthday
-         * mirrors, …). Their rows are excluded from selection rather than failing
-         * at delete time.
-         */
         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
     }
@@ -63,8 +66,8 @@ sealed interface BulkDeleteUiState {
     /** Terminal: [deleted] events went, [failed] wouldn't. */
     data class Done(val deleted: Int, val failed: Int) : BulkDeleteUiState
 
-    /** WRITE_CALENDAR was revoked mid-flight; nothing further was attempted. */
+    /** WRITE_CALENDAR was revoked after [deleted] went; the rest wasn't tried. */
-    data object NeedsPermission : BulkDeleteUiState
+    data class NeedsPermission(val deleted: Int) : BulkDeleteUiState
 }
 
 @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
@@ -96,12 +99,20 @@ class SearchViewModel @Inject constructor(
             if (q.length < MIN_QUERY_LENGTH) {
                 SearchUiState.Idle
             } else {
-                val results = repository.searchEvents(q)
+                val now = Clock.System.now()
-                if (results.isEmpty()) {
+                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(
-                        events = sortNearestFirst(results),
+                        results = results,
                         readOnlyCalendarIds = readOnlyCalendarIds(),
                     )
                 }
@@ -133,10 +144,7 @@ class SearchViewModel @Inject constructor(
         _selection.value = emptySet()
     }
 
-    /**
+    /** Whether the batch needs a [RecurringWriteScope] decision before it runs. */
-     * Whether the current selection contains a recurring event, i.e. whether the
-     * batch needs a [RecurringWriteScope] decision before it can run.
-     */
     fun selectionHasRecurring(): Boolean {
         val results = state.value as? SearchUiState.Results ?: return false
         val picked = _selection.value
@@ -144,10 +152,9 @@ class SearchViewModel @Inject constructor(
     }
 
     /**
-     * Delete every selected event. [scope] applies to the recurring ones only —
+     * Delete every selected event. [scope] reaches the recurring ones only; a
-     * a one-off is always removed whole, whatever the batch decision was. Runs
+     * one-off always goes whole. One at a time, so a single failure doesn't take
-     * one event at a time so a single failure doesn't take the rest with it;
+     * the rest with it — the tally lands in [deleteState].
-     * the tally lands in [deleteState].
      */
     fun deleteSelected(scope: RecurringWriteScope) {
         if (_deleteState.value == BulkDeleteUiState.Deleting) return
@@ -177,7 +184,7 @@ class SearchViewModel @Inject constructor(
             _selection.value = emptySet()
             _reload.value += 1
             _deleteState.value = if (denied) {
-                BulkDeleteUiState.NeedsPermission
+                BulkDeleteUiState.NeedsPermission(deleted = deleted)
             } else {
                 BulkDeleteUiState.Done(deleted = deleted, failed = failed)
             }
@@ -206,11 +213,4 @@ class SearchViewModel @Inject constructor(
             .filterNot { it.canModifyContents }
             .map { it.id }
             .toSet()
-
-    /** 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 }
-    }
 }

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,39 +39,21 @@ 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(
+        ViewPreviewFrame(
-            modifier = Modifier
+            selected = selected,
-                .fillMaxWidth()
+            label = "month-style-preview",
-                .padding(horizontal = 12.dp, vertical = 8.dp)
+            modifier = Modifier.padding(vertical = 8.dp),
-                .height(PREVIEW_HEIGHT),
+        ) { shown ->
-            contentAlignment = Alignment.Center,
+            MonthStylePreview(
-        ) {
+                style = shown,
-            Crossfade(
+                weekStart = weekStart,
-                targetState = selected,
+                height = PREVIEW_HEIGHT,
-                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+            )
-                label = "month-style-preview",
-            ) { 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
@@ -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,
-                    prefs.todayButtonInToolbar,
+                    combine(
-                ) { hourLines, weekNumbers, showToday, soften, todayInToolbar ->
+                        prefs.todayButtonInToolbar,
-                    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,38 +34,22 @@ 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(
+        ViewPreviewFrame(
-            modifier = Modifier
+            selected = resolved,
-                .fillMaxWidth()
+            label = "week-start-preview",
-                .padding(horizontal = 12.dp, vertical = 8.dp)
+            modifier = Modifier.padding(vertical = 8.dp),
-                .height(PREVIEW_HEIGHT),
+        ) { day ->
-            contentAlignment = Alignment.Center,
+            MonthStylePreview(
-        ) {
+                style = monthStyle,
-            Crossfade(
+                weekStart = day,
-                targetState = resolved,
+                height = PREVIEW_HEIGHT,
-                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+            )
-                label = "week-start-preview",
-            ) { 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 ->
@@ -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

@@ -52,6 +52,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -89,6 +90,7 @@ 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.declinedDecoration
 import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
 import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
@@ -99,6 +101,7 @@ 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.rememberEventDragSource
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
@@ -127,7 +130,9 @@ 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.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
+import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.time.isoWeekNumber
@@ -148,7 +153,7 @@ private val ALL_DAY_VERTICAL_PADDING = 6.dp
 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
@@ -402,7 +407,7 @@ private fun WeekContent(
 }
 
 @Composable
-private fun WeekSuccess(
+internal fun WeekSuccess(
     state: WeekUiState.Success,
     topSectionColor: Color,
     scrollState: ScrollState,
@@ -503,7 +508,7 @@ private fun WeekDayHeader(
     Row(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(top = 4.dp, bottom = 8.dp),
+            .padding(top = 4.dp, bottom = 8.dp, end = TIMELINE_CONTENT_END_INSET),
     ) {
         // Mirror the day-column layout (empty weekday line + spacer) so the
         // badge lines up vertically with the date numbers. The start inset centres
@@ -599,7 +604,11 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it slides and resizes smoothly;
             // padding sits inside it so the content area is lanes * row height.
             .height(height)
-            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+            .padding(
+                top = ALL_DAY_VERTICAL_PADDING,
+                bottom = ALL_DAY_VERTICAL_PADDING,
+                end = TIMELINE_CONTENT_END_INSET,
+            ),
     ) {
         // Keep the gutter-width offset so the bars line up with the day columns.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -659,6 +668,7 @@ private fun AllDayBar(
             maxLines = 1,
             overflow = TextOverflow.Ellipsis,
             color = eventInk(fill),
+            textDecoration = declinedDecoration(event.isDeclined),
         )
     }
 }
@@ -705,6 +715,7 @@ private fun Timeline(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
                     .verticalScroll(scrollState)
                     .onGloballyPositioned { dragController.geometry.viewport = it },
@@ -771,6 +782,12 @@ private fun DayColumnCard(
     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
+    // them, or taps land on the scale the column had before the zoom (#148).
+    val currentHourPx = rememberUpdatedState(hourPx)
+    val currentOnCreateAt = rememberUpdatedState(onCreateAt)
     Card(
         // Plain rectangular columns — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -790,8 +807,10 @@ private fun DayColumnCard(
                 // blocks are consumed by their own handler first. Snaps to hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
-                        val hour = (offset.y / hourPx).toInt().coerceIn(0, 23)
+                        currentOnCreateAt.value(
-                        onCreateAt(date, hour * 60)
+                            date,
+                            tappedMinuteOfDay(offset.y, currentHourPx.value),
+                        )
                     }
                 },
         ) {
@@ -895,7 +914,7 @@ private fun EventBlock(
     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 = moveAction != null && block.beginsOn(date, zone)
+    val draggable = eventDragAllowed(block.event) && block.beginsOn(date, zone)
     val dragModifier = rememberEventDragSource(
         enabled = draggable,
         key = block.event.instanceId,
@@ -929,6 +948,7 @@ private fun EventBlock(
                     maxLines = titleMaxLines,
                     overflow = TextOverflow.Ellipsis,
                     color = eventInk(fill, alpha = 0.85f),
+                    textDecoration = declinedDecoration(block.event.isDeclined),
                 )
             }
             if (showTime) {
@@ -966,7 +986,12 @@ private fun WeekLoading() {
             // Same scale resolution as the loaded timeline, so the skeleton's
             // columns don't resize the moment the real week arrives.
             val totalHeight = scale.hourHeight(maxHeight) * 24
-            Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+            Row(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
+                    .verticalScroll(scrollState),
+            ) {
                 Spacer(Modifier.width(GUTTER_WIDTH))
                 repeat(7) {
                     Box(

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/java/de/jeanlucmakiola/calendula/widget/WidgetTheme.kt

@@ -4,6 +4,7 @@ import android.os.Build
 import androidx.compose.runtime.Composable
 import androidx.glance.GlanceTheme
 import androidx.glance.material3.ColorProviders
+import androidx.glance.text.TextDecoration
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaDarkFallback
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaLightFallback
 
@@ -34,3 +35,10 @@ fun CalendulaGlanceTheme(content: @Composable () -> Unit) {
     }
     GlanceTheme(colors = colors, content = content)
 }
+
+/**
+ * Glance's counterpart to the app's `declinedDecoration`: a declined invitation
+ * reads the same on the home screen as it does inside the app (#180).
+ */
+fun glanceDeclinedDecoration(isDeclined: Boolean): TextDecoration =
+    if (isDeclined) TextDecoration.LineThrough else TextDecoration.None

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.agenda
 
+import de.jeanlucmakiola.calendula.widget.glanceDeclinedDecoration
 import android.content.Context
 import android.content.res.Configuration
 import androidx.compose.runtime.Composable
@@ -24,7 +25,6 @@ import androidx.glance.appwidget.cornerRadius
 import androidx.glance.appwidget.lazy.LazyColumn
 import androidx.glance.appwidget.lazy.items
 import androidx.glance.appwidget.provideContent
-import androidx.glance.appwidget.updateAll
 import androidx.glance.background
 import androidx.glance.currentState
 import androidx.glance.state.PreferencesGlanceStateDefinition
@@ -135,10 +135,14 @@ class AgendaWidget : GlanceAppWidget() {
     }
 }
 
-/** Re-reads the calendar and redraws the widget (header refresh button). */
+/**
+ * Re-reads the calendar and redraws the widget (header refresh button). Targets
+ * the tapped widget's own id rather than `updateAll`, whose provider-name lookup
+ * is empty in a process a tap woke from cold — see `ShiftMonthAction` (#18).
+ */
 class RefreshAgendaAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
-        AgendaWidget().updateAll(context.applicationContext)
+        AgendaWidget().update(context.applicationContext, glanceId)
     }
 }
 
@@ -416,7 +420,11 @@ private fun EventRow(
             Text(
                 text = title,
                 maxLines = 1,
-                style = TextStyle(color = titleColor, fontSize = metrics.eventTitle),
+                style = TextStyle(
+                    color = titleColor,
+                    fontSize = metrics.eventTitle,
+                    textDecoration = glanceDeclinedDecoration(event.isDeclined),
+                ),
             )
             Text(
                 text = eventTimeSummary(context, event, day, is24Hour),

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.month
 
+import de.jeanlucmakiola.calendula.widget.glanceDeclinedDecoration
 import android.content.Context
 import android.content.res.Configuration
 import androidx.compose.runtime.Composable
@@ -25,7 +26,6 @@ import androidx.glance.appwidget.action.actionStartActivity
 import androidx.glance.appwidget.cornerRadius
 import androidx.glance.appwidget.provideContent
 import androidx.glance.appwidget.state.updateAppWidgetState
-import androidx.glance.appwidget.updateAll
 import androidx.glance.background
 import androidx.glance.currentState
 import androidx.glance.layout.Alignment
@@ -33,6 +33,7 @@ import androidx.glance.layout.Box
 import androidx.glance.layout.Column
 import androidx.glance.layout.Row
 import androidx.glance.layout.Spacer
+import androidx.glance.layout.fillMaxHeight
 import androidx.glance.layout.fillMaxSize
 import androidx.glance.layout.fillMaxWidth
 import androidx.glance.layout.height
@@ -97,10 +98,27 @@ private fun yearMonthOf(index: Int): YearMonth =
  * inter-cell seam, with rounded end caps. The displayed month lives in Glance
  * state and is read reactively in the composition ([currentState]) so the arrows
  * move it via plain recomposition, not a (here-unreliable) widget session reload.
+ *
+ * Everything here is written to keep the published `RemoteViews` small. A widget
+ * update reaches the launcher as a *oneway* binder call, and the host's async
+ * buffer is 1 MB for all of it; overrun throws `TransactionTooLargeException` and
+ * the system drops the whole host, freezing every widget on the home screen until
+ * the launcher rebinds. [SizeMode.Exact] serialises the grid once per size the
+ * host reports, so the ceiling arrives at half the view count you would expect: a
+ * grid that emitted a view per cell blew past it after three taps (#214). Every
+ * row here emits only what it fills.
  */
 class MonthWidget : GlanceAppWidget() {
 
     override val stateDefinition = PreferencesGlanceStateDefinition
+
+    /**
+     * Exact rather than [SizeMode.Single] or [SizeMode.Responsive], both of which
+     * return early from `GlanceAppWidget.resize` — under those the grid is never
+     * recomposed for a new size and a resized widget clips instead of reflowing.
+     * Exact costs one serialised copy per host size, which is affordable now that
+     * a rendering is ~190 views rather than ~740.
+     */
     override val sizeMode = SizeMode.Exact
 
     override suspend fun provideGlance(context: Context, id: GlanceId) {
@@ -118,7 +136,17 @@ class MonthWidget : GlanceAppWidget() {
     }
 }
 
-/** Step the displayed month by the `delta` action parameter (±1). */
+/**
+ * Step the displayed month by the `delta` action parameter (±1).
+ *
+ * Redrawn through [GlanceAppWidget.update] with the id the callback was handed,
+ * never `updateAll`. `updateAll` resolves its targets through the provider-name
+ * -> app-widget-id map Glance persists for the *receiver*, and in a process that
+ * has done nothing else yet — the one a tap wakes after a reboot — that lookup
+ * comes back empty and the redraw is dropped: the state write lands, nothing
+ * recomposes, and the arrows read as dead until something else opens the app and
+ * starts a session (#18). The tapped widget's own id needs no lookup.
+ */
 class ShiftMonthAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
         val delta = parameters[deltaKey] ?: 0
@@ -126,7 +154,7 @@ class ShiftMonthAction : ActionCallback {
             val cur = prefs[MONTH_INDEX_KEY] ?: currentMonthIndex(systemZone())
             prefs[MONTH_INDEX_KEY] = cur + delta
         }
-        MonthWidget().updateAll(context.applicationContext)
+        MonthWidget().update(context.applicationContext, glanceId)
     }
 
     companion object {
@@ -134,11 +162,11 @@ class ShiftMonthAction : ActionCallback {
     }
 }
 
-/** Jump the displayed month back to the current month. */
+/** Jump the displayed month back to the current month. See [ShiftMonthAction]. */
 class ResetMonthAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
         updateAppWidgetState(context, glanceId) { prefs -> prefs.remove(MONTH_INDEX_KEY) }
-        MonthWidget().updateAll(context.applicationContext)
+        MonthWidget().update(context.applicationContext, glanceId)
     }
 }
 
@@ -286,29 +314,75 @@ private fun WeekRow(
     colW: Dp,
     modifier: GlanceModifier,
 ) {
-    Column(modifier = modifier.fillMaxWidth()) {
+    val context = LocalContext.current
-        // Day numbers.
+    val hidden = week.hiddenPerDay()
-        Row(modifier = GlanceModifier.fillMaxWidth()) {
+    Box(modifier = modifier.fillMaxWidth()) {
+        // Day-open targets, one full-height strip per column, sitting *under* the
+        // content: a tap anywhere in a day still opens it, as in the app, without
+        // every cell in the column carrying a click target of its own. The content
+        // above is not clickable, so touches fall through to this layer; only an
+        // event bar opts out to open its own detail.
+        Row(modifier = GlanceModifier.fillMaxSize()) {
             week.days.forEach { date ->
-                DayNumber(
+                Box(
-                    date = date,
+                    modifier = GlanceModifier
-                    isToday = date == today,
+                        .width(colW)
-                    inMonth = date.month == currentMonth,
+                        .fillMaxHeight()
-                    colW = colW,
+                        .clickable(openDayAction(context, date)),
-                )
+                ) {}
             }
         }
-        Spacer(GlanceModifier.height(2.dp))
+        Column(modifier = GlanceModifier.fillMaxWidth()) {
-        // One lane row per event row. A multi-day span is a single Box spanning
+            // Day numbers. Fixed height so every week's number row lines up whether
-        // its columns (colW * n) so it's connected with no seam and rounded ends.
+            // or not it holds today's larger pill.
-        repeat(MAX_LANES) { lane ->
+            Row(
-            LaneRow(week = week, lane = lane, dark = dark, soften = soften, colW = colW)
+                modifier = GlanceModifier.fillMaxWidth().height(DAY_NUMBER_HEIGHT),
-            Spacer(GlanceModifier.height(1.dp))
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                week.days.forEach { date ->
+                    DayNumber(
+                        date = date,
+                        isToday = date == today,
+                        inMonth = date.month == currentMonth,
+                        colW = colW,
+                    )
+                }
+            }
+            Spacer(GlanceModifier.height(2.dp))
+            // One lane row per event row. A multi-day span is a single Box spanning
+            // its columns (colW * n) so it's connected with no seam and rounded ends.
+            // Lanes past the last one this week fills emit nothing at all.
+            repeat(week.usedLanes()) { lane ->
+                LaneRow(week = week, lane = lane, dark = dark, soften = soften, colW = colW)
+                Spacer(GlanceModifier.height(1.dp))
+            }
+            if (hidden.any { it > 0 }) OverflowRow(hidden = hidden, colW = colW)
         }
-        OverflowRow(week = week, colW = colW)
     }
 }
 
+/**
+ * How many lanes this week actually fills, counting from the top. The grid draws
+ * that many rows instead of a fixed [MAX_LANES]; an empty lane costs three views
+ * per day and most weeks leave the last two empty.
+ */
+private fun MonthWeek.usedLanes(): Int {
+    for (lane in MAX_LANES - 1 downTo 0) {
+        val filled = spans.any { it.lane == lane } ||
+            days.indices.any { col -> timedEventAt(this, lane, col, days[col]) != null }
+        if (filled) return lane + 1
+    }
+    return 0
+}
+
+/** Events per day that no lane had room for — the "+N" counts, 0 where all fit. */
+private fun MonthWeek.hiddenPerDay(): List<Int> = days.mapIndexed { col, date ->
+    val shownSpans = spans.count { col in it.startCol..it.endCol && it.lane < MAX_LANES }
+    val freeSlots = (MAX_LANES - shownSpans).coerceAtLeast(0)
+    val timedShown = minOf(freeSlots, timedByDay[date].orEmpty().size)
+    ((countByDay[date] ?: 0) - shownSpans - timedShown).coerceAtLeast(0)
+}
+
 /**
  * Open [date]'s day view rooted in the month view (so back returns to the month
  * grid) — the same target the in-app month grid uses when a day cell is tapped.
@@ -318,64 +392,93 @@ private fun WeekRow(
 private fun openDayAction(context: Context, date: LocalDate) =
     actionStartActivity(MainActivity.openDateIntent(context, date, CalendarView.Month))
 
+/**
+ * A day's number. Every day but today is a bare centred [Text] carrying the column
+ * width itself — a wrapping Box costs three views, and there are 42 of these.
+ * Today keeps its filled circle, which does need the Box.
+ */
 @Composable
 private fun DayNumber(date: LocalDate, isToday: Boolean, inMonth: Boolean, colW: Dp) {
-    val context = LocalContext.current
+    val style = TextStyle(
-    Box(
+        color = when {
-        modifier = GlanceModifier
+            isToday -> GlanceTheme.colors.onPrimary
-            .width(colW)
+            inMonth -> GlanceTheme.colors.onSurface
-            .height(DAY_NUMBER_HEIGHT)
+            else -> GlanceTheme.colors.onSurfaceVariant
-            .clickable(openDayAction(context, date)),
+        },
-        contentAlignment = Alignment.Center,
+        fontSize = 11.sp,
-    ) {
+        fontWeight = if (isToday) FontWeight.Bold else FontWeight.Normal,
+        textAlign = TextAlign.Center,
+    )
+    if (!isToday) {
+        Text(text = date.day.toString(), style = style, modifier = GlanceModifier.width(colW))
+        return
+    }
+    Box(modifier = GlanceModifier.width(colW), contentAlignment = Alignment.Center) {
         Box(
             modifier = GlanceModifier
                 .size(DAY_NUMBER_HEIGHT)
-                .then(if (isToday) GlanceModifier.cornerRadius(DAY_NUMBER_HEIGHT / 2).background(GlanceTheme.colors.primary) else GlanceModifier),
+                .cornerRadius(DAY_NUMBER_HEIGHT / 2)
+                .background(GlanceTheme.colors.primary),
             contentAlignment = Alignment.Center,
         ) {
-            Text(
+            Text(text = date.day.toString(), style = style)
-                text = date.day.toString(),
-                style = TextStyle(
-                    color = when {
-                        isToday -> GlanceTheme.colors.onPrimary
-                        inMonth -> GlanceTheme.colors.onSurface
-                        else -> GlanceTheme.colors.onSurfaceVariant
-                    },
-                    fontSize = 11.sp,
-                    fontWeight = if (isToday) FontWeight.Bold else FontWeight.Normal,
-                ),
-            )
         }
     }
 }
 
+/** A bar occupying [cols] columns, or — with a null event — that many blank ones. */
+private data class LaneCell(val event: EventInstance?, val cols: Int)
+
+/**
+ * A lane split into bars and the gaps between them, with consecutive blank columns
+ * merged into one gap: the week's day-open taps come from the strip underneath, so
+ * a gap needs no per-column view and a mostly-empty lane collapses to a spacer.
+ */
+private fun MonthWeek.laneCells(lane: Int): List<LaneCell> {
+    val cells = mutableListOf<LaneCell>()
+    var gap = 0
+    var col = 0
+    fun closeGap() {
+        if (gap > 0) cells += LaneCell(null, gap)
+        gap = 0
+    }
+    while (col < 7) {
+        val span = spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }
+        val timed = if (span == null) timedEventAt(this, lane, col, days[col]) else null
+        when {
+            span != null -> {
+                closeGap()
+                cells += LaneCell(span.event, span.endCol - col + 1)
+                col = span.endCol + 1
+            }
+            timed != null -> {
+                closeGap()
+                cells += LaneCell(timed, 1)
+                col += 1
+            }
+            else -> {
+                gap += 1
+                col += 1
+            }
+        }
+    }
+    closeGap()
+    return cells
+}
+
 @Composable
 private fun LaneRow(week: MonthWeek, lane: Int, dark: Boolean, soften: Boolean, colW: Dp) {
-    val context = LocalContext.current
     Row(modifier = GlanceModifier.fillMaxWidth()) {
-        var col = 0
+        week.laneCells(lane).forEach { cell ->
-        while (col < 7) {
+            if (cell.event == null) {
-            val span = week.spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }
+                Spacer(GlanceModifier.width(colW * cell.cols).height(LANE_HEIGHT))
-            if (span != null) {
-                val cols = span.endCol - col + 1
-                SpanBar(event = span.event, dark = dark, soften = soften, width = colW * cols)
-                col = span.endCol + 1
             } else {
-                val timed = timedEventAt(week, lane, col, week.days[col])
+                SpanBar(
-                if (timed != null) {
+                    event = cell.event,
-                    SpanBar(event = timed, dark = dark, soften = soften, width = colW)
+                    dark = dark,
-                } else {
+                    soften = soften,
-                    // Empty lane cell: a tap opens that day, so blank space in a
+                    width = colW * cell.cols,
-                    // day column is a day-open target just like the number is.
+                )
-                    Box(
-                        GlanceModifier
-                            .width(colW)
-                            .height(LANE_HEIGHT)
-                            .clickable(openDayAction(context, week.days[col])),
-                    ) {}
-                }
-                col += 1
             }
         }
     }
@@ -414,41 +517,39 @@ private fun SpanBar(event: EventInstance, dark: Boolean, soften: Boolean, width:
             Text(
                 text = event.title.ifBlank { context.getString(R.string.event_untitled) },
                 maxLines = 1,
-                style = TextStyle(color = ColorProvider(eventInk(fill)), fontSize = 9.sp),
+                style = TextStyle(
+                    color = ColorProvider(eventInk(fill)),
+                    fontSize = 9.sp,
+                    textDecoration = glanceDeclinedDecoration(event.isDeclined),
+                ),
                 modifier = GlanceModifier.padding(horizontal = 3.dp),
             )
         }
     }
 }
 
+/** The "+N" row, drawn only for weeks that hide something, gaps merged as in a lane. */
 @Composable
-private fun OverflowRow(week: MonthWeek, colW: Dp) {
+private fun OverflowRow(hidden: List<Int>, colW: Dp) {
-    val context = LocalContext.current
     Row(modifier = GlanceModifier.fillMaxWidth()) {
-        week.days.forEachIndexed { col, date ->
+        var gap = 0
-            val shownSpans = week.spans.count { col in it.startCol..it.endCol && it.lane < MAX_LANES }
+        hidden.forEach { count ->
-            val freeSlots = (MAX_LANES - shownSpans).coerceAtLeast(0)
+            if (count == 0) {
-            val timedShown = minOf(freeSlots, week.timedByDay[date].orEmpty().size)
+                gap += 1
-            val hidden = (week.countByDay[date] ?: 0) - shownSpans - timedShown
+                return@forEach
-            // The overflow row is part of the day column too: tapping it (whether
-            // it shows "+N" or is blank) opens that day, same as the app.
-            Box(
-                modifier = GlanceModifier
-                    .width(colW)
-                    .height(LANE_HEIGHT)
-                    .clickable(openDayAction(context, date)),
-                contentAlignment = Alignment.CenterStart,
-            ) {
-                if (hidden > 0) {
-                    Text(
-                        text = "+$hidden",
-                        maxLines = 1,
-                        style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 9.sp),
-                        modifier = GlanceModifier.padding(start = 3.dp),
-                    )
-                }
             }
+            if (gap > 0) {
+                Spacer(GlanceModifier.width(colW * gap).height(LANE_HEIGHT))
+                gap = 0
+            }
+            Text(
+                text = "+$count",
+                maxLines = 1,
+                style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 9.sp),
+                modifier = GlanceModifier.width(colW).padding(start = 3.dp),
+            )
         }
+        if (gap > 0) Spacer(GlanceModifier.width(colW * gap).height(LANE_HEIGHT))
     }
 }
 

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

@@ -16,14 +16,14 @@
     <string name="state_failure_no_calendars_action">فتح إعدادات تقويم النظام</string>
     <string name="state_failure_provider">تعذّر قراءة التقويم.</string>
     <string name="permission_rationale_title">شاهد جميع أحداثك، بشكل جميل</string>
-    <string name="permission_rationale_body">Calendula يحتاج للوصول إلى تقويمك لعرض و إدارة أحداثك. هذا كل ما يطلبه مقدمًا — ولا يخرج أي شيء من جهازك على الإطلاق.</string>
+    <string name="permission_rationale_body">Calendula يحتاج للوصول إلى تقويمك لعرض و إدارة أحداثك.</string>
     <string name="permission_request_button">منح الوصول إلى التقويم</string>
     <string name="permission_denied_title">رُفِض الوصول إلى التقويم</string>
     <string name="permission_denied_body">Calendula لا يمكنه عرض الأحداث بدون الوصول إلى التقويم. يمكنك منحه مُجددًا في إعدادات النظام.</string>
     <string name="permission_retry_button">أعِد المحاولة</string>
     <string name="permission_open_settings_button">فتح إعدادات النظام</string>
-    <string name="permission_benefit_private_title">يبقى على جهازك</string>
+    <string name="permission_benefit_private_title">الخصوصية حسب التصميم</string>
-    <string name="permission_benefit_private_body">تقويماتك تتِم قراءتها محليًا ولا تُغادر الهاتف أبدًا.</string>
+    <string name="permission_benefit_private_body">لا يوجد إذن بالإنترنت، ولا تتبع عن بُعد — لا شيء يغادر هاتفك أبدًا.</string>
     <string name="permission_benefit_sync_title">جميع تقويماتك، مع بعض</string>
     <string name="permission_benefit_sync_body">جوجل، CalDAV، محلي — أي شيء تمت مزامنته مع الجهاز يظهر فورًا.</string>
     <string name="permission_benefit_privacy_title">لا تتبع، أبدًا</string>
@@ -126,6 +126,7 @@
     <string name="event_edit_recurrence_none">لا يتكرر</string>
     <string name="import_reminder_prompt_body_none">تم استيراد هذا الحدث بدون أي تذكير.</string>
     <plurals name="import_reminder_prompt_body_existing">
+        <item quantity="zero">تم استيراد هذا الحدث مع (%1$d) لا تذكيرات.</item>
         <item quantity="one">تم استيراد هذا الحدث مع %1$d تذكير.</item>
         <item quantity="two">تم استيراد هذا الحدث مع %1$d تذكيران.</item>
         <item quantity="few">تم استيراد هذا الحدث مع %1$d تذكيرات.</item>
@@ -177,7 +178,7 @@
     <string name="reminder_channel_name">تذكيرات الحدث</string>
     <string name="reminder_channel_description">الإشعارات في أوقات التذكير الخاصه بأحداثك</string>
     <string name="reminder_onboarding_title">لا تفوّت أي حدث أبدًا</string>
-    <string name="reminder_onboarding_body">Android لا يعرض تذكيرات الأحداث من نفسه — بل يجب أن يقوم تطبيق تقويم بذلك. دع Calendula يتولى هذه المهمة.</string>
+    <string name="reminder_onboarding_body">أندرويد لا يعرض تذكيرات الأحداث من نفسه — بل يجب أن يقوم تطبيق تقويم بذلك. دع Calendula يتولى هذه المهمة.</string>
     <string name="reminder_benefit_delivery_body">كل تذكير لأحداثك يصِل كإشعار، في الوقت المحدد تمامًا.</string>
     <string name="reminder_benefit_duplicates_title">هل تستخدم تطبيق تقويم ثانٍ؟</string>
     <string name="reminder_benefit_duplicates_body">إذا تطبيق آخر أيضًا ينشر تذكيرات، فستراهم مرتين — قم بإيقاف تشغيلهم هناك أو هنا.</string>
@@ -242,17 +243,17 @@
     <string name="agenda_range_this_week">هذا الأسبوع</string>
     <string name="settings_past_events_show">إظهار</string>
     <string name="settings_past_events_hide">إخفاء</string>
-    <string name="settings_agenda_header">جدول</string>
+    <string name="settings_agenda_header">الجدول</string>
     <string name="event_edit_timezone_device">المنطقة الزمنية للجهاز</string>
     <string name="event_edit_timezone_search">البحث عن المناطق الزمنية</string>
     <string name="event_edit_timezone_all">جميع المناطق الزمنية</string>
-    <string name="event_edit_timezone_none">لا منطقة زمنية تطابق \"%1$s\"</string>
+    <string name="event_edit_timezone_none">لا منطقة زمنية تطابق ”%1$s“</string>
     <string name="event_edit_timezone_local_time">%1$s توقيتك</string>
     <string name="event_edit_timezone_recent">الأحدث</string>
     <string name="event_edit_recurrence_incomplete">أدخل رقمًا من ١ إلى ٩٩٩</string>
     <plurals name="duration_minutes">
         <item quantity="zero">(%d) لا دقائق</item>
-        <item quantity="one">(%d) دقيقة واحده</item>
+        <item quantity="one">%d دقيقة واحده</item>
         <item quantity="two">%d دقيقتان</item>
         <item quantity="few">%d دقائق</item>
         <item quantity="many">%d دقيقة</item>
@@ -260,7 +261,7 @@
     </plurals>
     <plurals name="duration_hours">
         <item quantity="zero">(%d) لا ساعات</item>
-        <item quantity="one">(%d) ساعة واحده</item>
+        <item quantity="one">%d ساعة واحده</item>
         <item quantity="two">%d ساعتان</item>
         <item quantity="few">%d ساعات</item>
         <item quantity="many">%d ساعة</item>
@@ -268,7 +269,7 @@
     </plurals>
     <plurals name="duration_days">
         <item quantity="zero">(%d) لا أيام</item>
-        <item quantity="one">(%d) يوم واحد</item>
+        <item quantity="one">%d يوم واحد</item>
         <item quantity="two">%d يومان</item>
         <item quantity="few">%d أيام</item>
         <item quantity="many">%d يوم</item>
@@ -276,7 +277,7 @@
     </plurals>
     <plurals name="duration_weeks">
         <item quantity="zero">(%d) لا أسابيع</item>
-        <item quantity="one">(%d) أسبوع واحد</item>
+        <item quantity="one">%d أسبوع واحد</item>
         <item quantity="two">%d أسبوعان</item>
         <item quantity="few">%d أسابيع</item>
         <item quantity="many">%d أسبوع</item>
@@ -291,7 +292,7 @@
     <string name="settings_dim_completed_summary">تعتيم الأحداث التي انتهت بالفعل في عرض الشهر والأسبوع</string>
     <string name="settings_today_toolbar">زر اليوم في شريط الأدوات</string>
     <string name="settings_today_toolbar_summary">إظهار زر الانتقال إلى اليوم في شريط الأدوات بدلاً من زر عائم</string>
-    <string name="settings_app_name_summary">اعرض Calendula كـ \"Calendar\" في مشغّل التطبيقات الخاص بك. فقط الاسم في المشغّل يتغير؛ وقد ينتقل الرمز إلى مكان جديد بعد التبديل.</string>
+    <string name="settings_app_name_summary">اعرض Calendula كـ ”Calendar“ في مشغّل التطبيقات الخاص بك. فقط الاسم في المشغّل يتغير؛ وقد ينتقل الرمز إلى مكان جديد بعد التبديل.</string>
     <string name="settings_past_events_dim">تعتيم</string>
     <string name="settings_past_events">الأحداث السابقة</string>
     <string name="settings_agenda_range">مدى الجدول</string>
@@ -314,7 +315,6 @@
     <string name="settings_form_fields_hint">الخانات المعروضة افتراضيًا — كل شيء آخر موجود ضمن \"المزيد من الخانات\"</string>
     <string name="settings_section_event_form">نموذج حدث جديد</string>
     <string name="settings_quick_switch_header">زر التبديل السريع</string>
-    <string name="app_name">التقويم</string>
     <string name="settings_theme_system_summary">الحالي %1$s</string>
     <string name="settings_theme_hint">سواء التطبيق فاتحًا أو داكنًا. الاختيار يُطبق على الفور.</string>
     <string name="settings_week_start_auto_summary">الحالي %1$s</string>
@@ -329,7 +329,7 @@
     <string name="settings_widget_size_extra_large">كبير جدًا</string>
     <plurals name="agenda_range_days">
         <item quantity="zero">(%d) لا أيام</item>
-        <item quantity="one">(%d) يوم واحد</item>
+        <item quantity="one">%d يوم واحد</item>
         <item quantity="two">%d يومان</item>
         <item quantity="few">%d أيام</item>
         <item quantity="many">%d يوم</item>
@@ -383,7 +383,7 @@
     <string name="event_edit_recurrence_next">التالي: %1$s</string>
     <plurals name="reminder_minutes">
         <item quantity="zero">(%d) لا دقائق قبل</item>
-        <item quantity="one">(%d) دقيقة واحده قبل</item>
+        <item quantity="one">%d دقيقة واحده قبل</item>
         <item quantity="two">%d دقيقتان قبل</item>
         <item quantity="few">%d دقائق قبل</item>
         <item quantity="many">%d دقيقة قبل</item>
@@ -391,7 +391,7 @@
     </plurals>
     <plurals name="reminder_hours">
         <item quantity="zero">(%d) لا ساعات قبل</item>
-        <item quantity="one">(%d) ساعة واحده قبل</item>
+        <item quantity="one">%d ساعة واحده قبل</item>
         <item quantity="two">%d ساعتان قبل</item>
         <item quantity="few">%d ساعات قبل</item>
         <item quantity="many">%d ساعة قبل</item>
@@ -399,7 +399,7 @@
     </plurals>
     <plurals name="reminder_days">
         <item quantity="zero">(%d) لا أيام قبل</item>
-        <item quantity="one">(%d) يوم واحد قبل</item>
+        <item quantity="one">%d يوم واحد قبل</item>
         <item quantity="two">%d يومان قبل</item>
         <item quantity="few">%d أيام قبل</item>
         <item quantity="many">%d يوم قبل</item>
@@ -407,13 +407,13 @@
     </plurals>
     <plurals name="reminder_weeks">
         <item quantity="zero">(%d) لا أسابيع قبل</item>
-        <item quantity="one">(%d) أسبوع واحد قبل</item>
+        <item quantity="one">%d أسبوع واحد قبل</item>
         <item quantity="two">%d أسبوعان قبل</item>
         <item quantity="few">%d أسابيع قبل</item>
         <item quantity="many">%d أسبوع قبل</item>
         <item quantity="other">%d أسبوع قبل</item>
     </plurals>
-    <string name="reminder_benefit_reversible_body">يوجد المفتاح في الإعدادات، ضمن الإشعارات.</string>
+    <string name="reminder_benefit_reversible_body">يوجد مفتاح التبديل في الإعدادات، ضمن الإشعارات.</string>
     <string name="reminder_custom_amount">القيمة</string>
     <string name="settings_manage_calendars_hint">إنشاء تقويمات محلية؛ إدارة التقويمات المتزامنة</string>
     <string name="settings_snooze_duration">مدة التأجيل</string>
@@ -451,13 +451,13 @@
     <string name="settings_special_dates_grant">منح الوصول</string>
     <string name="calendars_backup_action">تصدير كملف ‎.ics</string>
     <string name="calendars_export_title">تصدير التقويمات</string>
-    <string name="calendars_export_hint">اختر التقويمات التي تريد تضمينها في ‎.ics الملف.</string>
+    <string name="calendars_export_hint">اختر التقويمات التي تريد تضمينها في ملف ‎.ics.</string>
     <string name="calendars_export_action">تصدير</string>
     <string name="calendars_restore_header">استعادة</string>
     <string name="calendars_restore_action">استعادة من ملف ‎.ics</string>
     <string name="calendars_restore_hint">استيراد الأحداث من نسخة احتياطية أو تطبيق تقويم آخر.</string>
     <string name="calendars_auto_backup">النسخ الاحتياطي التلقائي</string>
-    <string name="calendars_auto_backup_hint">قم بتصدير تقويماتك المحلية بشكل دوري إلى مجلد كـ ‎.ics الملف.</string>
+    <string name="calendars_auto_backup_hint">قم بتصدير تقويماتك المحلية بشكل دوري إلى مجلد كـ ملف ‎.ics.</string>
     <string name="calendars_auto_backup_folder">مجلد النسخ الاحتياطي</string>
     <string name="calendars_auto_backup_folder_unset">اضغط لاختيار مجلد</string>
     <string name="calendars_auto_backup_every">كل %1$s</string>
@@ -472,7 +472,7 @@
     <string name="calendars_backup_failed">تعذّر تصدير النسخة الاحتياطية.</string>
     <plurals name="calendars_backup_done">
         <item quantity="zero">تم تصدير (%d) لا أحداث.</item>
-        <item quantity="one">تم تصدير (%d) حدث واحد.</item>
+        <item quantity="one">تم تصدير %d حدث واحد.</item>
         <item quantity="two">تم تصدير %d حدثان.</item>
         <item quantity="few">تم تصدير %d أحداث.</item>
         <item quantity="many">تم تصدير %d حدث.</item>
@@ -520,7 +520,7 @@
     <string name="settings_past_events_hint">ما الذي يفعله جدول بالأحداث التي انتهت بالفعل.</string>
     <string name="calendars_visibility_a11y">إظهار \"%1$s\"</string>
     <string name="calendars_visibility_notice_title">بعض التقويمات متوقفة</string>
-    <string name="calendars_visibility_notice_message">Calendula يعرض الآن التقويمات التي تم تشغيلها لهذا الجهاز، لذلك ما تراه وما يذكرك لم يعد بإمكانه أن يختلف. بعض تقويماتك متوقفة حاليًا — تم إيقافها هنا أو في تطبيق تقويم آخر. أعد تشغيل أي منها في الإعدادات ← التقويمات.</string>
+    <string name="calendars_visibility_notice_message">Calendula يعرض التقويمات التي تم تشغيلها لهذا الجهاز، وبعض من خاصتك متوقفة. لرؤية أحداثهم، قم بتشغيلهم ضمن الإعدادات ← التقويمات.</string>
     <string name="calendar_picker_missing_title">تفتقد تقويمًا؟</string>
     <string name="calendar_picker_missing_summary">قد يكون متوقفًا عن التشغيل، للقراءة فقط أو مملوءًا من جهات الاتصال الخاصة بك — يمكنك إدارة تقويماتك هنا.</string>
     <string name="calendars_state_read_only">للقراءة فقط</string>
@@ -542,4 +542,140 @@
     <string name="timeline_scale_regular">العادي</string>
     <string name="timeline_scale_comfortable_summary">مجموعات أوسع، تمرير أكثر</string>
     <string name="timeline_scale_custom_summary">الارتفاع الذي قمت بضغظت المخطط الزمني إليه</string>
+    <string name="event_edit_timezone_device_summary">يتابعك أينما كنت</string>
+    <string name="event_access_confidential_summary">مُعَلَّم كـ سري؛ ما يعنيه ذلك متروك لحساب التقويم</string>
+    <string name="settings_widget_size_summary">نص الحدث %1$d%%</string>
+    <string name="settings_calendar_durations_hint">امنح تقويم طوله الافتراضي خاص به — للمثال. ٨ ساعات لمناوبات العمل.</string>
+    <string name="settings_backup_subtitle">تصدير، استيراد، النسخ الاحتياطي التلقائي</string>
+    <string name="settings_views_all_header">كل طُرق العرض</string>
+    <string name="settings_calendar_durations_title">المدة لكل تقويم</string>
+    <string name="event_move_done">تم النقل إلى %1$s</string>
+    <string name="event_move_undo">تراجع</string>
+    <string name="event_move_undone">تم التراجع عن النقل</string>
+    <string name="event_move_failed">تعذّر نقل الحدث</string>
+    <string name="event_move_write_denied">Calendula يحتاج إلى صلاحية للكتابة لنقل الأحداث</string>
+    <string name="event_move_gone">لم يعد هذا الحدث موجودًا</string>
+    <string name="onboarding_step_counter">الخطوة %1$d من %2$d</string>
+    <string name="onboarding_backup_title">أحداثك تعيش فقط هنا</string>
+    <string name="onboarding_backup_body">لا شئ على هذا الهاتف تتم مزامنته لحساب، لذلك فقدانها سيؤدي لفقدان تقويمك. Calendula يمكنه كتابة نسخة احتياطية لك.</string>
+    <string name="onboarding_backup_benefit_folder_body">النسخ الاحتياطية هي ملفات .ics عادية — ضعها في مكان ما يزامن، أو على بطاقة SD.</string>
+    <string name="onboarding_backup_benefit_daily_title">مرة واحدة يوميًا، من تلقاء نفسه</string>
+    <string name="onboarding_backup_benefit_daily_body">Calendula يقم بتصدير تقويماتك المحلية في الخلفية. يمكنك تغيير مدى المرات في الإعدادات.</string>
+    <string name="onboarding_backup_enable_button">اختر مجلد وانسخ احتياطيًا</string>
+    <string name="onboarding_backup_skip_button">ليس الآن</string>
+    <string name="onboarding_view_title">ما الذي يجب أن يفتح أولاً؟</string>
+    <string name="onboarding_month_style_title">كيف يجب أن يبدو الشهر؟</string>
+    <string name="onboarding_view_continue_button">متابعة</string>
+    <string name="onboarding_back">رجوع</string>
+    <string name="onboarding_visibility_button">فهمت</string>
+    <string name="onboarding_done_title">تم إعدادك بالكامل</string>
+    <string name="onboarding_done_body">تقويماتك جاهزه. يمكن تغيير كل ما اخترته للتو لاحقًا في الإعدادات.</string>
+    <string name="onboarding_done_button">افتح تقويمي</string>
+    <plurals name="search_selected_count">
+        <item quantity="zero">تم تحديد (%d)</item>
+        <item quantity="one">تم تحديد %d</item>
+        <item quantity="two">تم تحديد %d</item>
+        <item quantity="few">تم تحديد %d</item>
+        <item quantity="many">تم تحديد %d</item>
+        <item quantity="other">تم تحديد %d</item>
+    </plurals>
+    <string name="search_in_descriptions">عُثِر في الأوصاف</string>
+    <string name="search_selection_close">إلغاء التحديد</string>
+    <string name="search_select_all">تحديد الكل</string>
+    <string name="search_delete_selected">حذف المُحدّد</string>
+    <plurals name="search_delete_title">
+        <item quantity="zero">حذف (%d) حدث؟</item>
+        <item quantity="one">حذف %d حدث واحد؟</item>
+        <item quantity="two">حذف %d حدثان؟</item>
+        <item quantity="few">حذف %d أحداث؟</item>
+        <item quantity="many">حذف %d حدث؟</item>
+        <item quantity="other">حذف %d حدث؟</item>
+    </plurals>
+    <plurals name="search_delete_done">
+        <item quantity="zero">تم حذف (%d) لا حدث</item>
+        <item quantity="one">تم حذف %d حدث واحد</item>
+        <item quantity="two">تم حذف %d حدثان</item>
+        <item quantity="few">تم حذف %d أحداث</item>
+        <item quantity="many">تم حذف %d حدث</item>
+        <item quantity="other">تم حذف %d حدث</item>
+    </plurals>
+    <string name="search_delete_partial">تم حذف %1$d، وتعذّر حذف %2$d</string>
+    <string name="search_delete_denied_partial">تم حذف %1$d، ثم تم سحب صلاحية للكتابة</string>
+    <plurals name="import_done_skipped">
+        <item quantity="zero">تم تخطي (%d) بالفعل في هذا التقويم.</item>
+        <item quantity="one">تم تخطي %d بالفعل في هذا التقويم.</item>
+        <item quantity="two">تم تخطي %d بالفعل في هذا التقويم.</item>
+        <item quantity="few">تم تخطي %d بالفعل في هذا التقويم.</item>
+        <item quantity="many">تم تخطي %d بالفعل في هذا التقويم.</item>
+        <item quantity="other">تم تخطي %d بالفعل في هذا التقويم.</item>
+    </plurals>
+    <plurals name="import_done_imported">
+        <item quantity="zero">تم استيراد (%d) لا أحداث.</item>
+        <item quantity="one">تم استيراد %d حدث واحد.</item>
+        <item quantity="two">تم استيراد %d حدثان.</item>
+        <item quantity="few">تم استيراد %d أحداث.</item>
+        <item quantity="many">تم استيراد %d حدث.</item>
+        <item quantity="other">تم استيراد %d حدث.</item>
+    </plurals>
+    <plurals name="import_action">
+        <item quantity="zero">استيراد (%d) لا أحداث</item>
+        <item quantity="one">استيراد %d حدث واحد</item>
+        <item quantity="two">استيراد %d حدثان</item>
+        <item quantity="few">استيراد %d أحداث</item>
+        <item quantity="many">استيراد %d حدث</item>
+        <item quantity="other">استيراد %d حدث</item>
+    </plurals>
+    <plurals name="import_event_count">
+        <item quantity="zero">(%d) لا أحداث في هذا الملف.</item>
+        <item quantity="one">%d حدث واحد في هذا الملف.</item>
+        <item quantity="two">%d حدثان في هذا الملف.</item>
+        <item quantity="few">%d أحداث في هذا الملف.</item>
+        <item quantity="many">%d حدث في هذا الملف.</item>
+        <item quantity="other">%d حدث في هذا الملف.</item>
+    </plurals>
+    <plurals name="import_title_count">
+        <item quantity="zero">يتم استيراد (%d) لا أحداث</item>
+        <item quantity="one">يتم استيراد %d حدث واحد</item>
+        <item quantity="two">يتم استيراد %d حدثان</item>
+        <item quantity="few">يتم استيراد %d أحداث</item>
+        <item quantity="many">يتم استيراد %d حدث</item>
+        <item quantity="other">يتم استيراد %d حدث</item>
+    </plurals>
+    <string name="event_move_recurring_title">نقل الحدث المتكرر</string>
+    <string name="event_edit_conflict_overwrite_hint">فقط الحقول التي عدلتها هي التي ستحل محل التغيير الخارجي</string>
+    <string name="reorder_drag_handle">اسحب لإعادة الترتيب</string>
+    <string name="settings_drawer_order_hint">اسحب لإعادة ترتيب طرق العرض المدرجة في قائمة التنقل.</string>
+    <string name="settings_drawer_order_header">قائمة التنقل</string>
+    <string name="settings_default_reminder_allday">أحداث يوم كامل</string>
+    <string name="settings_allday_reminder_time">وقت تذكير اليوم الكامل</string>
+    <string name="reminder_none">لا شئ</string>
+    <string name="settings_reliable_delivery_hint">أندرويد قد يؤخر التذكيرات لتوفير البطارية. استثنِ Calendula لكي تصل في الوقت المحدد.</string>
+    <string name="settings_calendar_reminders_title">التذكيرات لكل تقويم</string>
+    <string name="settings_license_value">MIT</string>
+    <string name="settings_special_dates_paused_title">متوقف</string>
+    <string name="settings_special_dates_calendar_hint">اضبط لون كل تقويم وإمكانية ظهوره في إعدادات التقويمات.</string>
+    <string name="calendars_visibility_hint">قم بإيقاف تقويم لإخفائه على هذا الجهاز — تختفي أحداثه من التطبيق ويتوقف عن تذكيرك. هذا هو مفتاح التبديل نفسه الذي تستخدمه تطبيقات التقويم الأخرى خاصتك، لذلك تقوم بإخفائه أيضًا. لا شيء يتم حذفه، ولا يتأثر أي جهاز آخر، ويمكنك إعادة تشغيله من هنا في أي وقت.</string>
+    <string name="settings_allday_reminder_fires_at">يتم الإشعار في %1$s</string>
+    <string name="settings_agenda_widget_range">نطاق ودجت الجدول</string>
+    <string name="settings_widget_size">حجم ودجت الجدول</string>
+    <string name="settings_widgets_subtitle">ودجت الجدول، عنصر الإعدادات السريعة</string>
+    <string name="settings_drag_to_reschedule">السحب لتعديل الموعد</string>
+    <string name="settings_drag_to_reschedule_summary">انقل حدثًا عن طريق سحبه إلى يوم أو وقت آخر</string>
+    <string name="event_move_blocked_series_end">لا يمكن نقل حدث بعد نهاية سلسلته</string>
+    <string name="crash_dialog_report">تقرير</string>
+    <string name="settings_quick_switch_hint">اختر أي طُرق العرض التي يتم التنقل بينها باستخدام الزر الموجود في أعلى اليمين، واسحب لإعادة ترتيبها. تظل طرق العرض التي تم إيقاف تشغيلها متاحة من قائمة التنقل.</string>
+    <string name="calendars_account_from_source">%1$s (%2$s)</string>
+    <string name="duration_hours_minutes">%1$s %2$s</string>
+    <string name="settings_widgets_hint">إعدادات لوجدتز الشاشة الرئيسية وعنصر لوحة الإعدادات السريعة. أضف وجدت عن طريق الضغط لفترة طويلة على شاشتك الرئيسية.</string>
+    <string name="import_warning_attendees">لم يتم استيراد قوائم الضيوف.</string>
+    <string name="settings_reliable_delivery_exempt">معفى من تحسين البطارية — تصل التذكيرات في الوقت المحدد.</string>
+    <string name="settings_reliable_delivery">توصيل موثوق</string>
+    <string name="settings_allday_reminder_time_hint">تنطلق التذكيرات لأحداث التي تستمر طوال اليوم عند %1$s</string>
+    <string name="agenda_range_override_hint">فقط للآن — يعيد التعيين إلى المدى المحفوظ الخاص بك عند إعادة فتح Calendula.</string>
+    <string name="settings_past_events_sample_morning">مراجعة الفريق</string>
+    <string name="settings_past_events_sample_midday">غداء مع روبن</string>
+    <string name="settings_past_events_sample_evening">ممارسة الجوقة</string>
+    <string name="settings_special_dates_last_synced">آخر مزامنة %1$s</string>
+    <string name="settings_special_dates_disable_type_message">يؤدي هذا لحذف التقويم ”%1$s“ وأحداثه. سيتم فقدان أي تذكيرات أو ملاحظات أضفتها إليه.</string>
+    <string name="special_dates_default_title_birthday">عيد ميلاد {name} ({year})</string>
 </resources>

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_title">Datenschutz by Design</string>
-    <string name="permission_benefit_private_body">Deine Kalender werden lokal gelesen und verlassen das Telefon nie.</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_appearance_subtitle">Theme, Farben, Schriftarten</string>
-    <string name="settings_event_form_subtitle">Standardfelder für neue Termine</string>
+    <string name="settings_event_form_subtitle">Standardfelder und Verhalten</string>
-    <string name="settings_notifications_subtitle">Termin-Erinnerungen</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-es/strings.xml

@@ -491,4 +491,5 @@
         <item quantity="many">Importando %d eventos</item>
         <item quantity="other">Importando %d eventos</item>
     </plurals>
+    <string name="settings_soften_colors">Armoniza los colores del calendario</string>
 </resources>

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

@@ -17,14 +17,14 @@
     <string name="state_failure_no_calendars_action">Apri le impostazioni calendario di sistema</string>
     <string name="state_failure_provider">Errore nella lettura del calendario.</string>
     <string name="permission_rationale_title">Gestisci magnificamente tutti i tuoi eventi</string>
-    <string name="permission_rationale_body">Calendula ha bisogno di accedere al tuo calendario per mostrare e gestire gli eventi. È l\'unica cosa di cui ha bisogno: nessuna informazione lascerà mai il tuo dispositivo.</string>
+    <string name="permission_rationale_body">Calendula ha bisogno di accedere al tuo calendario per mostrare e gestire gli eventi.</string>
     <string name="permission_request_button">Concedi l\'accesso al calendario</string>
     <string name="permission_denied_title">Accesso al calendario negato</string>
     <string name="permission_denied_body">Calendula non può mostrare gli eventi senza accesso al calendario. Puoi concederlo dalle impostazioni di sistema.</string>
     <string name="permission_open_settings_button">Apri le impostazioni di sistema</string>
     <string name="permission_retry_button">Riprova</string>
-    <string name="permission_benefit_private_title">Rimane sul tuo dispositivo</string>
+    <string name="permission_benefit_private_title">Privato by design</string>
-    <string name="permission_benefit_private_body">I tuoi calendari sono letti localmente e non lasciano mai il tuo dispositivo.</string>
+    <string name="permission_benefit_private_body">Nessun accesso a internet, nessun tracking: nulla lascia il tuo dispositivo.</string>
     <string name="permission_benefit_sync_title">Tutti i tuoi calendari, insieme</string>
     <string name="permission_benefit_sync_body">Google, CalDAV, locali - qualsiasi calendario sincronizzato sul dispositivo, semplicemente, compare.</string>
     <string name="permission_benefit_privacy_title">Nessun tracking, per sempre</string>
@@ -301,8 +301,8 @@
     <string name="settings_language_auto">Lingua di sistema</string>
     <string name="settings_translate">Aiuta a tradurre</string>
     <string name="settings_translate_hint">Aggiungi o migliora una traduzione su Weblate</string>
-    <string name="settings_appearance_subtitle">Tema, vista di default, inizio settimana</string>
+    <string name="settings_appearance_subtitle">Tema, colori, font</string>
-    <string name="settings_event_form_subtitle">Campi di default per nuovi eventi</string>
+    <string name="settings_event_form_subtitle">Campi di default e comportamento</string>
     <string name="settings_section_about">A proposito</string>
     <string name="settings_license">Licenza</string>
     <string name="settings_license_value">MIT</string>
@@ -414,7 +414,7 @@
     <string name="agenda_range_this_week">Questa settimana</string>
     <string name="settings_reminders">Promemoria per gli eventi</string>
     <string name="settings_default_reminder">Promemoria per eventi standard</string>
-    <string name="settings_notifications_subtitle">Promemoria evento</string>
+    <string name="settings_notifications_subtitle">Promemoria</string>
     <string name="shortcut_new_event_short">Nuovo evento</string>
     <string name="event_edit_managed_hint">Gestito da “%1$s” - titolo, data e ripetizioni sono sincronizzate dai tuoi contatti. Promemoria e note sono modificabili dall\'utente.</string>
     <string name="settings_font_headings">Carattere del titolo</string>
@@ -423,13 +423,13 @@
     <string name="settings_font_choose_file">Scegli file…</string>
     <string name="settings_font_custom_selected">Font personalizzato</string>
     <string name="settings_font_import_failed">Impossibile leggere il file come font</string>
-    <string name="settings_section_views">Viste</string>
+    <string name="settings_section_views">Vista</string>
     <string name="settings_quick_switch_header">Pulsante di cambio rapido</string>
     <string name="settings_quick_switch_hint">Scegli attraverso quali viste scorrere col pulsante in alto a destra, trascinale per riordinarle. Le viste disattivate rimangono raggiungibili dal menù di navigazione.</string>
     <string name="settings_drawer_order_header">Menù di navigazione</string>
     <string name="settings_drawer_order_hint">Trascina per riordinare le viste elencate nel menù di navigazione.</string>
     <string name="reorder_drag_handle">Trascina per riordinare</string>
-    <string name="settings_views_subtitle">Ordine del pulsante di cambio rapido e del menù</string>
+    <string name="settings_views_subtitle">Vista di default, layout, ordine</string>
     <string name="settings_special_dates_subtitle">Compleanni e anniversari dei contatti</string>
     <string name="settings_section_special_dates">Date speciali dei contatti</string>
     <string name="settings_special_dates_enable">Mostra date dei contatti</string>
@@ -478,8 +478,8 @@
     <string name="reminder_day_yesterday">Ieri</string>
     <string name="agenda_no_more_today">Nessun altro evento per oggi</string>
     <string name="back">Indietro</string>
-    <string name="settings_soften_colors">Attenua i colori del calendario</string>
+    <string name="settings_soften_colors">Armonizza i colori del calendario</string>
-    <string name="settings_soften_colors_summary">I colori dei calendari e degli eventi vengono attenuati per adattarsi al tema. Deseleziona per mostrare i colori naturali.</string>
+    <string name="settings_soften_colors_summary">Mantieni i colori del calendario ma attenua la luminosità, così gli eventi rimangono leggibili e i colori sono armonizzati. Deseleziona per mostrare i colori originali.</string>
     <string name="settings_week_numbers">Numeri di settimana</string>
     <string name="settings_week_numbers_summary">Mostra i numeri di settimana nella vista Mese</string>
     <string name="settings_agenda_show_today">Mostra sempre Oggi</string>
@@ -499,4 +499,151 @@
         <item quantity="many">Importando %d eventi</item>
         <item quantity="other">Importando %d eventi</item>
     </plurals>
+    <string name="event_move_action">Sposta…</string>
+    <string name="event_move_recurring_title">Sposta un evento ricorrente</string>
+    <string name="event_move_done">Spostato al %1$s</string>
+    <string name="event_move_undo">Annulla ripianificazione</string>
+    <string name="event_move_undone">Ripianificazione annullata</string>
+    <string name="event_move_failed">Impossibile ripianificare l\'evento</string>
+    <string name="event_move_write_denied">Calendula ha bisogno dei permessi di scrittura per ripianificare gli eventi</string>
+    <string name="event_move_gone">Questo evento è stato eliminato.</string>
+    <string name="event_move_blocked_series_end">Non è possibile ripianificare un evento oltre la data di fine della sua serie</string>
+    <string name="event_edit_timezone_device">Fuso orario del dispositivo</string>
+    <string name="event_edit_timezone_device_summary">Segue il fuso orario in cui ti trovi</string>
+    <string name="event_edit_timezone_search">Seleziona fuso orario</string>
+    <string name="event_edit_timezone_recent">Recenti</string>
+    <string name="event_edit_timezone_all">Tutti i fusi orari</string>
+    <string name="event_edit_timezone_none">Nessun fuso corrisponde a \"%1$s\"</string>
+    <string name="event_edit_timezone_local_time">%1$s nel tuo fuso orario</string>
+    <string name="event_edit_recurrence_incomplete">Inserisci un numero tra 1 e 999</string>
+    <string name="event_edit_recurrence_next">Prossimo evento: %1$s</string>
+    <string name="event_edit_recurrence_next_none">Questa regola non si ripete</string>
+    <string name="event_access_default_summary">In base all\'impostazione del calendario</string>
+    <string name="event_access_public_summary">Chiunque acceda può vedere i dettagli completi</string>
+    <string name="event_access_private_summary">Gli altri vedranno solo che sei impegnato</string>
+    <string name="event_access_confidential_summary">Confidenziale; dipende dalle impostazioni dell\'account</string>
+    <string name="duration_hours_minutes">%1$s %2$s</string>
+    <string name="duration_custom_max">Al più %1$s</string>
+    <string name="onboarding_step_counter">Step %1$d di %2$d</string>
+    <string name="onboarding_backup_title">I tuoi eventi rimangono qui</string>
+    <string name="onboarding_backup_body">Nulla viene sincronizzato, perdere i dati presenti su questo dispositivo significa perdere i tuoi calendari. Calendula può fare un backup per te.</string>
+    <string name="onboarding_backup_benefit_folder_title">Una cartella a scelta</string>
+    <string name="onboarding_backup_benefit_folder_body">I backup sono file .ics. Mettili al sicuro sul cloud o su una scheda SD.</string>
+    <string name="onboarding_backup_benefit_daily_title">Giornaliero, in automatico</string>
+    <string name="onboarding_backup_benefit_daily_body">Calendula esporta i tuoi calendari locali in background. Selezione la frequenza nelle Impostazioni.</string>
+    <string name="onboarding_backup_enable_button">Seleziona la cartella ed esegui il backup</string>
+    <string name="onboarding_backup_skip_button">Non ora</string>
+    <string name="onboarding_view_title">Cosa viene aperto per primo?</string>
+    <string name="onboarding_month_style_title">Seleziona la vista Mese</string>
+    <string name="onboarding_view_continue_button">Continua</string>
+    <string name="onboarding_back">Indietro</string>
+    <string name="onboarding_visibility_button">Capito</string>
+    <string name="onboarding_done_title">Tutto fatto</string>
+    <string name="onboarding_done_body">I tuoi calendari sono pronti. Tutto ciò che hai scelto può essere modificato più tardi nelle Impostazioni.</string>
+    <string name="onboarding_done_button">Apri i miei calendari</string>
+    <string name="agenda_span_starts">Inizia alle %1$s</string>
+    <string name="agenda_span_ends">Finisce alle %1$s</string>
+    <string name="today_jump_action">Vai ad oggi</string>
+    <plurals name="search_selected_count">
+        <item quantity="one">%d selezionato</item>
+        <item quantity="many">%d selezionati</item>
+        <item quantity="other">%d selezionati</item>
+    </plurals>
+    <string name="search_in_descriptions">Trovato nelle descrizioni</string>
+    <string name="search_selection_close">Cancella selezione</string>
+    <string name="search_select_all">Seleziona tutti</string>
+    <string name="search_delete_selected">Elimina i selezionati</string>
+    <plurals name="search_delete_title">
+        <item quantity="one">Eliminare l\'evento?</item>
+        <item quantity="other">Eliminare l\'evento?</item>
+    </plurals>
+    <plurals name="search_delete_done">
+        <item quantity="one">Evento eliminato</item>
+        <item quantity="other">Evento eliminato</item>
+    </plurals>
+    <string name="search_delete_partial">%1$d eliminati, %2$d no</string>
+    <string name="search_delete_denied_partial">%1$d eliminati, poi permessi di scrittura negati</string>
+    <string name="event_move_occurrence_only">Ripianificare l\'intera serie cambia i giorni in cui cade, quindi puoi ripianificare solo questo evento.</string>
+    <string name="settings_theme_hint">Tema chiaro o scuro. La modifica viene applicata immediatamente.</string>
+    <string name="settings_theme_system_summary">Al momento %1$s</string>
+    <string name="settings_font_specimen_heading">Giovedì, 14 Maggio</string>
+    <string name="settings_font_specimen_body">Team review alle 10:00, poi pranzo con Ugo al bar a Piazza di Spagna.</string>
+    <string name="settings_week_start_auto_summary">Al momento %1$s</string>
+    <string name="settings_today_toolbar">Pulsante Oggi nella toolbar</string>
+    <string name="settings_today_toolbar_summary">Mostra il pulsante \"vai alla data\" nella toolbar invece che come pulsante flottante</string>
+    <string name="settings_app_name">Nome app</string>
+    <string name="settings_app_name_summary">Mostra Calendula come \"Calendario\" nel launcher. Il nome cambia solo nel launcher; l\'icona potrebbe spostarsi dopo la modifica.</string>
+    <string name="settings_time_format_auto_summary">Da sistema: %1$s</string>
+    <string name="settings_timeline_scale">Altezza ore</string>
+    <string name="settings_timeline_scale_hint">Spazio occupato verticalmente da un\'ora nella vista Giorno e Settimana. Puoi anche modificare l\'altezza come preverisci pizzicando la timeline.</string>
+    <string name="timeline_scale_fit_day">Occupa la giornata intera</string>
+    <string name="timeline_scale_fit_day_summary">Tutte le 24 ore in una schermata, senza scrolling</string>
+    <string name="timeline_scale_compact">Compatto</string>
+    <string name="timeline_scale_compact_summary">Più ore per schermata, blocchi più piccoli</string>
+    <string name="timeline_scale_regular">Regolare</string>
+    <string name="timeline_scale_regular_summary">La spaziatura standard</string>
+    <string name="timeline_scale_comfortable">Comodo</string>
+    <string name="timeline_scale_comfortable_summary">Blocchi più ampi, più scrolling</string>
+    <string name="timeline_scale_custom">Personalizza</string>
+    <string name="timeline_scale_custom_summary">L\'altezza a cui hai portato la timeline</string>
+    <string name="settings_drag_to_reschedule">Trascina per ripianificare</string>
+    <string name="settings_drag_to_reschedule_summary">Ripianifica un evento trascinandolo in un altro giorno o ora</string>
+    <string name="settings_past_events_sample_morning">Team review</string>
+    <string name="settings_past_events_sample_midday">Pranzo con Ugo</string>
+    <string name="settings_past_events_sample_evening">Allenamento di scacchi</string>
+    <string name="settings_widget_size">Dimensioni del widget Agenda</string>
+    <string name="settings_widget_size_hint">Dimensioni del testo del widget agenda. Il widget mensile non ha impostazioni, si adatta da solo alla dimensione data.</string>
+    <string name="settings_widget_size_small">Piccolo</string>
+    <string name="settings_widget_size_medium">Medio</string>
+    <string name="settings_widget_size_large">Grande</string>
+    <string name="settings_widget_size_extra_large">Molto grande</string>
+    <string name="settings_widget_size_summary">Carattere %1$d%%</string>
+    <string name="settings_month_header">Vista Mese</string>
+    <string name="settings_month_view_style">Stile vista Mese</string>
+    <string name="month_style_paged">Pagine</string>
+    <string name="month_style_paged_summary">Viene mostrato un singolo mese. Scorri a destra o a sinistra per cambiare mese.</string>
+    <string name="month_style_continuous">Scorrimento</string>
+    <string name="settings_past_events_hint">Ciò che fa l\'Agenda con eventi conclusi.</string>
+    <string name="settings_dynamic_color_summary">Deduci il colore dell\'app dallo sfondo.</string>
+    <string name="settings_about_privacy">Politica per la Privacy</string>
+    <string name="calendars_visibility_hint">Deseleziona un calendario per non mostrarlo sul dispositivo: scompariranno gli eventi e non riceverai più promemoria. Questa impostazione agisce anche su altre app calendario. Nulla viene eliminato e il calendario non scompare da nessun altro dispositivo. Puoi riselezionarlo in ogni momento.</string>
+    <string name="calendars_visibility_a11y">Mostra \"%1$s\"</string>
+    <string name="calendars_visibility_notice_title">Alcuni calendari non sono attivi</string>
+    <string name="calendars_visibility_notice_message">Calendula mostra solo i calendari che sono attivi sul dispositivo, e alcuni non lo sono. Per vedere gli eventi di quest\'ultimi, attivali dalle Impostazioni.</string>
+    <string name="calendar_picker_missing_title">Manca un calendario?</string>
+    <string name="calendar_picker_missing_summary">Può essere disattivato, in sola lettura o compilato in base ai tuoi contatti. Gestisci qui i tuoi calendari.</string>
+    <string name="calendars_state_read_only">Sola lettura</string>
+    <string name="calendars_state_not_synced">Non sincronizzato su questo dispositivo</string>
+    <string name="calendars_state_managed">Compilato dai tuoi contatti</string>
+    <string name="calendars_managed_delete_locked">Questo calendario è compilato in base ai tuoi contatti, quindi Calendula lo creerà di nuovo alla prossima sincronizzazione. Per eliminarlo disattiva l\'opzione \"Date Speciali\" nelle Impostazioni.</string>
+    <string name="calendars_account_from_source">%1$s (%2$s)</string>
+    <string name="month_style_continuous_summary">Ogni mese è sotto la sua testata, con un piccolo spazio a separarlo dal mese successivo.</string>
+    <string name="month_style_dense">Settimane continue</string>
+    <string name="month_style_dense_summary">Le settimane scorrono senza interruzione, ogni mese succede a quello precedente.</string>
+    <string name="month_style_split">Diviso</string>
+    <string name="month_style_split_summary">Una griglia compatta indica i giorni con eventi. Gli eventi del giorno selezionato sono elencati sotto.</string>
+    <string name="month_split_no_events">Nulla in programma</string>
+    <string name="month_split_expand">Mostra il mese completo</string>
+    <string name="month_split_collapse">Mostra gli eventi del giorno</string>
+    <string name="settings_event_duration">Durata standard</string>
+    <string name="settings_event_duration_hint">Quanto durano gli eventi se non modifichi l\'orario di fine. Non ha effetto sugli eventi giornalieri.</string>
+    <string name="settings_calendar_durations_title">Durata per calendario</string>
+    <string name="settings_calendar_durations_hint">Assegna a ciascun calendario la sua durata standard (e.g. 8 ore per il calendario dei turni lavorativi).</string>
+    <string name="settings_calendar_duration_inherits">Default (%1$s)</string>
+    <string name="settings_calendar_duration_use_default">Usa la durata standard (%1$s)</string>
+    <string name="settings_allday_reminder_fires_at">Promemoria alle %1$s</string>
+    <string name="settings_group_look">Aspetto e Comportamento</string>
+    <string name="settings_group_data">Dati</string>
+    <string name="settings_group_app">App</string>
+    <string name="settings_group_about">A proposito</string>
+    <string name="settings_widgets_subtitle">Widget Agenda e riquadro Impostazioni rapide</string>
+    <string name="settings_backup_subtitle">Export, Import, backup automatici</string>
+    <string name="settings_section_widgets">Widget &amp; Riquardi</string>
+    <string name="settings_widgets_hint">Impostazioni per i widget e il riquardo delle Impostazioni rapide. Aggiungi i widget tenendo premuto sulla home.</string>
+    <string name="settings_section_backup">Backup e ripristino</string>
+    <string name="settings_views_all_header">Tutte le viste</string>
+    <string name="settings_week_day_header">Giorno e settimana</string>
+    <string name="settings_default_view_hint">La vista di default all\'apertura dell\'app.</string>
+    <string name="settings_week_start_hint">Il giorno in cui inizia ogni settimana, in tutta l\'app e i suoi widget.</string>
+    <string name="settings_time_format_hint">Formato degli orari in tutta l\'app. Di default viene seguito il formato di sistema.</string>
 </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-ru/strings.xml

@@ -17,14 +17,14 @@
     <string name="state_failure_no_calendars_action">Перейти в системные настройки календаря</string>
     <string name="state_failure_provider">Не удалось просмотреть календарь.</string>
     <string name="permission_rationale_title">Следите за всеми своими событиями. С красотой</string>
-    <string name="permission_rationale_body">Calendula требуется доступ к вашему календарю, чтобы показывать и управлять вашими событиями. Это всё, что приложение требует с самого начала – и никакая информация не покидает ваш девайс.</string>
+    <string name="permission_rationale_body">Calendula требуется доступ к вашему календарю, чтобы показывать и управлять вашими событиями. Это всё, что приложение требует с самого начала – и никакая информация не покидает ваше устройство.</string>
     <string name="permission_request_button">Дать доступ к календарю</string>
     <string name="permission_denied_title">В доступе к календарю отказано</string>
     <string name="permission_denied_body">Calendula не может показать события без доступа к календарю. Предоставьте его снова в настройках телефона.</string>
     <string name="permission_open_settings_button">Открыть настройки телефона</string>
     <string name="permission_retry_button">Попытайтесь снова</string>
-    <string name="permission_benefit_private_title">Остаётся на вашем устройстве</string>
+    <string name="permission_benefit_private_title">Приватность по умолчанию</string>
-    <string name="permission_benefit_private_body">Ваши календари просматриваются локально и информация никогда не покидает устройство.</string>
+    <string name="permission_benefit_private_body">Нет доступа к интернету, нету телеметрии — ничто не покидает ваше устройство.</string>
     <string name="permission_benefit_sync_title">Все ваши календари. Вместе</string>
     <string name="permission_benefit_sync_body">Google, CalDAV, локальный календарь – всё синхронизированное с устройством просто подключается.</string>
     <string name="permission_benefit_privacy_title">Никакого отслеживания. Никогда</string>
@@ -62,4 +62,75 @@
     <string name="event_edit_close">Закрыть</string>
     <string name="event_edit_save">Сохранить</string>
     <string name="event_edit_title_hint">Добавить имя</string>
+    <string name="event_move_action">Перенести…</string>
+    <string name="event_move_recurring_title">Перенести повторяющиеся события</string>
+    <string name="event_move_done">Перенесено на %1$s</string>
+    <string name="event_move_undo">Отменить</string>
+    <string name="event_move_occurrence_only">Перемещение всей серии изменит дни на которые она попадёт, поэтому можно переместить только это событие.</string>
+    <string name="event_move_undone">Перемещение отменено</string>
+    <string name="event_move_failed">Не удалось переместить событие</string>
+    <string name="event_move_write_denied">Приложению Calendula требуется доступ на запись, чтобы перемещать события</string>
+    <string name="event_move_gone">Это событие больше не существует</string>
+    <string name="event_move_blocked_series_end">Нельзя переместить событие дальше за пределы его серии</string>
+    <string name="event_edit_managed_hint">Управляется «%1$s» — название, дата и повторение синхронизируются с ваших контактов. Напоминания, местоположения и заметки могут быть редактированы вами.</string>
+    <string name="event_edit_starts">Начинается</string>
+    <string name="event_edit_ends">Заканчивается</string>
+    <string name="event_edit_error_end_before_start">Заканчивается раньше, чем начинается</string>
+    <string name="event_edit_error_no_calendar">Нет календарей с правами на запись</string>
+    <string name="event_edit_save_failed">Не удалось сохранить событие</string>
+    <string name="event_edit_write_denied">Приложению Calendula требуется доступ на запись, чтобы создавать события</string>
+    <string name="event_edit_more_fields">Больше полей</string>
+    <string name="event_edit_add">Добавить</string>
+    <string name="event_edit_add_reminder">Добавить напоминание</string>
+    <string name="event_edit_remove_reminder">Удалить напоминание</string>
+    <string name="event_edit_attendees">Гости</string>
+    <string name="event_edit_add_guest">Добавить гостя</string>
+    <string name="event_edit_add_guest_hint">Добавить гостя по почте…</string>
+    <string name="event_edit_add_guest_from_contacts">Добавить из контактов</string>
+    <string name="event_edit_location_from_contacts">Выбрать адрес из контактов</string>
+    <string name="event_edit_remove_guest">Удалить гостя</string>
+    <string name="event_edit_attendee_required">Обязательный</string>
+    <string name="event_edit_attendee_optional">Необязательный</string>
+    <string name="event_edit_attendees_note_synced">Calendula не отправляет приглашения. Ваша учётная запись календаря может отправить письма гостям при синхронизации.</string>
+    <string name="event_edit_attendees_note_local">Хранится на этом устройстве. Никто не получит уведомление.</string>
+    <string name="event_edit_reminder_custom">Другое</string>
+    <string name="reminder_unit_minutes">минуты</string>
+    <string name="reminder_unit_hours">часы</string>
+    <string name="reminder_unit_days">дни</string>
+    <string name="reminder_unit_weeks">недели</string>
+    <string name="event_edit_availability">Занятость</string>
+    <string name="event_edit_visibility">Видимость</string>
+    <string name="event_edit_timezone_device">Часовой пояс устройства</string>
+    <string name="event_edit_timezone_device_summary">Следует за вами, где бы вы ни были</string>
+    <string name="event_edit_timezone_search">Поиск часовых поясов</string>
+    <string name="event_edit_timezone_recent">Недавние</string>
+    <string name="event_edit_timezone_all">Все часовые пояса</string>
+    <string name="event_edit_timezone_none">Часовые пояса, соответсвующие «%1$s», не найдены</string>
+    <string name="event_edit_timezone_local_time">%1$s по вашему времени</string>
+    <string name="event_edit_color">Цвет</string>
+    <string name="event_edit_color_default">Цвет календаря</string>
+    <string name="event_edit_color_custom">Свой цвет</string>
+    <string name="event_edit_color_reset">Сбросить</string>
+    <string name="event_edit_color_unsupported">Недоступно для этого календаря</string>
+    <string name="event_edit_color_unsupported_hint">Этот календарь не публикует набор цветов. Вы можете разрешить пользовательские цвета для таких календарей в Настройках.</string>
+    <string name="event_edit_color_sync_warning">Этот календарь может потерять или перезаписать цвет при следующей синхронизации.</string>
+    <string name="event_edit_conflict_title">Событие изменено в другом месте</string>
+    <string name="event_edit_conflict_body">Пока вы редактировали, это событие было изменено — синхронизацией или другим приложением. Что вы хотите сделать с вашими изменениями?</string>
+    <string name="event_edit_conflict_overwrite">Сохранить мои изменения</string>
+    <string name="event_edit_conflict_overwrite_hint">Только изменённые вами поля, перезаписывают внешние изменения</string>
+    <string name="event_edit_conflict_discard">Отменить мои изменения</string>
+    <string name="event_edit_conflict_discard_hint">Событие остаётся таким, как сейчас</string>
+    <string name="event_edit_gone_title">Событие удалено</string>
+    <string name="event_edit_gone_body">Это событие было удалено, пока вы его редактировали, например на другом устройстве. Ваши изменения больше не могут быть сохранены.</string>
+    <string name="import_reminder_prompt_title">Применить ваше стандартное напоминание?</string>
+    <string name="import_reminder_prompt_body_none">Это событие было импортировано без каких-либо напоминаний.</string>
+    <plurals name="import_reminder_prompt_body_existing">
+        <item quantity="one">Это событие было импортировано с %1$d напоминанием.</item>
+        <item quantity="few">Это событие было импортировано с %1$d напоминаниями.</item>
+        <item quantity="many">Это событие было импортировано с %1$d напоминаниями.</item>
+        <item quantity="other">Это событие было импортировано с %1$d напоминаниями.</item>
+    </plurals>
+    <string name="import_reminder_prompt_apply">Применить стандартное</string>
+    <string name="import_reminder_prompt_keep">Оставить как есть</string>
+    <string name="event_edit_recurrence_none">Не повторяется</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_title">Private by design</string>
-    <string name="permission_benefit_private_body">Your calendars are read locally and never leave the phone.</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>
@@ -268,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>
@@ -277,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>
@@ -323,6 +347,7 @@
         <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>
@@ -335,6 +360,7 @@
         <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>
@@ -413,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>
@@ -595,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),
+                    SearchCandidate(makeEvent(10L, "Shown", calendarId = 1L)),
-                    makeEvent(11L, "Switched off", calendarId = 2L),
+                    SearchCandidate(makeEvent(11L, "Switched off", calendarId = 2L)),
-                    makeEvent(12L, "Hidden", calendarId = 3L),
+                    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/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/InstanceMapperTest.kt

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import android.provider.CalendarContract
 import com.google.common.truth.Truth.assertThat
 import kotlin.time.Instant
 import org.junit.jupiter.api.Test
@@ -17,6 +18,7 @@ class InstanceMapperTest {
         eventColor: Any? = null,
         calendarColor: Int = 0xFFAABBCC.toInt(),
         location: String? = null,
+        selfAttendeeStatus: Int = CalendarContract.Attendees.ATTENDEE_STATUS_NONE,
     ): MapColumnReader = MapColumnReader(
         InstanceProjection.IDX_INSTANCE_ID to instanceId,
         InstanceProjection.IDX_EVENT_ID to eventId,
@@ -28,6 +30,7 @@ class InstanceMapperTest {
         InstanceProjection.IDX_EVENT_COLOR to eventColor,
         InstanceProjection.IDX_CALENDAR_COLOR to calendarColor,
         InstanceProjection.IDX_LOCATION to location,
+        InstanceProjection.IDX_SELF_ATTENDEE_STATUS to selfAttendeeStatus,
     )
 
     @Test
@@ -90,4 +93,20 @@ class InstanceMapperTest {
         val inst = reader(location = "Berlin").toEventInstance()
         assertThat(inst!!.location).isEqualTo("Berlin")
     }
+
+    @Test
+    fun `a declined invitation is marked, any other answer is not`() {
+        assertThat(reader().toEventInstance()!!.isDeclined).isFalse()
+        assertThat(
+            reader(selfAttendeeStatus = CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED)
+                .toEventInstance()!!.isDeclined,
+        ).isTrue()
+        listOf(
+            CalendarContract.Attendees.ATTENDEE_STATUS_ACCEPTED,
+            CalendarContract.Attendees.ATTENDEE_STATUS_TENTATIVE,
+            CalendarContract.Attendees.ATTENDEE_STATUS_INVITED,
+        ).forEach { status ->
+            assertThat(reader(selfAttendeeStatus = status).toEventInstance()!!.isDeclined).isFalse()
+        }
+    }
 }

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/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/ui/common/TimelineScaleTest.kt

@@ -126,4 +126,24 @@ class TimelineScaleTest {
             assertThat(parseTimelineScale(stored)).isEqualTo(TimelineScale.Regular)
         }
     }
+
+    @Test
+    fun `a tap creates at the hour it landed in, at whatever scale`() {
+        // Same point on the same column reads as a different hour once the
+        // timeline has been pinched — which is the whole of #148: the tap has to
+        // be measured against the height the column is drawing at now.
+        assertThat(tappedMinuteOfDay(offsetY = 500f, hourPx = 100f)).isEqualTo(5 * 60)
+        assertThat(tappedMinuteOfDay(offsetY = 500f, hourPx = 50f)).isEqualTo(10 * 60)
+        // Within an hour it snaps back to that hour's start.
+        assertThat(tappedMinuteOfDay(offsetY = 599f, hourPx = 100f)).isEqualTo(5 * 60)
+    }
+
+    @Test
+    fun `a tap outside the day stays inside it`() {
+        assertThat(tappedMinuteOfDay(offsetY = -20f, hourPx = 56f)).isEqualTo(0)
+        assertThat(tappedMinuteOfDay(offsetY = 99_999f, hourPx = 56f)).isEqualTo(23 * 60)
+        // A viewport measured at nothing has no grid to read — midnight, not a
+        // division by zero.
+        assertThat(tappedMinuteOfDay(offsetY = 500f, hourPx = 0f)).isEqualTo(0)
+    }
 }

app/src/test/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailViewModelTest.kt

@@ -0,0 +1,103 @@
+package de.jeanlucmakiola.calendula.ui.detail
+
+import android.content.ContextWrapper
+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.ics.IcsExporter
+import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventDetail
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.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
+
+/**
+ * Re-opening an occurrence must re-read it (#196): the view model outlives the
+ * sheet, so an edit that changed no time would otherwise show the pre-save row.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class EventDetailViewModelTest {
+
+    private val dispatcher = UnconfinedTestDispatcher()
+
+    @BeforeEach fun setUp() = Dispatchers.setMain(dispatcher)
+    @AfterEach fun tearDown() = Dispatchers.resetMain()
+
+    private val beginMillis = 1_781_164_800_000L
+    private val endMillis = beginMillis + 3_600_000L
+
+    private fun detail(description: String?) = EventDetail(
+        instance = EventInstance(
+            instanceId = 42L, eventId = 42L, calendarId = 1L, title = "Standup",
+            start = Instant.fromEpochMilliseconds(beginMillis),
+            end = Instant.fromEpochMilliseconds(endMillis),
+            isAllDay = false, color = 0xFF000000.toInt(), location = null,
+        ),
+        description = description, organizer = null, attendees = emptyList(), rrule = null,
+    )
+
+    private fun viewModel(tempDir: Path, fake: FakeCalendarDataSource): EventDetailViewModel {
+        val prefs = CalendarPrefs(
+            PreferenceDataStoreFactory.create(
+                scope = CoroutineScope(dispatcher),
+                produceFile = { tempDir.resolve("detail_prefs.preferences_pb").toFile() },
+            ),
+        )
+        val settings = SettingsPrefs(
+            PreferenceDataStoreFactory.create(
+                scope = CoroutineScope(dispatcher),
+                produceFile = { tempDir.resolve("detail_settings.preferences_pb").toFile() },
+            ),
+        )
+        val repo = CalendarRepositoryImpl(fake, prefs, settings, dispatcher as CoroutineDispatcher)
+        // Only `shareUri()` touches the exporter, and nothing here shares.
+        return EventDetailViewModel(repo, IcsExporter(ContextWrapper(null)), dispatcher)
+    }
+
+    @Test
+    fun `re-opening the same occurrence re-reads it`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        var stored: String? = null
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(
+                CalendarSource(
+                    id = 1L, displayName = "Cal", accountName = "acc@local", accountType = "LOCAL",
+                    color = 0xFF112233.toInt(), isVisibleInSystem = true, canModifyContents = true,
+                ),
+            )
+            eventDetailResult = { detail(stored) }
+        }
+        val vm = viewModel(tempDir, fake)
+        val collector = launch(Job()) { vm.state.collect {} }
+
+        vm.open(42L, beginMillis, endMillis)
+        advanceUntilIdle()
+        assertThat((vm.state.value as EventDetailUiState.Success).detail.description).isNull()
+
+        // The edit screen saved a description; the tapped occurrence is unchanged.
+        stored = "Bring the roadmap"
+        vm.open(42L, beginMillis, endMillis)
+        advanceUntilIdle()
+        assertThat((vm.state.value as EventDetailUiState.Success).detail.description)
+            .isEqualTo("Bring the roadmap")
+
+        collector.cancel()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/month/ChipAtCellYTest.kt

@@ -0,0 +1,122 @@
+package de.jeanlucmakiola.calendula.ui.month
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.Month
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.YearMonth
+import kotlinx.datetime.atTime
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import org.junit.jupiter.api.Test
+
+/**
+ * Which chip a tap in a month cell lands on (#187) — the geometry the tap layer
+ * uses to tell "open this event" from "open this day", given that the chips take
+ * no pointer input of their own.
+ */
+class ChipAtCellYTest {
+
+    private val zone = TimeZone.UTC
+    private val jul26 = YearMonth(2026, Month.JULY)
+
+    /** Band starts 40px down the cell; each lane is 20px tall. */
+    private val bandTop = 40f
+    private val laneHeight = 20f
+
+    /** July 2026 starts on a Wednesday, so this row — Jul 6–12 — sits wholly inside it. */
+    private fun rowOfJuly6(events: List<EventInstance>) =
+        layoutMonthWeeks(jul26, DayOfWeek.MONDAY, events, zone)[1]
+
+    private fun allDay(from: LocalDate, toInclusive: LocalDate, id: Long) = EventInstance(
+        instanceId = id,
+        eventId = id,
+        calendarId = 1L,
+        title = "A$id",
+        start = from.atTime(0, 0).toInstant(zone),
+        end = toInclusive.plus(1, DateTimeUnit.DAY).atTime(0, 0).toInstant(zone),
+        isAllDay = true,
+        color = 0xFF2196F3.toInt(),
+        location = null,
+    )
+
+    private fun timed(date: LocalDate, hour: Int, id: Long) = EventInstance(
+        instanceId = id,
+        eventId = id,
+        calendarId = 1L,
+        title = "T$id",
+        start = date.atTime(hour, 0).toInstant(zone),
+        end = date.atTime(hour + 1, 0).toInstant(zone),
+        isAllDay = false,
+        color = 0xFFF44336.toInt(),
+        location = null,
+    )
+
+    private fun MonthWeek.chipAt(col: Int, cellY: Float) =
+        chipAtCellY(col = col, cellY = cellY, bandTopInCell = bandTop, rowHeightPx = laneHeight)
+
+    @Test
+    fun `a tap on a lane resolves to the chip seated there`() {
+        val bar = allDay(LocalDate(2026, 7, 7), LocalDate(2026, 7, 9), id = 1L)
+        val meeting = timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)
+        val week = rowOfJuly6(listOf(bar, meeting))
+
+        // Jul 7 is column 1 of a Monday-anchored row starting Jul 6.
+        assertThat(week.chipAt(col = 1, cellY = bandTop + 5f)?.eventId).isEqualTo(1L)
+        assertThat(week.chipAt(col = 1, cellY = bandTop + laneHeight + 5f)?.eventId).isEqualTo(2L)
+    }
+
+    @Test
+    fun `a multi-day bar answers on every column it covers`() {
+        val bar = allDay(LocalDate(2026, 7, 7), LocalDate(2026, 7, 9), id = 1L)
+        val week = rowOfJuly6(listOf(bar))
+
+        (1..3).forEach { col ->
+            assertThat(week.chipAt(col = col, cellY = bandTop + 5f)?.eventId).isEqualTo(1L)
+        }
+        // Jul 10 is past the bar's last day.
+        assertThat(week.chipAt(col = 4, cellY = bandTop + 5f)).isNull()
+    }
+
+    @Test
+    fun `a tap above the band is the day number, not a chip`() {
+        val week = rowOfJuly6(listOf(timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)))
+
+        assertThat(week.chipAt(col = 1, cellY = bandTop - 1f)).isNull()
+        assertThat(week.chipAt(col = 1, cellY = 0f)).isNull()
+    }
+
+    @Test
+    fun `a tap on an empty lane of a day that has chips falls through to the day`() {
+        val week = rowOfJuly6(listOf(timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)))
+
+        assertThat(week.chipAt(col = 1, cellY = bandTop + laneHeight * 2 + 5f)).isNull()
+    }
+
+    @Test
+    fun `a tap on the overflow row opens the day rather than a hidden event`() {
+        val events = (1..MAX_EVENT_ROWS + 2).map {
+            timed(LocalDate(2026, 7, 7), hour = it, id = it.toLong())
+        }
+        val week = rowOfJuly6(events)
+
+        // The dots sit one lane below the last one the row draws.
+        val overflowY = bandTop + laneHeight * MAX_EVENT_ROWS + 2f
+        assertThat(week.chipAt(col = 1, cellY = overflowY)).isNull()
+    }
+
+    @Test
+    fun `unmeasured geometry resolves to no chip`() {
+        val week = rowOfJuly6(listOf(timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)))
+
+        assertThat(
+            week.chipAtCellY(col = 1, cellY = 45f, bandTopInCell = null, rowHeightPx = laneHeight),
+        ).isNull()
+        assertThat(
+            week.chipAtCellY(col = 1, cellY = 45f, bandTopInCell = bandTop, rowHeightPx = 0f),
+        ).isNull()
+    }
+}

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

@@ -9,6 +9,7 @@ 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
@@ -51,11 +52,13 @@ class SearchViewModelTest {
         calendarId: Long = 1L,
         recurring: Boolean = false,
         startMillis: Long = begin,
-    ) = EventInstance(
+    ) = SearchCandidate(
-        instanceId = id, eventId = id, calendarId = calendarId, title = "Standup $id",
+        EventInstance(
-        start = Instant.fromEpochMilliseconds(startMillis),
+            instanceId = id, eventId = id, calendarId = calendarId, title = "Standup $id",
-        end = Instant.fromEpochMilliseconds(startMillis + 3_600_000L),
+            start = Instant.fromEpochMilliseconds(startMillis),
-        isAllDay = false, color = 0xFF000000.toInt(), location = null, isRecurring = recurring,
+            end = Instant.fromEpochMilliseconds(startMillis + 3_600_000L),
+            isAllDay = false, color = 0xFF000000.toInt(), location = null, isRecurring = recurring,
+        ),
     )
 
     private fun viewModel(tempDir: Path, fake: FakeCalendarDataSource): SearchViewModel {
@@ -199,6 +202,30 @@ class SearchViewModelTest {
             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 {

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
+gates on the first-launch wizard (`ui/onboarding/`), then shows
-shows `CalendarHost`. `CalendarHost` holds the active view (month/week/day)
+`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

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

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

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/21801.txt

@@ -0,0 +1,2 @@
+Behoben
+• Wochen- und Tagesansicht: Ein Tippen auf einen freien Bereich legt den Termin jetzt zur angetippten Uhrzeit an – auch nachdem die Zeitleiste gezoomt oder die Stundenhöhe geändert wurde.

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/21801.txt

@@ -0,0 +1,2 @@
+Fixed
+• Week and day view: tapping an empty slot now creates the event at the hour you tapped, even after zooming the timeline or changing the hour height.

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/21801.txt

@@ -0,0 +1,2 @@
+Fixed
+• Week and day view: tapping an empty slot now creates the event at the hour you tapped, even after zooming the timeline or changing the hour height.

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/21801.txt

@@ -0,0 +1,2 @@
+Corregido
+• Vista de semana y día: al tocar un hueco libre, el evento se crea a la hora que has tocado, incluso después de ampliar la línea de tiempo o cambiar la altura de la hora.

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/21801.txt

@@ -0,0 +1,2 @@
+Corrigé
+• Vues Semaine et Jour : appuyer sur un créneau vide crée désormais l'événement à l'heure touchée, même après avoir zoomé sur la grille ou modifié la hauteur d'une heure.

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/21801.txt

@@ -0,0 +1,2 @@
+Corretto
+• Vista settimana e giorno: toccando uno spazio libero l'evento viene creato all'ora toccata, anche dopo aver ingrandito la linea temporale o cambiato l'altezza dell'ora.

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.

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

@@ -0,0 +1,3 @@
+Novità
+• Ora lo spostamento con il trascinamento si può disattivare: Impostazioni → Viste → «Trascina per spostare». Resta attivo di default; disattivato, gli eventi non si possono più trascinare nelle viste mese, settimana e giorno.
+• Calendula ora parla portoghese brasiliano, grazie a una traduzione della comunità. Si sceglie in Impostazioni → Lingua.