From 8d0b4f363366109eaa183105702a219753211205 Mon Sep 17 00:00:00 2001
From: William Harris <wharris@upscalews.com>
Date: Thu, 5 Mar 2026 00:23:02 +0000
Subject: [PATCH 1/5] docs: plan

---
 docs/README.md                             |   1 +
 docs/dev_todo/snoozed_until_filter_pill.md | 342 +++++++++++++++++++++
 2 files changed, 343 insertions(+)
 create mode 100644 docs/dev_todo/snoozed_until_filter_pill.md

diff --git a/docs/README.md b/docs/README.md
index d1fac1af..7bf4247a 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -61,6 +61,7 @@ Features and changes under consideration:
   - [Milestone 2: Pre-Actions](dev_todo/event_lookahead_milestone2_pre_actions.md) - Pre-mute, pre-snooze, pre-dismiss ✅
   - [Milestone 3: Filter Pills](dev_todo/event_lookahead_milestone3_filter_pills.md) - Status, Time, Calendar filters 🚧
   - [Upcoming Time Filter](dev_todo/upcoming_time_filter.md) - Time filter for Upcoming tab ([#216](https://github.com/williscool/CalendarNotification/issues/216))
+  - [Snoozed Until Filter Pill](dev_todo/snoozed_until_filter_pill.md) - Filter chip by snooze wake time ([#255](https://github.com/williscool/CalendarNotification/issues/255))
 - [Deprecated Features Removal](dev_todo/deprecated_features.md) - QuietHours, CalendarEditor
 - [Android Modernization](dev_todo/android_modernization.md) - Coroutines, Hilt DI opportunities
 - [Raise Min SDK](dev_todo/raise_min_sdk.md) - API 24 → 26+ considerations
diff --git a/docs/dev_todo/snoozed_until_filter_pill.md b/docs/dev_todo/snoozed_until_filter_pill.md
new file mode 100644
index 00000000..4ee88620
--- /dev/null
+++ b/docs/dev_todo/snoozed_until_filter_pill.md
@@ -0,0 +1,342 @@
+# Snoozed Until Filter Pill / Chip
+
+**Parent Doc:** [event_lookahead_milestone3_filter_pills.md](./event_lookahead_milestone3_filter_pills.md)  
+**GitHub Issue:** [#255](https://github.com/williscool/CalendarNotification/issues/255)
+
+## Overview
+
+Add a "Snoozed Until" filter chip to the Active tab that works like the existing Time filter chip, but filters on `event.snoozedUntil` instead of `event.instanceStartTime`.
+
+## Current State
+
+| Feature | Status |
+|---------|--------|
+| Time filter chip (Active/Dismissed) | ✅ Filters on `instanceStartTime` / `instanceEndTime` |
+| Status filter chip | ✅ Can filter to show only snoozed events |
+| Snoozed Until filter chip | ❌ Not implemented (this feature) |
+
+### Existing Pattern to Follow
+
+The Time filter has a clean, well-tested pattern:
+
+1. `TimeFilter` enum in `FilterState.kt` — filter options + `matches()` logic
+2. `TimeFilterBottomSheet` — bottom sheet UI with radio buttons + Apply
+3. `FilterState.timeFilter` field — holds the current selection
+4. `FilterType.TIME` — enables/disables the filter in `filterEvents()`
+5. `MainActivityModern.addTimeChip()` — creates the chip, wires up the bottom sheet
+6. `FilterStateTest` — comprehensive tests for matching + serialization
+
+The Snoozed Until filter follows this exact pattern.
+
+## Design Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Which tabs | **Active only** | Only active events can be snoozed (`snoozedUntil > 0`). Dismissed/Upcoming events don't have meaningful snooze times. |
+| Non-snoozed events | **Excluded when filter active** | When filter is not ALL, events with `snoozedUntil == 0` don't match — they have no snooze time to filter on. |
+| Tab-specific options | **No tab variation** | Unlike Time filter (which hides PAST on Dismissed, MONTH on Active), this only appears on Active so no tab logic needed. |
+| Bottom sheet vs dropdown | **Bottom sheet** | Matches Time filter UX. Single-select with Apply button. |
+| Interaction with Status filter | **Independent** | User can combine Status=Snoozed + SnoozedUntil=Today to see "events snoozed until today". Or use SnoozedUntil alone (implicitly shows only snoozed events since non-snoozed are excluded). |
+
+## UI Vision
+
+### Active Tab Chip Row (after this change)
+
+```
+┌──────────────────────────────────────────────────────────────────────────┐
+│  [ Calendar ▼ ]  [ Status ▼ ]  [ Time ▼ ]  [ Snoozed Until ▼ ]     →  │
+└──────────────────────────────────────────────────────────────────────────┘
+```
+
+### Snoozed Until Bottom Sheet
+
+```
+┌─────────────────────────────────────────────────┐
+│  Filter by Snoozed Until                        │
+├─────────────────────────────────────────────────┤
+│  ○  All                                         │
+│  ○  Snoozed until today                         │
+│  ○  Snoozed until this week                     │
+│  ○  Snoozed until this month                    │
+├─────────────────────────────────────────────────┤
+│              [ APPLY ]                          │
+└─────────────────────────────────────────────────┘
+```
+
+## Filter Definitions
+
+### SnoozedUntilFilter Options
+
+| Option | Logic | Notes |
+|--------|-------|-------|
+| ALL | No filter (default) | Shows all events regardless of snooze status |
+| SNOOZED_UNTIL_TODAY | `snoozedUntil > 0 && isToday(snoozedUntil, now)` | Events waking up today |
+| SNOOZED_UNTIL_THIS_WEEK | `snoozedUntil > 0 && isThisWeek(snoozedUntil, now)` | Events waking up this week |
+| SNOOZED_UNTIL_THIS_MONTH | `snoozedUntil > 0 && isThisMonth(snoozedUntil, now)` | Events waking up this month |
+
+All non-ALL options implicitly require `snoozedUntil > 0`, so non-snoozed events are excluded.
+
+Uses the same `DateTimeUtils.isToday()`, `isThisWeek()`, `isThisMonth()` helpers that `TimeFilter` already uses.
+
+---
+
+## Implementation Phases
+
+### Phase 1: SnoozedUntilFilter Enum + FilterState Integration
+
+**Goal:** Add the filter logic and state management.
+
+**Files to modify:**
+- `FilterState.kt`
+
+**Changes:**
+
+1. Add `SNOOZED_UNTIL` to `FilterType` enum:
+
+```kotlin
+enum class FilterType {
+    CALENDAR, STATUS, TIME, SNOOZED_UNTIL
+}
+```
+
+2. Add `SnoozedUntilFilter` enum (parallel to `TimeFilter`):
+
+```kotlin
+enum class SnoozedUntilFilter {
+    ALL,
+    SNOOZED_UNTIL_TODAY,
+    SNOOZED_UNTIL_THIS_WEEK,
+    SNOOZED_UNTIL_THIS_MONTH;
+
+    fun matches(event: EventAlertRecord, now: Long): Boolean {
+        if (this == ALL) return true
+        if (event.snoozedUntil == 0L) return false
+        return when (this) {
+            ALL -> true
+            SNOOZED_UNTIL_TODAY -> DateTimeUtils.isToday(event.snoozedUntil, now)
+            SNOOZED_UNTIL_THIS_WEEK -> DateTimeUtils.isThisWeek(event.snoozedUntil, now)
+            SNOOZED_UNTIL_THIS_MONTH -> DateTimeUtils.isThisMonth(event.snoozedUntil, now)
+        }
+    }
+}
+```
+
+3. Add `snoozedUntilFilter` field to `FilterState`:
+
+```kotlin
+data class FilterState(
+    val selectedCalendarIds: Set<Long>? = null,
+    val statusFilters: Set<StatusOption> = emptySet(),
+    val timeFilter: TimeFilter = TimeFilter.ALL,
+    val snoozedUntilFilter: SnoozedUntilFilter = SnoozedUntilFilter.ALL
+)
+```
+
+4. Add `matchesSnoozedUntil()` method to `FilterState`:
+
+```kotlin
+fun matchesSnoozedUntil(event: EventAlertRecord, now: Long): Boolean {
+    return snoozedUntilFilter.matches(event, now)
+}
+```
+
+5. Update `filterEvents()` to include `SNOOZED_UNTIL`:
+
+```kotlin
+(FilterType.SNOOZED_UNTIL !in apply || matchesSnoozedUntil(event, now))
+```
+
+6. Update `hasActiveFilters()`:
+
+```kotlin
+fun hasActiveFilters(): Boolean {
+    return selectedCalendarIds != null ||
+           statusFilters.isNotEmpty() ||
+           timeFilter != TimeFilter.ALL ||
+           snoozedUntilFilter != SnoozedUntilFilter.ALL
+}
+```
+
+7. Update `toDisplayString()` — add snoozed until section.
+
+8. Update `toBundle()` / `fromBundle()` — add `BUNDLE_SNOOZED_UNTIL_FILTER` serialization (same pattern as `BUNDLE_TIME_FILTER`).
+
+9. Update `filterEvents()` default `apply` set for active events to include `FilterType.SNOOZED_UNTIL`.
+
+---
+
+### Phase 2: Tests for SnoozedUntilFilter
+
+**Goal:** Add tests before building the UI.
+
+**Files to modify:**
+- `FilterStateTest.kt`
+
+**Tests to add** (mirroring existing `TimeFilter` tests):
+
+```
+SnoozedUntilFilter ALL matches all events
+SnoozedUntilFilter ALL matches non-snoozed events
+SnoozedUntilFilter SNOOZED_UNTIL_TODAY matches events snoozed until today
+SnoozedUntilFilter SNOOZED_UNTIL_TODAY excludes non-snoozed events
+SnoozedUntilFilter SNOOZED_UNTIL_THIS_WEEK matches events snoozed until this week
+SnoozedUntilFilter SNOOZED_UNTIL_THIS_MONTH matches events snoozed until this month
+FilterState matchesSnoozedUntil uses snoozedUntilFilter
+FilterState default has ALL snoozedUntilFilter
+toBundle and fromBundle round-trip snoozedUntilFilter
+toBundle and fromBundle round-trip all snoozedUntilFilter values
+hasActiveFilters returns true when snoozedUntilFilter is not ALL
+toDisplayString shows snoozed until filter when not ALL
+```
+
+---
+
+### Phase 3: Bottom Sheet UI
+
+**Goal:** Create the bottom sheet for selecting snoozed until filter options.
+
+**New files:**
+- `SnoozedUntilFilterBottomSheet.kt` (parallel to `TimeFilterBottomSheet.kt`)
+- `layout/bottom_sheet_snoozed_until_filter.xml` (parallel to `bottom_sheet_time_filter.xml`)
+
+**Strings to add** (in `strings.xml`):
+
+```xml
+<string name="filter_snoozed_until">Snoozed Until</string>
+<string name="filter_snoozed_until_all">All</string>
+<string name="filter_snoozed_until_today">Snoozed until today</string>
+<string name="filter_snoozed_until_this_week">Snoozed until this week</string>
+<string name="filter_snoozed_until_this_month">Snoozed until this month</string>
+```
+
+The bottom sheet follows the exact same pattern as `TimeFilterBottomSheet`:
+- `BottomSheetDialogFragment` with `RadioGroup`
+- `Fragment Result API` for communicating selection back
+- `REQUEST_KEY` / `RESULT_FILTER` constants
+
+---
+
+### Phase 4: Wire Up Chip in MainActivityModern
+
+**Goal:** Add the chip to the Active tab and connect it to the bottom sheet.
+
+**Files to modify:**
+- `MainActivityModern.kt`
+
+**Changes:**
+
+1. Add `addSnoozedUntilChip()` method (parallel to `addTimeChip()`):
+   - Creates chip with current filter text
+   - Shows `SnoozedUntilFilterBottomSheet` on click
+
+2. Add `getSnoozedUntilChipText()` method (parallel to `getTimeChipText()`).
+
+3. Add `showSnoozedUntilFilterBottomSheet()` method.
+
+4. Add fragment result listener in `setupFilterResultListeners()` for `SnoozedUntilFilterBottomSheet.REQUEST_KEY`.
+
+5. Update `updateFilterChipsForCurrentTab()` — add `addSnoozedUntilChip()` to the Active tab case:
+
+```kotlin
+R.id.activeEventsFragment -> {
+    addCalendarChip()
+    addStatusChip()
+    addTimeChip(TimeFilterBottomSheet.TabType.ACTIVE)
+    addSnoozedUntilChip()  // NEW
+}
+```
+
+---
+
+### Phase 5: Apply Filter in Fragment
+
+**Goal:** Active events fragment applies the snoozed until filter.
+
+**Files to modify:**
+- `ActiveEventsFragment.kt`
+
+The fragment's `loadEvents()` already calls `filterState.filterEvents()` which applies all `FilterType`s in its `apply` set. Just need to add `FilterType.SNOOZED_UNTIL` to the active tab's default apply set (done in Phase 1).
+
+---
+
+## Files Summary
+
+### New Files
+
+| File | Phase | Purpose |
+|------|-------|---------|
+| `SnoozedUntilFilterBottomSheet.kt` | 3 | Bottom sheet for snoozed until filter |
+| `bottom_sheet_snoozed_until_filter.xml` | 3 | Bottom sheet layout |
+
+### Modified Files
+
+| File | Phase | Changes |
+|------|-------|---------|
+| `FilterState.kt` | 1 | Add `SnoozedUntilFilter` enum, `FilterType.SNOOZED_UNTIL`, `FilterState.snoozedUntilFilter` field, matching/serialization |
+| `FilterStateTest.kt` | 2 | Tests for SnoozedUntilFilter matching + serialization |
+| `strings.xml` | 3 | Add snoozed until filter strings |
+| `MainActivityModern.kt` | 4 | Add chip, bottom sheet wiring, result listener |
+| `ActiveEventsFragment.kt` | 5 | Include `SNOOZED_UNTIL` in filter apply set (if not already default) |
+
+### Unchanged Files
+
+| File | Reason |
+|------|--------|
+| `TimeFilterBottomSheet.kt` | Separate filter, no changes needed |
+| `DismissedEventsFragment.kt` | No snoozed until chip on Dismissed tab |
+| `UpcomingEventsFragment.kt` | No snoozed until chip on Upcoming tab |
+| `SnoozeAllActivity.kt` | Future work — see snooze_all_filter_pills.md |
+
+---
+
+## Testing Strategy
+
+### Unit Tests (Phase 2)
+
+All in `FilterStateTest.kt` — Robolectric tests matching the existing pattern:
+
+- `SnoozedUntilFilter.matches()` for each enum value
+- Non-snoozed event exclusion (snoozedUntil == 0)
+- `FilterState.matchesSnoozedUntil()` delegation
+- Bundle round-trip serialization
+- `hasActiveFilters()` / `toDisplayString()` integration
+
+### Manual Testing Checklist
+
+- [ ] "Snoozed Until" chip appears only on Active tab
+- [ ] Chip does NOT appear on Upcoming or Dismissed tabs
+- [ ] Tapping chip opens bottom sheet with 4 radio options
+- [ ] Selecting option + Apply filters the event list
+- [ ] Non-snoozed events are hidden when filter is not "All"
+- [ ] Chip text updates to reflect current selection
+- [ ] Switching tabs clears the snoozed until filter
+- [ ] Filter survives app backgrounding (via `onSaveInstanceState`)
+- [ ] Filter clears on app restart
+- [ ] Combines correctly with Status filter (e.g., Status=Snoozed + SnoozedUntil=Today)
+- [ ] Combines correctly with Time filter and Calendar filter
+- [ ] "Snoozed until today" correctly includes events snoozed until later today
+- [ ] "Snoozed until this week" correctly uses locale-aware week boundaries
+
+---
+
+## Edge Cases
+
+| Scenario | Expected Behavior |
+|----------|-------------------|
+| No snoozed events, filter set to "Today" | Empty list (all events filtered out) |
+| Event snoozed until exactly midnight boundary | `isToday()` handles this correctly (same as Time filter) |
+| Filter active, then event snooze expires | Event disappears from filtered list on next refresh |
+| All filters combined (Calendar + Status + Time + SnoozedUntil) | AND logic across all filter types |
+| Filter set, then switch to Dismissed tab and back | Filter cleared (same as all other filters) |
+
+---
+
+## Implementation Order
+
+1. **Phase 1** — `SnoozedUntilFilter` enum + `FilterState` integration
+2. **Phase 2** — Tests (run before UI work)
+3. **Phase 3** — Bottom sheet UI + strings
+4. **Phase 4** — Wire up chip in `MainActivityModern`
+5. **Phase 5** — Verify fragment filtering works (may be zero changes if default apply set is updated in Phase 1)
+
+Each phase is independently testable. Phases 1-2 are purely logic/tests with no UI changes.

From f58c95d1b2f7e70da7a26264bf76438708ddfa01 Mon Sep 17 00:00:00 2001
From: William Harris <wharris@upscalews.com>
Date: Thu, 5 Mar 2026 01:54:53 +0000
Subject: [PATCH 2/5] docs: new features

---
 docs/dev_todo/snoozed_until_filter_pill.md | 468 ++++++++++++++-------
 1 file changed, 317 insertions(+), 151 deletions(-)

diff --git a/docs/dev_todo/snoozed_until_filter_pill.md b/docs/dev_todo/snoozed_until_filter_pill.md
index 4ee88620..ad8da0e3 100644
--- a/docs/dev_todo/snoozed_until_filter_pill.md
+++ b/docs/dev_todo/snoozed_until_filter_pill.md
@@ -5,7 +5,7 @@
 
 ## Overview
 
-Add a "Snoozed Until" filter chip to the Active tab that works like the existing Time filter chip, but filters on `event.snoozedUntil` instead of `event.instanceStartTime`.
+Add a "Snoozed Until" filter chip to the Active tab that filters events based on when their snooze expires (`event.snoozedUntil`). Features configurable interval presets, a before/after direction toggle, and custom period / specific date-time pickers — mirroring patterns from the Upcoming Time Filter and View Event snooze dialogs.
 
 ## Current State
 
@@ -13,30 +13,36 @@ Add a "Snoozed Until" filter chip to the Active tab that works like the existing
 |---------|--------|
 | Time filter chip (Active/Dismissed) | ✅ Filters on `instanceStartTime` / `instanceEndTime` |
 | Status filter chip | ✅ Can filter to show only snoozed events |
+| Upcoming time filter | ✅ Configurable presets, persisted to Settings |
+| View Event "For a custom period" | ✅ `TimeIntervalPickerController` + quick presets dialog |
+| View Event "Until a specific time and date" | ✅ `DatePicker` → `TimePicker` two-step flow |
 | Snoozed Until filter chip | ❌ Not implemented (this feature) |
 
-### Existing Pattern to Follow
+### Existing Patterns to Reuse
 
-The Time filter has a clean, well-tested pattern:
-
-1. `TimeFilter` enum in `FilterState.kt` — filter options + `matches()` logic
-2. `TimeFilterBottomSheet` — bottom sheet UI with radio buttons + Apply
-3. `FilterState.timeFilter` field — holds the current selection
-4. `FilterType.TIME` — enables/disables the filter in `filterEvents()`
-5. `MainActivityModern.addTimeChip()` — creates the chip, wires up the bottom sheet
-6. `FilterStateTest` — comprehensive tests for matching + serialization
-
-The Snoozed Until filter follows this exact pattern.
+| Pattern | Source | How we use it |
+|---------|--------|---------------|
+| Dynamic radio button presets | `UpcomingTimeFilterBottomSheet` | Generate interval options from configurable presets |
+| Preset parsing/formatting | `PreferenceUtils.parseSnoozePresets()` / `formatPresetHumanReadable()` | Parse `"12h, 1d, 3d, 7d, 4w"` format |
+| Custom period preference | `UpcomingTimePresetPreferenceX` / `SnoozePresetPreferenceX` | Settings UI for configuring presets |
+| Duration picker | `TimeIntervalPickerController` + `dialog_interval_picker.xml` | "For a custom period" option |
+| Date + time picker | `dialog_date_picker.xml` → `dialog_time_picker.xml` | "Until a specific time and date" option |
+| Fragment Result API | `TimeFilterBottomSheet`, `UpcomingTimeFilterBottomSheet` | Communicate selection back to activity |
+| In-memory filter state | `FilterState` + Bundle serialization | Filter clears on tab switch, survives rotation |
 
 ## Design Decisions
 
 | Decision | Choice | Rationale |
 |----------|--------|-----------|
-| Which tabs | **Active only** | Only active events can be snoozed (`snoozedUntil > 0`). Dismissed/Upcoming events don't have meaningful snooze times. |
-| Non-snoozed events | **Excluded when filter active** | When filter is not ALL, events with `snoozedUntil == 0` don't match — they have no snooze time to filter on. |
-| Tab-specific options | **No tab variation** | Unlike Time filter (which hides PAST on Dismissed, MONTH on Active), this only appears on Active so no tab logic needed. |
-| Bottom sheet vs dropdown | **Bottom sheet** | Matches Time filter UX. Single-select with Apply button. |
-| Interaction with Status filter | **Independent** | User can combine Status=Snoozed + SnoozedUntil=Today to see "events snoozed until today". Or use SnoozedUntil alone (implicitly shows only snoozed events since non-snoozed are excluded). |
+| Which tabs | **Active only** | Only active events can be snoozed. Dismissed/Upcoming don't have meaningful `snoozedUntil`. |
+| Non-snoozed events | **Excluded when filter active** | Events with `snoozedUntil == 0` don't match any non-ALL filter — they have no snooze time to filter on. |
+| Preset intervals | **Configurable via Settings** | Follow `UpcomingTimeFilterBottomSheet` pattern — presets parsed from comma-separated string using `PreferenceUtils`. |
+| Default presets | **12h, 1d, 3d, 7d, 4w** | Practical defaults for "show events waking up within X". |
+| Settings location | **Navigation & UI → Active Events** (new category) | Parallel to the existing "Upcoming Events" category. |
+| Filter persistence | **In-memory (`FilterState`)** | Same as Time filter — clears on tab switch, survives rotation. Presets live in Settings, but the current _selection_ is in-memory. |
+| Before/After | **Toggle in bottom sheet** | "Before" = `snoozedUntil <= now + interval`. "After" = `snoozedUntil > now + interval`. |
+| Custom period | **Reuse `TimeIntervalPickerController`** | Same widget used by View Event Activity's "For a custom period". |
+| Specific time | **Reuse `DatePicker` → `TimePicker` flow** | Same two-step flow used by View Event Activity's "Until a specific time and date". |
 
 ## UI Vision
 
@@ -54,169 +60,288 @@ The Snoozed Until filter follows this exact pattern.
 ┌─────────────────────────────────────────────────┐
 │  Filter by Snoozed Until                        │
 ├─────────────────────────────────────────────────┤
+│  [ ● Before | ○ After ]          ← toggle       │
+├─────────────────────────────────────────────────┤
 │  ○  All                                         │
-│  ○  Snoozed until today                         │
-│  ○  Snoozed until this week                     │
-│  ○  Snoozed until this month                    │
+│  ─────────────────────────────────              │
+│  ○  12 hours                                    │
+│  ●  1 day                          ← current   │
+│  ○  3 days                                      │
+│  ○  7 days                                      │
+│  ○  4 weeks                                     │
+│  ─────────────────────────────────              │
+│  ○  For a custom period...                      │
+│  ○  Until a specific time and date...           │
 ├─────────────────────────────────────────────────┤
 │              [ APPLY ]                          │
 └─────────────────────────────────────────────────┘
 ```
 
-## Filter Definitions
-
-### SnoozedUntilFilter Options
+**Behavior:**
 
-| Option | Logic | Notes |
-|--------|-------|-------|
-| ALL | No filter (default) | Shows all events regardless of snooze status |
-| SNOOZED_UNTIL_TODAY | `snoozedUntil > 0 && isToday(snoozedUntil, now)` | Events waking up today |
-| SNOOZED_UNTIL_THIS_WEEK | `snoozedUntil > 0 && isThisWeek(snoozedUntil, now)` | Events waking up this week |
-| SNOOZED_UNTIL_THIS_MONTH | `snoozedUntil > 0 && isThisMonth(snoozedUntil, now)` | Events waking up this month |
+- **Before + preset**: Show events where `snoozedUntil <= now + preset` (waking up within X)
+- **After + preset**: Show events where `snoozedUntil > now + preset` (won't wake up for at least X)
+- **Before + specific time**: Show events where `snoozedUntil <= specificTime`
+- **After + specific time**: Show events where `snoozedUntil > specificTime`
+- **All**: No filter regardless of direction toggle
 
-All non-ALL options implicitly require `snoozedUntil > 0`, so non-snoozed events are excluded.
+**Custom period flow:** Selecting "For a custom period..." opens the `TimeIntervalPickerController` dialog (same as snooze). The entered duration replaces the preset selection.
 
-Uses the same `DateTimeUtils.isToday()`, `isThisWeek()`, `isThisMonth()` helpers that `TimeFilter` already uses.
+**Specific time flow:** Selecting "Until a specific time and date..." opens the DatePicker → TimePicker two-step flow (same as snooze). The chosen absolute timestamp replaces the preset selection.
 
----
-
-## Implementation Phases
+### Chip Text Examples
 
-### Phase 1: SnoozedUntilFilter Enum + FilterState Integration
+| State | Chip Text |
+|-------|-----------|
+| No filter | "Snoozed Until" |
+| Before 1 day | "Snoozed ≤ 1 day" |
+| After 7 days | "Snoozed > 7 days" |
+| Before specific time | "Snoozed ≤ Mar 15 3:00 PM" |
+| After custom 6h | "Snoozed > 6 hours" |
 
-**Goal:** Add the filter logic and state management.
+---
 
-**Files to modify:**
-- `FilterState.kt`
+## Filter Definitions
 
-**Changes:**
+### SnoozedUntilFilterConfig
 
-1. Add `SNOOZED_UNTIL` to `FilterType` enum:
+Unlike the simple `TimeFilter` enum, this filter needs to represent multiple modes and a direction. Stored as a data class in `FilterState`:
 
 ```kotlin
-enum class FilterType {
-    CALENDAR, STATUS, TIME, SNOOZED_UNTIL
+data class SnoozedUntilFilterConfig(
+    val mode: SnoozedUntilFilterMode = SnoozedUntilFilterMode.ALL,
+    val direction: FilterDirection = FilterDirection.BEFORE,
+    val valueMillis: Long = 0L
+)
+
+enum class SnoozedUntilFilterMode {
+    ALL,            // no filter (default)
+    PRESET,         // from configurable interval presets; valueMillis = duration
+    CUSTOM_PERIOD,  // user-entered duration; valueMillis = duration
+    SPECIFIC_TIME   // user-picked date+time; valueMillis = absolute timestamp
 }
+
+enum class FilterDirection { BEFORE, AFTER }
 ```
 
-2. Add `SnoozedUntilFilter` enum (parallel to `TimeFilter`):
+### Matching Logic
 
 ```kotlin
-enum class SnoozedUntilFilter {
-    ALL,
-    SNOOZED_UNTIL_TODAY,
-    SNOOZED_UNTIL_THIS_WEEK,
-    SNOOZED_UNTIL_THIS_MONTH;
-
-    fun matches(event: EventAlertRecord, now: Long): Boolean {
-        if (this == ALL) return true
-        if (event.snoozedUntil == 0L) return false
-        return when (this) {
-            ALL -> true
-            SNOOZED_UNTIL_TODAY -> DateTimeUtils.isToday(event.snoozedUntil, now)
-            SNOOZED_UNTIL_THIS_WEEK -> DateTimeUtils.isThisWeek(event.snoozedUntil, now)
-            SNOOZED_UNTIL_THIS_MONTH -> DateTimeUtils.isThisMonth(event.snoozedUntil, now)
-        }
+fun matches(event: EventAlertRecord, now: Long): Boolean {
+    if (mode == ALL) return true
+    if (event.snoozedUntil == 0L) return false
+
+    val threshold = when (mode) {
+        ALL -> return true
+        PRESET, CUSTOM_PERIOD -> now + valueMillis
+        SPECIFIC_TIME -> valueMillis
+    }
+
+    return when (direction) {
+        BEFORE -> event.snoozedUntil <= threshold
+        AFTER -> event.snoozedUntil > threshold
     }
 }
 ```
 
-3. Add `snoozedUntilFilter` field to `FilterState`:
+### Bundle Serialization
+
+Three values to persist: `mode.ordinal` (Int), `direction.ordinal` (Int), `valueMillis` (Long). Same pattern as other `FilterState` fields.
+
+---
+
+## Settings: Active Events Category
+
+New category in `navigation_preferences.xml`, parallel to the existing "Upcoming Events" category:
+
+```xml
+<PreferenceCategory
+    android:title="@string/active_events_category"
+    android:key="_active_events"
+    android:dependency="use_new_navigation_ui">
+
+    <com.github.quarck.calnotify.prefs.SnoozedUntilPresetPreferenceX
+        android:key="pref_snoozed_until_presets"
+        android:title="@string/snoozed_until_presets_title"
+        android:summary="@string/snoozed_until_presets_summary"
+        android:defaultValue="12h, 1d, 3d, 7d, 4w" />
+
+</PreferenceCategory>
+```
+
+### Settings Properties
 
 ```kotlin
-data class FilterState(
-    val selectedCalendarIds: Set<Long>? = null,
-    val statusFilters: Set<StatusOption> = emptySet(),
-    val timeFilter: TimeFilter = TimeFilter.ALL,
-    val snoozedUntilFilter: SnoozedUntilFilter = SnoozedUntilFilter.ALL
-)
+// In Settings.kt
+private const val SNOOZED_UNTIL_PRESETS_KEY = "pref_snoozed_until_presets"
+const val DEFAULT_SNOOZED_UNTIL_PRESETS = "12h, 1d, 3d, 7d, 4w"
+
+val snoozedUntilPresetsRaw: String
+    get() = getString(SNOOZED_UNTIL_PRESETS_KEY, DEFAULT_SNOOZED_UNTIL_PRESETS)
+
+val snoozedUntilPresets: LongArray
+    get() {
+        val ret = PreferenceUtils.parseSnoozePresets(snoozedUntilPresetsRaw)
+            ?: PreferenceUtils.parseSnoozePresets(DEFAULT_SNOOZED_UNTIL_PRESETS)
+            ?: return longArrayOf()
+        return ret.filter { it > 0 }.toLongArray()
+    }
 ```
 
-4. Add `matchesSnoozedUntil()` method to `FilterState`:
+Uses the same `PreferenceUtils.parseSnoozePresets()` / `formatPresetHumanReadable()` infrastructure as snooze presets and upcoming time presets. No max lookahead clamping needed (unlike upcoming, there's no scan window limit for snoozed events).
+
+The `SnoozedUntilPresetPreferenceX` can either reuse or extend the existing `UpcomingTimePresetPreferenceX` / `SnoozePresetPreferenceX` pattern — custom `DialogPreference` with EditText, parsing via `PreferenceUtils`.
+
+---
+
+## Implementation Phases
+
+### Phase 1: Settings Infrastructure
+
+**Goal:** Add configurable presets and the Active Events settings category.
+
+**Files to modify:**
+- `Settings.kt` — Add `snoozedUntilPresetsRaw`, `snoozedUntilPresets`
+- `navigation_preferences.xml` — Add "Active Events" category with preset preference
+- `strings.xml` — Add `active_events_category`, `snoozed_until_presets_title`, `snoozed_until_presets_summary`
+
+**New files:**
+- `SnoozedUntilPresetPreferenceX.kt` — Custom preference (or generalize the existing `UpcomingTimePresetPreferenceX`)
+
+---
+
+### Phase 2: Filter State Model
+
+**Goal:** Add `SnoozedUntilFilterConfig` to `FilterState` with matching, serialization, and display.
+
+**Files to modify:**
+- `FilterState.kt`
+
+**Changes:**
+
+1. Add `SNOOZED_UNTIL` to `FilterType` enum:
 
 ```kotlin
-fun matchesSnoozedUntil(event: EventAlertRecord, now: Long): Boolean {
-    return snoozedUntilFilter.matches(event, now)
+enum class FilterType {
+    CALENDAR, STATUS, TIME, SNOOZED_UNTIL
 }
 ```
 
-5. Update `filterEvents()` to include `SNOOZED_UNTIL`:
+2. Add `FilterDirection` enum and `SnoozedUntilFilterMode` enum.
+
+3. Add `SnoozedUntilFilterConfig` data class with `matches()` method.
+
+4. Add `snoozedUntilFilter: SnoozedUntilFilterConfig` field to `FilterState`.
+
+5. Add `matchesSnoozedUntil()` method to `FilterState`.
+
+6. Update `filterEvents()` inline fun to include `SNOOZED_UNTIL`:
 
 ```kotlin
 (FilterType.SNOOZED_UNTIL !in apply || matchesSnoozedUntil(event, now))
 ```
 
-6. Update `hasActiveFilters()`:
+7. Update `hasActiveFilters()`:
 
 ```kotlin
-fun hasActiveFilters(): Boolean {
-    return selectedCalendarIds != null ||
-           statusFilters.isNotEmpty() ||
-           timeFilter != TimeFilter.ALL ||
-           snoozedUntilFilter != SnoozedUntilFilter.ALL
-}
+snoozedUntilFilter.mode != SnoozedUntilFilterMode.ALL
 ```
 
-7. Update `toDisplayString()` — add snoozed until section.
+8. Update `toDisplayString()` — show direction + value (e.g., "Snoozed ≤ 1 day").
 
-8. Update `toBundle()` / `fromBundle()` — add `BUNDLE_SNOOZED_UNTIL_FILTER` serialization (same pattern as `BUNDLE_TIME_FILTER`).
+9. Update `toBundle()` / `fromBundle()` — serialize `mode.ordinal`, `direction.ordinal`, `valueMillis`.
 
-9. Update `filterEvents()` default `apply` set for active events to include `FilterType.SNOOZED_UNTIL`.
+10. Update active events `filterEvents()` default apply set to include `FilterType.SNOOZED_UNTIL`.
 
 ---
 
-### Phase 2: Tests for SnoozedUntilFilter
+### Phase 3: Tests
 
-**Goal:** Add tests before building the UI.
+**Goal:** Tests before building UI.
 
 **Files to modify:**
 - `FilterStateTest.kt`
 
-**Tests to add** (mirroring existing `TimeFilter` tests):
+**Tests to add:**
 
 ```
-SnoozedUntilFilter ALL matches all events
-SnoozedUntilFilter ALL matches non-snoozed events
-SnoozedUntilFilter SNOOZED_UNTIL_TODAY matches events snoozed until today
-SnoozedUntilFilter SNOOZED_UNTIL_TODAY excludes non-snoozed events
-SnoozedUntilFilter SNOOZED_UNTIL_THIS_WEEK matches events snoozed until this week
-SnoozedUntilFilter SNOOZED_UNTIL_THIS_MONTH matches events snoozed until this month
-FilterState matchesSnoozedUntil uses snoozedUntilFilter
-FilterState default has ALL snoozedUntilFilter
-toBundle and fromBundle round-trip snoozedUntilFilter
-toBundle and fromBundle round-trip all snoozedUntilFilter values
-hasActiveFilters returns true when snoozedUntilFilter is not ALL
-toDisplayString shows snoozed until filter when not ALL
+SnoozedUntilFilter:
+- ALL matches all events including non-snoozed
+- ALL matches non-snoozed events (snoozedUntil == 0)
+- PRESET BEFORE matches events snoozed until within interval
+- PRESET BEFORE excludes events snoozed until beyond interval
+- PRESET BEFORE excludes non-snoozed events
+- PRESET AFTER matches events snoozed until beyond interval
+- PRESET AFTER excludes events snoozed until within interval
+- PRESET AFTER excludes non-snoozed events
+- CUSTOM_PERIOD works same as PRESET (both use now + valueMillis)
+- SPECIFIC_TIME BEFORE matches events snoozed until before timestamp
+- SPECIFIC_TIME BEFORE excludes events snoozed until after timestamp
+- SPECIFIC_TIME AFTER matches events snoozed until after timestamp
+- SPECIFIC_TIME AFTER excludes events snoozed until before timestamp
+- boundary: event.snoozedUntil == threshold with BEFORE matches (<=)
+- boundary: event.snoozedUntil == threshold with AFTER does not match (>)
+
+FilterState integration:
+- matchesSnoozedUntil delegates to config
+- default has ALL snoozedUntilFilter
+- hasActiveFilters true when snoozedUntilFilter is not ALL
+- toDisplayString shows snoozed until when not ALL
+
+Serialization:
+- toBundle/fromBundle round-trip for each mode
+- toBundle/fromBundle round-trip preserves direction
+- toBundle/fromBundle round-trip preserves valueMillis
+- fromBundle with null returns default
 ```
 
 ---
 
-### Phase 3: Bottom Sheet UI
+### Phase 4: Bottom Sheet UI
 
-**Goal:** Create the bottom sheet for selecting snoozed until filter options.
+**Goal:** Create the bottom sheet with dynamic presets, before/after toggle, and custom options.
 
 **New files:**
-- `SnoozedUntilFilterBottomSheet.kt` (parallel to `TimeFilterBottomSheet.kt`)
-- `layout/bottom_sheet_snoozed_until_filter.xml` (parallel to `bottom_sheet_time_filter.xml`)
+- `SnoozedUntilFilterBottomSheet.kt`
+- `layout/bottom_sheet_snoozed_until_filter.xml`
+
+**Bottom sheet structure** (follows `UpcomingTimeFilterBottomSheet` dynamic pattern):
+
+1. **Header** — "Filter by Snoozed Until"
+2. **Before/After toggle** — `RadioGroup` or `MaterialButtonToggleGroup` with two options
+3. **"All" radio button** — clears filter
+4. **Divider**
+5. **Dynamic preset radio buttons** — generated from `settings.snoozedUntilPresets` using `PreferenceUtils.formatPresetHumanReadable()` (same as `UpcomingTimeFilterBottomSheet`)
+6. **Divider**
+7. **"For a custom period..." radio button** — on select, opens `TimeIntervalPickerController` dialog (reuse from `ViewEventActivityNoRecents.customSnoozeShowDialog`)
+8. **"Until a specific time and date..." radio button** — on select, opens DatePicker → TimePicker flow (reuse from `ViewEventActivityNoRecents.snoozeUntilShowDatePickerDialog`)
+9. **Apply button** — sends result via Fragment Result API
+
+**Result bundle:**
 
-**Strings to add** (in `strings.xml`):
+```kotlin
+companion object {
+    const val REQUEST_KEY = "snoozed_until_filter_request"
+    const val RESULT_MODE = "result_mode"        // SnoozedUntilFilterMode ordinal
+    const val RESULT_DIRECTION = "result_direction" // FilterDirection ordinal
+    const val RESULT_VALUE = "result_value"       // Long — duration or timestamp
+}
+```
+
+**Strings to add:**
 
 ```xml
 <string name="filter_snoozed_until">Snoozed Until</string>
 <string name="filter_snoozed_until_all">All</string>
-<string name="filter_snoozed_until_today">Snoozed until today</string>
-<string name="filter_snoozed_until_this_week">Snoozed until this week</string>
-<string name="filter_snoozed_until_this_month">Snoozed until this month</string>
+<string name="filter_snoozed_until_before">Before</string>
+<string name="filter_snoozed_until_after">After</string>
+<string name="filter_snoozed_until_custom_period">For a custom period…</string>
+<string name="filter_snoozed_until_specific_time">Until a specific time and date…</string>
 ```
 
-The bottom sheet follows the exact same pattern as `TimeFilterBottomSheet`:
-- `BottomSheetDialogFragment` with `RadioGroup`
-- `Fragment Result API` for communicating selection back
-- `REQUEST_KEY` / `RESULT_FILTER` constants
-
 ---
 
-### Phase 4: Wire Up Chip in MainActivityModern
+### Phase 5: Wire Up Chip in MainActivityModern
 
 **Goal:** Add the chip to the Active tab and connect it to the bottom sheet.
 
@@ -225,17 +350,20 @@ The bottom sheet follows the exact same pattern as `TimeFilterBottomSheet`:
 
 **Changes:**
 
-1. Add `addSnoozedUntilChip()` method (parallel to `addTimeChip()`):
-   - Creates chip with current filter text
-   - Shows `SnoozedUntilFilterBottomSheet` on click
+1. `addSnoozedUntilChip()` — creates chip, shows `SnoozedUntilFilterBottomSheet` on click.
 
-2. Add `getSnoozedUntilChipText()` method (parallel to `getTimeChipText()`).
+2. `getSnoozedUntilChipText()` — returns text based on current `filterState.snoozedUntilFilter`:
+   - ALL → "Snoozed Until"
+   - BEFORE + preset/custom → "Snoozed ≤ {formatted duration}"
+   - AFTER + preset/custom → "Snoozed > {formatted duration}"
+   - BEFORE + specific → "Snoozed ≤ {formatted date}"
+   - AFTER + specific → "Snoozed > {formatted date}"
 
-3. Add `showSnoozedUntilFilterBottomSheet()` method.
+3. `showSnoozedUntilFilterBottomSheet()` — instantiates and shows the bottom sheet.
 
-4. Add fragment result listener in `setupFilterResultListeners()` for `SnoozedUntilFilterBottomSheet.REQUEST_KEY`.
+4. Fragment result listener in `setupFilterResultListeners()` for `SnoozedUntilFilterBottomSheet.REQUEST_KEY` — builds `SnoozedUntilFilterConfig` from result bundle, updates `filterState`, refreshes chips + fragment.
 
-5. Update `updateFilterChipsForCurrentTab()` — add `addSnoozedUntilChip()` to the Active tab case:
+5. Update `updateFilterChipsForCurrentTab()`:
 
 ```kotlin
 R.id.activeEventsFragment -> {
@@ -248,14 +376,14 @@ R.id.activeEventsFragment -> {
 
 ---
 
-### Phase 5: Apply Filter in Fragment
+### Phase 6: Verify Fragment Filtering
 
-**Goal:** Active events fragment applies the snoozed until filter.
+**Goal:** Ensure Active events fragment applies the snoozed until filter.
 
-**Files to modify:**
+**Files to verify:**
 - `ActiveEventsFragment.kt`
 
-The fragment's `loadEvents()` already calls `filterState.filterEvents()` which applies all `FilterType`s in its `apply` set. Just need to add `FilterType.SNOOZED_UNTIL` to the active tab's default apply set (done in Phase 1).
+The fragment's `loadEvents()` calls `filterState.filterEvents()` which applies all `FilterType`s in its `apply` set. Adding `FilterType.SNOOZED_UNTIL` to the active tab's default apply set (done in Phase 2) should be sufficient. If the active tab currently uses an explicit set that doesn't include `SNOOZED_UNTIL`, update it.
 
 ---
 
@@ -265,57 +393,90 @@ The fragment's `loadEvents()` already calls `filterState.filterEvents()` which a
 
 | File | Phase | Purpose |
 |------|-------|---------|
-| `SnoozedUntilFilterBottomSheet.kt` | 3 | Bottom sheet for snoozed until filter |
-| `bottom_sheet_snoozed_until_filter.xml` | 3 | Bottom sheet layout |
+| `SnoozedUntilFilterBottomSheet.kt` | 4 | Bottom sheet with presets, toggle, custom pickers |
+| `bottom_sheet_snoozed_until_filter.xml` | 4 | Bottom sheet layout |
+| `SnoozedUntilPresetPreferenceX.kt` | 1 | Custom Settings preference for presets (or generalize existing) |
 
 ### Modified Files
 
 | File | Phase | Changes |
 |------|-------|---------|
-| `FilterState.kt` | 1 | Add `SnoozedUntilFilter` enum, `FilterType.SNOOZED_UNTIL`, `FilterState.snoozedUntilFilter` field, matching/serialization |
-| `FilterStateTest.kt` | 2 | Tests for SnoozedUntilFilter matching + serialization |
-| `strings.xml` | 3 | Add snoozed until filter strings |
-| `MainActivityModern.kt` | 4 | Add chip, bottom sheet wiring, result listener |
-| `ActiveEventsFragment.kt` | 5 | Include `SNOOZED_UNTIL` in filter apply set (if not already default) |
+| `Settings.kt` | 1 | `snoozedUntilPresetsRaw`, `snoozedUntilPresets` |
+| `navigation_preferences.xml` | 1 | New "Active Events" category with preset preference |
+| `FilterState.kt` | 2 | `SnoozedUntilFilterConfig`, `FilterDirection`, `SnoozedUntilFilterMode`, `FilterType.SNOOZED_UNTIL`, matching/serialization |
+| `FilterStateTest.kt` | 3 | Tests for all matching modes, directions, serialization |
+| `strings.xml` | 1, 4 | Settings strings, bottom sheet strings, chip text strings |
+| `MainActivityModern.kt` | 5 | Chip, bottom sheet wiring, result listener |
+| `ActiveEventsFragment.kt` | 6 | Include `SNOOZED_UNTIL` in filter apply set (if needed) |
 
 ### Unchanged Files
 
 | File | Reason |
 |------|--------|
-| `TimeFilterBottomSheet.kt` | Separate filter, no changes needed |
+| `TimeFilterBottomSheet.kt` | Separate filter, no changes |
+| `UpcomingTimeFilterBottomSheet.kt` | Reference pattern only, no changes |
+| `TimeIntervalPickerController.kt` | Reused as-is from bottom sheet |
+| `dialog_interval_picker.xml` | Reused as-is |
+| `dialog_date_picker.xml` | Reused as-is |
+| `dialog_time_picker.xml` | Reused as-is |
 | `DismissedEventsFragment.kt` | No snoozed until chip on Dismissed tab |
 | `UpcomingEventsFragment.kt` | No snoozed until chip on Upcoming tab |
-| `SnoozeAllActivity.kt` | Future work — see snooze_all_filter_pills.md |
 
 ---
 
 ## Testing Strategy
 
-### Unit Tests (Phase 2)
+### Unit Tests (Phase 3)
+
+All in `FilterStateTest.kt` — Robolectric tests following existing patterns.
+
+**SnoozedUntilFilterConfig.matches():**
+- ALL mode — matches everything (snoozed and non-snoozed)
+- Non-snoozed events (snoozedUntil == 0) excluded for all non-ALL modes
+- PRESET + BEFORE — snoozedUntil <= now + duration
+- PRESET + AFTER — snoozedUntil > now + duration
+- CUSTOM_PERIOD — same threshold logic as PRESET
+- SPECIFIC_TIME + BEFORE — snoozedUntil <= absolute timestamp
+- SPECIFIC_TIME + AFTER — snoozedUntil > absolute timestamp
+- Boundary: snoozedUntil == threshold → BEFORE matches, AFTER doesn't
+
+**FilterState integration:**
+- `matchesSnoozedUntil()` delegates correctly
+- Default constructor has ALL mode
+- `hasActiveFilters()` detects non-ALL snoozedUntilFilter
 
-All in `FilterStateTest.kt` — Robolectric tests matching the existing pattern:
+**Bundle serialization:**
+- Round-trip each mode (ALL, PRESET, CUSTOM_PERIOD, SPECIFIC_TIME)
+- Round-trip both directions (BEFORE, AFTER)
+- Round-trip preserves `valueMillis`
+- Null bundle returns default
 
-- `SnoozedUntilFilter.matches()` for each enum value
-- Non-snoozed event exclusion (snoozedUntil == 0)
-- `FilterState.matchesSnoozedUntil()` delegation
-- Bundle round-trip serialization
-- `hasActiveFilters()` / `toDisplayString()` integration
+**Settings presets (separate test or existing PreferenceUtils tests):**
+- Parse `"12h, 1d, 3d, 7d, 4w"` correctly
+- Fallback to defaults on invalid input
+- Negative values filtered out
 
 ### Manual Testing Checklist
 
 - [ ] "Snoozed Until" chip appears only on Active tab
 - [ ] Chip does NOT appear on Upcoming or Dismissed tabs
-- [ ] Tapping chip opens bottom sheet with 4 radio options
-- [ ] Selecting option + Apply filters the event list
+- [ ] Tapping chip opens bottom sheet with toggle + presets + custom options
+- [ ] Before/After toggle switches direction
+- [ ] Preset radio buttons match configured intervals from Settings
+- [ ] Selecting preset + Apply filters the event list
+- [ ] "For a custom period..." opens duration picker dialog
+- [ ] Entering custom duration and Apply filters correctly
+- [ ] "Until a specific time and date..." opens DatePicker → TimePicker
+- [ ] Picking a specific date/time and Apply filters correctly
 - [ ] Non-snoozed events are hidden when filter is not "All"
-- [ ] Chip text updates to reflect current selection
+- [ ] Chip text updates with direction symbol (≤ / >) and value
+- [ ] "All" option clears the filter regardless of toggle state
 - [ ] Switching tabs clears the snoozed until filter
 - [ ] Filter survives app backgrounding (via `onSaveInstanceState`)
 - [ ] Filter clears on app restart
-- [ ] Combines correctly with Status filter (e.g., Status=Snoozed + SnoozedUntil=Today)
-- [ ] Combines correctly with Time filter and Calendar filter
-- [ ] "Snoozed until today" correctly includes events snoozed until later today
-- [ ] "Snoozed until this week" correctly uses locale-aware week boundaries
+- [ ] Changing presets in Settings → Navigation & UI → Active Events updates the bottom sheet
+- [ ] Invalid presets in Settings fall back to defaults
+- [ ] Combines correctly with Status, Time, and Calendar filters
 
 ---
 
@@ -323,20 +484,25 @@ All in `FilterStateTest.kt` — Robolectric tests matching the existing pattern:
 
 | Scenario | Expected Behavior |
 |----------|-------------------|
-| No snoozed events, filter set to "Today" | Empty list (all events filtered out) |
-| Event snoozed until exactly midnight boundary | `isToday()` handles this correctly (same as Time filter) |
-| Filter active, then event snooze expires | Event disappears from filtered list on next refresh |
+| No snoozed events, filter active | Empty list (all events filtered out) |
+| Event snoozedUntil exactly at threshold | BEFORE matches (≤), AFTER doesn't (>) |
+| Specific time in the past | Valid — shows events snoozed until before/after that past time |
+| Custom period of 0 | Effectively `now` — BEFORE shows events waking up now or earlier, AFTER shows all future snoozes |
 | All filters combined (Calendar + Status + Time + SnoozedUntil) | AND logic across all filter types |
 | Filter set, then switch to Dismissed tab and back | Filter cleared (same as all other filters) |
+| Presets changed in Settings while bottom sheet open | Bottom sheet reads presets on create — won't update mid-dialog, next open picks up changes |
+| SPECIFIC_TIME mode + rotation | `valueMillis` (absolute timestamp) preserved via Bundle — still correct after rotation |
+| PRESET/CUSTOM_PERIOD mode + time passes | Threshold is `now + duration` — recalculated each time `matches()` is called, so filter stays relative |
 
 ---
 
 ## Implementation Order
 
-1. **Phase 1** — `SnoozedUntilFilter` enum + `FilterState` integration
-2. **Phase 2** — Tests (run before UI work)
-3. **Phase 3** — Bottom sheet UI + strings
-4. **Phase 4** — Wire up chip in `MainActivityModern`
-5. **Phase 5** — Verify fragment filtering works (may be zero changes if default apply set is updated in Phase 1)
+1. **Phase 1** — Settings infrastructure (presets + Active Events category)
+2. **Phase 2** — `SnoozedUntilFilterConfig` + `FilterState` integration
+3. **Phase 3** — Tests (run before UI work)
+4. **Phase 4** — Bottom sheet UI (dynamic presets, toggle, custom pickers)
+5. **Phase 5** — Wire up chip in `MainActivityModern`
+6. **Phase 6** — Verify fragment filtering
 
-Each phase is independently testable. Phases 1-2 are purely logic/tests with no UI changes.
+Phases 1-3 are purely logic/settings/tests with no UI changes. Phase 4 is the bulk of the UI work. Phases 5-6 wire everything together.

From 44373c294964d92c90c3d57663e1a726d31e3414 Mon Sep 17 00:00:00 2001
From: William Harris <wharris@upscalews.com>
Date: Thu, 5 Mar 2026 02:10:40 +0000
Subject: [PATCH 3/5] feat: draw the rest of the fucking owl

---
 .../com/github/quarck/calnotify/Settings.kt   |  18 +
 .../prefs/NavigationSettingsFragmentX.kt      |  21 +-
 .../prefs/SnoozedUntilPresetPreferenceX.kt    | 136 ++++++
 .../github/quarck/calnotify/ui/FilterState.kt |  91 +++-
 .../quarck/calnotify/ui/MainActivityModern.kt |  64 ++-
 .../ui/SnoozedUntilFilterBottomSheet.kt       | 352 ++++++++++++++++
 .../bottom_sheet_snoozed_until_filter.xml     |  53 +++
 .../layout/dialog_snoozed_until_presets.xml   |  35 ++
 android/app/src/main/res/values/strings.xml   |  17 +
 .../main/res/xml/navigation_preferences.xml   |  13 +
 .../quarck/calnotify/ui/FilterStateTest.kt    | 389 ++++++++++++++++++
 11 files changed, 1175 insertions(+), 14 deletions(-)
 create mode 100644 android/app/src/main/java/com/github/quarck/calnotify/prefs/SnoozedUntilPresetPreferenceX.kt
 create mode 100644 android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
 create mode 100644 android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
 create mode 100644 android/app/src/main/res/layout/dialog_snoozed_until_presets.xml

diff --git a/android/app/src/main/java/com/github/quarck/calnotify/Settings.kt b/android/app/src/main/java/com/github/quarck/calnotify/Settings.kt
index 971b32ca..1df40d91 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/Settings.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/Settings.kt
@@ -501,6 +501,21 @@ class Settings(context: Context) : PersistentStorageBase(context), SettingsInter
                 .toLongArray()
         }
     
+    /** Raw configurable snoozed-until filter presets string (e.g., "12h, 1d, 3d, 7d, 4w") */
+    val snoozedUntilPresetsRaw: String
+        get() = getString(SNOOZED_UNTIL_PRESETS_KEY, DEFAULT_SNOOZED_UNTIL_PRESETS)
+    
+    /** Parsed snoozed-until filter presets in milliseconds. Filters out negative values. */
+    val snoozedUntilPresets: LongArray
+        get() {
+            val ret = PreferenceUtils.parseSnoozePresets(snoozedUntilPresetsRaw)
+                ?: PreferenceUtils.parseSnoozePresets(DEFAULT_SNOOZED_UNTIL_PRESETS)
+                ?: return longArrayOf()
+            return ret.filter { it > 0 }
+                .take(MAX_SNOOZED_UNTIL_PRESETS)
+                .toLongArray()
+        }
+    
     /** Max calendars to show in calendar filter. 0 = no limit (show all). */
     val calendarFilterMaxItems: Int
         get() = getString(CALENDAR_FILTER_MAX_ITEMS_KEY, DEFAULT_CALENDAR_FILTER_MAX_ITEMS.toString())
@@ -613,6 +628,7 @@ class Settings(context: Context) : PersistentStorageBase(context), SettingsInter
         private const val UPCOMING_EVENTS_FIXED_HOURS_KEY = "upcoming_events_fixed_hours"
         private const val UPCOMING_FIXED_LOOKAHEAD_MILLIS_KEY = "upcoming_fixed_lookahead_millis"
         private const val UPCOMING_TIME_PRESETS_KEY = "pref_upcoming_time_presets"
+        private const val SNOOZED_UNTIL_PRESETS_KEY = "pref_snoozed_until_presets"
         private const val CALENDAR_FILTER_MAX_ITEMS_KEY = "calendar_filter_max_items"
         private const val CALENDAR_FILTER_SHOW_SEARCH_KEY = "calendar_filter_show_search"
         private const val CALENDAR_FILTER_SHOW_IDS_KEY = "calendar_filter_show_ids"
@@ -638,6 +654,8 @@ class Settings(context: Context) : PersistentStorageBase(context), SettingsInter
         internal const val MAX_UPCOMING_TIME_PRESETS = 10
         internal const val MAX_LOOKAHEAD_DAYS = 30L
         internal const val MAX_LOOKAHEAD_MILLIS = MAX_LOOKAHEAD_DAYS * Consts.DAY_IN_MILLISECONDS
+        internal const val DEFAULT_SNOOZED_UNTIL_PRESETS = "12h, 1d, 3d, 7d, 4w"
+        internal const val MAX_SNOOZED_UNTIL_PRESETS = 10
         /** Default max calendars in filter (0 = no limit) */
         internal const val DEFAULT_CALENDAR_FILTER_MAX_ITEMS = 20
     }
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/prefs/NavigationSettingsFragmentX.kt b/android/app/src/main/java/com/github/quarck/calnotify/prefs/NavigationSettingsFragmentX.kt
index 6134738b..bd354b11 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/prefs/NavigationSettingsFragmentX.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/prefs/NavigationSettingsFragmentX.kt
@@ -60,13 +60,20 @@ class NavigationSettingsFragmentX : PreferenceFragmentCompat() {
     }
     
     override fun onDisplayPreferenceDialog(preference: Preference) {
-        if (preference is UpcomingTimePresetPreferenceX) {
-            val dialogFragment = UpcomingTimePresetPreferenceX.Dialog.newInstance(preference.key)
-            @Suppress("DEPRECATION")
-            dialogFragment.setTargetFragment(this, 0)
-            dialogFragment.show(parentFragmentManager, DIALOG_FRAGMENT_TAG)
-        } else {
-            super.onDisplayPreferenceDialog(preference)
+        when (preference) {
+            is UpcomingTimePresetPreferenceX -> {
+                val dialogFragment = UpcomingTimePresetPreferenceX.Dialog.newInstance(preference.key)
+                @Suppress("DEPRECATION")
+                dialogFragment.setTargetFragment(this, 0)
+                dialogFragment.show(parentFragmentManager, DIALOG_FRAGMENT_TAG)
+            }
+            is SnoozedUntilPresetPreferenceX -> {
+                val dialogFragment = SnoozedUntilPresetPreferenceX.Dialog.newInstance(preference.key)
+                @Suppress("DEPRECATION")
+                dialogFragment.setTargetFragment(this, 0)
+                dialogFragment.show(parentFragmentManager, DIALOG_FRAGMENT_TAG)
+            }
+            else -> super.onDisplayPreferenceDialog(preference)
         }
     }
     
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/prefs/SnoozedUntilPresetPreferenceX.kt b/android/app/src/main/java/com/github/quarck/calnotify/prefs/SnoozedUntilPresetPreferenceX.kt
new file mode 100644
index 00000000..c5c17eaa
--- /dev/null
+++ b/android/app/src/main/java/com/github/quarck/calnotify/prefs/SnoozedUntilPresetPreferenceX.kt
@@ -0,0 +1,136 @@
+//
+//   Calendar Notifications Plus
+//   Copyright (C) 2025 William Harris (wharris+cnplus@upscalews.com)
+//
+//   This program is free software; you can redistribute it and/or modify
+//   it under the terms of the GNU General Public License as published by
+//   the Free Software Foundation; either version 3 of the License, or
+//   (at your option) any later version.
+//
+//   This program is distributed in the hope that it will be useful,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//   GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program; if not, write to the Free Software Foundation,
+//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+//
+
+package com.github.quarck.calnotify.prefs
+
+import android.app.AlertDialog
+import android.content.Context
+import android.os.Bundle
+import android.util.AttributeSet
+import android.view.View
+import android.widget.EditText
+import android.widget.TextView
+import androidx.preference.DialogPreference
+import androidx.preference.PreferenceDialogFragmentCompat
+import com.github.quarck.calnotify.R
+import com.github.quarck.calnotify.Settings
+
+class SnoozedUntilPresetPreferenceX @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = androidx.preference.R.attr.dialogPreferenceStyle,
+    defStyleRes: Int = 0
+) : DialogPreference(context, attrs, defStyleAttr, defStyleRes) {
+
+    var presetValue: String = Settings.DEFAULT_SNOOZED_UNTIL_PRESETS
+        private set
+
+    init {
+        dialogLayoutResource = R.layout.dialog_snoozed_until_presets
+        positiveButtonText = context.getString(android.R.string.ok)
+        negativeButtonText = context.getString(android.R.string.cancel)
+    }
+
+    fun persistPreset(value: String) {
+        presetValue = value
+        persistString(value)
+        notifyChanged()
+    }
+
+    override fun onSetInitialValue(defaultValue: Any?) {
+        presetValue = getPersistedString((defaultValue as? String) ?: Settings.DEFAULT_SNOOZED_UNTIL_PRESETS)
+    }
+
+    override fun onGetDefaultValue(a: android.content.res.TypedArray, index: Int): Any? {
+        return a.getString(index)
+    }
+
+    class Dialog : PreferenceDialogFragmentCompat() {
+        private var edit: EditText? = null
+
+        override fun onBindDialogView(view: View) {
+            super.onBindDialogView(view)
+
+            val pref = preference as SnoozedUntilPresetPreferenceX
+
+            val label = view.findViewById<TextView>(R.id.text_label_snoozed_until_presets)
+            label?.text = getString(R.string.dialog_snoozed_until_presets_label, Settings.MAX_SNOOZED_UNTIL_PRESETS)
+
+            edit = view.findViewById(R.id.edit_text_snoozed_until_presets)
+            edit?.setText(pref.presetValue)
+        }
+
+        override fun onDialogClosed(positiveResult: Boolean) {
+            if (!positiveResult) return
+            val value = edit?.text?.toString() ?: return
+
+            val result = PreferenceUtils.normalizePresetInput(
+                value, Settings.DEFAULT_SNOOZED_UNTIL_PRESETS
+            ) { it > 0 }
+
+            if (result != null) {
+                val pref = preference as SnoozedUntilPresetPreferenceX
+                if (pref.callChangeListener(result.value)) {
+                    pref.persistPreset(result.value)
+                }
+
+                if (result.droppedCount > 0) {
+                    showMessage(R.string.warning_presets_invalid_removed)
+                }
+
+                val parsed = PreferenceUtils.parseSnoozePresets(result.value)
+                if (parsed != null && parsed.size > Settings.MAX_SNOOZED_UNTIL_PRESETS) {
+                    showFormattedMessage(R.string.error_too_many_snoozed_until_presets, Settings.MAX_SNOOZED_UNTIL_PRESETS)
+                }
+            } else {
+                showMessage(R.string.error_cannot_parse_preset)
+            }
+        }
+
+        private fun showMessage(id: Int) {
+            val context = requireContext()
+            AlertDialog.Builder(context)
+                .setMessage(context.getString(id))
+                .setCancelable(false)
+                .setPositiveButton(android.R.string.ok) { _, _ -> }
+                .create()
+                .show()
+        }
+
+        private fun showFormattedMessage(id: Int, vararg args: Any) {
+            val context = requireContext()
+            AlertDialog.Builder(context)
+                .setMessage(context.getString(id, *args))
+                .setCancelable(false)
+                .setPositiveButton(android.R.string.ok) { _, _ -> }
+                .create()
+                .show()
+        }
+
+        companion object {
+            fun newInstance(key: String): Dialog {
+                val fragment = Dialog()
+                val args = Bundle(1)
+                args.putString(ARG_KEY, key)
+                fragment.arguments = args
+                return fragment
+            }
+        }
+    }
+}
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt b/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt
index fda65b5c..225530a1 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt
@@ -30,7 +30,52 @@ import com.github.quarck.calnotify.utils.DateTimeUtils
  * Which filters to apply when filtering events.
  */
 enum class FilterType {
-    CALENDAR, STATUS, TIME
+    CALENDAR, STATUS, TIME, SNOOZED_UNTIL
+}
+
+/**
+ * Direction for the snoozed-until filter threshold.
+ */
+enum class FilterDirection {
+    BEFORE,  // snoozedUntil <= threshold
+    AFTER    // snoozedUntil > threshold
+}
+
+/**
+ * Mode for the snoozed-until filter.
+ */
+enum class SnoozedUntilFilterMode {
+    ALL,            // no filter (default)
+    PRESET,         // from configurable interval presets; valueMillis = duration
+    CUSTOM_PERIOD,  // user-entered duration; valueMillis = duration
+    SPECIFIC_TIME   // user-picked date+time; valueMillis = absolute timestamp
+}
+
+/**
+ * Configuration for the snoozed-until filter. Unlike the simple TimeFilter enum,
+ * this supports multiple modes (presets, custom duration, specific time) and a
+ * before/after direction toggle.
+ */
+data class SnoozedUntilFilterConfig(
+    val mode: SnoozedUntilFilterMode = SnoozedUntilFilterMode.ALL,
+    val direction: FilterDirection = FilterDirection.BEFORE,
+    val valueMillis: Long = 0L
+) {
+    fun matches(event: EventAlertRecord, now: Long): Boolean {
+        if (mode == SnoozedUntilFilterMode.ALL) return true
+        if (event.snoozedUntil == 0L) return false
+
+        val threshold = when (mode) {
+            SnoozedUntilFilterMode.ALL -> return true
+            SnoozedUntilFilterMode.PRESET, SnoozedUntilFilterMode.CUSTOM_PERIOD -> now + valueMillis
+            SnoozedUntilFilterMode.SPECIFIC_TIME -> valueMillis
+        }
+
+        return when (direction) {
+            FilterDirection.BEFORE -> event.snoozedUntil <= threshold
+            FilterDirection.AFTER -> event.snoozedUntil > threshold
+        }
+    }
 }
 
 /**
@@ -39,7 +84,8 @@ enum class FilterType {
 data class FilterState(
     val selectedCalendarIds: Set<Long>? = null,  // null = no filter (all), empty = none, set = specific
     val statusFilters: Set<StatusOption> = emptySet(),  // empty = show all (no filter)
-    val timeFilter: TimeFilter = TimeFilter.ALL
+    val timeFilter: TimeFilter = TimeFilter.ALL,
+    val snoozedUntilFilter: SnoozedUntilFilterConfig = SnoozedUntilFilterConfig()
 ) {
     
     companion object {
@@ -47,6 +93,9 @@ data class FilterState(
         private const val BUNDLE_CALENDAR_NULL = "filter_calendar_null"
         private const val BUNDLE_STATUS_FILTERS = "filter_status"
         private const val BUNDLE_TIME_FILTER = "filter_time"
+        private const val BUNDLE_SNOOZED_UNTIL_MODE = "filter_snoozed_until_mode"
+        private const val BUNDLE_SNOOZED_UNTIL_DIRECTION = "filter_snoozed_until_direction"
+        private const val BUNDLE_SNOOZED_UNTIL_VALUE = "filter_snoozed_until_value"
         
         /** Deserialize FilterState from a Bundle */
         fun fromBundle(bundle: Bundle?): FilterState {
@@ -67,10 +116,21 @@ data class FilterState(
                 bundle.getInt(BUNDLE_TIME_FILTER, 0)
             ) ?: TimeFilter.ALL
             
+            val snoozedUntilFilter = SnoozedUntilFilterConfig(
+                mode = SnoozedUntilFilterMode.entries.getOrNull(
+                    bundle.getInt(BUNDLE_SNOOZED_UNTIL_MODE, 0)
+                ) ?: SnoozedUntilFilterMode.ALL,
+                direction = FilterDirection.entries.getOrNull(
+                    bundle.getInt(BUNDLE_SNOOZED_UNTIL_DIRECTION, 0)
+                ) ?: FilterDirection.BEFORE,
+                valueMillis = bundle.getLong(BUNDLE_SNOOZED_UNTIL_VALUE, 0L)
+            )
+            
             return FilterState(
                 selectedCalendarIds = calendarIds,
                 statusFilters = statusFilters,
-                timeFilter = timeFilter
+                timeFilter = timeFilter,
+                snoozedUntilFilter = snoozedUntilFilter
             )
         }
     }
@@ -83,13 +143,17 @@ data class FilterState(
         
         putIntArray(BUNDLE_STATUS_FILTERS, statusFilters.map { it.ordinal }.toIntArray())
         putInt(BUNDLE_TIME_FILTER, timeFilter.ordinal)
+        putInt(BUNDLE_SNOOZED_UNTIL_MODE, snoozedUntilFilter.mode.ordinal)
+        putInt(BUNDLE_SNOOZED_UNTIL_DIRECTION, snoozedUntilFilter.direction.ordinal)
+        putLong(BUNDLE_SNOOZED_UNTIL_VALUE, snoozedUntilFilter.valueMillis)
     }
     
     /** Check if any filters are active */
     fun hasActiveFilters(): Boolean {
         return selectedCalendarIds != null || 
                statusFilters.isNotEmpty() || 
-               timeFilter != TimeFilter.ALL
+               timeFilter != TimeFilter.ALL ||
+               snoozedUntilFilter.mode != SnoozedUntilFilterMode.ALL
     }
     
     /**
@@ -130,6 +194,15 @@ data class FilterState(
             TimeFilter.STARTED_THIS_MONTH -> parts.add(context.getString(R.string.filter_time_started_this_month))
         }
         
+        // Snoozed until filter
+        if (snoozedUntilFilter.mode != SnoozedUntilFilterMode.ALL) {
+            val symbol = when (snoozedUntilFilter.direction) {
+                FilterDirection.BEFORE -> "\u2264"  // ≤
+                FilterDirection.AFTER -> ">"
+            }
+            parts.add(context.getString(R.string.filter_snoozed_until_display, symbol))
+        }
+        
         return if (parts.isEmpty()) null else parts.joinToString(", ")
     }
     /** Check if an event matches current status filters (empty set = match all) */
@@ -143,6 +216,11 @@ data class FilterState(
         return timeFilter.matches(event, now)
     }
     
+    /** Check if an event matches current snoozed-until filter */
+    fun matchesSnoozedUntil(event: EventAlertRecord, now: Long): Boolean {
+        return snoozedUntilFilter.matches(event, now)
+    }
+    
     /** Check if an event matches current calendar filter (null = all, empty = none) */
     fun matchesCalendar(event: EventAlertRecord): Boolean {
         if (selectedCalendarIds == null) return true  // No filter = show all
@@ -165,7 +243,8 @@ data class FilterState(
             val event = eventExtractor(item)
             (FilterType.CALENDAR !in apply || matchesCalendar(event)) &&
             (FilterType.STATUS !in apply || matchesStatus(event)) &&
-            (FilterType.TIME !in apply || matchesTime(event, now))
+            (FilterType.TIME !in apply || matchesTime(event, now)) &&
+            (FilterType.SNOOZED_UNTIL !in apply || matchesSnoozedUntil(event, now))
         }.toTypedArray()
     }
     
@@ -173,7 +252,7 @@ data class FilterState(
     fun filterEvents(
         events: List<EventAlertRecord>,
         now: Long,
-        apply: Set<FilterType> = setOf(FilterType.CALENDAR, FilterType.STATUS, FilterType.TIME)
+        apply: Set<FilterType> = setOf(FilterType.CALENDAR, FilterType.STATUS, FilterType.TIME, FilterType.SNOOZED_UNTIL)
     ): Array<EventAlertRecord> {
         return filterEvents(events, now, apply) { it }
     }
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt b/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt
index 441c2af2..13d2f786 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt
@@ -400,10 +400,11 @@ class MainActivityModern : MainActivityBase() {
         
         when (currentDestination) {
             R.id.activeEventsFragment -> {
-                // Active tab: Calendar, Status, Time
+                // Active tab: Calendar, Status, Time, Snoozed Until
                 addCalendarChip()
                 addStatusChip()
                 addTimeChip(TimeFilterBottomSheet.TabType.ACTIVE)
+                addSnoozedUntilChip()
             }
             R.id.upcomingEventsFragment -> {
                 addCalendarChip()
@@ -634,6 +635,51 @@ class MainActivityModern : MainActivityBase() {
         bottomSheet.show(supportFragmentManager, "UpcomingTimeFilterBottomSheet")
     }
     
+    // === Snoozed Until Filter Chip ===
+    
+    private fun addSnoozedUntilChip() {
+        val materialContext = ContextThemeWrapper(this, com.google.android.material.R.style.Theme_MaterialComponents_DayNight)
+        val chip = Chip(materialContext).apply {
+            text = getSnoozedUntilChipText()
+            isCheckable = false
+            isChipIconVisible = false
+            isCloseIconVisible = true
+            closeIcon = getDrawable(R.drawable.ic_arrow_drop_down)
+            setOnClickListener { showSnoozedUntilFilterBottomSheet() }
+            setOnCloseIconClickListener { showSnoozedUntilFilterBottomSheet() }
+        }
+        chipGroup?.addView(chip)
+    }
+    
+    private fun getSnoozedUntilChipText(): String {
+        val config = filterState.snoozedUntilFilter
+        if (config.mode == SnoozedUntilFilterMode.ALL) {
+            return getString(R.string.filter_snoozed_until)
+        }
+        val symbol = when (config.direction) {
+            FilterDirection.BEFORE -> "\u2264"  // ≤
+            FilterDirection.AFTER -> ">"
+        }
+        val valueText = when (config.mode) {
+            SnoozedUntilFilterMode.ALL -> ""
+            SnoozedUntilFilterMode.PRESET, SnoozedUntilFilterMode.CUSTOM_PERIOD ->
+                PreferenceUtils.formatPresetHumanReadable(this, config.valueMillis)
+            SnoozedUntilFilterMode.SPECIFIC_TIME ->
+                android.text.format.DateUtils.formatDateTime(
+                    this, config.valueMillis,
+                    android.text.format.DateUtils.FORMAT_SHOW_DATE or
+                    android.text.format.DateUtils.FORMAT_SHOW_TIME or
+                    android.text.format.DateUtils.FORMAT_ABBREV_ALL
+                )
+        }
+        return "$symbol $valueText"
+    }
+    
+    private fun showSnoozedUntilFilterBottomSheet() {
+        val bottomSheet = SnoozedUntilFilterBottomSheet.newInstance(filterState.snoozedUntilFilter)
+        bottomSheet.show(supportFragmentManager, "SnoozedUntilFilterBottomSheet")
+    }
+    
     /** Setup Fragment Result listeners for bottom sheets (survives config changes) */
     private fun setupFilterResultListeners() {
         // Time filter result
@@ -674,6 +720,22 @@ class MainActivityModern : MainActivityBase() {
             updateFilterChipsForCurrentTab()
             notifyCurrentFragmentFilterChanged()
         }
+        
+        // Snoozed until filter result
+        supportFragmentManager.setFragmentResultListener(
+            SnoozedUntilFilterBottomSheet.REQUEST_KEY, this
+        ) { _, bundle ->
+            val mode = SnoozedUntilFilterMode.entries.getOrNull(
+                bundle.getInt(SnoozedUntilFilterBottomSheet.RESULT_MODE, 0)
+            ) ?: SnoozedUntilFilterMode.ALL
+            val direction = FilterDirection.entries.getOrNull(
+                bundle.getInt(SnoozedUntilFilterBottomSheet.RESULT_DIRECTION, 0)
+            ) ?: FilterDirection.BEFORE
+            val value = bundle.getLong(SnoozedUntilFilterBottomSheet.RESULT_VALUE, 0L)
+            filterState = filterState.copy(snoozedUntilFilter = SnoozedUntilFilterConfig(mode, direction, value))
+            updateFilterChipsForCurrentTab()
+            notifyCurrentFragmentFilterChanged()
+        }
     }
 
     // === Selection Mode Coordination ===
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt b/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
new file mode 100644
index 00000000..953a82f1
--- /dev/null
+++ b/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
@@ -0,0 +1,352 @@
+//
+//   Calendar Notifications Plus
+//   Copyright (C) 2025 William Harris (wharris+cnplus@upscalews.com)
+//
+//   This program is free software; you can redistribute it and/or modify
+//   it under the terms of the GNU General Public License as published by
+//   the Free Software Foundation; either version 3 of the License, or
+//   (at your option) any later version.
+//
+//   This program is distributed in the hope that it will be useful,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//   GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program; if not, write to the Free Software Foundation,
+//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+//
+
+package com.github.quarck.calnotify.ui
+
+import android.content.DialogInterface
+import android.os.Bundle
+import android.text.format.DateUtils
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.DatePicker
+import android.widget.RadioButton
+import android.widget.RadioGroup
+import android.widget.TimePicker
+import android.widget.TextView
+import androidx.appcompat.app.AlertDialog
+import androidx.core.os.bundleOf
+import androidx.fragment.app.setFragmentResult
+import com.github.quarck.calnotify.R
+import com.github.quarck.calnotify.Settings
+import com.github.quarck.calnotify.prefs.PreferenceUtils
+import com.github.quarck.calnotify.utils.findOrThrow
+import com.github.quarck.calnotify.utils.hourCompat
+import com.github.quarck.calnotify.utils.minuteCompat
+import com.google.android.material.bottomsheet.BottomSheetDialogFragment
+import java.util.Calendar
+
+/**
+ * Bottom sheet for filtering active events by snoozed-until time.
+ * Features configurable interval presets, before/after toggle,
+ * and custom period / specific date-time pickers.
+ */
+class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
+    
+    private val ALL_RADIO_ID = View.generateViewId()
+    private val CUSTOM_PERIOD_RADIO_ID = View.generateViewId()
+    private val SPECIFIC_TIME_RADIO_ID = View.generateViewId()
+    
+    private var customPeriodMillis: Long = 0L
+    private var specificTimeMillis: Long = 0L
+    
+    private val currentConfig: SnoozedUntilFilterConfig
+        get() {
+            val args = arguments ?: return SnoozedUntilFilterConfig()
+            return SnoozedUntilFilterConfig(
+                mode = SnoozedUntilFilterMode.entries.getOrNull(
+                    args.getInt(ARG_MODE, 0)
+                ) ?: SnoozedUntilFilterMode.ALL,
+                direction = FilterDirection.entries.getOrNull(
+                    args.getInt(ARG_DIRECTION, 0)
+                ) ?: FilterDirection.BEFORE,
+                valueMillis = args.getLong(ARG_VALUE, 0L)
+            )
+        }
+    
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.bottom_sheet_snoozed_until_filter, container, false)
+    }
+    
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        
+        val settings = Settings(requireContext())
+        val directionGroup = view.findViewById<RadioGroup>(R.id.direction_toggle)
+        val radioGroup = view.findViewById<RadioGroup>(R.id.snoozed_until_radio_group).apply {
+            isSaveEnabled = false
+        }
+        val applyButton = view.findViewById<Button>(R.id.btn_apply)
+        
+        val config = currentConfig
+        val presets = settings.snoozedUntilPresets
+        val radioPaddingV = resources.getDimensionPixelSize(R.dimen.bottom_sheet_radio_padding_vertical)
+        val dividerHeight = resources.getDimensionPixelSize(R.dimen.bottom_sheet_divider_height)
+        
+        // Restore custom values if editing existing filter
+        if (config.mode == SnoozedUntilFilterMode.CUSTOM_PERIOD) {
+            customPeriodMillis = config.valueMillis
+        } else if (config.mode == SnoozedUntilFilterMode.SPECIFIC_TIME) {
+            specificTimeMillis = config.valueMillis
+        }
+        
+        // Direction toggle
+        when (config.direction) {
+            FilterDirection.BEFORE -> directionGroup.check(R.id.radio_before)
+            FilterDirection.AFTER -> directionGroup.check(R.id.radio_after)
+        }
+        
+        // "All" option
+        val allRadio = RadioButton(requireContext()).apply {
+            id = ALL_RADIO_ID
+            text = getString(R.string.filter_snoozed_until_all)
+            setPadding(0, radioPaddingV, 0, radioPaddingV)
+        }
+        radioGroup.addView(allRadio)
+        
+        // Divider
+        radioGroup.addView(createDivider(dividerHeight))
+        
+        // Preset options
+        val presetRadioIds = mutableListOf<Pair<Int, Long>>()
+        for (presetMillis in presets) {
+            val radioId = View.generateViewId()
+            presetRadioIds.add(radioId to presetMillis)
+            val radio = RadioButton(requireContext()).apply {
+                id = radioId
+                text = PreferenceUtils.formatPresetHumanReadable(requireContext(), presetMillis)
+                setPadding(0, radioPaddingV, 0, radioPaddingV)
+            }
+            radioGroup.addView(radio)
+        }
+        
+        // Divider
+        radioGroup.addView(createDivider(dividerHeight))
+        
+        // "For a custom period..." option
+        val customPeriodRadio = RadioButton(requireContext()).apply {
+            id = CUSTOM_PERIOD_RADIO_ID
+            text = if (customPeriodMillis > 0) {
+                PreferenceUtils.formatPresetHumanReadable(requireContext(), customPeriodMillis)
+            } else {
+                getString(R.string.filter_snoozed_until_custom_period)
+            }
+            setPadding(0, radioPaddingV, 0, radioPaddingV)
+        }
+        radioGroup.addView(customPeriodRadio)
+        
+        // "Until a specific time and date..." option
+        val specificTimeRadio = RadioButton(requireContext()).apply {
+            id = SPECIFIC_TIME_RADIO_ID
+            text = if (specificTimeMillis > 0) {
+                DateUtils.formatDateTime(
+                    requireContext(), specificTimeMillis,
+                    DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_TIME or DateUtils.FORMAT_ABBREV_ALL
+                )
+            } else {
+                getString(R.string.filter_snoozed_until_specific_time)
+            }
+            setPadding(0, radioPaddingV, 0, radioPaddingV)
+        }
+        radioGroup.addView(specificTimeRadio)
+        
+        // Pre-select current
+        when (config.mode) {
+            SnoozedUntilFilterMode.ALL -> radioGroup.check(ALL_RADIO_ID)
+            SnoozedUntilFilterMode.PRESET -> {
+                val match = presetRadioIds.firstOrNull { it.second == config.valueMillis }
+                if (match != null) radioGroup.check(match.first)
+            }
+            SnoozedUntilFilterMode.CUSTOM_PERIOD -> radioGroup.check(CUSTOM_PERIOD_RADIO_ID)
+            SnoozedUntilFilterMode.SPECIFIC_TIME -> radioGroup.check(SPECIFIC_TIME_RADIO_ID)
+        }
+        
+        // Open picker dialogs when custom options are tapped
+        radioGroup.setOnCheckedChangeListener { _, checkedId ->
+            when (checkedId) {
+                CUSTOM_PERIOD_RADIO_ID -> showCustomPeriodDialog(customPeriodRadio)
+                SPECIFIC_TIME_RADIO_ID -> showDatePickerDialog(specificTimeRadio)
+            }
+        }
+        
+        applyButton.setOnClickListener {
+            val direction = when (directionGroup.checkedRadioButtonId) {
+                R.id.radio_after -> FilterDirection.AFTER
+                else -> FilterDirection.BEFORE
+            }
+            
+            val checkedId = radioGroup.checkedRadioButtonId
+            when {
+                checkedId == ALL_RADIO_ID -> {
+                    setFragmentResult(REQUEST_KEY, bundleOf(
+                        RESULT_MODE to SnoozedUntilFilterMode.ALL.ordinal,
+                        RESULT_DIRECTION to direction.ordinal,
+                        RESULT_VALUE to 0L
+                    ))
+                }
+                checkedId == CUSTOM_PERIOD_RADIO_ID && customPeriodMillis > 0 -> {
+                    setFragmentResult(REQUEST_KEY, bundleOf(
+                        RESULT_MODE to SnoozedUntilFilterMode.CUSTOM_PERIOD.ordinal,
+                        RESULT_DIRECTION to direction.ordinal,
+                        RESULT_VALUE to customPeriodMillis
+                    ))
+                }
+                checkedId == SPECIFIC_TIME_RADIO_ID && specificTimeMillis > 0 -> {
+                    setFragmentResult(REQUEST_KEY, bundleOf(
+                        RESULT_MODE to SnoozedUntilFilterMode.SPECIFIC_TIME.ordinal,
+                        RESULT_DIRECTION to direction.ordinal,
+                        RESULT_VALUE to specificTimeMillis
+                    ))
+                }
+                else -> {
+                    val selectedPreset = presetRadioIds.firstOrNull { it.first == checkedId }
+                    if (selectedPreset != null) {
+                        setFragmentResult(REQUEST_KEY, bundleOf(
+                            RESULT_MODE to SnoozedUntilFilterMode.PRESET.ordinal,
+                            RESULT_DIRECTION to direction.ordinal,
+                            RESULT_VALUE to selectedPreset.second
+                        ))
+                    } else {
+                        setFragmentResult(REQUEST_KEY, bundleOf(
+                            RESULT_MODE to SnoozedUntilFilterMode.ALL.ordinal,
+                            RESULT_DIRECTION to direction.ordinal,
+                            RESULT_VALUE to 0L
+                        ))
+                    }
+                }
+            }
+            dismiss()
+        }
+    }
+    
+    private fun createDivider(height: Int): View {
+        val dividerAttrs = intArrayOf(android.R.attr.listDivider)
+        val ta = requireContext().obtainStyledAttributes(dividerAttrs)
+        val dividerDrawable = ta.getDrawable(0)
+        ta.recycle()
+        return View(requireContext()).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, height
+            )
+            background = dividerDrawable
+        }
+    }
+    
+    private fun showCustomPeriodDialog(radioButton: RadioButton) {
+        val ctx = context ?: return
+        val dialogView = LayoutInflater.from(ctx).inflate(R.layout.dialog_interval_picker, null)
+        val picker = TimeIntervalPickerController(dialogView, R.string.snooze_for, 0, false)
+        if (customPeriodMillis > 0) {
+            picker.intervalMilliseconds = customPeriodMillis
+        }
+        
+        AlertDialog.Builder(ctx)
+            .setView(dialogView)
+            .setPositiveButton(android.R.string.ok) { _: DialogInterface?, _: Int ->
+                customPeriodMillis = picker.intervalMilliseconds
+                radioButton.text = PreferenceUtils.formatPresetHumanReadable(ctx, customPeriodMillis)
+            }
+            .setNegativeButton(android.R.string.cancel, null)
+            .create()
+            .show()
+    }
+    
+    private fun showDatePickerDialog(radioButton: RadioButton) {
+        val ctx = context ?: return
+        val dialogView = LayoutInflater.from(ctx).inflate(R.layout.dialog_date_picker, null) ?: return
+        val datePicker = dialogView.findOrThrow<DatePicker>(R.id.datePickerCustomSnooze)
+        
+        val firstDayOfWeek = Settings(ctx).firstDayOfWeek
+        if (firstDayOfWeek != -1) {
+            datePicker.firstDayOfWeek = firstDayOfWeek
+        }
+        
+        if (specificTimeMillis > 0) {
+            val cal = Calendar.getInstance()
+            cal.timeInMillis = specificTimeMillis
+            datePicker.updateDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH))
+        }
+        
+        AlertDialog.Builder(ctx)
+            .setView(dialogView)
+            .setPositiveButton(R.string.next) { _: DialogInterface?, _: Int ->
+                datePicker.clearFocus()
+                val date = Calendar.getInstance()
+                date.set(datePicker.year, datePicker.month, datePicker.dayOfMonth, 0, 0, 0)
+                showTimePickerDialog(radioButton, date.timeInMillis)
+            }
+            .setNegativeButton(android.R.string.cancel, null)
+            .create()
+            .show()
+    }
+    
+    private fun showTimePickerDialog(radioButton: RadioButton, dateMillis: Long) {
+        val ctx = context ?: return
+        val dialogView = LayoutInflater.from(ctx).inflate(R.layout.dialog_time_picker, null) ?: return
+        val timePicker = dialogView.findOrThrow<TimePicker>(R.id.timePickerCustomSnooze)
+        timePicker.setIs24HourView(android.text.format.DateFormat.is24HourFormat(ctx))
+        
+        if (specificTimeMillis > 0) {
+            val cal = Calendar.getInstance()
+            cal.timeInMillis = specificTimeMillis
+            timePicker.hourCompat = cal.get(Calendar.HOUR_OF_DAY)
+            timePicker.minuteCompat = cal.get(Calendar.MINUTE)
+        }
+        
+        val title = dialogView.findOrThrow<TextView>(R.id.textViewSnoozeUntilDate)
+        title.text = String.format(
+            resources.getString(R.string.choose_time),
+            DateUtils.formatDateTime(ctx, dateMillis, DateUtils.FORMAT_SHOW_DATE)
+        )
+        
+        AlertDialog.Builder(ctx)
+            .setView(dialogView)
+            .setPositiveButton(android.R.string.ok) { _: DialogInterface?, _: Int ->
+                timePicker.clearFocus()
+                val date = Calendar.getInstance()
+                date.timeInMillis = dateMillis
+                date.set(Calendar.HOUR_OF_DAY, timePicker.hourCompat)
+                date.set(Calendar.MINUTE, timePicker.minuteCompat)
+                specificTimeMillis = date.timeInMillis
+                radioButton.text = DateUtils.formatDateTime(
+                    ctx, specificTimeMillis,
+                    DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_TIME or DateUtils.FORMAT_ABBREV_ALL
+                )
+            }
+            .setNegativeButton(android.R.string.cancel, null)
+            .create()
+            .show()
+    }
+    
+    companion object {
+        private const val ARG_MODE = "arg_mode"
+        private const val ARG_DIRECTION = "arg_direction"
+        private const val ARG_VALUE = "arg_value"
+        
+        const val REQUEST_KEY = "snoozed_until_filter_request"
+        const val RESULT_MODE = "result_mode"
+        const val RESULT_DIRECTION = "result_direction"
+        const val RESULT_VALUE = "result_value"
+        
+        fun newInstance(config: SnoozedUntilFilterConfig): SnoozedUntilFilterBottomSheet {
+            return SnoozedUntilFilterBottomSheet().apply {
+                arguments = Bundle().apply {
+                    putInt(ARG_MODE, config.mode.ordinal)
+                    putInt(ARG_DIRECTION, config.direction.ordinal)
+                    putLong(ARG_VALUE, config.valueMillis)
+                }
+            }
+        }
+    }
+}
diff --git a/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml b/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
new file mode 100644
index 00000000..27a02e4c
--- /dev/null
+++ b/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp">
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/filter_snoozed_until_title"
+        android:textSize="18sp"
+        android:textStyle="bold"
+        android:paddingBottom="12dp" />
+
+    <RadioGroup
+        android:id="@+id/direction_toggle"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:paddingBottom="12dp">
+
+        <RadioButton
+            android:id="@+id/radio_before"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/filter_snoozed_until_before" />
+
+        <RadioButton
+            android:id="@+id/radio_after"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/filter_snoozed_until_after" />
+
+    </RadioGroup>
+
+    <RadioGroup
+        android:id="@+id/snoozed_until_radio_group"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <Button
+        android:id="@+id/btn_apply"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="16dp"
+        android:text="@string/filter_apply"
+        android:backgroundTint="@color/primary"
+        android:textColor="@android:color/white" />
+
+</LinearLayout>
diff --git a/android/app/src/main/res/layout/dialog_snoozed_until_presets.xml b/android/app/src/main/res/layout/dialog_snoozed_until_presets.xml
new file mode 100644
index 00000000..d0295112
--- /dev/null
+++ b/android/app/src/main/res/layout/dialog_snoozed_until_presets.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<ScrollView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    >
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        >
+        <TextView
+            android:id="@+id/text_label_snoozed_until_presets"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:textAppearance="?android:textAppearanceMedium"
+            android:padding="@dimen/dlg_snooze_presets_text_label_padding" />
+
+        <EditText
+            android:id="@+id/edit_text_snoozed_until_presets"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:ems="10"
+            android:padding="@dimen/dlg_snooze_presets_input_padding"
+            android:inputType="text"
+            tools:ignore="LabelFor" >
+
+            <requestFocus />
+        </EditText>
+
+    </LinearLayout>
+
+</ScrollView>
diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml
index f769cdff..11b3758c 100644
--- a/android/app/src/main/res/values/strings.xml
+++ b/android/app/src/main/res/values/strings.xml
@@ -825,6 +825,13 @@
     <string name="upcoming_time_presets_summary">Comma-separated intervals (e.g., 4h, 8h, 1d, 3d, 1w)</string>
     <string name="dialog_upcoming_time_presets_label">Comma-separated list of lookahead intervals\n\nSupported values like \'4h\', \'1d\' or \'1w\'\n\nMaximum %1$d days (calendar scan limit)\n\nUp to %2$d items in the list\n\nLeave empty to use defaults</string>
     
+    <!-- Active events settings -->
+    <string name="active_events_category">Active Events</string>
+    <string name="snoozed_until_presets_title">Snoozed until filter presets</string>
+    <string name="snoozed_until_presets_summary">Comma-separated intervals (e.g., 12h, 1d, 3d, 7d, 4w)</string>
+    <string name="dialog_snoozed_until_presets_label">Comma-separated list of filter intervals\n\nSupported values like \'12h\', \'1d\' or \'4w\'\n\nUp to %1$d items in the list\n\nLeave empty to use defaults</string>
+    <string name="error_too_many_snoozed_until_presets">Only up to %d presets are supported, extra presets will be ignored</string>
+    
     <!-- Filter settings -->
     <string name="filter_settings_category">Filters</string>
     <string name="calendar_filter_max_items_title">Max calendars in filter</string>
@@ -836,6 +843,16 @@
     <string name="calendar_filter_showing_count">Showing %1$d of %2$d</string>
     <string name="calendar_filter_search_hint">Search calendars…</string>
     
+    <!-- Snoozed until filter -->
+    <string name="filter_snoozed_until">Snoozed Until</string>
+    <string name="filter_snoozed_until_display">Snoozed %s</string>
+    <string name="filter_snoozed_until_all">All</string>
+    <string name="filter_snoozed_until_before">Before</string>
+    <string name="filter_snoozed_until_after">After</string>
+    <string name="filter_snoozed_until_custom_period">For a custom period…</string>
+    <string name="filter_snoozed_until_specific_time">Until a specific time and date…</string>
+    <string name="filter_snoozed_until_title">Filter by Snoozed Until</string>
+    
     <string-array name="calendar_filter_max_items_entries">
         <item>No limit</item>
         <item>10</item>
diff --git a/android/app/src/main/res/xml/navigation_preferences.xml b/android/app/src/main/res/xml/navigation_preferences.xml
index 89c157cc..f1c19183 100644
--- a/android/app/src/main/res/xml/navigation_preferences.xml
+++ b/android/app/src/main/res/xml/navigation_preferences.xml
@@ -56,6 +56,19 @@
 
     </PreferenceCategory>
 
+    <PreferenceCategory
+        android:title="@string/active_events_category"
+        android:key="_active_events"
+        android:dependency="use_new_navigation_ui">
+
+        <com.github.quarck.calnotify.prefs.SnoozedUntilPresetPreferenceX
+            android:key="pref_snoozed_until_presets"
+            android:title="@string/snoozed_until_presets_title"
+            android:summary="@string/snoozed_until_presets_summary"
+            android:defaultValue="12h, 1d, 3d, 7d, 4w" />
+
+    </PreferenceCategory>
+
     <PreferenceCategory
         android:title="@string/filter_settings_category"
         android:key="_filter_settings"
diff --git a/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt b/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt
index 33746c59..35ceff45 100644
--- a/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt
+++ b/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt
@@ -666,4 +666,393 @@ class FilterStateTest {
         val commaCount = result!!.count { it == ',' }
         assertTrue(commaCount >= 2)  // At least 2 commas for 3 parts
     }
+    
+    // === SnoozedUntilFilterConfig.matches() Tests ===
+    
+    private val HOUR_MILLIS = 3600 * 1000L
+    private val DAY_MILLIS = 24 * HOUR_MILLIS
+    
+    private fun createSnoozedEventWithSnoozedUntil(snoozedUntilTime: Long): EventAlertRecord {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        return EventAlertRecord(
+            calendarId = 1L,
+            eventId = 1L,
+            isAllDay = false,
+            isRepeating = false,
+            alertTime = now,
+            notificationId = 0,
+            title = "Test Event",
+            desc = "",
+            startTime = now + HOUR_MILLIS,
+            endTime = now + 2 * HOUR_MILLIS,
+            instanceStartTime = now + HOUR_MILLIS,
+            instanceEndTime = now + 2 * HOUR_MILLIS,
+            location = "",
+            lastStatusChangeTime = now,
+            snoozedUntil = snoozedUntilTime,
+            displayStatus = EventDisplayStatus.Hidden,
+            color = 0
+        )
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter ALL matches all events including non-snoozed`() {
+        val config = SnoozedUntilFilterConfig(mode = SnoozedUntilFilterMode.ALL)
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(0L), now))
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + HOUR_MILLIS), now))
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter PRESET BEFORE matches events snoozed until within interval`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        )
+        
+        // Event snoozed until 6 hours from now (within 1 day)
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + 6 * HOUR_MILLIS), now))
+        // Event snoozed until 23 hours from now (within 1 day)
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + 23 * HOUR_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter PRESET BEFORE excludes events snoozed until beyond interval`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        )
+        
+        // Event snoozed until 2 days from now (beyond 1 day)
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(now + 2 * DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter PRESET BEFORE excludes non-snoozed events`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        )
+        
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(0L), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter PRESET AFTER matches events snoozed until beyond interval`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.AFTER,
+            valueMillis = DAY_MILLIS
+        )
+        
+        // Event snoozed until 2 days from now (beyond 1 day threshold)
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + 2 * DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter PRESET AFTER excludes events snoozed until within interval`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.AFTER,
+            valueMillis = DAY_MILLIS
+        )
+        
+        // Event snoozed until 6 hours from now (within 1 day threshold)
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(now + 6 * HOUR_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter PRESET AFTER excludes non-snoozed events`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.AFTER,
+            valueMillis = DAY_MILLIS
+        )
+        
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(0L), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter CUSTOM_PERIOD works same as PRESET`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val configPreset = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = 6 * HOUR_MILLIS
+        )
+        val configCustom = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.CUSTOM_PERIOD,
+            direction = FilterDirection.BEFORE,
+            valueMillis = 6 * HOUR_MILLIS
+        )
+        
+        val event = createSnoozedEventWithSnoozedUntil(now + 3 * HOUR_MILLIS)
+        assertEquals(configPreset.matches(event, now), configCustom.matches(event, now))
+        
+        val farEvent = createSnoozedEventWithSnoozedUntil(now + 12 * HOUR_MILLIS)
+        assertEquals(configPreset.matches(farEvent, now), configCustom.matches(farEvent, now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter SPECIFIC_TIME BEFORE matches events snoozed until before timestamp`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val targetTime = now + 2 * DAY_MILLIS
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.SPECIFIC_TIME,
+            direction = FilterDirection.BEFORE,
+            valueMillis = targetTime
+        )
+        
+        // Event snoozed until 1 day from now (before target of 2 days)
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter SPECIFIC_TIME BEFORE excludes events snoozed until after timestamp`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val targetTime = now + 2 * DAY_MILLIS
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.SPECIFIC_TIME,
+            direction = FilterDirection.BEFORE,
+            valueMillis = targetTime
+        )
+        
+        // Event snoozed until 3 days from now (after target of 2 days)
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(now + 3 * DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter SPECIFIC_TIME AFTER matches events snoozed until after timestamp`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val targetTime = now + 2 * DAY_MILLIS
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.SPECIFIC_TIME,
+            direction = FilterDirection.AFTER,
+            valueMillis = targetTime
+        )
+        
+        // Event snoozed until 3 days from now (after target of 2 days)
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + 3 * DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter SPECIFIC_TIME AFTER excludes events snoozed until before timestamp`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val targetTime = now + 2 * DAY_MILLIS
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.SPECIFIC_TIME,
+            direction = FilterDirection.AFTER,
+            valueMillis = targetTime
+        )
+        
+        // Event snoozed until 1 day from now (before target of 2 days)
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(now + DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter boundary - BEFORE matches when snoozedUntil equals threshold`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        )
+        
+        // Event snoozed until exactly at threshold (now + 1 day)
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter boundary - AFTER does not match when snoozedUntil equals threshold`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.AFTER,
+            valueMillis = DAY_MILLIS
+        )
+        
+        // Event snoozed until exactly at threshold (now + 1 day) — AFTER uses strict >
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(now + DAY_MILLIS), now))
+    }
+    
+    // === SnoozedUntilFilter FilterState integration ===
+    
+    @Test
+    fun `FilterState matchesSnoozedUntil delegates to config`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        )
+        val filter = FilterState(snoozedUntilFilter = config)
+        
+        val nearEvent = createSnoozedEventWithSnoozedUntil(now + 6 * HOUR_MILLIS)
+        val farEvent = createSnoozedEventWithSnoozedUntil(now + 2 * DAY_MILLIS)
+        
+        assertTrue(filter.matchesSnoozedUntil(nearEvent, now))
+        assertFalse(filter.matchesSnoozedUntil(farEvent, now))
+    }
+    
+    @Test
+    fun `FilterState default has ALL snoozedUntilFilter`() {
+        val filter = FilterState()
+        assertEquals(SnoozedUntilFilterMode.ALL, filter.snoozedUntilFilter.mode)
+    }
+    
+    @Test
+    fun `hasActiveFilters returns true when snoozedUntilFilter is not ALL`() {
+        val filter = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        ))
+        assertTrue(filter.hasActiveFilters())
+    }
+    
+    @Test
+    fun `hasActiveFilters returns false when snoozedUntilFilter is ALL`() {
+        val filter = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.ALL
+        ))
+        assertFalse(filter.hasActiveFilters())
+    }
+    
+    @Test
+    fun `toDisplayString shows snoozed until when not ALL`() {
+        val filter = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        ))
+        val context = org.robolectric.RuntimeEnvironment.getApplication()
+        
+        val result = filter.toDisplayString(context)
+        assertNotNull(result)
+    }
+    
+    @Test
+    fun `toDisplayString returns null when snoozedUntilFilter is ALL`() {
+        val filter = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.ALL
+        ))
+        val context = org.robolectric.RuntimeEnvironment.getApplication()
+        
+        assertNull(filter.toDisplayString(context))
+    }
+    
+    // === SnoozedUntilFilter Bundle Serialization Tests ===
+    
+    @Test
+    fun `toBundle and fromBundle round-trip snoozedUntilFilter PRESET`() {
+        val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = 12 * HOUR_MILLIS
+        ))
+        
+        val restored = FilterState.fromBundle(original.toBundle())
+        
+        assertEquals(SnoozedUntilFilterMode.PRESET, restored.snoozedUntilFilter.mode)
+        assertEquals(FilterDirection.BEFORE, restored.snoozedUntilFilter.direction)
+        assertEquals(12 * HOUR_MILLIS, restored.snoozedUntilFilter.valueMillis)
+    }
+    
+    @Test
+    fun `toBundle and fromBundle round-trip snoozedUntilFilter CUSTOM_PERIOD`() {
+        val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.CUSTOM_PERIOD,
+            direction = FilterDirection.AFTER,
+            valueMillis = 6 * HOUR_MILLIS
+        ))
+        
+        val restored = FilterState.fromBundle(original.toBundle())
+        
+        assertEquals(SnoozedUntilFilterMode.CUSTOM_PERIOD, restored.snoozedUntilFilter.mode)
+        assertEquals(FilterDirection.AFTER, restored.snoozedUntilFilter.direction)
+        assertEquals(6 * HOUR_MILLIS, restored.snoozedUntilFilter.valueMillis)
+    }
+    
+    @Test
+    fun `toBundle and fromBundle round-trip snoozedUntilFilter SPECIFIC_TIME`() {
+        val specificTime = TestTimeConstants.STANDARD_TEST_TIME + 5 * DAY_MILLIS
+        val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.SPECIFIC_TIME,
+            direction = FilterDirection.BEFORE,
+            valueMillis = specificTime
+        ))
+        
+        val restored = FilterState.fromBundle(original.toBundle())
+        
+        assertEquals(SnoozedUntilFilterMode.SPECIFIC_TIME, restored.snoozedUntilFilter.mode)
+        assertEquals(FilterDirection.BEFORE, restored.snoozedUntilFilter.direction)
+        assertEquals(specificTime, restored.snoozedUntilFilter.valueMillis)
+    }
+    
+    @Test
+    fun `toBundle and fromBundle round-trip snoozedUntilFilter ALL`() {
+        val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.ALL
+        ))
+        
+        val restored = FilterState.fromBundle(original.toBundle())
+        
+        assertEquals(SnoozedUntilFilterMode.ALL, restored.snoozedUntilFilter.mode)
+    }
+    
+    @Test
+    fun `toBundle and fromBundle round-trip preserves AFTER direction`() {
+        val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.AFTER,
+            valueMillis = 7 * DAY_MILLIS
+        ))
+        
+        val restored = FilterState.fromBundle(original.toBundle())
+        
+        assertEquals(FilterDirection.AFTER, restored.snoozedUntilFilter.direction)
+    }
+    
+    @Test
+    fun `toBundle and fromBundle round-trip all SnoozedUntilFilterMode values`() {
+        SnoozedUntilFilterMode.entries.forEach { mode ->
+            val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+                mode = mode, valueMillis = 1000L
+            ))
+            val restored = FilterState.fromBundle(original.toBundle())
+            assertEquals(mode, restored.snoozedUntilFilter.mode)
+        }
+    }
+    
+    @Test
+    fun `toBundle and fromBundle round-trip both FilterDirection values`() {
+        FilterDirection.entries.forEach { direction ->
+            val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+                mode = SnoozedUntilFilterMode.PRESET,
+                direction = direction,
+                valueMillis = DAY_MILLIS
+            ))
+            val restored = FilterState.fromBundle(original.toBundle())
+            assertEquals(direction, restored.snoozedUntilFilter.direction)
+        }
+    }
+    
+    @Test
+    fun `fromBundle with null returns default snoozedUntilFilter`() {
+        val restored = FilterState.fromBundle(null)
+        assertEquals(SnoozedUntilFilterMode.ALL, restored.snoozedUntilFilter.mode)
+        assertEquals(FilterDirection.BEFORE, restored.snoozedUntilFilter.direction)
+        assertEquals(0L, restored.snoozedUntilFilter.valueMillis)
+    }
 }

From 64f0efed0f574842149584080ba52d25f749cb3b Mon Sep 17 00:00:00 2001
From: William Harris <wharris@upscalews.com>
Date: Thu, 5 Mar 2026 04:07:52 +0000
Subject: [PATCH 4/5] fix: better with off

---
 .../ui/SnoozedUntilFilterBottomSheet.kt       | 82 +++++++++++--------
 .../bottom_sheet_snoozed_until_filter.xml     |  7 ++
 android/app/src/main/res/values/strings.xml   |  2 +-
 3 files changed, 57 insertions(+), 34 deletions(-)

diff --git a/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt b/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
index 953a82f1..2a28860a 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
@@ -50,7 +50,6 @@ import java.util.Calendar
  */
 class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
     
-    private val ALL_RADIO_ID = View.generateViewId()
     private val CUSTOM_PERIOD_RADIO_ID = View.generateViewId()
     private val SPECIFIC_TIME_RADIO_ID = View.generateViewId()
     
@@ -101,23 +100,13 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
             specificTimeMillis = config.valueMillis
         }
         
-        // Direction toggle
-        when (config.direction) {
-            FilterDirection.BEFORE -> directionGroup.check(R.id.radio_before)
-            FilterDirection.AFTER -> directionGroup.check(R.id.radio_after)
+        // 3-way direction toggle: Off / Before / After
+        when {
+            config.mode == SnoozedUntilFilterMode.ALL -> directionGroup.check(R.id.radio_off)
+            config.direction == FilterDirection.BEFORE -> directionGroup.check(R.id.radio_before)
+            config.direction == FilterDirection.AFTER -> directionGroup.check(R.id.radio_after)
         }
         
-        // "All" option
-        val allRadio = RadioButton(requireContext()).apply {
-            id = ALL_RADIO_ID
-            text = getString(R.string.filter_snoozed_until_all)
-            setPadding(0, radioPaddingV, 0, radioPaddingV)
-        }
-        radioGroup.addView(allRadio)
-        
-        // Divider
-        radioGroup.addView(createDivider(dividerHeight))
-        
         // Preset options
         val presetRadioIds = mutableListOf<Pair<Int, Long>>()
         for (presetMillis in presets) {
@@ -161,15 +150,35 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
         }
         radioGroup.addView(specificTimeRadio)
         
-        // Pre-select current
-        when (config.mode) {
-            SnoozedUntilFilterMode.ALL -> radioGroup.check(ALL_RADIO_ID)
-            SnoozedUntilFilterMode.PRESET -> {
-                val match = presetRadioIds.firstOrNull { it.second == config.valueMillis }
-                if (match != null) radioGroup.check(match.first)
+        // Pre-select current value in preset list (only if filter is active)
+        if (config.mode != SnoozedUntilFilterMode.ALL) {
+            when (config.mode) {
+                SnoozedUntilFilterMode.PRESET -> {
+                    val match = presetRadioIds.firstOrNull { it.second == config.valueMillis }
+                    if (match != null) radioGroup.check(match.first)
+                }
+                SnoozedUntilFilterMode.CUSTOM_PERIOD -> radioGroup.check(CUSTOM_PERIOD_RADIO_ID)
+                SnoozedUntilFilterMode.SPECIFIC_TIME -> radioGroup.check(SPECIFIC_TIME_RADIO_ID)
+                else -> {}
+            }
+        }
+        
+        // Enable/disable preset radios based on direction toggle
+        fun setPresetsEnabled(enabled: Boolean) {
+            for (i in 0 until radioGroup.childCount) {
+                val child = radioGroup.getChildAt(i)
+                child.isEnabled = enabled
+                child.alpha = if (enabled) 1.0f else 0.4f
+            }
+        }
+        setPresetsEnabled(config.mode != SnoozedUntilFilterMode.ALL)
+        
+        directionGroup.setOnCheckedChangeListener { _, checkedId ->
+            val isOff = checkedId == R.id.radio_off
+            setPresetsEnabled(!isOff)
+            if (isOff) {
+                radioGroup.clearCheck()
             }
-            SnoozedUntilFilterMode.CUSTOM_PERIOD -> radioGroup.check(CUSTOM_PERIOD_RADIO_ID)
-            SnoozedUntilFilterMode.SPECIFIC_TIME -> radioGroup.check(SPECIFIC_TIME_RADIO_ID)
         }
         
         // Open picker dialogs when custom options are tapped
@@ -181,20 +190,26 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
         }
         
         applyButton.setOnClickListener {
-            val direction = when (directionGroup.checkedRadioButtonId) {
+            val directionId = directionGroup.checkedRadioButtonId
+            
+            // Off = clear filter
+            if (directionId == R.id.radio_off) {
+                setFragmentResult(REQUEST_KEY, bundleOf(
+                    RESULT_MODE to SnoozedUntilFilterMode.ALL.ordinal,
+                    RESULT_DIRECTION to FilterDirection.BEFORE.ordinal,
+                    RESULT_VALUE to 0L
+                ))
+                dismiss()
+                return@setOnClickListener
+            }
+            
+            val direction = when (directionId) {
                 R.id.radio_after -> FilterDirection.AFTER
                 else -> FilterDirection.BEFORE
             }
             
             val checkedId = radioGroup.checkedRadioButtonId
             when {
-                checkedId == ALL_RADIO_ID -> {
-                    setFragmentResult(REQUEST_KEY, bundleOf(
-                        RESULT_MODE to SnoozedUntilFilterMode.ALL.ordinal,
-                        RESULT_DIRECTION to direction.ordinal,
-                        RESULT_VALUE to 0L
-                    ))
-                }
                 checkedId == CUSTOM_PERIOD_RADIO_ID && customPeriodMillis > 0 -> {
                     setFragmentResult(REQUEST_KEY, bundleOf(
                         RESULT_MODE to SnoozedUntilFilterMode.CUSTOM_PERIOD.ordinal,
@@ -218,9 +233,10 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
                             RESULT_VALUE to selectedPreset.second
                         ))
                     } else {
+                        // Before/After selected but no preset chosen — treat as off
                         setFragmentResult(REQUEST_KEY, bundleOf(
                             RESULT_MODE to SnoozedUntilFilterMode.ALL.ordinal,
-                            RESULT_DIRECTION to direction.ordinal,
+                            RESULT_DIRECTION to FilterDirection.BEFORE.ordinal,
                             RESULT_VALUE to 0L
                         ))
                     }
diff --git a/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml b/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
index 27a02e4c..1773e64f 100644
--- a/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
+++ b/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
@@ -20,6 +20,13 @@
         android:orientation="horizontal"
         android:paddingBottom="12dp">
 
+        <RadioButton
+            android:id="@+id/radio_off"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@string/filter_snoozed_until_off" />
+
         <RadioButton
             android:id="@+id/radio_before"
             android:layout_width="0dp"
diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml
index 11b3758c..f30c395c 100644
--- a/android/app/src/main/res/values/strings.xml
+++ b/android/app/src/main/res/values/strings.xml
@@ -846,7 +846,7 @@
     <!-- Snoozed until filter -->
     <string name="filter_snoozed_until">Snoozed Until</string>
     <string name="filter_snoozed_until_display">Snoozed %s</string>
-    <string name="filter_snoozed_until_all">All</string>
+    <string name="filter_snoozed_until_off">Off</string>
     <string name="filter_snoozed_until_before">Before</string>
     <string name="filter_snoozed_until_after">After</string>
     <string name="filter_snoozed_until_custom_period">For a custom period…</string>

From c5c26ca88f74533874a6a25fdfa90fcebe3f0164 Mon Sep 17 00:00:00 2001
From: William Harris <wharris@upscalews.com>
Date: Thu, 5 Mar 2026 04:14:36 +0000
Subject: [PATCH 5/5] feat: include unsnoozed

---
 .../github/quarck/calnotify/ui/FilterState.kt |  10 +-
 .../quarck/calnotify/ui/MainActivityModern.kt |   3 +-
 .../ui/SnoozedUntilFilterBottomSheet.kt       |  40 +++++--
 .../bottom_sheet_snoozed_until_filter.xml     |  13 +++
 android/app/src/main/res/values/strings.xml   |   1 +
 .../quarck/calnotify/ui/FilterStateTest.kt    | 106 ++++++++++++++++++
 docs/dev_todo/snoozed_until_filter_pill.md    |  11 +-
 7 files changed, 164 insertions(+), 20 deletions(-)

diff --git a/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt b/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt
index 225530a1..71980cd4 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/ui/FilterState.kt
@@ -59,11 +59,12 @@ enum class SnoozedUntilFilterMode {
 data class SnoozedUntilFilterConfig(
     val mode: SnoozedUntilFilterMode = SnoozedUntilFilterMode.ALL,
     val direction: FilterDirection = FilterDirection.BEFORE,
-    val valueMillis: Long = 0L
+    val valueMillis: Long = 0L,
+    val includeUnsnoozed: Boolean = false
 ) {
     fun matches(event: EventAlertRecord, now: Long): Boolean {
         if (mode == SnoozedUntilFilterMode.ALL) return true
-        if (event.snoozedUntil == 0L) return false
+        if (event.snoozedUntil == 0L) return includeUnsnoozed
 
         val threshold = when (mode) {
             SnoozedUntilFilterMode.ALL -> return true
@@ -96,6 +97,7 @@ data class FilterState(
         private const val BUNDLE_SNOOZED_UNTIL_MODE = "filter_snoozed_until_mode"
         private const val BUNDLE_SNOOZED_UNTIL_DIRECTION = "filter_snoozed_until_direction"
         private const val BUNDLE_SNOOZED_UNTIL_VALUE = "filter_snoozed_until_value"
+        private const val BUNDLE_SNOOZED_UNTIL_INCLUDE_UNSNOOZED = "filter_snoozed_until_include_unsnoozed"
         
         /** Deserialize FilterState from a Bundle */
         fun fromBundle(bundle: Bundle?): FilterState {
@@ -123,7 +125,8 @@ data class FilterState(
                 direction = FilterDirection.entries.getOrNull(
                     bundle.getInt(BUNDLE_SNOOZED_UNTIL_DIRECTION, 0)
                 ) ?: FilterDirection.BEFORE,
-                valueMillis = bundle.getLong(BUNDLE_SNOOZED_UNTIL_VALUE, 0L)
+                valueMillis = bundle.getLong(BUNDLE_SNOOZED_UNTIL_VALUE, 0L),
+                includeUnsnoozed = bundle.getBoolean(BUNDLE_SNOOZED_UNTIL_INCLUDE_UNSNOOZED, false)
             )
             
             return FilterState(
@@ -146,6 +149,7 @@ data class FilterState(
         putInt(BUNDLE_SNOOZED_UNTIL_MODE, snoozedUntilFilter.mode.ordinal)
         putInt(BUNDLE_SNOOZED_UNTIL_DIRECTION, snoozedUntilFilter.direction.ordinal)
         putLong(BUNDLE_SNOOZED_UNTIL_VALUE, snoozedUntilFilter.valueMillis)
+        putBoolean(BUNDLE_SNOOZED_UNTIL_INCLUDE_UNSNOOZED, snoozedUntilFilter.includeUnsnoozed)
     }
     
     /** Check if any filters are active */
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt b/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt
index 13d2f786..adc4fcf2 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/ui/MainActivityModern.kt
@@ -732,7 +732,8 @@ class MainActivityModern : MainActivityBase() {
                 bundle.getInt(SnoozedUntilFilterBottomSheet.RESULT_DIRECTION, 0)
             ) ?: FilterDirection.BEFORE
             val value = bundle.getLong(SnoozedUntilFilterBottomSheet.RESULT_VALUE, 0L)
-            filterState = filterState.copy(snoozedUntilFilter = SnoozedUntilFilterConfig(mode, direction, value))
+            val includeUnsnoozed = bundle.getBoolean(SnoozedUntilFilterBottomSheet.RESULT_INCLUDE_UNSNOOZED, false)
+            filterState = filterState.copy(snoozedUntilFilter = SnoozedUntilFilterConfig(mode, direction, value, includeUnsnoozed))
             updateFilterChipsForCurrentTab()
             notifyCurrentFragmentFilterChanged()
         }
diff --git a/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt b/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
index 2a28860a..cb007acd 100644
--- a/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
+++ b/android/app/src/main/java/com/github/quarck/calnotify/ui/SnoozedUntilFilterBottomSheet.kt
@@ -26,6 +26,7 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Button
+import android.widget.CheckBox
 import android.widget.DatePicker
 import android.widget.RadioButton
 import android.widget.RadioGroup
@@ -66,7 +67,8 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
                 direction = FilterDirection.entries.getOrNull(
                     args.getInt(ARG_DIRECTION, 0)
                 ) ?: FilterDirection.BEFORE,
-                valueMillis = args.getLong(ARG_VALUE, 0L)
+                valueMillis = args.getLong(ARG_VALUE, 0L),
+                includeUnsnoozed = args.getBoolean(ARG_INCLUDE_UNSNOOZED, false)
             )
         }
     
@@ -87,6 +89,7 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
             isSaveEnabled = false
         }
         val applyButton = view.findViewById<Button>(R.id.btn_apply)
+        val includeUnsnoozedCheckbox = view.findViewById<CheckBox>(R.id.checkbox_include_unsnoozed)
         
         val config = currentConfig
         val presets = settings.snoozedUntilPresets
@@ -107,6 +110,11 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
             config.direction == FilterDirection.AFTER -> directionGroup.check(R.id.radio_after)
         }
         
+        includeUnsnoozedCheckbox.isChecked = config.includeUnsnoozed
+        val isFilterActive = config.mode != SnoozedUntilFilterMode.ALL
+        includeUnsnoozedCheckbox.isEnabled = isFilterActive
+        includeUnsnoozedCheckbox.alpha = if (isFilterActive) 1.0f else 0.4f
+        
         // Preset options
         val presetRadioIds = mutableListOf<Pair<Int, Long>>()
         for (presetMillis in presets) {
@@ -163,19 +171,20 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
             }
         }
         
-        // Enable/disable preset radios based on direction toggle
-        fun setPresetsEnabled(enabled: Boolean) {
+        fun setControlsEnabled(enabled: Boolean) {
             for (i in 0 until radioGroup.childCount) {
                 val child = radioGroup.getChildAt(i)
                 child.isEnabled = enabled
                 child.alpha = if (enabled) 1.0f else 0.4f
             }
+            includeUnsnoozedCheckbox.isEnabled = enabled
+            includeUnsnoozedCheckbox.alpha = if (enabled) 1.0f else 0.4f
         }
-        setPresetsEnabled(config.mode != SnoozedUntilFilterMode.ALL)
+        setControlsEnabled(config.mode != SnoozedUntilFilterMode.ALL)
         
         directionGroup.setOnCheckedChangeListener { _, checkedId ->
             val isOff = checkedId == R.id.radio_off
-            setPresetsEnabled(!isOff)
+            setControlsEnabled(!isOff)
             if (isOff) {
                 radioGroup.clearCheck()
             }
@@ -192,12 +201,15 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
         applyButton.setOnClickListener {
             val directionId = directionGroup.checkedRadioButtonId
             
+            val includeUnsnoozed = includeUnsnoozedCheckbox.isChecked
+            
             // Off = clear filter
             if (directionId == R.id.radio_off) {
                 setFragmentResult(REQUEST_KEY, bundleOf(
                     RESULT_MODE to SnoozedUntilFilterMode.ALL.ordinal,
                     RESULT_DIRECTION to FilterDirection.BEFORE.ordinal,
-                    RESULT_VALUE to 0L
+                    RESULT_VALUE to 0L,
+                    RESULT_INCLUDE_UNSNOOZED to false
                 ))
                 dismiss()
                 return@setOnClickListener
@@ -214,14 +226,16 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
                     setFragmentResult(REQUEST_KEY, bundleOf(
                         RESULT_MODE to SnoozedUntilFilterMode.CUSTOM_PERIOD.ordinal,
                         RESULT_DIRECTION to direction.ordinal,
-                        RESULT_VALUE to customPeriodMillis
+                        RESULT_VALUE to customPeriodMillis,
+                        RESULT_INCLUDE_UNSNOOZED to includeUnsnoozed
                     ))
                 }
                 checkedId == SPECIFIC_TIME_RADIO_ID && specificTimeMillis > 0 -> {
                     setFragmentResult(REQUEST_KEY, bundleOf(
                         RESULT_MODE to SnoozedUntilFilterMode.SPECIFIC_TIME.ordinal,
                         RESULT_DIRECTION to direction.ordinal,
-                        RESULT_VALUE to specificTimeMillis
+                        RESULT_VALUE to specificTimeMillis,
+                        RESULT_INCLUDE_UNSNOOZED to includeUnsnoozed
                     ))
                 }
                 else -> {
@@ -230,14 +244,15 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
                         setFragmentResult(REQUEST_KEY, bundleOf(
                             RESULT_MODE to SnoozedUntilFilterMode.PRESET.ordinal,
                             RESULT_DIRECTION to direction.ordinal,
-                            RESULT_VALUE to selectedPreset.second
+                            RESULT_VALUE to selectedPreset.second,
+                            RESULT_INCLUDE_UNSNOOZED to includeUnsnoozed
                         ))
                     } else {
-                        // Before/After selected but no preset chosen — treat as off
                         setFragmentResult(REQUEST_KEY, bundleOf(
                             RESULT_MODE to SnoozedUntilFilterMode.ALL.ordinal,
                             RESULT_DIRECTION to FilterDirection.BEFORE.ordinal,
-                            RESULT_VALUE to 0L
+                            RESULT_VALUE to 0L,
+                            RESULT_INCLUDE_UNSNOOZED to false
                         ))
                     }
                 }
@@ -349,11 +364,13 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
         private const val ARG_MODE = "arg_mode"
         private const val ARG_DIRECTION = "arg_direction"
         private const val ARG_VALUE = "arg_value"
+        private const val ARG_INCLUDE_UNSNOOZED = "arg_include_unsnoozed"
         
         const val REQUEST_KEY = "snoozed_until_filter_request"
         const val RESULT_MODE = "result_mode"
         const val RESULT_DIRECTION = "result_direction"
         const val RESULT_VALUE = "result_value"
+        const val RESULT_INCLUDE_UNSNOOZED = "result_include_unsnoozed"
         
         fun newInstance(config: SnoozedUntilFilterConfig): SnoozedUntilFilterBottomSheet {
             return SnoozedUntilFilterBottomSheet().apply {
@@ -361,6 +378,7 @@ class SnoozedUntilFilterBottomSheet : BottomSheetDialogFragment() {
                     putInt(ARG_MODE, config.mode.ordinal)
                     putInt(ARG_DIRECTION, config.direction.ordinal)
                     putLong(ARG_VALUE, config.valueMillis)
+                    putBoolean(ARG_INCLUDE_UNSNOOZED, config.includeUnsnoozed)
                 }
             }
         }
diff --git a/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml b/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
index 1773e64f..85a87526 100644
--- a/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
+++ b/android/app/src/main/res/layout/bottom_sheet_snoozed_until_filter.xml
@@ -43,6 +43,19 @@
 
     </RadioGroup>
 
+    <CheckBox
+        android:id="@+id/checkbox_include_unsnoozed"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/filter_include_unsnoozed"
+        android:paddingBottom="8dp" />
+
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="1dp"
+        android:background="?android:attr/listDivider"
+        android:layout_marginBottom="8dp" />
+
     <RadioGroup
         android:id="@+id/snoozed_until_radio_group"
         android:layout_width="match_parent"
diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml
index f30c395c..c44cc324 100644
--- a/android/app/src/main/res/values/strings.xml
+++ b/android/app/src/main/res/values/strings.xml
@@ -849,6 +849,7 @@
     <string name="filter_snoozed_until_off">Off</string>
     <string name="filter_snoozed_until_before">Before</string>
     <string name="filter_snoozed_until_after">After</string>
+    <string name="filter_include_unsnoozed">Include unsnoozed</string>
     <string name="filter_snoozed_until_custom_period">For a custom period…</string>
     <string name="filter_snoozed_until_specific_time">Until a specific time and date…</string>
     <string name="filter_snoozed_until_title">Filter by Snoozed Until</string>
diff --git a/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt b/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt
index 35ceff45..a2ee3d95 100644
--- a/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt
+++ b/android/app/src/test/java/com/github/quarck/calnotify/ui/FilterStateTest.kt
@@ -886,6 +886,83 @@ class FilterStateTest {
         assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(now + DAY_MILLIS), now))
     }
     
+    // === SnoozedUntilFilter includeUnsnoozed Tests ===
+    
+    @Test
+    fun `SnoozedUntilFilter includeUnsnoozed true matches non-snoozed events`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS,
+            includeUnsnoozed = true
+        )
+        
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(0L), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter includeUnsnoozed false excludes non-snoozed events`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS,
+            includeUnsnoozed = false
+        )
+        
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(0L), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter includeUnsnoozed defaults to false`() {
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS
+        )
+        assertFalse(config.includeUnsnoozed)
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter includeUnsnoozed true still filters snoozed events normally`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS,
+            includeUnsnoozed = true
+        )
+        
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + 6 * HOUR_MILLIS), now))
+        assertFalse(config.matches(createSnoozedEventWithSnoozedUntil(now + 2 * DAY_MILLIS), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter includeUnsnoozed with AFTER direction matches non-snoozed`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.AFTER,
+            valueMillis = DAY_MILLIS,
+            includeUnsnoozed = true
+        )
+        
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(0L), now))
+    }
+    
+    @Test
+    fun `SnoozedUntilFilter includeUnsnoozed with ALL mode still matches all`() {
+        val now = TestTimeConstants.STANDARD_TEST_TIME
+        val config = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.ALL,
+            includeUnsnoozed = true
+        )
+        
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(0L), now))
+        assertTrue(config.matches(createSnoozedEventWithSnoozedUntil(now + HOUR_MILLIS), now))
+    }
+    
     // === SnoozedUntilFilter FilterState integration ===
     
     @Test
@@ -1048,11 +1125,40 @@ class FilterStateTest {
         }
     }
     
+    @Test
+    fun `toBundle and fromBundle round-trip includeUnsnoozed true`() {
+        val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS,
+            includeUnsnoozed = true
+        ))
+        
+        val restored = FilterState.fromBundle(original.toBundle())
+        
+        assertTrue(restored.snoozedUntilFilter.includeUnsnoozed)
+    }
+    
+    @Test
+    fun `toBundle and fromBundle round-trip includeUnsnoozed false`() {
+        val original = FilterState(snoozedUntilFilter = SnoozedUntilFilterConfig(
+            mode = SnoozedUntilFilterMode.PRESET,
+            direction = FilterDirection.BEFORE,
+            valueMillis = DAY_MILLIS,
+            includeUnsnoozed = false
+        ))
+        
+        val restored = FilterState.fromBundle(original.toBundle())
+        
+        assertFalse(restored.snoozedUntilFilter.includeUnsnoozed)
+    }
+    
     @Test
     fun `fromBundle with null returns default snoozedUntilFilter`() {
         val restored = FilterState.fromBundle(null)
         assertEquals(SnoozedUntilFilterMode.ALL, restored.snoozedUntilFilter.mode)
         assertEquals(FilterDirection.BEFORE, restored.snoozedUntilFilter.direction)
         assertEquals(0L, restored.snoozedUntilFilter.valueMillis)
+        assertFalse(restored.snoozedUntilFilter.includeUnsnoozed)
     }
 }
diff --git a/docs/dev_todo/snoozed_until_filter_pill.md b/docs/dev_todo/snoozed_until_filter_pill.md
index ad8da0e3..117af67c 100644
--- a/docs/dev_todo/snoozed_until_filter_pill.md
+++ b/docs/dev_todo/snoozed_until_filter_pill.md
@@ -60,9 +60,8 @@ Add a "Snoozed Until" filter chip to the Active tab that filters events based on
 ┌─────────────────────────────────────────────────┐
 │  Filter by Snoozed Until                        │
 ├─────────────────────────────────────────────────┤
-│  [ ● Before | ○ After ]          ← toggle       │
-├─────────────────────────────────────────────────┤
-│  ○  All                                         │
+│  [ ○ Off | ● Before | ○ After ]   ← 3-way      │
+│  ☐ Include unsnoozed              ← checkbox    │
 │  ─────────────────────────────────              │
 │  ○  12 hours                                    │
 │  ●  1 day                          ← current   │
@@ -111,7 +110,8 @@ Unlike the simple `TimeFilter` enum, this filter needs to represent multiple mod
 data class SnoozedUntilFilterConfig(
     val mode: SnoozedUntilFilterMode = SnoozedUntilFilterMode.ALL,
     val direction: FilterDirection = FilterDirection.BEFORE,
-    val valueMillis: Long = 0L
+    val valueMillis: Long = 0L,
+    val includeUnsnoozed: Boolean = false
 )
 
 enum class SnoozedUntilFilterMode {
@@ -432,13 +432,14 @@ All in `FilterStateTest.kt` — Robolectric tests following existing patterns.
 
 **SnoozedUntilFilterConfig.matches():**
 - ALL mode — matches everything (snoozed and non-snoozed)
-- Non-snoozed events (snoozedUntil == 0) excluded for all non-ALL modes
+- Non-snoozed events (snoozedUntil == 0) — excluded by default; included when `includeUnsnoozed = true`
 - PRESET + BEFORE — snoozedUntil <= now + duration
 - PRESET + AFTER — snoozedUntil > now + duration
 - CUSTOM_PERIOD — same threshold logic as PRESET
 - SPECIFIC_TIME + BEFORE — snoozedUntil <= absolute timestamp
 - SPECIFIC_TIME + AFTER — snoozedUntil > absolute timestamp
 - Boundary: snoozedUntil == threshold → BEFORE matches, AFTER doesn't
+- `includeUnsnoozed` — checkbox in bottom sheet; when checked, events with snoozedUntil == 0 pass through the filter regardless of mode/direction
 
 **FilterState integration:**
 - `matchesSnoozedUntil()` delegates correctly