feat(agenda): add calendar-aligned "this week"/"this month" ranges

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>

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
@@ -70,6 +73,28 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[WEEK_START_KEY] = pref.name }
     }
 
+    /**
+     * 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() }
+    }
+
     /**
      * The calendar view the app opens on (M1). Defaults to [CalendarView.Week] —
      * the historical hard-coded startup view — so existing users see no change
@@ -259,6 +284,8 @@ 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 DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val FORM_FIELDS_KEY = stringPreferencesKey("event_form_default_fields")
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")

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

@@ -0,0 +1,85 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import java.time.YearMonth
+
+/**
+ * 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
+}
+
+private const val CUSTOM_PREFIX = "CUSTOM:"

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,12 @@ 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.LocalDate
 import kotlinx.datetime.TimeZone
+import java.util.Locale
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
@@ -30,16 +34,20 @@ 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() {
 
+    private val screenRange = settingsPrefs.agendaScreenRange
+
+    // 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,12 +56,15 @@ class AgendaViewModel @Inject constructor(
     private val _anchor = MutableStateFlow(todayDate)
     val anchor: StateFlow<LocalDate> = _anchor
 
-    val state: StateFlow<AgendaUiState> = _anchor
+    val state: StateFlow<AgendaUiState> =
-        .flatMapLatest { anchor ->
+        combine(_anchor, screenRange, weekStartDay) { anchor, range, weekStart ->
-            val range = agendaRange(anchor, AGENDA_WINDOW_DAYS, zone)
+            Triple(anchor, range, weekStart)
+        }
+        .flatMapLatest { (anchor, range, weekStart) ->
+            val window = agendaRange(anchor, range.dayCount(anchor, weekStart) - 1, zone)
             combine(
                 repository.calendars(),
-                repository.instances(range),
+                repository.instances(window),
             ) { calendars, instances ->
                 buildState(anchor, calendars, instances)
             }

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

@@ -30,6 +30,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 +38,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
@@ -269,6 +271,138 @@ private fun SelectedCheck() {
     )
 }
 
+/**
+ * Agenda-range picker, full-screen: the fixed 1 day / 1 week / 1 month windows
+ * as grouped rows, plus a "Custom" row that expands an inline day-count editor
+ * (1–365). Mirrors [ReminderDefaultPicker]'s custom-expand pattern.
+ */
+@Composable
+fun AgendaRangePicker(
+    title: String,
+    selected: AgendaRange,
+    onSelect: (AgendaRange) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val presets = listOf(
+        AgendaRange.Day,
+        AgendaRange.ThisWeek,
+        AgendaRange.ThisMonth,
+        AgendaRange.Week,
+        AgendaRange.Month,
+    )
+    val customSelected = selected is AgendaRange.Custom
+    val rowCount = presets.size + 1 // + the custom row
+
+    var customExpanded by rememberSaveable { mutableStateOf(false) }
+    var amountText by rememberSaveable {
+        mutableStateOf((selected as? AgendaRange.Custom)?.days?.toString() ?: "")
+    }
+
+    FullScreenPicker(title = title, onDismiss = onDismiss) {
+        presets.forEachIndexed { index, option ->
+            val isSelected = option == selected
+            GroupedRow(
+                title = agendaRangeLabel(option),
+                position = positionOf(index, rowCount),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = {
+                    onSelect(option)
+                    onDismiss()
+                },
+            )
+        }
+        GroupedRow(
+            title = if (customSelected) {
+                agendaRangeLabel(selected)
+            } else {
+                stringResource(R.string.agenda_range_custom)
+            },
+            position = if (customExpanded) Position.Top else positionOf(presets.size, rowCount),
+            selected = customSelected,
+            trailing = if (customSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(
+            visible = customExpanded,
+            enter = 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)

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

@@ -92,6 +92,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
@@ -425,6 +427,8 @@ private fun AppearanceScreen(
     var showTheme by remember { mutableStateOf(false) }
     var showWeekStart 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),
@@ -466,9 +470,21 @@ private fun AppearanceScreen(
         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_agenda_range),
+            summary = agendaRangeLabel(state.agendaScreenRange),
+            position = Position.Middle,
+            onClick = { showAgendaScreenRange = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_agenda_widget_range),
+            summary = agendaRangeLabel(state.agendaWidgetRange),
+            position = Position.Bottom,
+            onClick = { showAgendaWidgetRange = true },
+        )
     }
 
     if (showTheme) {
@@ -491,6 +507,22 @@ private fun AppearanceScreen(
             onDismiss = { showWeekStart = false },
         )
     }
+    if (showAgendaScreenRange) {
+        AgendaRangePicker(
+            title = stringResource(R.string.settings_agenda_range),
+            selected = state.agendaScreenRange,
+            onSelect = viewModel::setAgendaScreenRange,
+            onDismiss = { showAgendaScreenRange = false },
+        )
+    }
+    if (showAgendaWidgetRange) {
+        AgendaRangePicker(
+            title = stringResource(R.string.settings_agenda_widget_range),
+            selected = state.agendaWidgetRange,
+            onSelect = viewModel::setAgendaWidgetRange,
+            onDismiss = { showAgendaWidgetRange = false },
+        )
+    }
     if (showDefaultView) {
         OptionPicker(
             title = stringResource(R.string.settings_default_view),

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

@@ -5,6 +5,7 @@ import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 
 /**
@@ -18,6 +19,10 @@ data class SettingsUiState(
     val dynamicColor: Boolean = true,
     val dynamicColorAvailable: Boolean = true,
     val weekStart: WeekStartPref = WeekStartPref.AUTO,
+    /** 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,
     /** 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"). */

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

@@ -11,6 +11,7 @@ import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
@@ -73,10 +74,16 @@ class SettingsViewModel @Inject constructor(
             ) { overrides, allDayOverrides, calendars ->
                 ReminderOverrides(overrides, allDayOverrides, calendars)
             },
-            prefs.defaultView,
+            combine(
-        ) { base, defaults, overrides, defaultView ->
+                prefs.defaultView,
+                prefs.agendaScreenRange,
+                prefs.agendaWidgetRange,
+            ) { view, screenRange, widgetRange -> ViewSettings(view, screenRange, widgetRange) },
+        ) { base, defaults, overrides, views ->
             base.copy(
-                defaultView = defaultView,
+                defaultView = views.defaultView,
+                agendaScreenRange = views.agendaScreenRange,
+                agendaWidgetRange = views.agendaWidgetRange,
                 allowColorOnUnsupportedCalendars = defaults.allowColor,
                 defaultReminderMinutes = defaults.defaultReminder,
                 defaultAllDayReminderMinutes = defaults.allDayReminder,
@@ -106,6 +113,12 @@ class SettingsViewModel @Inject constructor(
         val calendars: List<CalendarSource>,
     )
 
+    private data class ViewSettings(
+        val defaultView: CalendarView,
+        val agendaScreenRange: AgendaRange,
+        val agendaWidgetRange: AgendaRange,
+    )
+
     fun setThemeMode(mode: ThemeMode) {
         viewModelScope.launch { prefs.setThemeMode(mode) }
     }
@@ -118,6 +131,14 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setWeekStart(pref) }
     }
 
+    fun setAgendaScreenRange(range: AgendaRange) {
+        viewModelScope.launch { prefs.setAgendaScreenRange(range) }
+    }
+
+    fun setAgendaWidgetRange(range: AgendaRange) {
+        viewModelScope.launch { prefs.setAgendaWidgetRange(range) }
+    }
+
     fun setDefaultView(view: CalendarView) {
         viewModelScope.launch { prefs.setDefaultView(view) }
     }

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

@@ -8,6 +8,7 @@ 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.dayCount
 import de.jeanlucmakiola.calendula.ui.agenda.groupAgendaDays
 import kotlinx.coroutines.flow.first
 import kotlinx.datetime.DateTimeUnit
@@ -23,9 +24,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
@@ -91,8 +89,12 @@ internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
     if (!hasCalendarPermission()) return AgendaWidgetData.NeedsPermission
     val zone = systemZone()
     val anchor = today(zone)
-    val repo = widgetEntryPoint().calendarRepository()
+    val ep = widgetEntryPoint()
-    val instances = repo.instances(agendaRange(anchor, AGENDA_WIDGET_DAYS, zone)).first()
+    val prefs = ep.settingsPrefs()
+    val range = prefs.agendaWidgetRange.first()
+    val weekStart = prefs.weekStart.first().resolveFirstDay(Locale.getDefault())
+    val window = agendaRange(anchor, range.dayCount(anchor, weekStart) - 1, zone)
+    val instances = ep.calendarRepository().instances(window).first()
     return AgendaWidgetData.Ready(today = anchor, days = groupAgendaDays(anchor, instances, zone))
 }
 

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

@@ -278,6 +278,19 @@
     <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_agenda_range">Agenda-Zeitraum</string>
+    <string name="settings_agenda_widget_range">Agenda-Widget-Zeitraum</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>
+    <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>

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

@@ -271,6 +271,19 @@
     <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_agenda_range">Agenda range</string>
+    <string name="settings_agenda_widget_range">Agenda widget range</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>
+    <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>

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
@@ -49,6 +50,18 @@ class SettingsPrefsTest {
         assertThat(prefs.weekStart.first()).isEqualTo(WeekStartPref.SUNDAY)
     }
 
+    @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
     fun `garbage stored enum falls back to default`(@TempDir tempDir: Path) = runTest {
         val store = newDataStore(tempDir)

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))
+    }
+}