docs(changelog): note agenda range bar and Appearance tidy-up in 2.11.0

Expand the #4 entry to cover the in-agenda range bar (date header + session range switch) and add a Changed note for the Appearance regrouping and the friendlier agenda empty state. Regenerate the F-Droid changelog. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Merge pull request 'feat(agenda): limit how far ahead the agenda screen and widget show (#4 )' (!44 ) from feat/agenda-range-limit into release/v2.11.0
2026-06-27 17:11:29 +02:00 · 2026-06-27 15:08:34 +00:00 · 2026-06-27 17:03:48 +02:00 · 2026-06-27 16:44:52 +02:00 · 2026-06-27 16:37:57 +02:00 · 2026-06-27 16:30:27 +02:00
34 changed files with 1416 additions and 122 deletions
--- a/.gitea/ISSUE_TEMPLATE/crash_report.md
+++ b/.gitea/ISSUE_TEMPLATE/crash_report.md
@@ -5,6 +5,7 @@ title: "Crash: "
 labels:
  - bug
  - crash
+  - priority:high
 ---

 <!--
--- a/.gitea/ISSUE_TEMPLATE/feature_request.md
+++ b/.gitea/ISSUE_TEMPLATE/feature_request.md
@@ -3,7 +3,7 @@ name: Feature request
 about: Suggest an idea or improvement
 title: ""
 labels:
-  - enhancement
+  - feat
 ---

 ### What would you like Calendula to do?
--- a/.gitea/ISSUE_TEMPLATE/question.md
+++ b/.gitea/ISSUE_TEMPLATE/question.md
@@ -0,0 +1,19 @@
+---
+name: Question
+about: Ask how something works or get help using Calendula
+title: ""
+labels:
+  - question
+---
+
+### Your question
+
+
+### What you've tried
+<!-- so far, if anything -->
+
+
+### Context
+- Calendula version: <!-- Settings → bottom of the screen -->
+- Android version:
+- Device:
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+## [2.11.0] — 2026-06-27
+
+### Added
+- Start the week on any day. The **Week starts on** setting (Settings →
+  Appearance) now offers every weekday — not just Monday or Sunday — alongside
+  the automatic, locale-based default. Thanks to @zmaherdev for the suggestion
+  ([#3]).
+- Choose a 12- or 24-hour clock. A new **Time format** setting (Settings →
+  Appearance) lets you force a 12-hour (2:00 PM) or 24-hour (14:00) clock, or
+  follow the system setting automatically. It applies everywhere times appear —
+  the week and day timelines, agenda, event details, search and reminders — so
+  the format is now consistent across the whole app. Thanks to @zmaherdev for
+  the suggestion ([#6]).
+- Optional hour lines in the timeline. A new **Hour lines** switch (Settings →
+  Appearance) draws a faint separator at each hour in the week and day views,
+  making it easier to see when events start and end. Off by default. Thanks to
+  @zmaherdev for the suggestion ([#5]).
+- Limit how far ahead the agenda looks, and switch it on the fly. New **Agenda
+  range** and **Agenda widget range** settings (Settings → Appearance) let the
+  agenda screen and its home-screen widget each show just today, the rest of this
+  week, the rest of this month, a rolling 7 or 30 days, or a custom number of
+  days — "This week" follows your week-start. The agenda also gains a bar at the
+  top naming the exact dates in view, with a button to switch the range just for
+  the current session (it resets when you reopen the app); the bar can be turned
+  off. Thanks to @zmaherdev for the suggestion ([#4]).
+
+### Changed
+- Tidied **Settings → Appearance** into clearer groups (theme & colour, calendar,
+  agenda), and the agenda's empty state now reads "You're all caught up".
+
 ## [2.10.0] — 2026-06-25

 ### Added
@@ -627,3 +657,7 @@ automatically, with zero telemetry and no internet permission.

 [#1]: https://codeberg.org/jlmakiola/calendula/issues/1
 [#2]: https://codeberg.org/jlmakiola/calendula/issues/2
+[#3]: https://codeberg.org/jlmakiola/calendula/issues/3
+[#4]: https://codeberg.org/jlmakiola/calendula/issues/4
+[#5]: https://codeberg.org/jlmakiola/calendula/issues/5
+[#6]: https://codeberg.org/jlmakiola/calendula/issues/6
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -28,8 +28,8 @@ android {
        // which builds this version and then creates the matching vX.Y.Z tag +
        // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
        // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 21000
-        versionName = "2.10.0"
+        versionCode = 21100
+        versionName = "2.11.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt
@@ -9,10 +9,13 @@ import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.core.content.IntentCompat
 import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
@@ -20,7 +23,10 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import dagger.hilt.android.AndroidEntryPoint
 import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.ui.RootScreen
+import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.WidgetNavRequest
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
@@ -81,19 +87,31 @@ class MainActivity : AppCompatActivity() {
                ThemeMode.LIGHT -> false
                ThemeMode.DARK -> true
            }
+            // The app-wide clock convention: the time-format preference resolved
+            // against the device's 24-hour system setting, provided once here so
+            // every time label reads it via LocalUse24HourFormat.
+            val context = LocalContext.current
+            val use24Hour = remember(settings.timeFormat, context) {
+                settings.timeFormat.is24Hour(android.text.format.DateFormat.is24HourFormat(context))
+            }
            CalendulaTheme(
                darkTheme = darkTheme,
                dynamicColor = settings.dynamicColor,
            ) {
-                RootScreen(
-                    modifier = Modifier.fillMaxSize(),
-                    requestedDetailKey = requestedDetailKey,
-                    onDetailKeyConsumed = { requestedDetailKey = null },
-                    widgetNavRequest = requestedNav,
-                    onWidgetNavConsumed = { requestedNav = null },
-                    requestedImportUri = requestedImportUri,
-                    onImportConsumed = { requestedImportUri = null },
-                )
+                CompositionLocalProvider(
+                    LocalUse24HourFormat provides use24Hour,
+                    LocalShowHourLines provides settings.showHourLines,
+                ) {
+                    RootScreen(
+                        modifier = Modifier.fillMaxSize(),
+                        requestedDetailKey = requestedDetailKey,
+                        onDetailKeyConsumed = { requestedDetailKey = null },
+                        widgetNavRequest = requestedNav,
+                        onWidgetNavConsumed = { requestedNav = null },
+                        requestedImportUri = requestedImportUri,
+                        onImportConsumed = { requestedImportUri = null },
+                    )
+                }
                pendingCrashReport?.let { report ->
                    CrashReportDialog(
                        report = report,
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt
@@ -7,6 +7,9 @@ import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
+import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
+import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
@@ -19,18 +22,39 @@ import javax.inject.Singleton
 /** Light/dark override. SYSTEM follows the device setting. */
 enum class ThemeMode { SYSTEM, LIGHT, DARK }

-/** Week-start override. AUTO derives the first day from the active locale. */
-enum class WeekStartPref { AUTO, MONDAY, SUNDAY }
+/**
+ * Week-start override. [Auto] derives the first day from the active locale;
+ * [Day] pins a specific weekday (any of the seven).
+ */
+sealed interface WeekStartPref {
+    data object Auto : WeekStartPref
+    data class Day(val day: DayOfWeek) : WeekStartPref
+}

 /**
- * Resolve the preference to a concrete first-day-of-week. AUTO reads the
- * locale's convention (e.g. Monday in DE, Sunday in en-US).
+ * Clock convention for time-of-day labels. AUTO follows the device's 24-hour
+ * system setting; the others force a 12- or 24-hour clock app-wide.
+ */
+enum class TimeFormatPref { AUTO, TWELVE_HOUR, TWENTY_FOUR_HOUR }
+
+/**
+ * Resolve to a concrete 24-hour flag. AUTO defers to [systemIs24Hour] (the
+ * device's `DateFormat.is24HourFormat` value).
+ */
+fun TimeFormatPref.is24Hour(systemIs24Hour: Boolean): Boolean = when (this) {
+    TimeFormatPref.AUTO -> systemIs24Hour
+    TimeFormatPref.TWELVE_HOUR -> false
+    TimeFormatPref.TWENTY_FOUR_HOUR -> true
+}
+
+/**
+ * Resolve the preference to a concrete first-day-of-week. [WeekStartPref.Auto]
+ * reads the locale's convention (e.g. Monday in DE, Sunday in en-US).
 */
 fun WeekStartPref.resolveFirstDay(locale: Locale): DayOfWeek = when (this) {
-    WeekStartPref.MONDAY -> DayOfWeek.MONDAY
-    WeekStartPref.SUNDAY -> DayOfWeek.SUNDAY
+    is WeekStartPref.Day -> day
    // java.time.DayOfWeek.value is ISO 1..7 (Mon..Sun) — same numbering kotlinx uses.
-    WeekStartPref.AUTO -> DayOfWeek(WeekFields.of(locale).firstDayOfWeek.value)
+    WeekStartPref.Auto -> DayOfWeek(WeekFields.of(locale).firstDayOfWeek.value)
 }

 /**
@@ -55,7 +79,7 @@ class SettingsPrefs @Inject constructor(
    }

    val weekStart: Flow<WeekStartPref> = store.data.map { prefs ->
-        prefs[WEEK_START_KEY].toEnum(WeekStartPref.AUTO)
+        parseWeekStart(prefs[WEEK_START_KEY])
    }

    suspend fun setThemeMode(mode: ThemeMode) {
@@ -67,7 +91,62 @@ class SettingsPrefs @Inject constructor(
    }

    suspend fun setWeekStart(pref: WeekStartPref) {
-        store.edit { it[WEEK_START_KEY] = pref.name }
+        store.edit { it[WEEK_START_KEY] = pref.storageValue() }
+    }
+
+    /** Clock convention for time-of-day labels (v2.11). Defaults to AUTO (system). */
+    val timeFormat: Flow<TimeFormatPref> = store.data.map { prefs ->
+        prefs[TIME_FORMAT_KEY].toEnum(TimeFormatPref.AUTO)
+    }
+
+    suspend fun setTimeFormat(pref: TimeFormatPref) {
+        store.edit { it[TIME_FORMAT_KEY] = pref.name }
+    }
+
+    /**
+     * Whether the week/day timeline draws a faint separator line at each hour
+     * (v2.11). Defaults to OFF — the historical clean look; users opt in.
+     */
+    val showHourLines: Flow<Boolean> = store.data.map { prefs ->
+        prefs[SHOW_HOUR_LINES_KEY] ?: false
+    }
+
+    suspend fun setShowHourLines(enabled: Boolean) {
+        store.edit { it[SHOW_HOUR_LINES_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
+     * widget's [agendaWidgetRange].
+     */
+    val agendaScreenRange: Flow<AgendaRange> = store.data.map { prefs ->
+        parseAgendaRange(prefs[AGENDA_SCREEN_RANGE_KEY], AgendaRange.Month)
+    }
+
+    suspend fun setAgendaScreenRange(range: AgendaRange) {
+        store.edit { it[AGENDA_SCREEN_RANGE_KEY] = range.storageValue() }
+    }
+
+    /** How far ahead the agenda **widget** shows events (v2.11). Defaults to Month. */
+    val agendaWidgetRange: Flow<AgendaRange> = store.data.map { prefs ->
+        parseAgendaRange(prefs[AGENDA_WIDGET_RANGE_KEY], AgendaRange.Month)
+    }
+
+    suspend fun setAgendaWidgetRange(range: AgendaRange) {
+        store.edit { it[AGENDA_WIDGET_RANGE_KEY] = range.storageValue() }
+    }
+
+    /**
+     * Whether the agenda shows its top range bar — the "showing …" header and
+     * the session range switcher (v2.11). Default ON.
+     */
+    val agendaShowRangeBar: Flow<Boolean> = store.data.map { prefs ->
+        prefs[AGENDA_SHOW_RANGE_BAR_KEY] ?: true
+    }
+
+    suspend fun setAgendaShowRangeBar(enabled: Boolean) {
+        store.edit { it[AGENDA_SHOW_RANGE_BAR_KEY] = enabled }
    }

    /**
@@ -259,6 +338,11 @@ class SettingsPrefs @Inject constructor(
        internal val THEME_MODE_KEY = stringPreferencesKey("theme_mode")
        internal val DYNAMIC_COLOR_KEY = booleanPreferencesKey("dynamic_color")
        internal val WEEK_START_KEY = stringPreferencesKey("week_start")
+        internal val AGENDA_SCREEN_RANGE_KEY = stringPreferencesKey("agenda_screen_range")
+        internal val AGENDA_WIDGET_RANGE_KEY = stringPreferencesKey("agenda_widget_range")
+        internal val AGENDA_SHOW_RANGE_BAR_KEY = booleanPreferencesKey("agenda_show_range_bar")
+        internal val TIME_FORMAT_KEY = stringPreferencesKey("time_format")
+        internal val SHOW_HOUR_LINES_KEY = booleanPreferencesKey("show_hour_lines")
        internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
        internal val FORM_FIELDS_KEY = stringPreferencesKey("event_form_default_fields")
        internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
@@ -331,6 +415,25 @@ private fun MutableMap<Long, Int?>.applyOverride(
    }
 }

+/** Sentinel stored for [WeekStartPref.Auto]; days store their [DayOfWeek.name]. */
+private const val WEEK_START_AUTO = "AUTO"
+
+private fun WeekStartPref.storageValue(): String = when (this) {
+    WeekStartPref.Auto -> WEEK_START_AUTO
+    is WeekStartPref.Day -> day.name
+}
+
+/**
+ * Parse the stored week-start value. "AUTO"/null/garbage → [WeekStartPref.Auto];
+ * a [DayOfWeek] name → [WeekStartPref.Day]. The legacy "MONDAY"/"SUNDAY" enum
+ * values migrate transparently, since both are valid day names.
+ */
+private fun parseWeekStart(stored: String?): WeekStartPref = when (stored) {
+    null, WEEK_START_AUTO -> WeekStartPref.Auto
+    else -> DayOfWeek.entries.firstOrNull { it.name == stored }
+        ?.let { WeekStartPref.Day(it) } ?: WeekStartPref.Auto
+}
+
 private const val NONE = "none"
 private const val ENTRY_SEP = ";"
 private const val KEY_VALUE_SEP = "="
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/EventReminderReceiver.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/EventReminderReceiver.kt
@@ -46,7 +46,7 @@ class EventReminderReceiver : BroadcastReceiver() {
                if (settingsPrefs.remindersEnabled.first()) {
                    val now = System.currentTimeMillis()
                    val due = alertStore.dueAlerts(now)
-                    due.forEach(notifier::post)
+                    due.forEach { notifier.post(it) }
                    alertStore.markFired(due.map { it.alertId }, now)
                }
            } finally {
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt
@@ -14,6 +14,9 @@ import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.prefs.is24Hour
+import kotlinx.coroutines.flow.first
 import java.time.ZoneId
 import java.util.Locale
 import javax.inject.Inject
@@ -29,6 +32,7 @@ import javax.inject.Singleton
@Singleton
 class ReminderNotifier @Inject constructor(
    @ApplicationContext private val context: Context,
+    private val settingsPrefs: SettingsPrefs,
 ) {

    /** False when the user declined `POST_NOTIFICATIONS` or muted the app. */
@@ -39,15 +43,18 @@ class ReminderNotifier @Inject constructor(
        return granted && NotificationManagerCompat.from(context).areNotificationsEnabled()
    }

-    fun post(alert: ReminderAlert) {
+    suspend fun post(alert: ReminderAlert) {
        ensureChannel()
        val title = alert.title.ifBlank { context.getString(R.string.event_untitled) }
+        val is24Hour = settingsPrefs.timeFormat.first()
+            .is24Hour(android.text.format.DateFormat.is24HourFormat(context))
        val time = reminderTimeText(
            beginMillis = alert.beginMillis,
            endMillis = alert.endMillis,
            isAllDay = alert.isAllDay,
            zone = ZoneId.systemDefault(),
            locale = Locale.getDefault(),
+            is24Hour = is24Hour,
        )
        val text = listOfNotNull(time, alert.location).joinToString(" · ")
        val notification = NotificationCompat.Builder(context, CHANNEL_ID)
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeText.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeText.kt
@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.data.reminders

+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
@@ -25,6 +26,7 @@ fun reminderTimeText(
    isAllDay: Boolean,
    zone: ZoneId,
    locale: Locale,
+    is24Hour: Boolean,
 ): String {
    if (isAllDay) {
        val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
@@ -40,16 +42,18 @@ fun reminderTimeText(
        }
    }

-    val timeFormat = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+    val timeFormat = timeOfDayFormatter(is24Hour, locale)
    val begin = Instant.ofEpochMilli(beginMillis).atZone(zone)
    val end = Instant.ofEpochMilli(endMillis).atZone(zone)
    return if (begin.toLocalDate() == end.toLocalDate()) {
        timeFormat.format(begin) + RANGE + timeFormat.format(end)
    } else {
-        val dateTimeFormat = DateTimeFormatter
-            .ofLocalizedDateTime(FormatStyle.MEDIUM, FormatStyle.SHORT)
-            .withLocale(locale)
-        dateTimeFormat.format(begin) + RANGE + dateTimeFormat.format(end)
+        // Cross-day: medium date + the chosen short time, joined per side. Built
+        // from the two formatters (not ofLocalizedDateTime) so the 12/24h choice
+        // applies to the time portion too.
+        val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
+        val dateTime = { z: java.time.ZonedDateTime -> "${dateFormat.format(z)}, ${timeFormat.format(z)}" }
+        dateTime(begin) + RANGE + dateTime(end)
    }
 }

--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRange.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRange.kt
@@ -0,0 +1,111 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import java.time.YearMonth
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+import java.util.Locale
+
+/**
+ * How far ahead the agenda (screen or widget) shows events, starting at today.
+ *
+ * Two flavours:
+ * - **Rolling** windows of a fixed length: [Day] (today), [Week] (7 days),
+ *   [Month] (30 days), [Custom] (1–365 days). These never degenerate.
+ * - **Calendar-aligned** windows that end at a period boundary: [ThisWeek] runs
+ *   through the end of the current week (respecting the week-start preference —
+ *   a Monday start means "everything before next Monday"); [ThisMonth] runs
+ *   through the last day of the current month. These shrink as the period ends.
+ */
+sealed interface AgendaRange {
+    data object Day : AgendaRange
+    data object Week : AgendaRange
+    data object Month : AgendaRange
+    data object ThisWeek : AgendaRange
+    data object ThisMonth : AgendaRange
+    data class Custom(val days: Int) : AgendaRange
+
+    companion object {
+        /** Allowed bounds for a [Custom] day count. */
+        const val MIN_CUSTOM_DAYS = 1
+        const val MAX_CUSTOM_DAYS = 365
+    }
+}
+
+private const val DAYS_PER_WEEK = 7
+
+/**
+ * Inclusive number of days the window spans, starting at (and including)
+ * [anchor]. The calendar-aligned ranges depend on the anchor day and, for
+ * [AgendaRange.ThisWeek], the [weekStart] preference.
+ */
+fun AgendaRange.dayCount(anchor: LocalDate, weekStart: DayOfWeek): Int = when (this) {
+    AgendaRange.Day -> 1
+    AgendaRange.Week -> DAYS_PER_WEEK
+    AgendaRange.Month -> 30
+    AgendaRange.ThisWeek -> {
+        // Days elapsed since the week's first day (0 when today *is* the start),
+        // so the window is the rest of the week through the day before it repeats.
+        val sinceWeekStart = ((anchor.dayOfWeek.ordinal - weekStart.ordinal) + DAYS_PER_WEEK) % DAYS_PER_WEEK
+        DAYS_PER_WEEK - sinceWeekStart
+    }
+    AgendaRange.ThisMonth -> {
+        val daysInMonth = YearMonth.of(anchor.year, anchor.month.ordinal + 1).lengthOfMonth()
+        daysInMonth - anchor.day + 1
+    }
+    is AgendaRange.Custom -> days.coerceIn(AgendaRange.MIN_CUSTOM_DAYS, AgendaRange.MAX_CUSTOM_DAYS)
+}
+
+/** Stored representation: a fixed token, or `CUSTOM:<days>`. */
+fun AgendaRange.storageValue(): String = when (this) {
+    AgendaRange.Day -> "DAY"
+    AgendaRange.Week -> "WEEK"
+    AgendaRange.Month -> "MONTH"
+    AgendaRange.ThisWeek -> "THIS_WEEK"
+    AgendaRange.ThisMonth -> "THIS_MONTH"
+    is AgendaRange.Custom -> "$CUSTOM_PREFIX$days"
+}
+
+/** Parse a stored value; unknown/garbage falls back to [default]. */
+fun parseAgendaRange(stored: String?, default: AgendaRange): AgendaRange = when {
+    stored == "DAY" -> AgendaRange.Day
+    stored == "WEEK" -> AgendaRange.Week
+    stored == "MONTH" -> AgendaRange.Month
+    stored == "THIS_WEEK" -> AgendaRange.ThisWeek
+    stored == "THIS_MONTH" -> AgendaRange.ThisMonth
+    stored != null && stored.startsWith(CUSTOM_PREFIX) -> {
+        val days = stored.removePrefix(CUSTOM_PREFIX).toIntOrNull()
+        if (days != null) {
+            AgendaRange.Custom(days.coerceIn(AgendaRange.MIN_CUSTOM_DAYS, AgendaRange.MAX_CUSTOM_DAYS))
+        } else {
+            default
+        }
+    }
+    else -> default
+}
+
+/**
+ * The concrete span the range covers, starting at [start] through [end]
+ * (inclusive), for a human-readable header:
+ * - [AgendaRange.Day] → a single medium date ("27 Jun 2026")
+ * - [AgendaRange.ThisMonth] → month and year ("June 2026")
+ * - everything else → "start – end" ("27 Jun – 3 Jul 2026")
+ */
+fun agendaRangeWindowSummary(
+    range: AgendaRange,
+    start: LocalDate,
+    end: LocalDate,
+    locale: Locale,
+): String {
+    val javaStart = java.time.LocalDate.of(start.year, start.month.ordinal + 1, start.day)
+    val javaEnd = java.time.LocalDate.of(end.year, end.month.ordinal + 1, end.day)
+    val medium = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
+    return when (range) {
+        AgendaRange.Day -> medium.format(javaStart)
+        AgendaRange.ThisMonth -> DateTimeFormatter.ofPattern("LLLL yyyy", locale).format(javaStart)
+        else -> "${DateTimeFormatter.ofPattern("d MMM", locale).format(javaStart)} – ${medium.format(javaEnd)}"
+    }
+}
+
+private const val CUSTOM_PREFIX = "CUSTOM:"
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaScreen.kt
@@ -2,22 +2,26 @@ package de.jeanlucmakiola.calendula.ui.agenda

 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.EventAvailable
+import androidx.compose.material.icons.filled.Coffee
+import androidx.compose.material.icons.filled.DateRange
 import androidx.compose.material.icons.filled.Menu
 import androidx.compose.material.icons.filled.Search
 import androidx.compose.material3.DrawerValue
@@ -35,7 +39,10 @@ import androidx.compose.material3.TopAppBarScrollBehavior
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -47,6 +54,8 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
+import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.calendula.ui.common.calendarAnimateItem
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
@@ -58,6 +67,9 @@ import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.positionOf
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import kotlinx.coroutines.launch
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
@@ -88,11 +100,13 @@ fun AgendaScreen(
    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
    val drawerState = rememberDrawerState(DrawerValue.Closed)
    val scope = rememberCoroutineScope()
+    var showRangePicker by remember { mutableStateOf(false) }

    val isOnToday = when (val s = state) {
        is AgendaUiState.Success -> s.anchor == s.today
        else -> true
    }
+    val successState = state as? AgendaUiState.Success

    ModalNavigationDrawer(
        drawerState = drawerState,
@@ -135,18 +149,129 @@ fun AgendaScreen(
                )
            },
        ) { innerPadding ->
-            AgendaContent(
-                state = state,
-                onRetry = viewModel::goToToday,
-                onEventClick = onEventClick,
+            Column(
                modifier = Modifier
-                    .padding(innerPadding)
-                    .fillMaxSize(),
+                    .fillMaxSize()
+                    .padding(innerPadding),
+            ) {
+                // One bar at the top: the "showing …" header on the left and the
+                // session range switcher on the right (one settings toggle).
+                successState?.takeIf { it.showRangeBar }?.let { s ->
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(start = 28.dp, end = 16.dp, top = 8.dp, bottom = 8.dp),
+                    ) {
+                        AgendaRangeBanner(
+                            range = s.range,
+                            start = s.anchor,
+                            end = s.rangeEnd,
+                            modifier = Modifier.weight(1f),
+                        )
+                        AgendaRangePill(
+                            range = s.range,
+                            isOverride = s.rangeIsOverride,
+                            onClick = { showRangePicker = true },
+                        )
+                    }
+                }
+                AgendaContent(
+                    state = state,
+                    onRetry = viewModel::goToToday,
+                    onEventClick = onEventClick,
+                    modifier = Modifier
+                        .weight(1f)
+                        .fillMaxWidth(),
+                )
+            }
+        }
+    }
+
+    if (showRangePicker) {
+        AgendaRangePicker(
+            title = stringResource(R.string.settings_agenda_range),
+            description = stringResource(R.string.agenda_range_override_hint),
+            selected = successState?.range ?: AgendaRange.Month,
+            onSelect = viewModel::setRangeOverride,
+            onDismiss = { showRangePicker = false },
+        )
+    }
+}
+
+/**
+ * A compact tonal pill showing the agenda's current range. Tapping it opens the
+ * range picker as a session-only override. Filled with the primary container
+ * while an override is active, so the temporary state is obvious.
+ */
+@Composable
+private fun AgendaRangePill(
+    range: AgendaRange,
+    isOverride: Boolean,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val container = if (isOverride) {
+        MaterialTheme.colorScheme.primaryContainer
+    } else {
+        MaterialTheme.colorScheme.surfaceContainerHigh
+    }
+    val content = if (isOverride) {
+        MaterialTheme.colorScheme.onPrimaryContainer
+    } else {
+        MaterialTheme.colorScheme.onSurfaceVariant
+    }
+    Surface(
+        color = container,
+        contentColor = content,
+        shape = RoundedCornerShape(50),
+        modifier = modifier.clickable(onClick = onClick),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 10.dp),
+        ) {
+            Icon(
+                imageVector = Icons.Filled.DateRange,
+                contentDescription = null,
+                modifier = Modifier.size(18.dp),
+            )
+            Spacer(Modifier.width(8.dp))
+            Text(
+                text = agendaRangeLabel(range),
+                style = MaterialTheme.typography.labelLarge,
            )
        }
    }
 }

+/**
+ * A header naming the concrete window currently shown, e.g. "Showing all events
+ * for · Today, 27 Jun 2026" / "This week, 27 Jun – 3 Jul" / "This month, June 2026".
+ */
+@Composable
+private fun AgendaRangeBanner(
+    range: AgendaRange,
+    start: LocalDate,
+    end: LocalDate,
+    modifier: Modifier = Modifier,
+) {
+    val locale = currentLocale()
+    val window = agendaRangeWindowSummary(range, start, end, locale)
+    Column(modifier = modifier) {
+        Text(
+            text = stringResource(R.string.agenda_range_showing_label),
+            style = MaterialTheme.typography.labelMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+        Text(
+            text = "${agendaRangeLabel(range)}, $window",
+            style = MaterialTheme.typography.titleMedium,
+            color = MaterialTheme.colorScheme.onSurface,
+        )
+    }
+}
+
@Composable
 private fun AgendaContent(
    state: AgendaUiState,
@@ -254,7 +379,7 @@ private fun AgendaEmpty(modifier: Modifier = Modifier) {
        horizontalAlignment = Alignment.CenterHorizontally,
    ) {
        Icon(
-            imageVector = Icons.Filled.EventAvailable,
+            imageVector = Icons.Filled.Coffee,
            contentDescription = null,
            tint = MaterialTheme.colorScheme.onSurfaceVariant,
            modifier = Modifier.size(48.dp),
@@ -265,13 +390,6 @@ private fun AgendaEmpty(modifier: Modifier = Modifier) {
            style = MaterialTheme.typography.titleMedium,
            textAlign = TextAlign.Center,
        )
-        Spacer(Modifier.height(4.dp))
-        Text(
-            text = stringResource(R.string.agenda_empty_subtitle),
-            style = MaterialTheme.typography.bodyMedium,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            textAlign = TextAlign.Center,
-        )
    }
 }

@@ -338,15 +456,17 @@ private fun agendaTimeSummary(event: EventInstance): String {
    val time = if (event.isAllDay) {
        stringResource(R.string.event_detail_all_day)
    } else {
-        "${formatTime(event.start)} – ${formatTime(event.end)}"
+        val is24Hour = LocalUse24HourFormat.current
+        val locale = currentLocale()
+        "${formatTime(event.start, is24Hour, locale)} – ${formatTime(event.end, is24Hour, locale)}"
    }
    val location = event.location?.takeIf { it.isNotBlank() }
    return if (location != null) "$time · $location" else time
 }

-private fun formatTime(instant: Instant): String {
+private fun formatTime(instant: Instant, is24Hour: Boolean, locale: Locale): String {
    val t = instant.toLocalDateTime(zone).time
-    return "%02d:%02d".format(t.hour, t.minute)
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, locale)
 }

 private fun formatAgendaDate(date: LocalDate): String {
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaUiState.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaUiState.kt
@@ -53,5 +53,13 @@ sealed interface AgendaUiState {
        val anchor: LocalDate,
        val today: LocalDate,
        val days: List<AgendaDay>,
+        /** The range currently in effect — the saved default or a session override. */
+        val range: AgendaRange,
+        /** True when [range] is a temporary in-view override of the saved default. */
+        val rangeIsOverride: Boolean,
+        /** Last day the current [range] covers (inclusive), for the range header. */
+        val rangeEnd: LocalDate,
+        /** Whether to show the top range bar — header + switcher (toggle, on by default). */
+        val showRangeBar: Boolean,
    ) : AgendaUiState
 }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaViewModel.kt
@@ -5,6 +5,8 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
@@ -17,10 +19,13 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
+import java.util.Locale
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
@@ -30,16 +35,24 @@ import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject

-/** How far ahead the agenda loads events from its anchor day. */
-internal const val AGENDA_WINDOW_DAYS = 60
-
@OptIn(ExperimentalCoroutinesApi::class)
@HiltViewModel
 class AgendaViewModel @Inject constructor(
    private val repository: CalendarRepository,
+    settingsPrefs: SettingsPrefs,
    @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {

+    // The saved agenda range plus the range-bar visibility toggle.
+    private val agendaSettings = combine(
+        settingsPrefs.agendaScreenRange,
+        settingsPrefs.agendaShowRangeBar,
+    ) { range, showBar -> AgendaSettings(range, showBar) }
+
+    // First day of the week, for the calendar-aligned "this week" range.
+    private val weekStartDay = settingsPrefs.weekStart
+        .map { it.resolveFirstDay(Locale.getDefault()) }
+
    private val zone = TimeZone.currentSystemDefault()

    private val todayDate: LocalDate
@@ -48,14 +61,32 @@ class AgendaViewModel @Inject constructor(
    private val _anchor = MutableStateFlow(todayDate)
    val anchor: StateFlow<LocalDate> = _anchor

-    val state: StateFlow<AgendaUiState> = _anchor
-        .flatMapLatest { anchor ->
-            val range = agendaRange(anchor, AGENDA_WINDOW_DAYS, zone)
+    // A transient, in-view override of the saved agenda range. Held in memory
+    // (not persisted), so it survives view switches and rotation within the
+    // session but resets to the saved default when the app is relaunched.
+    private val _rangeOverride = MutableStateFlow<AgendaRange?>(null)
+
+    val state: StateFlow<AgendaUiState> =
+        combine(_anchor, agendaSettings, _rangeOverride, weekStartDay) { anchor, settings, override, weekStart ->
+            AgendaParams(
+                anchor = anchor,
+                range = override ?: settings.range,
+                rangeIsOverride = override != null && override != settings.range,
+                weekStart = weekStart,
+                showRangeBar = settings.showBar,
+            )
+        }
+        .flatMapLatest { params ->
+            val window = agendaRange(
+                params.anchor,
+                params.range.dayCount(params.anchor, params.weekStart) - 1,
+                zone,
+            )
            combine(
                repository.calendars(),
-                repository.instances(range),
+                repository.instances(window),
            ) { calendars, instances ->
-                buildState(anchor, calendars, instances)
+                buildState(params, calendars, instances)
            }
        }
        .catch { emit(AgendaUiState.Failure(FailureReason.ProviderUnavailable)) }
@@ -75,16 +106,47 @@ class AgendaViewModel @Inject constructor(
        _anchor.value = date
    }

+    /** Temporarily override the agenda range for this session (the bottom-left pill). */
+    fun setRangeOverride(range: AgendaRange) {
+        _rangeOverride.value = range
+    }
+
+    private data class AgendaSettings(
+        val range: AgendaRange,
+        val showBar: Boolean,
+    )
+
+    private data class AgendaParams(
+        val anchor: LocalDate,
+        val range: AgendaRange,
+        val rangeIsOverride: Boolean,
+        val weekStart: DayOfWeek,
+        val showRangeBar: Boolean,
+    )
+
    private fun buildState(
-        anchor: LocalDate,
+        params: AgendaParams,
        calendars: List<CalendarSource>,
        instances: List<EventInstance>,
    ): AgendaUiState {
        if (calendars.isEmpty()) {
            return AgendaUiState.Failure(FailureReason.NoCalendarsConfigured)
        }
+        val anchor = params.anchor
        val days = groupAgendaDays(anchor, instances, zone)
-        return AgendaUiState.Success(anchor = anchor, today = todayDate, days = days)
+        val rangeEnd = anchor.plus(
+            params.range.dayCount(anchor, params.weekStart) - 1,
+            DateTimeUnit.DAY,
+        )
+        return AgendaUiState.Success(
+            anchor = anchor,
+            today = todayDate,
+            days = days,
+            range = params.range,
+            rangeIsOverride = params.rangeIsOverride,
+            rangeEnd = rangeEnd,
+            showRangeBar = params.showRangeBar,
+        )
    }
 }

--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/HourLines.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/HourLines.kt
@@ -0,0 +1,38 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+
+/**
+ * Whether the week/day timeline draws an hour separator line, from the
+ * `showHourLines` preference. Provided once at the app root (like
+ * [LocalUse24HourFormat]) so the timeline reads it without ViewModel plumbing.
+ * Defaults to off — the historical clean look.
+ */
+val LocalShowHourLines = staticCompositionLocalOf { false }
+
+/**
+ * Draw a faint separator line at the top of each hour (1..23) when [show] is
+ * true. Applied to a day column's content so each line sits over the column's
+ * background but beneath the event blocks. [hourHeightPx] is one hour's pixel
+ * height; [color] is resolved by the caller from the theme.
+ */
+fun Modifier.hourSeparatorLines(show: Boolean, hourHeightPx: Float, color: Color): Modifier =
+    if (!show) {
+        this
+    } else {
+        drawBehind {
+            for (hour in 1 until 24) {
+                val y = hour * hourHeightPx
+                drawLine(
+                    color = color,
+                    start = Offset(0f, y),
+                    end = Offset(size.width, y),
+                    strokeWidth = 1f,
+                )
+            }
+        }
+    }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/Picker.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/Picker.kt
@@ -7,6 +7,7 @@ import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -30,6 +31,7 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
@@ -37,6 +39,7 @@ import androidx.compose.ui.window.DialogProperties
 import androidx.compose.ui.window.DialogWindowProvider
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange

 /**
 * Shared full-screen scaffold for selection pickers: a full-bleed [Dialog] that
@@ -260,6 +263,17 @@ private fun CustomReminderEditor(
    }
 }

+/** A short explanatory paragraph shown under a picker's title, above the rows. */
+@Composable
+private fun PickerDescription(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.bodyMedium,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+    )
+}
+
@Composable
 private fun SelectedCheck() {
    Icon(
@@ -269,6 +283,149 @@ private fun SelectedCheck() {
    )
 }

+/**
+ * Agenda-range picker, full-screen. Two grouped lists — the calendar-aligned
+ * options (today / this week / this month) and the rolling windows (next 7 / 30
+ * days), with a "Custom" row that expands an inline day-count editor (1–365).
+ * Mirrors [ReminderDefaultPicker]'s custom-expand pattern.
+ */
+@Composable
+fun AgendaRangePicker(
+    title: String,
+    description: String,
+    selected: AgendaRange,
+    onSelect: (AgendaRange) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val calendarAligned = listOf(AgendaRange.Day, AgendaRange.ThisWeek, AgendaRange.ThisMonth)
+    val rolling = listOf(AgendaRange.Week, AgendaRange.Month)
+    val rollingRowCount = rolling.size + 1 // + the custom row
+    val customSelected = selected is AgendaRange.Custom
+
+    var customExpanded by rememberSaveable { mutableStateOf(false) }
+    var amountText by rememberSaveable {
+        mutableStateOf((selected as? AgendaRange.Custom)?.days?.toString() ?: "")
+    }
+
+    val rangeRow: @Composable (AgendaRange, Position) -> Unit = { option, position ->
+        val isSelected = option == selected
+        GroupedRow(
+            title = agendaRangeLabel(option),
+            position = position,
+            selected = isSelected,
+            trailing = if (isSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = {
+                onSelect(option)
+                onDismiss()
+            },
+        )
+    }
+
+    FullScreenPicker(title = title, onDismiss = onDismiss) {
+        PickerDescription(description)
+
+        // Calendar-aligned windows.
+        calendarAligned.forEachIndexed { index, option ->
+            rangeRow(option, positionOf(index, calendarAligned.size))
+        }
+
+        Spacer(Modifier.height(12.dp))
+
+        // Rolling windows + custom.
+        rolling.forEachIndexed { index, option ->
+            rangeRow(option, positionOf(index, rollingRowCount))
+        }
+        GroupedRow(
+            title = if (customSelected) {
+                agendaRangeLabel(selected)
+            } else {
+                stringResource(R.string.agenda_range_custom)
+            },
+            position = if (customExpanded) Position.Top else positionOf(rolling.size, rollingRowCount),
+            selected = customSelected,
+            trailing = if (customSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(
+            visible = customExpanded,
+            enter = calendarExpandEnter(),
+            exit = calendarCollapseExit(),
+        ) {
+            CustomDaysEditor(
+                amountText = amountText,
+                onAmountChange = { amountText = it },
+                onConfirm = { days ->
+                    onSelect(AgendaRange.Custom(days))
+                    onDismiss()
+                },
+            )
+        }
+    }
+}
+
+/** The expanded "Custom" day-count editor: an amount field (1–365) and Set. */
+@Composable
+private fun CustomDaysEditor(
+    amountText: String,
+    onAmountChange: (String) -> Unit,
+    onConfirm: (Int) -> Unit,
+) {
+    val days = amountText.toIntOrNull()
+        ?.takeIf { it in AgendaRange.MIN_CUSTOM_DAYS..AgendaRange.MAX_CUSTOM_DAYS }
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(topStart = 6.dp, topEnd = 6.dp, bottomStart = 22.dp, bottomEnd = 22.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp),
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            DialogAmountField(
+                value = amountText,
+                onValueChange = onAmountChange,
+                placeholder = "30",
+            )
+            Spacer(Modifier.width(16.dp))
+            Text(
+                text = days?.let { pluralStringResource(R.plurals.agenda_range_days, it, it) }
+                    ?: stringResource(R.string.agenda_range_custom_hint),
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.weight(1f),
+            )
+            Spacer(Modifier.width(16.dp))
+            FilledTonalButton(
+                onClick = { days?.let(onConfirm) },
+                enabled = days != null,
+            ) {
+                Text(stringResource(R.string.reminder_custom_set))
+            }
+        }
+    }
+}
+
+/** Human label for an [AgendaRange] (used by the picker rows and settings summary). */
+@Composable
+fun agendaRangeLabel(range: AgendaRange): String = when (range) {
+    AgendaRange.Day -> stringResource(R.string.agenda_range_day)
+    AgendaRange.ThisWeek -> stringResource(R.string.agenda_range_this_week)
+    AgendaRange.ThisMonth -> stringResource(R.string.agenda_range_this_month)
+    AgendaRange.Week -> stringResource(R.string.agenda_range_week)
+    AgendaRange.Month -> stringResource(R.string.agenda_range_month)
+    is AgendaRange.Custom -> pluralStringResource(R.plurals.agenda_range_days, range.days, range.days)
+}
+
@Composable
 private fun reminderOverrideLabel(override: CalendarReminderOverride): String = when (override) {
    CalendarReminderOverride.Inherit -> stringResource(R.string.reminder_use_default)
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimeFormat.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimeFormat.kt
@@ -0,0 +1,57 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import java.time.LocalTime
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * The resolved clock convention for the whole UI: `true` = 24-hour ("14:00"),
+ * `false` = 12-hour ("2:00 PM"). Provided once at the app root from the
+ * `TimeFormatPref` preference resolved against the device's 24-hour system
+ * setting, so every time label reads it without per-screen plumbing. Defaults
+ * to 24-hour for previews and any composition that forgets to provide it.
+ */
+val LocalUse24HourFormat = staticCompositionLocalOf { true }
+
+private const val PATTERN_24 = "HH:mm"
+private const val PATTERN_12 = "h:mm a"
+private const val HOUR_PATTERN_12 = "h a"
+
+/** A time-of-day [DateTimeFormatter] for the resolved convention and [locale]. */
+fun timeOfDayFormatter(is24Hour: Boolean, locale: Locale): DateTimeFormatter =
+    DateTimeFormatter.ofPattern(if (is24Hour) PATTERN_24 else PATTERN_12, locale)
+
+/**
+ * Format a wall-clock time (hour 0..23, minute 0..59) honouring the resolved
+ * [is24Hour] convention and [locale]: 24h → "14:00", 12h → "2:00 PM". Pure, so
+ * it can be unit-tested and used off the main thread (widget, notifications).
+ */
+fun formatTimeOfDay(hour: Int, minute: Int, is24Hour: Boolean, locale: Locale): String =
+    LocalTime.of(hour.coerceIn(0, 23), minute.coerceIn(0, 59))
+        .format(timeOfDayFormatter(is24Hour, locale))
+
+/**
+ * Format minutes-from-midnight (0..1440) as a time label. The end-of-day value
+ * 1440 renders as "24:00" in 24h (its established reading) and as midnight
+ * ("12:00 AM") in 12h, which has no 24:00 equivalent.
+ */
+fun formatMinuteOfDay(minutes: Int, is24Hour: Boolean, locale: Locale): String = when {
+    minutes >= MINUTES_PER_DAY && is24Hour -> "24:00"
+    minutes >= MINUTES_PER_DAY -> formatTimeOfDay(0, 0, is24Hour = false, locale)
+    else -> formatTimeOfDay(minutes / 60, minutes % 60, is24Hour, locale)
+}
+
+/**
+ * The compact hour-only label for a timeline gutter: 24h → "13" (zero-padded,
+ * the prior look); 12h → "1 PM".
+ */
+fun formatHourLabel(hour: Int, is24Hour: Boolean, locale: Locale): String =
+    if (is24Hour) {
+        "%02d".format(hour)
+    } else {
+        LocalTime.of(hour.coerceIn(0, 23), 0)
+            .format(DateTimeFormatter.ofPattern(HOUR_PATTERN_12, locale))
+    }
+
+private const val MINUTES_PER_DAY = 1_440
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt
@@ -80,7 +80,12 @@ import de.jeanlucmakiola.calendula.ui.common.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
-import de.jeanlucmakiola.calendula.ui.week.MINUTES_PER_DAY
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
+import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
+import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
@@ -466,6 +471,8 @@ private fun Timeline(
 ) {
    val totalHeight = HOUR_HEIGHT * 24
    val dark = isSystemInDarkTheme()
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()

    Box(modifier = Modifier.fillMaxSize()) {
        // Gutter and day column are two scroll viewports that SHARE one scroll
@@ -488,7 +495,7 @@ private fun Timeline(
                    ) {
                        if (h > 0) {
                            Text(
-                                text = "%02d".format(h),
+                                text = formatHourLabel(h, use24Hour, locale),
                                style = MaterialTheme.typography.labelSmall,
                                color = MaterialTheme.colorScheme.onSurfaceVariant,
                                modifier = Modifier
@@ -534,6 +541,8 @@ private fun DayColumnCard(
    modifier: Modifier = Modifier,
 ) {
    val hourPx = with(LocalDensity.current) { HOUR_HEIGHT.toPx() }
+    val showHourLines = LocalShowHourLines.current
+    val hourLineColor = MaterialTheme.colorScheme.outlineVariant
    Card(
        // Plain rectangular column — the soft corners come from the outer
        // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -546,6 +555,9 @@ private fun DayColumnCard(
        BoxWithConstraints(
            modifier = Modifier
                .fillMaxSize()
+                // Faint hour separators sit over the column background but under
+                // the event blocks (drawBehind paints before the children).
+                .hourSeparatorLines(showHourLines, hourPx, hourLineColor)
                // Tap an empty slot to create an event there. Taps on event
                // blocks are consumed by their own click handler first, so this
                // only fires on the column background. Snaps to the tapped hour.
@@ -589,7 +601,10 @@ private fun EventBlock(
    modifier: Modifier = Modifier,
 ) {
    val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
-    val timeLabel = "${minToHm(block.startMin)}–${minToHm(block.endMin)}"
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    val timeLabel = "${minToHm(block.startMin, use24Hour, locale)}–" +
+        minToHm(block.endMin, use24Hour, locale)
    val showTime = block.endMin - block.startMin >= 45
    Box(
        modifier = modifier
@@ -635,8 +650,8 @@ private fun DayLoading() {
    }
 }

-private fun minToHm(min: Int): String =
-    if (min >= MINUTES_PER_DAY) "24:00" else "%02d:%02d".format(min / 60, min % 60)
+private fun minToHm(min: Int, is24Hour: Boolean, locale: Locale): String =
+    formatMinuteOfDay(min, is24Hour, locale)

 private fun formatDayTitle(date: LocalDate): String {
    val locale = Locale.getDefault()
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt
@@ -95,6 +95,8 @@ import de.jeanlucmakiola.calendula.ui.common.predictiveBack
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.OptionCard
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
@@ -781,7 +783,7 @@ private fun formatWhen(
    val zid = ZoneId.of(zone.id)
    val dateFull = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(locale)
    val dateMedium = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
-    val timeShort = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+    val timeShort = timeOfDayFormatter(LocalUse24HourFormat.current, locale)

    val startLdt = instance.start.toJavaLocalDateTime(zid)
    val allDayLabel = stringResource(R.string.event_detail_all_day)
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt
@@ -132,6 +132,8 @@ import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
 import de.jeanlucmakiola.calendula.ui.common.ReminderUnit
 import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.reminderUnitLabel
 import de.jeanlucmakiola.calendula.ui.common.pastelize
@@ -1891,8 +1893,9 @@ private fun ScheduleRow(
    val dateFormat = remember(locale) {
        DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
    }
-    val timeFormat = remember(locale) {
-        DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+    val use24Hour = LocalUse24HourFormat.current
+    val timeFormat = remember(locale, use24Hour) {
+        timeOfDayFormatter(use24Hour, locale)
    }
    // Tappable values read as links (primary), like the location on the
    // detail screen; errors flip them to the error colour.
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchScreen.kt
@@ -54,6 +54,8 @@ import de.jeanlucmakiola.calendula.ui.common.GroupedRow
 import de.jeanlucmakiola.calendula.ui.common.InlineTextField
 import de.jeanlucmakiola.calendula.ui.common.Position
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.positionOf
 import java.time.Instant as JavaInstant
@@ -217,12 +219,11 @@ private fun searchSummary(event: EventInstance): String {
    val dateText = remember(locale) {
        DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
    }.format(start)
+    val use24Hour = LocalUse24HourFormat.current
    val timeText = if (event.isAllDay) {
        stringResource(R.string.event_detail_all_day)
    } else {
-        remember(locale) {
-            DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
-        }.format(start)
+        remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }.format(start)
    }
    val base = "$dateText · $timeText"
    return event.location?.takeIf { it.isNotBlank() }?.let { "$base · $it" } ?: base
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt
@@ -84,6 +84,7 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.qs.NewEventTileService
@@ -92,6 +93,8 @@ import de.jeanlucmakiola.calendula.ui.crash.openIssueTracker
 import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
 import de.jeanlucmakiola.calendula.ui.common.calendarCollapseExit
 import de.jeanlucmakiola.calendula.ui.common.calendarExpandEnter
+import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
+import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.calendula.ui.common.CollapsingScaffold
 import de.jeanlucmakiola.calendula.ui.common.GroupedRow
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
@@ -105,7 +108,10 @@ import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.calendula.ui.common.positionOf
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalTime
+import java.time.format.TextStyle as JavaTextStyle
 import java.util.Calendar

 /** The settings sub-screens reached from the hub's category rows. */
@@ -424,24 +430,22 @@ private fun AppearanceScreen(
 ) {
    var showTheme by remember { mutableStateOf(false) }
    var showWeekStart by remember { mutableStateOf(false) }
+    var showTimeFormat by remember { mutableStateOf(false) }
    var showDefaultView by remember { mutableStateOf(false) }
+    var showAgendaScreenRange by remember { mutableStateOf(false) }
+    var showAgendaWidgetRange by remember { mutableStateOf(false) }

    CollapsingScaffold(
        title = stringResource(R.string.settings_section_appearance),
        onBack = onBack,
    ) {
+        // Theme & colour
        GroupedRow(
            title = stringResource(R.string.settings_theme),
            summary = themeLabel(state.themeMode),
            position = Position.Top,
            onClick = { showTheme = true },
        )
-        GroupedRow(
-            title = stringResource(R.string.settings_default_view),
-            summary = stringResource(state.defaultView.labelRes),
-            position = Position.Middle,
-            onClick = { showDefaultView = true },
-        )
        GroupedRow(
            title = stringResource(R.string.settings_dynamic_color),
            summary = if (state.dynamicColorAvailable) {
@@ -449,7 +453,7 @@ private fun AppearanceScreen(
            } else {
                stringResource(R.string.settings_dynamic_color_unavailable)
            },
-            position = Position.Middle,
+            position = Position.Bottom,
            trailing = {
                Switch(
                    checked = state.dynamicColor,
@@ -463,12 +467,68 @@ private fun AppearanceScreen(
                null
            },
        )
+
+        Spacer(Modifier.height(16.dp))
+
+        // Calendar — view, week, and timeline formatting
+        GroupedRow(
+            title = stringResource(R.string.settings_default_view),
+            summary = stringResource(state.defaultView.labelRes),
+            position = Position.Top,
+            onClick = { showDefaultView = true },
+        )
        GroupedRow(
            title = stringResource(R.string.settings_week_start),
            summary = weekStartLabel(state.weekStart),
-            position = Position.Bottom,
+            position = Position.Middle,
            onClick = { showWeekStart = true },
        )
+        GroupedRow(
+            title = stringResource(R.string.settings_time_format),
+            summary = timeFormatLabel(state.timeFormat),
+            position = Position.Middle,
+            onClick = { showTimeFormat = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_hour_lines),
+            summary = stringResource(R.string.settings_hour_lines_summary),
+            position = Position.Bottom,
+            trailing = {
+                Switch(
+                    checked = state.showHourLines,
+                    onCheckedChange = viewModel::setShowHourLines,
+                )
+            },
+            onClick = { viewModel.setShowHourLines(!state.showHourLines) },
+        )
+
+        Spacer(Modifier.height(16.dp))
+
+        // Agenda
+        GroupedRow(
+            title = stringResource(R.string.settings_agenda_range),
+            summary = agendaRangeLabel(state.agendaScreenRange),
+            position = Position.Top,
+            onClick = { showAgendaScreenRange = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_agenda_widget_range),
+            summary = agendaRangeLabel(state.agendaWidgetRange),
+            position = Position.Middle,
+            onClick = { showAgendaWidgetRange = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_agenda_range_bar),
+            summary = stringResource(R.string.settings_agenda_range_bar_hint),
+            position = Position.Bottom,
+            trailing = {
+                Switch(
+                    checked = state.agendaShowRangeBar,
+                    onCheckedChange = viewModel::setAgendaShowRangeBar,
+                )
+            },
+            onClick = { viewModel.setAgendaShowRangeBar(!state.agendaShowRangeBar) },
+        )
    }

    if (showTheme) {
@@ -484,13 +544,41 @@ private fun AppearanceScreen(
    if (showWeekStart) {
        OptionPicker(
            title = stringResource(R.string.settings_week_start),
-            options = WeekStartPref.entries,
+            options = WEEK_START_OPTIONS,
            selected = state.weekStart,
            label = { weekStartLabel(it) },
            onSelect = viewModel::setWeekStart,
            onDismiss = { showWeekStart = false },
        )
    }
+    if (showAgendaScreenRange) {
+        AgendaRangePicker(
+            title = stringResource(R.string.settings_agenda_range),
+            description = stringResource(R.string.settings_agenda_range_hint),
+            selected = state.agendaScreenRange,
+            onSelect = viewModel::setAgendaScreenRange,
+            onDismiss = { showAgendaScreenRange = false },
+        )
+    }
+    if (showAgendaWidgetRange) {
+        AgendaRangePicker(
+            title = stringResource(R.string.settings_agenda_widget_range),
+            description = stringResource(R.string.settings_agenda_widget_range_hint),
+            selected = state.agendaWidgetRange,
+            onSelect = viewModel::setAgendaWidgetRange,
+            onDismiss = { showAgendaWidgetRange = false },
+        )
+    }
+    if (showTimeFormat) {
+        OptionPicker(
+            title = stringResource(R.string.settings_time_format),
+            options = TimeFormatPref.entries,
+            selected = state.timeFormat,
+            label = { timeFormatLabel(it) },
+            onSelect = viewModel::setTimeFormat,
+            onDismiss = { showTimeFormat = false },
+        )
+    }
    if (showDefaultView) {
        OptionPicker(
            title = stringResource(R.string.settings_default_view),
@@ -993,12 +1081,25 @@ private fun themeLabel(mode: ThemeMode): String = stringResource(
    },
 )

+/** Picker options: "Follow system" first, then Monday…Sunday in ISO order. */
+private val WEEK_START_OPTIONS: List<WeekStartPref> =
+    listOf(WeekStartPref.Auto) + DayOfWeek.entries.map { WeekStartPref.Day(it) }
+
@Composable
-private fun weekStartLabel(pref: WeekStartPref): String = stringResource(
+private fun weekStartLabel(pref: WeekStartPref): String = when (pref) {
+    WeekStartPref.Auto -> stringResource(R.string.settings_week_start_auto)
+    // Localised full weekday name, so any of the seven days reads naturally
+    // without a per-day string resource.
+    is WeekStartPref.Day -> java.time.DayOfWeek.of(pref.day.ordinal + 1)
+        .getDisplayName(JavaTextStyle.FULL, currentLocale())
+}
+
+@Composable
+private fun timeFormatLabel(pref: TimeFormatPref): String = stringResource(
    when (pref) {
-        WeekStartPref.AUTO -> R.string.settings_week_start_auto
-        WeekStartPref.MONDAY -> R.string.settings_week_start_monday
-        WeekStartPref.SUNDAY -> R.string.settings_week_start_sunday
+        TimeFormatPref.AUTO -> R.string.settings_time_format_auto
+        TimeFormatPref.TWELVE_HOUR -> R.string.settings_time_format_12h
+        TimeFormatPref.TWENTY_FOUR_HOUR -> R.string.settings_time_format_24h
    },
 )

--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt
@@ -2,9 +2,11 @@ package de.jeanlucmakiola.calendula.ui.settings

 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView

 /**
@@ -17,7 +19,17 @@ data class SettingsUiState(
    val themeMode: ThemeMode = ThemeMode.SYSTEM,
    val dynamicColor: Boolean = true,
    val dynamicColorAvailable: Boolean = true,
-    val weekStart: WeekStartPref = WeekStartPref.AUTO,
+    val weekStart: WeekStartPref = WeekStartPref.Auto,
+    /** Clock convention for time labels (v2.11). AUTO follows the system setting. */
+    val timeFormat: TimeFormatPref = TimeFormatPref.AUTO,
+    /** Whether the week/day timeline draws an hour separator line (v2.11). */
+    val showHourLines: Boolean = false,
+    /** 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). */
+    val agendaWidgetRange: AgendaRange = AgendaRange.Month,
+    /** Whether the agenda shows its top range bar — header + switcher (v2.11). */
+    val agendaShowRangeBar: Boolean = true,
    /** The calendar view the app opens on, and the home of the view back stack (M1). */
    val defaultView: CalendarView = CalendarView.Week,
    /** Optional event-form fields shown by default (rest behind "more fields"). */
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt
@@ -1,17 +1,28 @@
 package de.jeanlucmakiola.calendula.ui.settings

+import android.content.Context
 import android.os.Build
+import androidx.glance.appwidget.GlanceAppWidgetManager
+import androidx.glance.appwidget.state.updateAppWidgetState
+import androidx.glance.appwidget.updateAll
 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.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
+import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.widget.agenda.AGENDA_RANGE_KEY
+import de.jeanlucmakiola.calendula.widget.agenda.AgendaWidget
+import de.jeanlucmakiola.calendula.widget.month.MonthWidget
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
@@ -20,12 +31,15 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject

@HiltViewModel
 class SettingsViewModel @Inject constructor(
    private val prefs: SettingsPrefs,
    repository: CalendarRepository,
+    @ApplicationContext private val appContext: Context,
 ) : ViewModel() {

    private val dynamicColorAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
@@ -73,10 +87,24 @@ class SettingsViewModel @Inject constructor(
            ) { overrides, allDayOverrides, calendars ->
                ReminderOverrides(overrides, allDayOverrides, calendars)
            },
-            prefs.defaultView,
-        ) { base, defaults, overrides, defaultView ->
+            combine(
+                prefs.defaultView,
+                prefs.agendaScreenRange,
+                prefs.agendaWidgetRange,
+                prefs.timeFormat,
+                prefs.showHourLines,
+            ) { view, screenRange, widgetRange, timeFormat, showHourLines ->
+                ViewSettings(view, screenRange, widgetRange, timeFormat, showHourLines)
+            },
+            prefs.agendaShowRangeBar,
+        ) { base, defaults, overrides, views, showRangeBar ->
            base.copy(
-                defaultView = defaultView,
+                defaultView = views.defaultView,
+                agendaScreenRange = views.agendaScreenRange,
+                agendaWidgetRange = views.agendaWidgetRange,
+                timeFormat = views.timeFormat,
+                showHourLines = views.showHourLines,
+                agendaShowRangeBar = showRangeBar,
                allowColorOnUnsupportedCalendars = defaults.allowColor,
                defaultReminderMinutes = defaults.defaultReminder,
                defaultAllDayReminderMinutes = defaults.allDayReminder,
@@ -92,6 +120,12 @@ class SettingsViewModel @Inject constructor(
            initialValue = SettingsUiState(dynamicColorAvailable = dynamicColorAvailable),
        )

+    // Serialises widget redraws so a rapid flip-and-flip-back can't run two
+    // updateAll calls at once — concurrent calls coalesce around a stale read
+    // and can leave the widget on the intermediate value. Held sequentially,
+    // the last call reads the final committed pref and renders it.
+    private val widgetRefreshMutex = Mutex()
+
    private data class ReminderDefaults(
        val allowColor: Boolean,
        val defaultReminder: Int?,
@@ -106,6 +140,14 @@ class SettingsViewModel @Inject constructor(
        val calendars: List<CalendarSource>,
    )

+    private data class ViewSettings(
+        val defaultView: CalendarView,
+        val agendaScreenRange: AgendaRange,
+        val agendaWidgetRange: AgendaRange,
+        val timeFormat: TimeFormatPref,
+        val showHourLines: Boolean,
+    )
+
    fun setThemeMode(mode: ThemeMode) {
        viewModelScope.launch { prefs.setThemeMode(mode) }
    }
@@ -115,7 +157,48 @@ class SettingsViewModel @Inject constructor(
    }

    fun setWeekStart(pref: WeekStartPref) {
-        viewModelScope.launch { prefs.setWeekStart(pref) }
+        viewModelScope.launch {
+            prefs.setWeekStart(pref)
+            // Both widgets depend on the week start (month weekday header; the
+            // agenda widget's "this week" range).
+            widgetRefreshMutex.withLock {
+                AgendaWidget().updateAll(appContext)
+                MonthWidget().updateAll(appContext)
+            }
+        }
+    }
+
+    fun setAgendaScreenRange(range: AgendaRange) {
+        viewModelScope.launch { prefs.setAgendaScreenRange(range) }
+    }
+
+    fun setAgendaWidgetRange(range: AgendaRange) {
+        viewModelScope.launch {
+            prefs.setAgendaWidgetRange(range)
+            widgetRefreshMutex.withLock {
+                // Push the range into each instance's Glance state and recompose.
+                // The widget reads it via currentState, so this reflects reliably
+                // even when updateAll only recomposes a live session (it does not
+                // re-run provideGlance's data preamble).
+                val manager = GlanceAppWidgetManager(appContext)
+                manager.getGlanceIds(AgendaWidget::class.java).forEach { id ->
+                    updateAppWidgetState(appContext, id) { it[AGENDA_RANGE_KEY] = range.storageValue() }
+                }
+                AgendaWidget().updateAll(appContext)
+            }
+        }
+    }
+
+    fun setAgendaShowRangeBar(enabled: Boolean) {
+        viewModelScope.launch { prefs.setAgendaShowRangeBar(enabled) }
+    }
+
+    fun setTimeFormat(pref: TimeFormatPref) {
+        viewModelScope.launch { prefs.setTimeFormat(pref) }
+    }
+
+    fun setShowHourLines(enabled: Boolean) {
+        viewModelScope.launch { prefs.setShowHourLines(enabled) }
    }

    fun setDefaultView(view: CalendarView) {
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt
@@ -83,6 +83,11 @@ import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.calendula.ui.common.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
+import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
+import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
+import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
@@ -572,6 +577,8 @@ private fun Timeline(
 ) {
    val totalHeight = HOUR_HEIGHT * 24
    val dark = isSystemInDarkTheme()
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()

    Box(modifier = Modifier.fillMaxSize()) {
        // Gutter and day columns are two scroll viewports that SHARE one scroll
@@ -595,7 +602,7 @@ private fun Timeline(
                    ) {
                        if (h > 0) {
                            Text(
-                                text = "%02d".format(h),
+                                text = formatHourLabel(h, use24Hour, locale),
                                style = MaterialTheme.typography.labelSmall,
                                color = MaterialTheme.colorScheme.onSurfaceVariant,
                                modifier = Modifier
@@ -650,6 +657,8 @@ private fun DayColumnCard(
    modifier: Modifier = Modifier,
 ) {
    val hourPx = with(LocalDensity.current) { HOUR_HEIGHT.toPx() }
+    val showHourLines = LocalShowHourLines.current
+    val hourLineColor = MaterialTheme.colorScheme.outlineVariant
    Card(
        // Plain rectangular columns — the soft corners come from the outer
        // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -662,6 +671,9 @@ private fun DayColumnCard(
        BoxWithConstraints(
            modifier = Modifier
                .fillMaxSize()
+                // Faint hour separators sit over the column background but under
+                // the event blocks (drawBehind paints before the children).
+                .hourSeparatorLines(showHourLines, hourPx, hourLineColor)
                // Tap an empty slot to create an event there; taps on event
                // blocks are consumed by their own handler first. Snaps to hour.
                .pointerInput(date) {
@@ -704,7 +716,10 @@ private fun EventBlock(
    modifier: Modifier = Modifier,
 ) {
    val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
-    val timeLabel = "${minToHm(block.startMin)}–${minToHm(block.endMin)}"
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    val timeLabel = "${minToHm(block.startMin, use24Hour, locale)}–" +
+        minToHm(block.endMin, use24Hour, locale)
    val showTime = block.endMin - block.startMin >= 45
    Box(
        modifier = modifier
@@ -773,8 +788,8 @@ private fun WeekLoading() {
    }
 }

-private fun minToHm(min: Int): String =
-    if (min >= MINUTES_PER_DAY) "24:00" else "%02d:%02d".format(min / 60, min % 60)
+private fun minToHm(min: Int, is24Hour: Boolean, locale: java.util.Locale): String =
+    formatMinuteOfDay(min, is24Hour, locale)

 private fun formatWeekRange(weekStart: LocalDate): String {
    val locale = Locale.getDefault()
--- a/app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetData.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetData.kt
@@ -4,9 +4,11 @@ import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
 import androidx.core.content.ContextCompat
+import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaDay
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.agendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.groupAgendaDays
 import kotlinx.coroutines.flow.first
@@ -23,9 +25,6 @@ import kotlinx.datetime.toLocalDateTime
 import java.util.Locale
 import kotlin.time.Clock

-/** How far ahead the agenda widget loads (a month of upcoming events). */
-private const val AGENDA_WIDGET_DAYS = 30
-
 /**
 * How far either side of today the month widget pre-loads. The displayed month
 * is chosen reactively in the composition, so one wide read covers ~13 months of
@@ -46,7 +45,22 @@ internal fun Context.hasCalendarPermission(): Boolean =
 sealed interface AgendaWidgetData {
    /** Calendar permission not granted — the widget can't read events. */
    data object NeedsPermission : AgendaWidgetData
-    data class Ready(val today: LocalDate, val days: List<AgendaDay>) : AgendaWidgetData
+    data class Ready(
+        val today: LocalDate,
+        /**
+         * Days with events across the **widest** selectable window. The displayed
+         * range is sliced from this in the composition (read reactively from
+         * Glance state), so a range change is pure recomposition rather than a
+         * flaky widget session restart — the same approach the month widget uses.
+         */
+        val days: List<AgendaDay>,
+        /** Resolved clock convention for event time labels (the time-format pref). */
+        val is24Hour: Boolean,
+        /** First day of the week, for the calendar-aligned "this week" range. */
+        val weekStart: DayOfWeek,
+        /** Saved range pref — the fallback when an instance has no Glance state yet. */
+        val savedRange: AgendaRange,
+    ) : AgendaWidgetData
 }

 /**
@@ -91,9 +105,24 @@ internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
    if (!hasCalendarPermission()) return AgendaWidgetData.NeedsPermission
    val zone = systemZone()
    val anchor = today(zone)
-    val repo = widgetEntryPoint().calendarRepository()
-    val instances = repo.instances(agendaRange(anchor, AGENDA_WIDGET_DAYS, zone)).first()
-    return AgendaWidgetData.Ready(today = anchor, days = groupAgendaDays(anchor, instances, zone))
+    val ep = widgetEntryPoint()
+    val prefs = ep.settingsPrefs()
+    val savedRange = prefs.agendaWidgetRange.first()
+    val weekStart = prefs.weekStart.first().resolveFirstDay(Locale.getDefault())
+    // Load the widest selectable window once; the displayed range is sliced in
+    // the composition from Glance state, so changing the range is a plain
+    // recomposition and never depends on the widget session restarting.
+    val window = agendaRange(anchor, AgendaRange.MAX_CUSTOM_DAYS - 1, zone)
+    val instances = ep.calendarRepository().instances(window).first()
+    val is24Hour = prefs.timeFormat.first()
+        .is24Hour(android.text.format.DateFormat.is24HourFormat(this))
+    return AgendaWidgetData.Ready(
+        today = anchor,
+        days = groupAgendaDays(anchor, instances, zone),
+        is24Hour = is24Hour,
+        weekStart = weekStart,
+        savedRange = savedRange,
+    )
 }

 /** One-shot wide read backing the month widget's grid for any nearby month. */
--- a/app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidget.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidget.kt
@@ -6,6 +6,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.glance.ColorFilter
 import androidx.glance.GlanceId
 import androidx.glance.GlanceModifier
@@ -24,6 +25,8 @@ 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
 import androidx.glance.layout.Alignment
 import androidx.glance.layout.Box
 import androidx.glance.layout.Column
@@ -41,7 +44,11 @@ import androidx.glance.text.TextStyle
 import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
+import de.jeanlucmakiola.calendula.ui.agenda.dayCount
+import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.widget.AgendaWidgetData
 import de.jeanlucmakiola.calendula.widget.CalendulaGlanceTheme
@@ -62,8 +69,20 @@ import java.util.Locale
 * of events grouped under day headers (the Google "Schedule" widget model).
 * Reuses the app's [groupAgendaDays] grouping so it matches the in-app agenda.
 */
+/**
+ * Per-instance Glance state key holding the agenda range (as [AgendaRange.storageValue]).
+ * The range is read reactively in the composition ([currentState]) so a settings
+ * change is reflected by plain recomposition — `updateAll` does NOT reliably
+ * re-run the `provideGlance` preamble for a live widget session, so loading the
+ * range there and slicing it would silently keep the stale value (mirrors the
+ * month widget's MONTH_INDEX_KEY approach).
+ */
+internal val AGENDA_RANGE_KEY = stringPreferencesKey("agenda_range")
+
 class AgendaWidget : GlanceAppWidget() {

+    override val stateDefinition = PreferencesGlanceStateDefinition
+
    override suspend fun provideGlance(context: Context, id: GlanceId) {
        val data = context.loadAgendaWidgetData()
        val dark = (context.resources.configuration.uiMode and
@@ -101,12 +120,21 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
        Spacer(GlanceModifier.height(4.dp))
        when (data) {
            AgendaWidgetData.NeedsPermission -> WidgetMessage(R.string.widget_needs_permission)
-            is AgendaWidgetData.Ready ->
-                if (data.days.isEmpty()) {
+            is AgendaWidgetData.Ready -> {
+                // Range read reactively from per-instance Glance state (falls back
+                // to the saved pref for a freshly placed widget), then the wide
+                // pre-loaded window is sliced to it — pure recomposition.
+                val range = parseAgendaRange(currentState(AGENDA_RANGE_KEY), data.savedRange)
+                val rangeEnd = data.today.plus(
+                    range.dayCount(data.today, data.weekStart) - 1,
+                    DateTimeUnit.DAY,
+                )
+                val visibleDays = data.days.filter { it.date <= rangeEnd }
+                if (visibleDays.isEmpty()) {
                    WidgetMessage(R.string.agenda_empty_title)
                } else {
                    val rows = buildList {
-                        data.days.forEach { day ->
+                        visibleDays.forEach { day ->
                            add(AgendaRow.Header(day.date, data.today))
                            day.events.forEach { add(AgendaRow.Event(it)) }
                        }
@@ -115,11 +143,12 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
                        items(rows.size) { index ->
                            when (val row = rows[index]) {
                                is AgendaRow.Header -> DayHeaderRow(row.date, row.today)
-                                is AgendaRow.Event -> EventRow(row.event, dark)
+                                is AgendaRow.Event -> EventRow(row.event, dark, data.is24Hour)
                            }
                        }
                    }
                }
+            }
        }
    }
 }
@@ -195,7 +224,7 @@ private fun DayHeaderRow(date: LocalDate, today: LocalDate) {
 }

@Composable
-private fun EventRow(event: EventInstance, dark: Boolean) {
+private fun EventRow(event: EventInstance, dark: Boolean, is24Hour: Boolean) {
    val context = androidx.glance.LocalContext.current
    val title = event.title.ifBlank { context.getString(R.string.event_untitled) }
    Row(
@@ -230,7 +259,7 @@ private fun EventRow(event: EventInstance, dark: Boolean) {
                style = TextStyle(color = GlanceTheme.colors.onSurface, fontSize = 14.sp),
            )
            Text(
-                text = eventTimeSummary(context, event),
+                text = eventTimeSummary(context, event, is24Hour),
                maxLines = 1,
                style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 12.sp),
            )
@@ -269,17 +298,17 @@ private fun agendaDayLabel(context: Context, date: LocalDate, today: LocalDate):
    return if (relative != null) "$relative · $formatted" else formatted
 }

-private fun eventTimeSummary(context: Context, event: EventInstance): String {
+private fun eventTimeSummary(context: Context, event: EventInstance, is24Hour: Boolean): String {
    val time = if (event.isAllDay) {
        context.getString(R.string.event_detail_all_day)
    } else {
-        "${formatTime(event.start)} – ${formatTime(event.end)}"
+        "${formatTime(event.start, is24Hour)} – ${formatTime(event.end, is24Hour)}"
    }
    val location = event.location?.takeIf { it.isNotBlank() }
    return if (location != null) "$time · $location" else time
 }

-private fun formatTime(instant: Instant): String {
+private fun formatTime(instant: Instant, is24Hour: Boolean): String {
    val t = instant.toLocalDateTime(zone()).time
-    return "%02d:%02d".format(t.hour, t.minute)
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, Locale.getDefault())
 }
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -230,8 +230,7 @@
    <string name="agenda_today_action">Heute</string>
    <string name="agenda_header_today">Heute</string>
    <string name="agenda_header_tomorrow">Morgen</string>
-    <string name="agenda_empty_title">Nichts geplant</string>
-    <string name="agenda_empty_subtitle">Anstehende Termine erscheinen hier.</string>
+    <string name="agenda_empty_title">Alles erledigt</string>

    <!-- Terminsuche -->
    <string name="search_action">Suchen</string>
@@ -276,8 +275,31 @@
    <string name="settings_dynamic_color_unavailable">Erfordert Android 12 oder neuer</string>
    <string name="settings_week_start">Wochenstart</string>
    <string name="settings_week_start_auto">Automatisch</string>
-    <string name="settings_week_start_monday">Montag</string>
-    <string name="settings_week_start_sunday">Sonntag</string>
+    <string name="settings_time_format">Zeitformat</string>
+    <string name="settings_time_format_auto">Automatisch</string>
+    <string name="settings_time_format_12h">12-Stunden (2:00 PM)</string>
+    <string name="settings_time_format_24h">24-Stunden (14:00)</string>
+    <string name="settings_hour_lines">Stundenlinien</string>
+    <string name="settings_hour_lines_summary">Trennlinie zu jeder vollen Stunde in Wochen- und Tagesansicht anzeigen</string>
+    <string name="settings_agenda_range">Agenda-Zeitraum</string>
+    <string name="settings_agenda_range_hint">Wie weit im Voraus die Agenda-Ansicht Termine anzeigt.</string>
+    <string name="settings_agenda_widget_range">Agenda-Widget-Zeitraum</string>
+    <string name="settings_agenda_widget_range_hint">Wie weit im Voraus das Agenda-Widget auf dem Startbildschirm Termine anzeigt.</string>
+    <string name="settings_agenda_range_bar">Zeitraum-Leiste</string>
+    <string name="settings_agenda_range_bar_hint">Eine Leiste oben in der Agenda anzeigen, die den dargestellten Zeitraum benennt, mit einer Schaltfläche zum Wechseln des Zeitraums für die Sitzung</string>
+    <string name="agenda_range_day">Heute</string>
+    <string name="agenda_range_this_week">Diese Woche</string>
+    <string name="agenda_range_this_month">Dieser Monat</string>
+    <string name="agenda_range_week">Nächste 7 Tage</string>
+    <string name="agenda_range_month">Nächste 30 Tage</string>
+    <string name="agenda_range_custom">Benutzerdefiniert…</string>
+    <string name="agenda_range_custom_hint">Tage</string>
+    <string name="agenda_range_override_hint">Nur vorübergehend — wird beim erneuten Öffnen von Calendula auf deinen gespeicherten Zeitraum zurückgesetzt.</string>
+    <string name="agenda_range_showing_label">Alle anstehenden Termine für</string>
+    <plurals name="agenda_range_days">
+        <item quantity="one">%d Tag</item>
+        <item quantity="other">%d Tage</item>
+    </plurals>
    <string name="settings_section_event_form">Termin-Formular</string>
    <string name="settings_form_fields_hint">Standardmäßig angezeigte Felder — alles Weitere liegt hinter \"Weitere Felder\"</string>
    <string name="settings_color_unsupported">Farben auf nicht unterstützten Kalendern erlauben</string>
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -231,8 +231,7 @@
    <string name="agenda_today_action">Today</string>
    <string name="agenda_header_today">Today</string>
    <string name="agenda_header_tomorrow">Tomorrow</string>
-    <string name="agenda_empty_title">Nothing scheduled</string>
-    <string name="agenda_empty_subtitle">Upcoming events will show up here.</string>
+    <string name="agenda_empty_title">You\'re all caught up</string>

    <!-- Event search -->
    <string name="search_action">Search</string>
@@ -269,8 +268,31 @@
    <string name="settings_dynamic_color_unavailable">Requires Android 12 or newer</string>
    <string name="settings_week_start">Week starts on</string>
    <string name="settings_week_start_auto">Automatic</string>
-    <string name="settings_week_start_monday">Monday</string>
-    <string name="settings_week_start_sunday">Sunday</string>
+    <string name="settings_time_format">Time format</string>
+    <string name="settings_time_format_auto">Automatic</string>
+    <string name="settings_time_format_12h">12-hour (2:00 PM)</string>
+    <string name="settings_time_format_24h">24-hour (14:00)</string>
+    <string name="settings_hour_lines">Hour lines</string>
+    <string name="settings_hour_lines_summary">Show a separator line at each hour in week and day view</string>
+    <string name="settings_agenda_range">Agenda range</string>
+    <string name="settings_agenda_range_hint">How far ahead the Agenda screen lists events.</string>
+    <string name="settings_agenda_widget_range">Agenda widget range</string>
+    <string name="settings_agenda_widget_range_hint">How far ahead the agenda home-screen widget lists events.</string>
+    <string name="settings_agenda_range_bar">Range bar</string>
+    <string name="settings_agenda_range_bar_hint">Show a bar at the top of the agenda naming the dates shown, with a button to switch the range for the session</string>
+    <string name="agenda_range_day">Today</string>
+    <string name="agenda_range_this_week">This week</string>
+    <string name="agenda_range_this_month">This month</string>
+    <string name="agenda_range_week">Next 7 days</string>
+    <string name="agenda_range_month">Next 30 days</string>
+    <string name="agenda_range_custom">Custom…</string>
+    <string name="agenda_range_custom_hint">Days</string>
+    <string name="agenda_range_override_hint">Just for now — resets to your saved range when you reopen Calendula.</string>
+    <string name="agenda_range_showing_label">Showing all upcoming events for</string>
+    <plurals name="agenda_range_days">
+        <item quantity="one">%d day</item>
+        <item quantity="other">%d days</item>
+    </plurals>
    <string name="settings_section_event_form">New event form</string>
    <string name="settings_form_fields_hint">Fields shown by default — everything else sits behind \"More fields\"</string>
    <string name="settings_color_unsupported">Allow colors on unsupported calendars</string>
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt
@@ -5,6 +5,7 @@ import androidx.datastore.preferences.core.PreferenceDataStoreFactory
 import androidx.datastore.preferences.core.Preferences
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import kotlinx.datetime.DayOfWeek
@@ -25,7 +26,7 @@ class SettingsPrefsTest {
        val prefs = SettingsPrefs(newDataStore(tempDir))
        assertThat(prefs.themeMode.first()).isEqualTo(ThemeMode.SYSTEM)
        assertThat(prefs.dynamicColor.first()).isTrue()
-        assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.AUTO)
+        assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.Auto)
    }

    @Test
@@ -43,10 +44,62 @@ class SettingsPrefsTest {
    }

    @Test
-    fun `week start round-trips`(@TempDir tempDir: Path) = runTest {
+    fun `week start round-trips any day`(@TempDir tempDir: Path) = runTest {
        val prefs = SettingsPrefs(newDataStore(tempDir))
-        prefs.setWeekStart(WeekStartPref.SUNDAY)
-        assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.SUNDAY)
+        prefs.setWeekStart(WeekStartPref.Day(DayOfWeek.SATURDAY))
+        assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.Day(DayOfWeek.SATURDAY))
+    }
+
+    @Test
+    fun `legacy MONDAY week-start value migrates to Day`(@TempDir tempDir: Path) = runTest {
+        val store = newDataStore(tempDir)
+        val prefs = SettingsPrefs(store)
+        store.updateData { p ->
+            val m = p.toMutablePreferences()
+            m[SettingsPrefs.WEEK_START_KEY] = "MONDAY"
+            m
+        }
+        assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.Day(DayOfWeek.MONDAY))
+    }
+
+    @Test
+    fun `garbage week-start value falls back to Auto`(@TempDir tempDir: Path) = runTest {
+        val store = newDataStore(tempDir)
+        val prefs = SettingsPrefs(store)
+        store.updateData { p ->
+            val m = p.toMutablePreferences()
+            m[SettingsPrefs.WEEK_START_KEY] = "FUNDAY"
+            m
+        }
+        assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.Auto)
+    }
+
+    @Test
+    fun `time format defaults to auto and round-trips`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.timeFormat.first()).isEqualTo(TimeFormatPref.AUTO)
+        prefs.setTimeFormat(TimeFormatPref.TWELVE_HOUR)
+        assertThat(prefs.timeFormat.first()).isEqualTo(TimeFormatPref.TWELVE_HOUR)
+    }
+
+    @Test
+    fun `hour lines default off and round-trips`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.showHourLines.first()).isFalse()
+        prefs.setShowHourLines(true)
+        assertThat(prefs.showHourLines.first()).isTrue()
+    }
+
+    @Test
+    fun `agenda ranges default to month and round-trip independently`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.agendaScreenRange.first()).isEqualTo(AgendaRange.Month)
+        assertThat(prefs.agendaWidgetRange.first()).isEqualTo(AgendaRange.Month)
+
+        prefs.setAgendaScreenRange(AgendaRange.Custom(14))
+        prefs.setAgendaWidgetRange(AgendaRange.Week)
+        assertThat(prefs.agendaScreenRange.first()).isEqualTo(AgendaRange.Custom(14))
+        assertThat(prefs.agendaWidgetRange.first()).isEqualTo(AgendaRange.Week)
    }

    @Test
@@ -252,13 +305,15 @@ class SettingsPrefsTest {

    @Test
    fun `explicit week-start prefs resolve regardless of locale`() {
-        assertThat(WeekStartPref.MONDAY.resolveFirstDay(Locale.US)).isEqualTo(DayOfWeek.MONDAY)
-        assertThat(WeekStartPref.SUNDAY.resolveFirstDay(Locale.GERMANY)).isEqualTo(DayOfWeek.SUNDAY)
+        assertThat(WeekStartPref.Day(DayOfWeek.MONDAY).resolveFirstDay(Locale.US))
+            .isEqualTo(DayOfWeek.MONDAY)
+        assertThat(WeekStartPref.Day(DayOfWeek.SATURDAY).resolveFirstDay(Locale.GERMANY))
+            .isEqualTo(DayOfWeek.SATURDAY)
    }

    @Test
    fun `auto week start follows the locale convention`() {
-        assertThat(WeekStartPref.AUTO.resolveFirstDay(Locale.GERMANY)).isEqualTo(DayOfWeek.MONDAY)
-        assertThat(WeekStartPref.AUTO.resolveFirstDay(Locale.US)).isEqualTo(DayOfWeek.SUNDAY)
+        assertThat(WeekStartPref.Auto.resolveFirstDay(Locale.GERMANY)).isEqualTo(DayOfWeek.MONDAY)
+        assertThat(WeekStartPref.Auto.resolveFirstDay(Locale.US)).isEqualTo(DayOfWeek.SUNDAY)
    }
 }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeTextTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeTextTest.kt
@@ -26,10 +26,24 @@ class ReminderTimeTextTest {
            isAllDay = false,
            zone = berlin,
            locale = Locale.GERMANY,
+            is24Hour = true,
        )
        assertThat(text).isEqualTo("09:30 – 10:00")
    }

+    @Test
+    fun `12-hour preference renders an am-pm time range`() {
+        val text = reminderTimeText(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 11, 14, 0), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 11, 15, 0), berlin),
+            isAllDay = false,
+            zone = berlin,
+            locale = Locale.US,
+            is24Hour = false,
+        )
+        assertThat(text).isEqualTo("2:00 PM – 3:00 PM")
+    }
+
    @Test
    fun `timed event crossing midnight includes both dates`() {
        val text = reminderTimeText(
@@ -38,6 +52,7 @@ class ReminderTimeTextTest {
            isAllDay = false,
            zone = berlin,
            locale = Locale.GERMANY,
+            is24Hour = true,
        )
        assertThat(text).contains("11.06.2026")
        assertThat(text).contains("12.06.2026")
@@ -54,6 +69,7 @@ class ReminderTimeTextTest {
            // 02:00 in Berlin — naive local reading would shift the day.
            zone = berlin,
            locale = Locale.GERMANY,
+            is24Hour = true,
        )
        assertThat(text).isEqualTo("11.06.2026")
    }
@@ -66,6 +82,7 @@ class ReminderTimeTextTest {
            isAllDay = true,
            zone = berlin,
            locale = Locale.GERMANY,
+            is24Hour = true,
        )
        assertThat(text).isEqualTo("11.06.2026 – 12.06.2026")
    }
@@ -79,6 +96,7 @@ class ReminderTimeTextTest {
            isAllDay = true,
            zone = berlin,
            locale = Locale.GERMANY,
+            is24Hour = true,
        )
        assertThat(text).isEqualTo("11.06.2026")
    }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRangeTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRangeTest.kt
@@ -0,0 +1,83 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import org.junit.jupiter.api.Test
+
+class AgendaRangeTest {
+
+    // A reference anchor: 2026-06-17 is a Wednesday.
+    private val wednesday = LocalDate(2026, 6, 17)
+
+    @Test
+    fun `rolling ranges have fixed 1, 7, 30 day counts regardless of anchor`() {
+        assertThat(AgendaRange.Day.dayCount(wednesday, DayOfWeek.MONDAY)).isEqualTo(1)
+        assertThat(AgendaRange.Week.dayCount(wednesday, DayOfWeek.MONDAY)).isEqualTo(7)
+        assertThat(AgendaRange.Month.dayCount(wednesday, DayOfWeek.MONDAY)).isEqualTo(30)
+    }
+
+    @Test
+    fun `this week runs through the day before the week repeats`() {
+        // Mon-start week: Wed → Wed,Thu,Fri,Sat,Sun = 5 days (everything before next Monday).
+        assertThat(AgendaRange.ThisWeek.dayCount(wednesday, DayOfWeek.MONDAY)).isEqualTo(5)
+        // On the first day of the week the whole 7 days remain.
+        val monday = LocalDate(2026, 6, 15)
+        assertThat(AgendaRange.ThisWeek.dayCount(monday, DayOfWeek.MONDAY)).isEqualTo(7)
+        // A Sunday-start week shifts the boundary: Wed → 4 days left (through Saturday).
+        assertThat(AgendaRange.ThisWeek.dayCount(wednesday, DayOfWeek.SUNDAY)).isEqualTo(4)
+    }
+
+    @Test
+    fun `this month runs through the last day of the month`() {
+        // June has 30 days: the 17th leaves 14 days (17..30 inclusive).
+        assertThat(AgendaRange.ThisMonth.dayCount(wednesday, DayOfWeek.MONDAY)).isEqualTo(14)
+        // February 2026 (non-leap) has 28 days.
+        assertThat(AgendaRange.ThisMonth.dayCount(LocalDate(2026, 2, 20), DayOfWeek.MONDAY))
+            .isEqualTo(9)
+    }
+
+    @Test
+    fun `custom day count is clamped to bounds`() {
+        assertThat(AgendaRange.Custom(45).dayCount(wednesday, DayOfWeek.MONDAY)).isEqualTo(45)
+        assertThat(AgendaRange.Custom(0).dayCount(wednesday, DayOfWeek.MONDAY))
+            .isEqualTo(AgendaRange.MIN_CUSTOM_DAYS)
+        assertThat(AgendaRange.Custom(9_999).dayCount(wednesday, DayOfWeek.MONDAY))
+            .isEqualTo(AgendaRange.MAX_CUSTOM_DAYS)
+    }
+
+    @Test
+    fun `fixed ranges round-trip through storage`() {
+        listOf(
+            AgendaRange.Day,
+            AgendaRange.Week,
+            AgendaRange.Month,
+            AgendaRange.ThisWeek,
+            AgendaRange.ThisMonth,
+        ).forEach { range ->
+            assertThat(parseAgendaRange(range.storageValue(), default = AgendaRange.Day))
+                .isEqualTo(range)
+        }
+    }
+
+    @Test
+    fun `custom range round-trips through storage`() {
+        val range = AgendaRange.Custom(14)
+        assertThat(range.storageValue()).isEqualTo("CUSTOM:14")
+        assertThat(parseAgendaRange("CUSTOM:14", default = AgendaRange.Day))
+            .isEqualTo(AgendaRange.Custom(14))
+    }
+
+    @Test
+    fun `garbage and null fall back to the default`() {
+        assertThat(parseAgendaRange(null, default = AgendaRange.Month)).isEqualTo(AgendaRange.Month)
+        assertThat(parseAgendaRange("YEAR", default = AgendaRange.Week)).isEqualTo(AgendaRange.Week)
+        assertThat(parseAgendaRange("CUSTOM:abc", default = AgendaRange.Day)).isEqualTo(AgendaRange.Day)
+    }
+
+    @Test
+    fun `out-of-range custom value clamps on parse`() {
+        assertThat(parseAgendaRange("CUSTOM:9999", default = AgendaRange.Day))
+            .isEqualTo(AgendaRange.Custom(AgendaRange.MAX_CUSTOM_DAYS))
+    }
+}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/common/TimeFormatTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/common/TimeFormatTest.kt
@@ -0,0 +1,37 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+import java.util.Locale
+
+class TimeFormatTest {
+
+    @Test
+    fun `24-hour format is zero-padded HH mm`() {
+        assertThat(formatTimeOfDay(9, 5, is24Hour = true, Locale.US)).isEqualTo("09:05")
+        assertThat(formatTimeOfDay(14, 0, is24Hour = true, Locale.US)).isEqualTo("14:00")
+        assertThat(formatTimeOfDay(0, 0, is24Hour = true, Locale.US)).isEqualTo("00:00")
+    }
+
+    @Test
+    fun `12-hour format adds a localised am-pm marker`() {
+        assertThat(formatTimeOfDay(14, 0, is24Hour = false, Locale.US)).isEqualTo("2:00 PM")
+        assertThat(formatTimeOfDay(0, 30, is24Hour = false, Locale.US)).isEqualTo("12:30 AM")
+        assertThat(formatTimeOfDay(12, 0, is24Hour = false, Locale.US)).isEqualTo("12:00 PM")
+    }
+
+    @Test
+    fun `minute-of-day end-of-day renders 24 00 in 24h and midnight in 12h`() {
+        assertThat(formatMinuteOfDay(1_440, is24Hour = true, Locale.US)).isEqualTo("24:00")
+        assertThat(formatMinuteOfDay(1_440, is24Hour = false, Locale.US)).isEqualTo("12:00 AM")
+        assertThat(formatMinuteOfDay(13 * 60 + 15, is24Hour = true, Locale.US)).isEqualTo("13:15")
+    }
+
+    @Test
+    fun `hour label is zero-padded in 24h and compact am-pm in 12h`() {
+        assertThat(formatHourLabel(13, is24Hour = true, Locale.US)).isEqualTo("13")
+        assertThat(formatHourLabel(13, is24Hour = false, Locale.US)).isEqualTo("1 PM")
+        assertThat(formatHourLabel(1, is24Hour = false, Locale.US)).isEqualTo("1 AM")
+        assertThat(formatHourLabel(0, is24Hour = false, Locale.US)).isEqualTo("12 AM")
+    }
+}
--- a/fastlane/metadata/android/en-US/changelogs/21100.txt
+++ b/fastlane/metadata/android/en-US/changelogs/21100.txt
@@ -0,0 +1,28 @@
+### Added
+- Start the week on any day. The **Week starts on** setting (Settings →
+  Appearance) now offers every weekday — not just Monday or Sunday — alongside
+  the automatic, locale-based default. Thanks to @zmaherdev for the suggestion
+  ([#3]).
+- Choose a 12- or 24-hour clock. A new **Time format** setting (Settings →
+  Appearance) lets you force a 12-hour (2:00 PM) or 24-hour (14:00) clock, or
+  follow the system setting automatically. It applies everywhere times appear —
+  the week and day timelines, agenda, event details, search and reminders — so
+  the format is now consistent across the whole app. Thanks to @zmaherdev for
+  the suggestion ([#6]).
+- Optional hour lines in the timeline. A new **Hour lines** switch (Settings →
+  Appearance) draws a faint separator at each hour in the week and day views,
+  making it easier to see when events start and end. Off by default. Thanks to
+  @zmaherdev for the suggestion ([#5]).
+- Limit how far ahead the agenda looks, and switch it on the fly. New **Agenda
+  range** and **Agenda widget range** settings (Settings → Appearance) let the
+  agenda screen and its home-screen widget each show just today, the rest of this
+  week, the rest of this month, a rolling 7 or 30 days, or a custom number of
+  days — "This week" follows your week-start. The agenda also gains a bar at the
+  top naming the exact dates in view, with a button to switch the range just for
+  the current session (it resets when you reopen the app); the bar can be turned
+  off. Thanks to @zmaherdev for the suggestion ([#4]).
+
+### Changed
+- Tidied **Settings → Appearance** into clearer groups (theme & colour, calendar,
+  agenda), and the agenda's empty state now reads "You're all caught up".
+
Author	SHA1	Message	Date
Jean-Luc Makiola	301904be6d	docs(changelog): note agenda range bar and Appearance tidy-up in 2.11.0 Expand the #4 entry to cover the in-agenda range bar (date header + session range switch) and add a Changed note for the Appearance regrouping and the friendlier agenda empty state. Regenerate the F-Droid changelog. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 17:11:29 +02:00
Jean-Luc Makiola	3ca7200624	Merge pull request 'feat(agenda): limit how far ahead the agenda screen and widget show (#4 )' (!44 ) from feat/agenda-range-limit into release/v2.11.0	2026-06-27 15:08:34 +00:00
Jean-Luc Makiola	c30a153552	fix(widget): drive agenda range via reactive Glance state All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 4m22s Details The agenda widget loaded and sliced its data in the provideGlance preamble and captured it as a non-reactive local. updateAll() reliably recomposes a live Glance session but does not reliably re-run that preamble, so a range change was redrawn against the stale slice (intermittently — only when no session was alive did it pick up the new range). This is the same platform limitation the month widget already works around. Mirror that pattern: load the widest selectable window once, store the range in per-instance Glance state (AGENDA_RANGE_KEY), read it reactively via currentState, and slice in the composition. The settings setter writes the state into each instance and recomposes, so a range change now reflects via plain recomposition regardless of session lifecycle. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 17:03:48 +02:00
Jean-Luc Makiola	bb92d02000	fix(widget): refresh from setter, serialized with a mutex All checks were successful Translations / check (pull_request) Successful in 4s Details CI / ci (pull_request) Successful in 4m29s Details The debounced observer was unreliable: drop(1) plus the ViewModel lifecycle could swallow a change after re-entering the app, so a single range change sometimes didn't refresh the widget. Refresh directly from the settings setters instead (always fires on a real change), serialized through a mutex so a rapid flip-and-flip-back can't run two updateAll calls at once and strand the widget on the intermediate value. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 16:44:52 +02:00
Jean-Luc Makiola	cd703e9d54	fix(widget): debounce widget refresh on pref change All checks were successful Translations / check (pull_request) Successful in 4s Details CI / ci (pull_request) Successful in 4m38s Details Refreshing the widget directly from the setter raced when a setting was flipped and flipped back quickly: two concurrent updateAll calls could coalesce around a stale read and leave the widget on the intermediate value. Observe the agenda-widget-range and week-start prefs instead and push a single debounced updateAll once changes settle, so the widget always converges to the final value. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 16:37:57 +02:00
Jean-Luc Makiola	f27b0e269d	fix(widget): refresh agenda widget when its range (or week start) changes All checks were successful Translations / check (pull_request) Successful in 6s Details CI / ci (pull_request) Successful in 9m18s Details The agenda widget only re-read agendaWidgetRange on the next data-change / midnight / periodic refresh (or re-placement), so a settings change appeared to do nothing until then. Push an updateAll from the settings setters: the agenda widget on an agenda-widget-range change, and both widgets on a week-start change (month weekday header + the agenda widget's "this week"). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 16:30:27 +02:00
Jean-Luc Makiola	0f31981d26	refactor(agenda): one toggle for the whole range bar All checks were successful Translations / check (pull_request) Successful in 4s Details CI / ci (pull_request) Successful in 4m43s Details Consolidate the separate "range title" and "range button" settings into a single "Range bar" toggle, now that the header and switcher live on one bar. On by default. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 16:25:46 +02:00
Jean-Luc Makiola	6471c48528	refactor(agenda): put range header and pill on one bar All checks were successful Translations / check (pull_request) Successful in 6s Details CI / ci (pull_request) Successful in 9m46s Details Move the session range pill from the bottom-left corner onto the same top bar as the "Showing all upcoming events for …" header — header on the left, pill on the right, each still independently toggleable. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 16:22:33 +02:00
Jean-Luc Makiola	f8a2569831	feat(agenda): warmer empty state + "upcoming" wording All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 4m30s Details Reword the range header to "Showing all upcoming events for". Replace the dry empty state ("Nothing scheduled" + subtitle) with a single warmer line ("You're all caught up"), drop the subtitle, and switch the icon to a coffee cup. The empty title is shared with the agenda widget. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 16:20:33 +02:00
Jean-Luc Makiola	6ba7f38887	feat(agenda): range header banner + toggles for banner and pill All checks were successful Translations / check (pull_request) Successful in 4s Details CI / ci (pull_request) Successful in 4m29s Details Move the "Showing all events for <window>" line out of the picker and into the agenda view as an always-visible header above the list. Add two settings (Agenda group, both ON by default) to toggle the range header banner and the bottom-left range pill independently. The picker keeps its two-list grouping but no longer carries the header. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 16:08:23 +02:00
Jean-Luc Makiola	366059b012	feat(agenda): split range picker into two lists with a concrete header All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 4m27s Details Group the range options into calendar-aligned (today / this week / this month) and rolling (next 7 / 30 days / custom) lists. Add a header showing the concrete span currently in effect — a single date for Today, the month and year for This month, otherwise a start–end span — so it's clear what the agenda is showing. The header appears only where a window is supplied (the agenda pill), not in Settings. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 15:59:56 +02:00
Jean-Luc Makiola	3cf1439850	feat(agenda): bottom-left pill to override the range for the session All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 9m4s Details Add a tonal pill in the agenda's bottom-left corner showing the current range; tapping it opens the existing AgendaRangePicker as a session-only override. The override lives in AgendaViewModel (in-memory), so it survives view switches and rotation but resets to the saved default when the app is relaunched. The pill fills with the primary container while an override is active, and a hint in the picker spells out the temporary nature. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 15:50:18 +02:00
Jean-Luc Makiola	b2bfdc0f42	refactor(settings): regroup Appearance into theme / calendar / agenda All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 9m0s Details Drop the uniform two-per-card grouping for meaningful sections: theme & colour (2), calendar — default view, week start, time format, hour lines (4), and agenda (2). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 15:36:19 +02:00
Jean-Luc Makiola	7c9830deda	Merge release/v2.11.0 into feat/agenda-range-limit All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 4m26s Details Integrate #3/#5/#6 (week-start, time-format, hour-lines) into the agenda range branch. SettingsViewModel folds all five view prefs into one combine; WidgetData keeps the range-based window and adds the resolved is24Hour. Also, in the same Appearance section: - regroup the rows into four titled-by-spacing groups (theme & colour / calendar layout / timeline display / agenda) instead of one long card. - add an explanatory description line under the title of each agenda-range picker (PickerDescription). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 15:31:44 +02:00
Jean-Luc Makiola	5e98059388	Merge pull request 'feat(timeline): optional hour separator lines in week & day view (#5 )' (!43 ) from feat/timeline-hour-lines into release/v2.11.0 Reviewed-on: #43	2026-06-27 13:18:26 +00:00
Jean-Luc Makiola	53c0482760	Merge pull request 'feat(settings): add 12/24-hour time format toggle (#6 )' (!42 ) from feat/time-format-toggle into release/v2.11.0 Reviewed-on: #42	2026-06-27 13:18:05 +00:00
Jean-Luc Makiola	f8efa4d3e4	Merge branch 'feat/time-format-toggle' into feat/timeline-hour-lines All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 6m51s Details	2026-06-27 14:54:38 +02:00
Jean-Luc Makiola	93cc264fbf	Merge remote-tracking branch 'origin/release/v2.11.0' into feat/time-format-toggle All checks were successful Translations / check (pull_request) Successful in 7s Details CI / ci (pull_request) Successful in 9m45s Details # Conflicts: # app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt # app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt # app/src/main/res/values-de/strings.xml # app/src/main/res/values/strings.xml	2026-06-27 14:53:45 +02:00
Jean-Luc Makiola	585cdac4ab	Merge pull request 'feat(settings): allow week to start on any day (#3 )' (!41 ) from feat/week-start-any-day into release/v2.11.0 Reviewed-on: #41	2026-06-27 12:47:45 +00:00
Jean-Luc Makiola	9994e8c534	chore(release): prepare v2.11.0 Bump versionName to 2.11.0 (versionCode 21100) and add the 2.11.0 changelog: any-day week start (#3), 12/24-hour time format (#6), optional timeline hour lines (#5), and agenda range limits (#4). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 14:34:48 +02:00
Jean-Luc Makiola	766c2ffcf8	feat(agenda): add calendar-aligned "this week"/"this month" ranges All checks were successful Translations / check (pull_request) Successful in 4s Details CI / ci (pull_request) Successful in 11m22s Details Extend AgendaRange with calendar-aligned windows alongside the rolling ones: ThisWeek runs through the end of the current week (respecting the week-start preference — a Monday start means everything before next Monday), ThisMonth through the last day of the current month. dayCount now takes the anchor day and week-start; the agenda screen and widget resolve the week-start preference and pass it through. Rolling options relabelled ("Today", "Next 7 days", "Next 30 days") to read distinctly from the new calendar-aligned ones. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 14:25:59 +02:00
Jean-Luc Makiola	add88fbadf	feat(agenda): limit how far ahead the agenda screen and widget show Add independent agendaScreenRange and agendaWidgetRange preferences, each a rolling window: 1 day / 1 week / 1 month / custom 1–365 days (default Month). Rolling (not calendar-aligned) so the span never degenerates near a period boundary. The in-app Agenda screen and the agenda widget each read their own setting, configured via a new AgendaRangePicker with an inline custom-days editor. Closes #4 (Codeberg) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 14:15:46 +02:00
Jean-Luc Makiola	09a1aecb76	feat(timeline): optional hour separator lines in week & day view All checks were successful Translations / check (pull_request) Successful in 4s Details CI / ci (pull_request) Successful in 11m25s Details Add a showHourLines preference (default off — the existing clean look). When on, the week and day timelines draw a faint outline-variant line at each hour boundary, sitting over the column background but beneath event blocks. The toggle is provided app-wide via LocalShowHourLines and applied through a reusable hourSeparatorLines() modifier. Closes #5 (Codeberg) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 14:07:09 +02:00
Jean-Luc Makiola	c91608e48a	feat(settings): add 12/24-hour time format toggle All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 11m16s Details Add a TimeFormatPref (Auto/12h/24h) preference. Auto follows the device's 24-hour system setting; the others force a clock app-wide. The resolved convention is provided once at the app root via LocalUse24HourFormat, so every in-app time label reads it without per-screen plumbing. A shared, pure TimeFormat helper (formatTimeOfDay / formatMinuteOfDay / formatHourLabel / timeOfDayFormatter) is now the single source for all time-of-day rendering. Routing every site through it also fixes a pre-existing inconsistency: the week/day timeline gutters and the agenda screen + widget hard-coded 24h, while event detail/edit/search/reminders followed the locale — so a 12h-locale user previously saw mixed formats. Covered: week & day timelines (gutter + event blocks), agenda screen and widget, event detail/edit, search, and reminder notifications. Closes #6 (Codeberg) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 14:02:22 +02:00
Jean-Luc Makiola	47e8036000	feat(settings): allow week to start on any day All checks were successful Translations / check (pull_request) Successful in 5s Details CI / ci (pull_request) Successful in 6m7s Details Replace the AUTO/MONDAY/SUNDAY week-start enum with a sealed type (Auto + Day(DayOfWeek)) so users can pick any of the seven days as the first day of the week. The picker now lists "Automatic" plus all seven localised weekday names; labels come from java.time display names rather than per-day string resources. Stored values round-trip by DayOfWeek.name, so the legacy MONDAY/SUNDAY preferences migrate transparently. Garbage values fall back to Auto. Closes #3 (Codeberg) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-27 13:45:01 +02:00
Jean-Luc Makiola	07a8faf2df	Merge pull request 'release: v2.10.0' (!40 ) from release/v2.10.0 into main All checks were successful Release — F-Droid repo + Gitea release / detect (push) Successful in 5s Details Release — F-Droid repo + Gitea release / release (push) Successful in 6m11s Details Reviewed-on: #40	2026-06-25 12:53:12 +00:00