fix: event lookahead milestone one fast follow p3 (#177)

* fix: cuttoff become day boundary

* fix: s/cutoff/dayboundary/g

* fix: bug bot ignore old banner settings

im ok with people seeing it one more time now that it actually goes to
the right place

* fix: fully replace cuttoff with day boundary

Author: williscool

android/app/src/main/java/com/github/quarck/calnotify/Settings.kt

@@ -450,32 +450,23 @@ class Settings(context: Context) : PersistentStorageBase(context), SettingsInter
         get() = getBoolean(USE_NEW_NAVIGATION_UI_KEY, true)
         set(value) = setBoolean(USE_NEW_NAVIGATION_UI_KEY, value)
 
-    /** Whether the "new UI" info banner has been dismissed (legacy, kept for compatibility) */
-    var newUIBannerDismissed: Boolean
-        get() = getBoolean(NEW_UI_BANNER_DISMISSED_KEY, false)
-        set(value) = setBoolean(NEW_UI_BANNER_DISMISSED_KEY, value)
-    
-    /** Whether to show the "new UI" info banner on Active events screen.
-     *  Migrates from old newUIBannerDismissed preference if user previously dismissed banner. */
+    /** Whether to show the "new UI" info banner on Active events screen */
     var showNewUIBanner: Boolean
-        get() {
-            // Migration: if user dismissed banner with old preference, respect that
-            if (newUIBannerDismissed) return false
-            return getBoolean(SHOW_NEW_UI_BANNER_KEY, true)
-        }
+        get() = getBoolean(SHOW_NEW_UI_BANNER_KEY, true)
         set(value) = setBoolean(SHOW_NEW_UI_BANNER_KEY, value)
 
-    /** Lookahead mode: "cutoff" = next morning cutoff, "fixed" = fixed hours */
+    /** Lookahead mode: "fixed" = fixed hours ahead (default), "day_boundary" = until day boundary.*/
     var upcomingEventsMode: String
-        get() = getString(UPCOMING_EVENTS_MODE_KEY, "cutoff")
+        get() = getString(UPCOMING_EVENTS_MODE_KEY, "fixed")
         set(value) = setString(UPCOMING_EVENTS_MODE_KEY, value)
 
-    /** Hour of day for morning cutoff (6-12, default 10). Bounded to prevent date rollover. */
-    var upcomingEventsCutoffHour: Int
-        get() = (getString(UPCOMING_EVENTS_CUTOFF_HOUR_KEY, DEFAULT_UPCOMING_EVENTS_CUTOFF_HOUR.toString())
-            .toIntOrNull() ?: DEFAULT_UPCOMING_EVENTS_CUTOFF_HOUR)
-            .coerceIn(MIN_CUTOFF_HOUR, MAX_CUTOFF_HOUR)
-        set(value) = setString(UPCOMING_EVENTS_CUTOFF_HOUR_KEY, value.coerceIn(MIN_CUTOFF_HOUR, MAX_CUTOFF_HOUR).toString())
+    /** Hour when "new day" begins (0-10, default 4am). Before this hour, show until today's boundary;
+     *  after, show until tomorrow's boundary. */
+    var upcomingEventsDayBoundaryHour: Int
+        get() = (getString(UPCOMING_EVENTS_DAY_BOUNDARY_HOUR_KEY, DEFAULT_UPCOMING_EVENTS_DAY_BOUNDARY_HOUR.toString())
+            .toIntOrNull() ?: DEFAULT_UPCOMING_EVENTS_DAY_BOUNDARY_HOUR)
+            .coerceIn(MIN_DAY_BOUNDARY_HOUR, MAX_DAY_BOUNDARY_HOUR)
+        set(value) = setString(UPCOMING_EVENTS_DAY_BOUNDARY_HOUR_KEY, value.coerceIn(MIN_DAY_BOUNDARY_HOUR, MAX_DAY_BOUNDARY_HOUR).toString())
 
     /** Fixed hours lookahead (1-48, default 8). Bounded to prevent misconfiguration. */
     var upcomingEventsFixedHours: Int
@@ -577,10 +568,9 @@ class Settings(context: Context) : PersistentStorageBase(context), SettingsInter
 
         // Upcoming events / navigation settings
         private const val USE_NEW_NAVIGATION_UI_KEY = "use_new_navigation_ui"
-        private const val NEW_UI_BANNER_DISMISSED_KEY = "new_ui_banner_dismissed"
         private const val SHOW_NEW_UI_BANNER_KEY = "show_new_ui_banner"
         private const val UPCOMING_EVENTS_MODE_KEY = "upcoming_events_mode"
-        private const val UPCOMING_EVENTS_CUTOFF_HOUR_KEY = "upcoming_events_cutoff_hour"
+        private const val UPCOMING_EVENTS_DAY_BOUNDARY_HOUR_KEY = "upcoming_events_day_boundary_hour"
         private const val UPCOMING_EVENTS_FIXED_HOURS_KEY = "upcoming_events_fixed_hours"
 
         // Default values
@@ -594,10 +584,10 @@ class Settings(context: Context) : PersistentStorageBase(context), SettingsInter
         internal const val DEFAULT_KEEP_HISTORY_DAYS = 14
 
         // Upcoming events defaults and bounds
-        internal const val DEFAULT_UPCOMING_EVENTS_CUTOFF_HOUR = 10
+        internal const val DEFAULT_UPCOMING_EVENTS_DAY_BOUNDARY_HOUR = 4  // 4am - when "new day" begins
         internal const val DEFAULT_UPCOMING_EVENTS_FIXED_HOURS = 8
-        internal const val MIN_CUTOFF_HOUR = 6
-        internal const val MAX_CUTOFF_HOUR = 12
+        internal const val MIN_DAY_BOUNDARY_HOUR = 0   // Midnight (no slack)
+        internal const val MAX_DAY_BOUNDARY_HOUR = 10  // 10am (max slack for night owls)
         internal const val MIN_FIXED_HOURS = 1
         internal const val MAX_FIXED_HOURS = 48
     }

android/app/src/main/java/com/github/quarck/calnotify/upcoming/UpcomingEventsLookahead.kt

@@ -25,74 +25,75 @@ import com.github.quarck.calnotify.utils.CNPlusClockInterface
 import java.util.Calendar
 
 /**
- * Calculates the cutoff time for the upcoming events lookahead window.
+ * Calculates the end time for the upcoming events lookahead window.
  * 
  * Supports two modes:
- * - "cutoff": Shows events until the next morning cutoff time (e.g., 10 AM tomorrow)
- * - "fixed": Shows events for a fixed number of hours ahead
+ * - "fixed" (default): Shows events for a fixed number of hours ahead
+ * - "day_boundary": Shows events until the next day boundary (e.g., 4 AM)
  * 
- * The cutoff mode is useful for seeing late-night events without showing all of tomorrow's events.
+ * The day boundary mode is for night owls who think in terms of "today" vs "tomorrow"
+ * rather than fixed hours. Before the boundary hour, you're still mentally in "yesterday";
+ * after it, you're planning "today".
  */
 class UpcomingEventsLookahead(
     private val settings: Settings,
     private val clock: CNPlusClockInterface
 ) {
 
     /**
-     * Get the cutoff time for the upcoming events window.
-     * Events with alertTime between now and this cutoff will be shown.
+     * Get the end time for the upcoming events lookahead window.
+     * Events with alertTime between now and this end time will be shown.
      * 
-     * @return The cutoff time in milliseconds since epoch
+     * @return The lookahead end time in milliseconds since epoch
      */
-    fun getCutoffTime(): Long {
+    fun getLookaheadEndTime(): Long {
         val now = clock.currentTimeMillis()
 
         return when (settings.upcomingEventsMode) {
-            MODE_FIXED -> calculateFixedCutoff(now)
-            MODE_CUTOFF -> calculateMorningCutoff(now)
-            else -> calculateMorningCutoff(now)  // Default to cutoff mode
+            MODE_DAY_BOUNDARY -> calculateDayBoundaryEndTime(now)
+            else -> calculateFixedEndTime(now)  // Default to fixed mode
         }
     }
 
     /**
      * Fixed hours lookahead: now + configured hours
      */
-    private fun calculateFixedCutoff(now: Long): Long {
+    private fun calculateFixedEndTime(now: Long): Long {
         val fixedHours = settings.upcomingEventsFixedHours
         return now + (fixedHours * Consts.HOUR_IN_MILLISECONDS)
     }
 
     /**
-     * Next morning cutoff: Shows events until the cutoff hour the next morning.
+     * Day boundary mode: before the boundary hour, show until today's boundary;
+     * after the boundary hour, show until tomorrow's boundary.
      * 
-     * If current time is before the cutoff hour, use today's cutoff.
-     * If current time is at or after the cutoff hour, use tomorrow's cutoff.
-     * 
-     * Example with cutoff at 10 AM:
-     * - At 2 AM: show events until 10 AM today
-     * - At 11 PM: show events until 10 AM tomorrow
+     * Example with boundary at 4 AM:
+     * - At 1 AM: show until 4 AM today (3 hours) - "still yesterday"
+     * - At 5 AM: show until 4 AM tomorrow (23 hours) - "today has begun"
+     * - At 10 PM: show until 4 AM tomorrow (6 hours) - "winding down"
      */
-    private fun calculateMorningCutoff(now: Long): Long {
-        val cutoffHour = settings.upcomingEventsCutoffHour
+    private fun calculateDayBoundaryEndTime(now: Long): Long {
+        val boundaryHour = settings.upcomingEventsDayBoundaryHour
+        
         val calendar = Calendar.getInstance().apply { timeInMillis = now }
         val currentHour = calendar.get(Calendar.HOUR_OF_DAY)
 
-        // Set to today at cutoff hour
-        calendar.set(Calendar.HOUR_OF_DAY, cutoffHour)
+        // Set to today at boundary hour
+        calendar.set(Calendar.HOUR_OF_DAY, boundaryHour)
         calendar.set(Calendar.MINUTE, 0)
         calendar.set(Calendar.SECOND, 0)
         calendar.set(Calendar.MILLISECOND, 0)
 
-        // If we're past the cutoff already, move to tomorrow
-        if (currentHour >= cutoffHour) {
+        // If we're at or past the boundary, use tomorrow's boundary
+        if (currentHour >= boundaryHour) {
             calendar.add(Calendar.DAY_OF_YEAR, 1)
         }
 
         return calendar.timeInMillis
     }
 
     companion object {
-        const val MODE_CUTOFF = "cutoff"
         const val MODE_FIXED = "fixed"
+        const val MODE_DAY_BOUNDARY = "day_boundary"
     }
 }

android/app/src/main/java/com/github/quarck/calnotify/upcoming/UpcomingEventsProvider.kt

@@ -32,7 +32,7 @@ import com.github.quarck.calnotify.utils.CNPlusClockInterface
  * 
  * "Upcoming" events are alerts that:
  * - Have not been handled yet (wasHandled = false)
- * - Have alertTime between now and the lookahead cutoff
+ * - Have alertTime within the configured lookahead window
  * 
  * This class is designed to be testable with injected dependencies.
  */
@@ -53,12 +53,12 @@ class UpcomingEventsProvider(
      */
     fun getUpcomingEvents(): List<EventAlertRecord> {
         val now = clock.currentTimeMillis()
-        val cutoffTime = lookahead.getCutoffTime()
+        val endTime = lookahead.getLookaheadEndTime()
 
-        DevLog.debug(LOG_TAG, "getUpcomingEvents: now=$now, cutoff=$cutoffTime")
+        DevLog.debug(LOG_TAG, "getUpcomingEvents: now=$now, endTime=$endTime")
 
         // Fetch alerts in the time range
-        val alerts = monitorStorage.getAlertsForAlertRange(now, cutoffTime)
+        val alerts = monitorStorage.getAlertsForAlertRange(now, endTime)
             .filter { !it.wasHandled }
             .sortedBy { it.alertTime }
 

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

@@ -602,33 +602,42 @@
 
     <!-- Upcoming Events Settings -->
     <string-array name="upcoming_events_mode_entries">
-        <item>@string/upcoming_events_mode_cutoff</item>
         <item>@string/upcoming_events_mode_fixed</item>
+        <item>@string/upcoming_events_mode_day_boundary</item>
     </string-array>
 
     <string-array name="upcoming_events_mode_values">
-        <item>cutoff</item>
         <item>fixed</item>
+        <item>day_boundary</item>
     </string-array>
 
-    <string-array name="upcoming_events_cutoff_hour_entries">
+    <!-- Day boundary hour: 0 (midnight) to 10 AM, default 4 AM -->
+    <string-array name="upcoming_events_day_boundary_hour_entries">
+        <item>12 AM (midnight)</item>
+        <item>1 AM</item>
+        <item>2 AM</item>
+        <item>3 AM</item>
+        <item>4 AM</item>
+        <item>5 AM</item>
         <item>6 AM</item>
         <item>7 AM</item>
         <item>8 AM</item>
         <item>9 AM</item>
         <item>10 AM</item>
-        <item>11 AM</item>
-        <item>12 PM</item>
     </string-array>
 
-    <string-array name="upcoming_events_cutoff_hour_values">
+    <string-array name="upcoming_events_day_boundary_hour_values">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+        <item>4</item>
+        <item>5</item>
         <item>6</item>
         <item>7</item>
         <item>8</item>
         <item>9</item>
         <item>10</item>
-        <item>11</item>
-        <item>12</item>
     </string-array>
 
     <string-array name="upcoming_events_fixed_hours_entries">
@@ -707,9 +716,9 @@
     <!-- Upcoming events settings -->
     <string name="upcoming_events_category">Upcoming Events</string>
     <string name="upcoming_events_mode_title">Lookahead Mode</string>
-    <string name="upcoming_events_mode_cutoff">Next morning cutoff</string>
     <string name="upcoming_events_mode_fixed">Fixed hours</string>
-    <string name="upcoming_events_cutoff_hour_title">Morning Cutoff Time</string>
+    <string name="upcoming_events_mode_day_boundary">Day boundary</string>
+    <string name="upcoming_events_day_boundary_hour_title">Day Boundary Hour</string>
     <string name="upcoming_events_fixed_hours_title">Hours to Look Ahead</string>
     <string name="navigation_settings_title">Navigation &amp; UI</string>
     <string name="use_new_navigation_ui_title">New Navigation UI</string>

android/app/src/main/res/xml/navigation_preferences.xml

@@ -24,15 +24,15 @@
             android:dialogTitle="@string/upcoming_events_mode_title"
             android:entries="@array/upcoming_events_mode_entries"
             android:entryValues="@array/upcoming_events_mode_values"
-            android:defaultValue="cutoff" />
+            android:defaultValue="fixed" />
 
         <ListPreference
-            android:key="upcoming_events_cutoff_hour"
-            android:title="@string/upcoming_events_cutoff_hour_title"
-            android:dialogTitle="@string/upcoming_events_cutoff_hour_title"
-            android:entries="@array/upcoming_events_cutoff_hour_entries"
-            android:entryValues="@array/upcoming_events_cutoff_hour_values"
-            android:defaultValue="10" />
+            android:key="upcoming_events_day_boundary_hour"
+            android:title="@string/upcoming_events_day_boundary_hour_title"
+            android:dialogTitle="@string/upcoming_events_day_boundary_hour_title"
+            android:entries="@array/upcoming_events_day_boundary_hour_entries"
+            android:entryValues="@array/upcoming_events_day_boundary_hour_values"
+            android:defaultValue="4" />
 
         <ListPreference
             android:key="upcoming_events_fixed_hours"