docs: record v0.3.0 (month/week/day views, view switcher) in CHANGELOG

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
feat(day): single-column day view, wire into view switcher
2026-06-10 20:44:22 +02:00 · 2026-06-10 20:40:02 +02:00 · 2026-06-10 20:05:40 +02:00 · 2026-06-10 20:05:40 +02:00 · 2026-06-09 10:38:08 +02:00 · 2026-06-08 20:30:40 +02:00
37 changed files with 3022 additions and 379 deletions
--- a/.planning/ROADMAP.md
+++ b/.planning/ROADMAP.md
@@ -6,8 +6,8 @@
 |---|---|---|
 | v0.1 | Foundation & CI | complete |
 | v0.2 | Data Layer & Permission Flow | complete |
-| v0.3 | Month view | pending |
-| v0.4 | Week view | pending |
+| v0.3 | Month view | in progress |
+| v0.4 | Week view | in progress |
 | v0.5 | Day view | pending |
 | v0.6 | Event Detail Sheet | pending |
 | v0.7 | Filter & Settings | pending |
--- a/.planning/STATE.md
+++ b/.planning/STATE.md
@@ -1,11 +1,12 @@
 # Calendula — Current State

-*Last updated: 2026-06-08*
+*Last updated: 2026-06-10*

 ## Status

-**Milestone:** v0.2 — Data Layer & Permission Flow
-**Phase:** Plan 02 complete; UI-design iteration pending before Plan 03
+**Milestone:** v0.4 — Week view (in progress)
+**Phase:** Month + Week views implemented; cross-cutting wiring (detail sheet,
+filter, settings, jump-to-date) still stubbed

 ## Progress

@@ -13,11 +14,15 @@
 - [x] V1 design decisions resolved (App name "Calendula", icon, seed color)
 - [x] Plan 01 written and executed — foundation lands (theme, icon, i18n, Hilt, DataStore, CI green)
 - [x] Plan 02 written and executed — data layer + permission flow + debug screen
- [ ] UI-design iteration (mockups for Month/Week/Day/Detail/Filter/Settings, all three states)
- [ ] Plan 03 (Month view)
+- [x] Month view (S1) — 6-week grid, event dots, today marker, swipe nav, three states (replaces debug screen)
+- [x] Week view (S2) — time schedule with overlap-resolved lanes, all-day strip, swipe nav, three states
+- [x] View-switcher (M1) wired — cycles Month ↔ Week (Day joins once S3 lands)
+- [ ] Day view (S3)
+- [ ] Event-detail sheet (S4) — week/month event taps are currently no-ops
+- [ ] Filter sheet (M3), Settings (M4), Jump-to-date (M2) — drawer entries stubbed

 ## Next

-1. Iterate on UI design (mockups per screen, all three states)
-2. Write Plan 03: Month view
-3. Execute Plan 03 — Debug screen gets replaced by month view
+1. Day view (S3) — slot it into the view-switcher cycle
+2. Event-detail sheet (S4) — wire month-day and week-event taps to it
+3. Revisit month/week UI polish + shared anchor-date continuity across views
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+## [0.3.0] — 2026-06-10
+
+### Added
+- Month view (S1): Material 3 Expressive card-per-day grid (only the current
+  month's weeks; neighbouring days left blank), per-day event dots with "+N"
+  overflow, today emphasised via `primaryContainer`, spring-based press
+  feedback from the active motion scheme, swipe + drawer navigation,
+  Loading/Failure/Success states
+- Week view (S2): vertical time schedule with overlap-resolved lanes,
+  separate all-day strip, midnight-spanning events clipped per day, swipe
+  navigation, Loading/Failure/Success states
+- Day view (S3): single-column slice of the week schedule reusing its
+  overlap-lane layout, per-day swipe navigation, noon-centred scroll that
+  persists across swipes, animated all-day strip, compact top bar with the
+  full date, Loading/Failure/Success states
+- Functional view-switcher (M1) cycling Month ↔ Week ↔ Day
+- Shared calendar UI building blocks in `ui/common/` (navigation drawer,
+  failure screen, view-switcher pill, color pastelizer, observable locale)
+
+### Removed
+- Throwaway debug screen — superseded by the month view
+
+## [0.2.1] — 2026-06-09
+
+### Changed
+- Regenerated the F-Droid catalog `icon.png` (512x512, both locales) so it
+  is pixel-faithful to the on-device adaptive launcher icon: same slate
+  background (`#5C6B7A`), off-white mark (`#FAF6F0`), and the foreground
+  group transform (`scale 0.5`, pivot `114,108`, translate `2,8`) baked in.
+- Added `design/icon/calendula_launcher.svg` — the composed full-bleed
+  icon (background + transformed mark) as the single source of truth for
+  store/F-Droid renders.
+
 ## [0.2.0] — 2026-06-08

 ### Added
@@ -19,6 +52,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Unit-Tests für Cursor-Mapping (alle §8-Defensiv-Cases), Repository-Flows mit Turbine, DataStore round-trip
 - Instrumented smoke test against the real CalendarContract provider

+### Changed
+- Redesigned launcher icon: line-art calendar with a stylized "1" inside
+  (kalendae reference) and a small calendula bloom badge in the
+  bottom-right corner. Replaces the simple "1"-only foreground from
+  v0.1.0. Source SVG checked in at `design/icon/calendula_mark.svg`,
+  also used to regenerate the F-Droid catalog `icon.png` (512x512)
+  per locale.
+
 ## [0.1.1] — 2026-06-08

 ### Fixed
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -98,6 +98,7 @@ dependencies {
    implementation(libs.androidx.ui.graphics)
    implementation(libs.androidx.ui.tooling.preview)
    implementation(libs.androidx.material3)
+    implementation(libs.androidx.compose.material.icons.core)

    implementation(libs.hilt.android)
    implementation(libs.androidx.hilt.navigation.compose)
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt
@@ -0,0 +1,41 @@
+package de.jeanlucmakiola.calendula.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.day.DayScreen
+import de.jeanlucmakiola.calendula.ui.month.MonthScreen
+import de.jeanlucmakiola.calendula.ui.week.WeekScreen
+
+/**
+ * Holds the active top-level view (spec M1) and swaps between the calendar
+ * screens. Each screen owns its own ViewModel and date anchor; the view-switcher
+ * pill in their top bars writes back here via [onSelectView].
+ */
+@Composable
+fun CalendarHost(modifier: Modifier = Modifier) {
+    var view by rememberSaveable { mutableStateOf(CalendarView.Month) }
+    val onSelectView: (CalendarView) -> Unit = { view = it }
+
+    when (view) {
+        CalendarView.Week -> WeekScreen(
+            selectedView = view,
+            onSelectView = onSelectView,
+            modifier = modifier,
+        )
+        CalendarView.Day -> DayScreen(
+            selectedView = view,
+            onSelectView = onSelectView,
+            modifier = modifier,
+        )
+        CalendarView.Month -> MonthScreen(
+            selectedView = view,
+            onSelectView = onSelectView,
+            modifier = modifier,
+        )
+    }
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/RootScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/RootScreen.kt
@@ -2,21 +2,18 @@ package de.jeanlucmakiola.calendula.ui

 import android.Manifest
 import android.content.pm.PackageManager
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
-import de.jeanlucmakiola.calendula.ui.debug.DebugScreen
 import de.jeanlucmakiola.calendula.ui.permission.PermissionScreen

@Composable
@@ -42,14 +39,12 @@ fun RootScreen(modifier: Modifier = Modifier) {
        onDispose { lifecycle.removeObserver(obs) }
    }

-    Scaffold(modifier = modifier) { innerPadding ->
-        if (hasPermission) {
-            DebugScreen(modifier = Modifier.padding(innerPadding))
-        } else {
-            PermissionScreen(
-                onGranted = { hasPermission = true },
-                modifier = Modifier.padding(innerPadding),
-            )
-        }
+    if (hasPermission) {
+        CalendarHost(modifier = modifier)
+    } else {
+        PermissionScreen(
+            onGranted = { hasPermission = true },
+            modifier = modifier,
+        )
    }
 }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarColors.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarColors.kt
@@ -0,0 +1,17 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.ui.graphics.Color
+
+/**
+ * Soften a raw calendar color toward a pastel that fits the active theme.
+ *  - Keeps the hue (so users still recognise their calendars)
+ *  - Caps saturation so harsh provider colors stop screaming
+ *  - Pins value/brightness to a band that reads on both light and dark surfaces
+ */
+fun pastelize(rawArgb: Int, dark: Boolean): Color {
+    val hsv = FloatArray(3)
+    android.graphics.Color.colorToHSV(rawArgb, hsv)
+    hsv[1] = (hsv[1] * 0.6f).coerceIn(0.25f, 0.65f)
+    hsv[2] = if (dark) 0.82f else 0.72f
+    return Color(android.graphics.Color.HSVToColor(hsv))
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt
@@ -0,0 +1,65 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalDrawerSheet
+import androidx.compose.material3.NavigationDrawerItem
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Navigation drawer shared by every top-level calendar screen (M2/M3/M4
+ * entry points). Stateless — the host screen owns the drawer state and wires
+ * the callbacks.
+ */
+@Composable
+fun CalendarDrawer(
+    onToday: () -> Unit,
+    onJumpToDate: () -> Unit,
+    onFilter: () -> Unit,
+    onSettings: () -> Unit,
+) {
+    ModalDrawerSheet {
+        Text(
+            text = stringResource(R.string.app_name),
+            style = MaterialTheme.typography.titleLarge,
+            modifier = Modifier.padding(horizontal = 28.dp, vertical = 24.dp),
+        )
+        HorizontalDivider()
+        Spacer(Modifier.height(8.dp))
+        NavigationDrawerItem(
+            label = { Text(stringResource(R.string.month_today_action)) },
+            selected = false,
+            onClick = onToday,
+            modifier = Modifier.padding(horizontal = 12.dp),
+        )
+        NavigationDrawerItem(
+            label = { Text(stringResource(R.string.month_action_jump_to_date)) },
+            selected = false,
+            onClick = onJumpToDate,
+            modifier = Modifier.padding(horizontal = 12.dp),
+        )
+        NavigationDrawerItem(
+            label = { Text(stringResource(R.string.month_action_filter)) },
+            selected = false,
+            onClick = onFilter,
+            modifier = Modifier.padding(horizontal = 12.dp),
+        )
+        Spacer(Modifier.height(8.dp))
+        HorizontalDivider()
+        Spacer(Modifier.height(8.dp))
+        NavigationDrawerItem(
+            label = { Text(stringResource(R.string.month_action_settings)) },
+            selected = false,
+            onClick = onSettings,
+            modifier = Modifier.padding(horizontal = 12.dp),
+        )
+    }
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarFailure.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarFailure.kt
@@ -0,0 +1,56 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.FailureReason
+
+/**
+ * Full-screen failure state shared by every calendar screen (spec §7).
+ * One explanation line + one recovery action, never a toast.
+ */
+@Composable
+fun CalendarFailure(reason: FailureReason, onRetry: () -> Unit) {
+    val titleRes = when (reason) {
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars
+        FailureReason.ProviderUnavailable -> R.string.state_failure_provider
+        FailureReason.Unknown,
+        FailureReason.EventNotFound -> R.string.state_failure_unknown
+    }
+    val actionRes = when (reason) {
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars_action
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission_action
+        else -> R.string.state_retry
+    }
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(32.dp),
+        verticalArrangement = Arrangement.Center,
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(
+            text = stringResource(titleRes),
+            style = MaterialTheme.typography.headlineSmall,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(24.dp))
+        FilledTonalButton(onClick = onRetry) {
+            Text(stringResource(actionRes))
+        }
+    }
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarTransitions.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarTransitions.kt
@@ -0,0 +1,40 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.ContentTransform
+import androidx.compose.animation.core.FiniteAnimationSpec
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.IntOffset
+
+/**
+ * The M3 Expressive spatial spring used for the month/week slide: the *fast*
+ * spring-physics spec from the active motion scheme — snappy with a subtle
+ * springy settle, rather than a fixed easing curve.
+ *
+ * Read it in a composable scope (this helper) so it can be captured by the
+ * non-composable `AnimatedContent` transitionSpec lambda.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun rememberCalendarSlideSpec(): FiniteAnimationSpec<IntOffset> =
+    MaterialTheme.motionScheme.fastSpatialSpec()
+
+/**
+ * Horizontal slide for navigating between adjacent months/weeks.
+ *
+ * @param slideDir +1 = forward (incoming from the right), -1 = back, 0 = jump
+ *                 (e.g. "today"); a jump reuses the forward direction.
+ * @param spec     spatial animation spec, typically [rememberCalendarSlideSpec].
+ */
+fun calendarSlideTransition(
+    slideDir: Int,
+    spec: FiniteAnimationSpec<IntOffset>,
+): ContentTransform {
+    val dir = if (slideDir == 0) 1 else slideDir
+    return slideInHorizontally(spec) { w -> dir * w }
+        .togetherWith(slideOutHorizontally(spec) { w -> -dir * w })
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarView.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarView.kt
@@ -0,0 +1,25 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+/**
+ * The top-level calendar views the user can switch between (spec M1).
+ * Day is declared but not yet implemented (v0.5) — see [IMPLEMENTED_VIEWS].
+ */
+enum class CalendarView {
+    Month,
+    Week,
+    Day,
+}
+
+/**
+ * Views that actually have a screen today. The view-switcher pill cycles
+ * through these in order.
+ */
+val IMPLEMENTED_VIEWS: List<CalendarView> =
+    listOf(CalendarView.Month, CalendarView.Week, CalendarView.Day)
+
+/** Next view in [available], wrapping around. Falls back to Month if absent. */
+fun CalendarView.next(available: List<CalendarView> = IMPLEMENTED_VIEWS): CalendarView {
+    val i = available.indexOf(this)
+    if (i < 0) return available.firstOrNull() ?: CalendarView.Month
+    return available[(i + 1) % available.size]
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/LocaleSupport.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/LocaleSupport.kt
@@ -0,0 +1,20 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.core.os.ConfigurationCompat
+import java.util.Locale
+
+/**
+ * Current display [Locale], read observably from [LocalConfiguration] so the UI
+ * recomposes after a locale change (lint: NonObservableLocale). Used for
+ * weekday/month name formatting.
+ */
+@Composable
+fun currentLocale(): Locale {
+    val configuration = LocalConfiguration.current
+    return remember(configuration) {
+        ConfigurationCompat.getLocales(configuration).get(0) ?: Locale.getDefault()
+    }
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ViewSwitcherPill.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ViewSwitcherPill.kt
@@ -0,0 +1,33 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Top-bar pill that shows the current view and cycles to the next one on tap
+ * (spec M1: Month → Week → Day → Month, restricted to [IMPLEMENTED_VIEWS]).
+ */
+@Composable
+fun ViewSwitcherPill(
+    current: CalendarView,
+    onCycle: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val labelRes = when (current) {
+        CalendarView.Month -> R.string.view_month
+        CalendarView.Week -> R.string.view_week
+        CalendarView.Day -> R.string.view_day
+    }
+    FilledTonalButton(
+        onClick = onCycle,
+        shape = MaterialTheme.shapes.large,
+        modifier = modifier,
+    ) {
+        Text(stringResource(labelRes))
+    }
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt
@@ -0,0 +1,552 @@
+package de.jeanlucmakiola.calendula.ui.day
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.DrawerValue
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExtendedFloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalNavigationDrawer
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberDrawerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
+import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
+import de.jeanlucmakiola.calendula.ui.common.next
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
+import de.jeanlucmakiola.calendula.ui.week.MINUTES_PER_DAY
+import de.jeanlucmakiola.calendula.ui.week.TimedBlock
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.datetime.LocalDate
+import java.time.format.TextStyle as JavaTextStyle
+import java.util.Locale
+import kotlin.math.roundToInt
+
+private val HOUR_HEIGHT = 56.dp
+private val GUTTER_WIDTH = 48.dp
+private val MIN_EVENT_HEIGHT = 24.dp
+private val ALL_DAY_ROW_HEIGHT = 24.dp
+private val ALL_DAY_VERTICAL_PADDING = 6.dp
+
+/** Total all-day strip height for the day (0 when there are no all-day events). */
+private fun DayUiState.Success.allDayStripHeight(): Dp {
+    if (allDay.isEmpty()) return 0.dp
+    val lanes = allDay.maxOf { it.lane } + 1
+    return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DayScreen(
+    selectedView: CalendarView,
+    onSelectView: (CalendarView) -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: DayViewModel = hiltViewModel(),
+) {
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    val date by viewModel.date.collectAsStateWithLifecycle()
+
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+
+    // The all-day strip shares the app bar's scrolled colour so the whole top
+    // region elevates together once the timeline scrolls under it.
+    val topSectionColor by animateColorAsState(
+        targetValue = if (scrollBehavior.state.overlappedFraction > 0.01f) {
+            MaterialTheme.colorScheme.surfaceContainer
+        } else {
+            MaterialTheme.colorScheme.surface
+        },
+        label = "day-top-section-color",
+    )
+
+    val isOnToday = when (val s = state) {
+        is DayUiState.Success -> s.date == s.today
+        else -> true
+    }
+
+    // Slide direction for the day transition: +1 = next, -1 = prev, 0 = jump.
+    var slideDir by remember { mutableIntStateOf(0) }
+    val goNext = { slideDir = 1; viewModel.goToNext() }
+    val goPrev = { slideDir = -1; viewModel.goToPrev() }
+    val jumpToToday = { slideDir = 0; viewModel.goToToday() }
+
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        // Open only via the menu button — edge-swipe would fight the day swipe.
+        gesturesEnabled = drawerState.isOpen,
+        drawerContent = {
+            CalendarDrawer(
+                onToday = { jumpToToday(); scope.launch { drawerState.close() } },
+                onJumpToDate = { scope.launch { drawerState.close() } /* TODO: date picker */ },
+                onFilter = { scope.launch { drawerState.close() } /* TODO: filter sheet */ },
+                onSettings = { scope.launch { drawerState.close() } /* TODO: settings */ },
+            )
+        },
+    ) {
+        Scaffold(
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
+            topBar = {
+                DayTopBar(
+                    date = date,
+                    selectedView = selectedView,
+                    onCycleView = { onSelectView(selectedView.next()) },
+                    onOpenDrawer = { scope.launch { drawerState.open() } },
+                    scrollBehavior = scrollBehavior,
+                )
+            },
+            floatingActionButton = {
+                AnimatedVisibility(
+                    visible = !isOnToday,
+                    enter = scaleIn(),
+                    exit = scaleOut(),
+                ) {
+                    ExtendedFloatingActionButton(
+                        onClick = jumpToToday,
+                        icon = { Icon(Icons.Default.Refresh, contentDescription = null) },
+                        text = { Text(stringResource(R.string.day_today_action)) },
+                    )
+                }
+            },
+        ) { innerPadding ->
+            DayContent(
+                state = state,
+                slideDir = slideDir,
+                topSectionColor = topSectionColor,
+                onSwipeNext = goNext,
+                onSwipePrev = goPrev,
+                onRetry = jumpToToday,
+                modifier = Modifier
+                    .padding(innerPadding)
+                    .fillMaxSize(),
+            )
+        }
+    }
+}
+
+@Composable
+private fun DayContent(
+    state: DayUiState,
+    slideDir: Int,
+    topSectionColor: Color,
+    onSwipeNext: () -> Unit,
+    onSwipePrev: () -> Unit,
+    onRetry: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val density = LocalDensity.current
+    val threshold = with(density) { 24.dp.toPx() }
+    var dragAccum by remember { mutableFloatStateOf(0f) }
+    val slideSpec = rememberCalendarSlideSpec()
+
+    // Hoisted above the per-day AnimatedContent so the vertical scroll position
+    // survives day-to-day swipes. We only centre on noon once, on first entry
+    // into the day view (i.e. when arriving from the month/week view).
+    val scrollState = rememberScrollState()
+    LaunchedEffect(Unit) {
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        val maxV = scrollState.maxValue
+        val target = with(density) {
+            (HOUR_HEIGHT.toPx() * 12 - (HOUR_HEIGHT.toPx() * 24 - maxV) / 2f).roundToInt()
+        }.coerceIn(0, maxV)
+        scrollState.scrollTo(target)
+    }
+
+    // Single, hoisted all-day strip height — shared by the outgoing and incoming
+    // day during a swipe, so the strip slides along but never jumps in height.
+    val targetAllDayHeight = (state as? DayUiState.Success)?.allDayStripHeight() ?: 0.dp
+    val allDayHeight by animateDpAsState(
+        targetValue = targetAllDayHeight,
+        label = "day-all-day-strip-height",
+    )
+
+    // Whole-page horizontal swipe, one level above the timeline's vertical
+    // scroll: a horizontal drag crosses this detector's slop, while a vertical
+    // drag is consumed by the inner scroll first — the two gestures coexist.
+    val swipeModifier = Modifier.pointerInput(Unit) {
+        detectHorizontalDragGestures(
+            onDragStart = { dragAccum = 0f },
+            onDragEnd = {
+                when {
+                    dragAccum < -threshold -> onSwipeNext()
+                    dragAccum > threshold -> onSwipePrev()
+                }
+                dragAccum = 0f
+            },
+            onDragCancel = { dragAccum = 0f },
+            onHorizontalDrag = { _, drag -> dragAccum += drag },
+        )
+    }
+
+    AnimatedContent(
+        targetState = state,
+        modifier = modifier.then(swipeModifier),
+        contentKey = { s ->
+            when (s) {
+                is DayUiState.Success -> "success-${s.date}"
+                is DayUiState.Failure -> "failure-${s.reason}"
+                DayUiState.Loading -> "loading"
+            }
+        },
+        transitionSpec = { calendarSlideTransition(slideDir, slideSpec) },
+        label = "day-transition",
+    ) { s ->
+        when (s) {
+            DayUiState.Loading -> DayLoading()
+            is DayUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onRetry)
+            is DayUiState.Success -> DaySuccess(
+                state = s,
+                topSectionColor = topSectionColor,
+                scrollState = scrollState,
+                allDayHeight = allDayHeight,
+            )
+        }
+    }
+}
+
+@Composable
+private fun DaySuccess(
+    state: DayUiState.Success,
+    topSectionColor: Color,
+    scrollState: ScrollState,
+    allDayHeight: Dp,
+) {
+    Column(modifier = Modifier.fillMaxSize()) {
+        // All-day strip collapses to nothing when the day has no all-day events,
+        // so the timeline sits directly under the app bar.
+        AllDayStrip(
+            state = state,
+            height = allDayHeight,
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(topSectionColor),
+        )
+        // Breathing room between the (colour-shifting) top section and the
+        // scrolling timeline below.
+        Spacer(Modifier.height(8.dp))
+        Timeline(state = state, scrollState = scrollState)
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun DayTopBar(
+    date: LocalDate,
+    selectedView: CalendarView,
+    onCycleView: () -> Unit,
+    onOpenDrawer: () -> Unit,
+    scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
+) {
+    TopAppBar(
+        title = {
+            Text(
+                text = formatDayTitle(date),
+                style = MaterialTheme.typography.titleLarge,
+            )
+        },
+        navigationIcon = {
+            IconButton(onClick = onOpenDrawer) {
+                Icon(
+                    imageVector = Icons.Default.Menu,
+                    contentDescription = stringResource(R.string.month_open_menu),
+                )
+            }
+        },
+        actions = {
+            ViewSwitcherPill(
+                current = selectedView,
+                onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
+            )
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surfaceContainer,
+        ),
+        scrollBehavior = scrollBehavior,
+    )
+}
+
+@Composable
+private fun AllDayStrip(
+    state: DayUiState.Success,
+    height: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val dark = isSystemInDarkTheme()
+
+    Row(
+        modifier = modifier
+            // Height is hoisted + animated so it resizes smoothly; padding sits
+            // inside it so the content area is lanes * row height.
+            .height(height)
+            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+    ) {
+        // Keep the gutter-width offset so the bars line up with the day column.
+        Spacer(Modifier.width(GUTTER_WIDTH))
+        // Bars are positioned absolutely by lane (vertical stacking); each spans
+        // the full day-column width. clipToBounds keeps bars from spilling out
+        // while the height animates.
+        BoxWithConstraints(
+            modifier = Modifier
+                .weight(1f)
+                .fillMaxHeight()
+                .clipToBounds(),
+        ) {
+            val barWidth = maxWidth
+            state.allDay.forEach { span ->
+                AllDayBar(
+                    event = span.event,
+                    dark = dark,
+                    modifier = Modifier
+                        .offset(y = ALL_DAY_ROW_HEIGHT * span.lane)
+                        .width(barWidth)
+                        .height(ALL_DAY_ROW_HEIGHT)
+                        .padding(horizontal = 1.dp, vertical = 1.dp),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun AllDayBar(event: EventInstance, dark: Boolean, modifier: Modifier = Modifier) {
+    val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
+    Box(
+        modifier = modifier
+            .background(pastelize(event.color, dark), RoundedCornerShape(4.dp))
+            .padding(horizontal = 6.dp, vertical = 2.dp)
+            .semantics { contentDescription = title },
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.labelSmall,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            color = Color.Black.copy(alpha = 0.8f),
+        )
+    }
+}
+
+@Composable
+private fun Timeline(state: DayUiState.Success, scrollState: ScrollState) {
+    val totalHeight = HOUR_HEIGHT * 24
+    val dark = isSystemInDarkTheme()
+
+    Box(modifier = Modifier.fillMaxSize()) {
+        // Gutter and day column are two scroll viewports that SHARE one scroll
+        // state, so they stay perfectly aligned. The day-column viewport is a
+        // static, rounded-clipped window — the content scrolls inside it, so the
+        // soft corners are permanent at any scroll position.
+        Row(modifier = Modifier.fillMaxSize()) {
+            // Hour gutter (scrolls in sync with the day column)
+            Column(
+                modifier = Modifier
+                    .width(GUTTER_WIDTH)
+                    .fillMaxHeight()
+                    .verticalScroll(scrollState),
+            ) {
+                (0 until 24).forEach { h ->
+                    Box(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .height(HOUR_HEIGHT),
+                    ) {
+                        if (h > 0) {
+                            Text(
+                                text = "%02d".format(h),
+                                style = MaterialTheme.typography.labelSmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                modifier = Modifier
+                                    .align(Alignment.TopCenter)
+                                    .offset(y = (-6).dp),
+                            )
+                        }
+                    }
+                }
+            }
+            // Day column: rounded, clipped scroll viewport (permanent corners).
+            Box(
+                modifier = Modifier
+                    .weight(1f)
+                    .fillMaxHeight()
+                    .clip(RoundedCornerShape(16.dp))
+                    .verticalScroll(scrollState),
+            ) {
+                DayColumnCard(
+                    blocks = state.timed,
+                    dark = dark,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(totalHeight),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun DayColumnCard(
+    blocks: List<TimedBlock>,
+    dark: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    Card(
+        // Plain rectangular column — the soft corners come from the outer
+        // rounded scroll viewport, so inner rounding would look odd at the edges.
+        shape = RectangleShape,
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        ),
+        modifier = modifier,
+    ) {
+        BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
+            val colWidth = maxWidth
+            blocks.forEach { block ->
+                val laneWidth = colWidth / block.laneCount
+                val top = HOUR_HEIGHT * (block.startMin / 60f)
+                val rawHeight = HOUR_HEIGHT * ((block.endMin - block.startMin) / 60f)
+                val height = if (rawHeight < MIN_EVENT_HEIGHT) MIN_EVENT_HEIGHT else rawHeight
+                EventBlock(
+                    block = block,
+                    dark = dark,
+                    modifier = Modifier
+                        .offset(x = laneWidth * block.lane, y = top)
+                        .width(laneWidth)
+                        .height(height)
+                        .padding(horizontal = 1.dp),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun EventBlock(
+    block: TimedBlock,
+    dark: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
+    val timeLabel = "${minToHm(block.startMin)}–${minToHm(block.endMin)}"
+    val showTime = block.endMin - block.startMin >= 45
+    Box(
+        modifier = modifier
+            .background(pastelize(block.event.color, dark), RoundedCornerShape(4.dp))
+            .padding(horizontal = 4.dp, vertical = 2.dp)
+            .semantics { contentDescription = "$title, $timeLabel" },
+    ) {
+        Column {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.labelMedium,
+                maxLines = if (showTime) 1 else 2,
+                overflow = TextOverflow.Ellipsis,
+                color = Color.Black.copy(alpha = 0.85f),
+            )
+            if (showTime) {
+                Text(
+                    text = timeLabel,
+                    style = MaterialTheme.typography.labelSmall,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    color = Color.Black.copy(alpha = 0.6f),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun DayLoading() {
+    val totalHeight = HOUR_HEIGHT * 24
+    val scrollState = rememberScrollState()
+    Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+        Spacer(Modifier.width(GUTTER_WIDTH))
+        Box(
+            modifier = Modifier
+                .weight(1f)
+                .height(totalHeight)
+                .padding(horizontal = 2.dp)
+                .background(MaterialTheme.colorScheme.surfaceContainer),
+        )
+    }
+}
+
+private fun minToHm(min: Int): String =
+    if (min >= MINUTES_PER_DAY) "24:00" else "%02d:%02d".format(min / 60, min % 60)
+
+private fun formatDayTitle(date: LocalDate): String {
+    val locale = Locale.getDefault()
+    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
+    val weekday = java.dayOfWeek.getDisplayName(JavaTextStyle.SHORT, locale)
+    val monthName = java.month.getDisplayName(JavaTextStyle.SHORT, locale)
+    return "$weekday, ${date.day}. $monthName ${date.year}"
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayUiState.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayUiState.kt
@@ -0,0 +1,25 @@
+package de.jeanlucmakiola.calendula.ui.day
+
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import de.jeanlucmakiola.calendula.ui.week.AllDaySpan
+import de.jeanlucmakiola.calendula.ui.week.TimedBlock
+import kotlinx.datetime.LocalDate
+
+/**
+ * The day view is a single-column slice of the week view (spec S3). It reuses the
+ * week's [TimedBlock] and [AllDaySpan] layout primitives — for one day, all-day
+ * spans collapse to a single column ([AllDaySpan.startCol] == [AllDaySpan.endCol]
+ * == 0) and only their [AllDaySpan.lane] (vertical stacking) matters.
+ */
+sealed interface DayUiState {
+    data object Loading : DayUiState
+    data class Failure(val reason: FailureReason) : DayUiState
+    data class Success(
+        val date: LocalDate,
+        val today: LocalDate,
+        /** All-day/multi-day events covering this day, stacked by lane. */
+        val allDay: List<AllDaySpan>,
+        /** Timed events clipped to this day with overlap lanes resolved. */
+        val timed: List<TimedBlock>,
+    ) : DayUiState
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayViewModel.kt
@@ -0,0 +1,106 @@
+package de.jeanlucmakiola.calendula.ui.day
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
+import de.jeanlucmakiola.calendula.ui.week.layoutDay
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
+import kotlinx.datetime.minus
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+import kotlin.time.Instant
+import javax.inject.Inject
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+class DayViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val zone = TimeZone.currentSystemDefault()
+
+    private val todayDate: LocalDate
+        get() = Clock.System.now().toLocalDateTime(zone).date
+
+    private val _date = MutableStateFlow(todayDate)
+    val date: StateFlow<LocalDate> = _date
+
+    val state: StateFlow<DayUiState> = _date
+        .flatMapLatest { day ->
+            val range = dayRange(day, zone)
+            combine(
+                repository.calendars(),
+                repository.instances(range),
+            ) { calendars, instances ->
+                buildState(day, calendars, instances)
+            }
+        }
+        .catch { emit(DayUiState.Failure(FailureReason.ProviderUnavailable)) }
+        .flowOn(io)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = DayUiState.Loading,
+        )
+
+    fun goToPrev() {
+        _date.value = _date.value.minus(1, DateTimeUnit.DAY)
+    }
+
+    fun goToNext() {
+        _date.value = _date.value.plus(1, DateTimeUnit.DAY)
+    }
+
+    fun goToToday() {
+        _date.value = todayDate
+    }
+
+    private fun buildState(
+        day: LocalDate,
+        calendars: List<CalendarSource>,
+        instances: List<EventInstance>,
+    ): DayUiState {
+        if (calendars.isEmpty()) {
+            return DayUiState.Failure(FailureReason.NoCalendarsConfigured)
+        }
+        val days = listOf(day)
+        val allDay = instances.filter { it.isAllDay }
+        val timed = instances.filterNot { it.isAllDay }
+        return DayUiState.Success(
+            date = day,
+            today = todayDate,
+            allDay = layoutAllDay(allDay, days, zone),
+            timed = layoutDay(timed, day, zone),
+        )
+    }
+}
+
+/** Half-open instant range covering the single calendar [date]. */
+internal fun dayRange(date: LocalDate, zone: TimeZone): ClosedRange<Instant> {
+    val from = date.atStartOfDayIn(zone)
+    val to = date.atTime(23, 59, 59).toInstant(zone)
+    return from..to
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/debug/DebugScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/debug/DebugScreen.kt
@@ -1,159 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.debug
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
-
-@Composable
-fun DebugScreen(
-    modifier: Modifier = Modifier,
-    viewModel: DebugViewModel = hiltViewModel(),
-) {
-    val state by viewModel.state.collectAsStateWithLifecycle()
-    Column(modifier = modifier.fillMaxSize()) {
-        DebugBanner()
-        when (val s = state) {
-            DebugUiState.Loading -> LoadingContent()
-            is DebugUiState.Failure -> FailureContent()
-            is DebugUiState.Success -> SuccessContent(s)
-        }
-    }
-}
-
-@Composable
-private fun DebugBanner() {
-    Box(
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(MaterialTheme.colorScheme.tertiaryContainer)
-            .padding(horizontal = 16.dp, vertical = 8.dp),
-    ) {
-        Text(
-            text = stringResource(R.string.debug_banner),
-            style = MaterialTheme.typography.labelMedium,
-            color = MaterialTheme.colorScheme.onTertiaryContainer,
-        )
-    }
-}
-
-@Composable
-private fun LoadingContent() {
-    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
-        CircularProgressIndicator()
-    }
-}
-
-@Composable
-private fun FailureContent() {
-    Box(modifier = Modifier.fillMaxSize().padding(24.dp), contentAlignment = Alignment.Center) {
-        Text(
-            text = stringResource(R.string.state_failure_provider),
-            style = MaterialTheme.typography.bodyLarge,
-        )
-    }
-}
-
-@Composable
-private fun SuccessContent(state: DebugUiState.Success) {
-    LazyColumn(
-        modifier = Modifier.fillMaxSize().padding(horizontal = 16.dp),
-        verticalArrangement = Arrangement.spacedBy(4.dp),
-    ) {
-        item { SectionHeader(stringResource(R.string.debug_calendars_header)) }
-        if (state.calendars.isEmpty()) {
-            item {
-                Text(
-                    text = stringResource(R.string.debug_no_calendars),
-                    style = MaterialTheme.typography.bodyMedium,
-                )
-            }
-        } else {
-            items(state.calendars, key = { it.id }) { CalendarRow(it) }
-        }
-
-        item { Spacer(Modifier.height(16.dp)) }
-        item { SectionHeader(stringResource(R.string.debug_events_header)) }
-
-        if (state.nextEvents.isEmpty()) {
-            item {
-                Text(
-                    text = stringResource(R.string.debug_no_events),
-                    style = MaterialTheme.typography.bodyMedium,
-                )
-            }
-        } else {
-            items(state.nextEvents, key = { it.instanceId }) { EventRow(it) }
-        }
-    }
-}
-
-@Composable
-private fun SectionHeader(text: String) {
-    Column(modifier = Modifier.padding(vertical = 8.dp)) {
-        Text(text = text, style = MaterialTheme.typography.titleMedium)
-        HorizontalDivider()
-    }
-}
-
-@Composable
-private fun CalendarRow(cal: CalendarSource) {
-    Row(
-        modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Box(
-            modifier = Modifier
-                .size(12.dp)
-                .background(Color(cal.color), CircleShape),
-        )
-        Text(
-            text = "  ${cal.displayName}  (${cal.accountName})",
-            style = MaterialTheme.typography.bodyMedium,
-        )
-    }
-}
-
-@Composable
-private fun EventRow(event: EventInstance) {
-    val zone = TimeZone.currentSystemDefault()
-    val start = event.start.toLocalDateTime(zone)
-    Column(modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp)) {
-        Text(text = event.title, style = MaterialTheme.typography.bodyMedium)
-        val date = "%04d-%02d-%02d".format(start.year, start.month.ordinal + 1, start.day)
-        val time = "%02d:%02d".format(start.hour, start.minute)
-        Text(
-            text = "$date  $time",
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-        )
-    }
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/debug/DebugUiState.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/debug/DebugUiState.kt
@@ -1,14 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.debug
-
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.FailureReason
-
-sealed interface DebugUiState {
-    data object Loading : DebugUiState
-    data class Failure(val reason: FailureReason) : DebugUiState
-    data class Success(
-        val calendars: List<CalendarSource>,
-        val nextEvents: List<EventInstance>,
-    ) : DebugUiState
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/debug/DebugViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/debug/DebugViewModel.kt
@@ -1,49 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.debug
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
-import de.jeanlucmakiola.calendula.data.di.IoDispatcher
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.stateIn
-import kotlin.time.Duration.Companion.days
-import kotlin.time.Instant
-import javax.inject.Inject
-
-private const val MAX_DEBUG_EVENTS = 50
-private val DEBUG_WINDOW = 30.days
-
-@HiltViewModel
-class DebugViewModel @Inject constructor(
-    private val repository: CalendarRepository,
-    @IoDispatcher private val io: CoroutineDispatcher,
-) : ViewModel() {
-
-    val state: StateFlow<DebugUiState> = run {
-        val now = Instant.fromEpochMilliseconds(System.currentTimeMillis())
-        val range = now..(now + DEBUG_WINDOW)
-        combine(
-            repository.calendars(),
-            repository.instances(range),
-        ) { calendars, instances ->
-            DebugUiState.Success(
-                calendars = calendars,
-                nextEvents = instances.take(MAX_DEBUG_EVENTS),
-            ) as DebugUiState
-        }
-            .catch { emit(DebugUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(5_000L),
-                initialValue = DebugUiState.Loading,
-            )
-    }
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthScreen.kt
@@ -0,0 +1,464 @@
+package de.jeanlucmakiola.calendula.ui.month
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsPressedAsState
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.DrawerValue
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.ExtendedFloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalNavigationDrawer
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberDrawerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
+import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
+import de.jeanlucmakiola.calendula.ui.common.next
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import kotlinx.coroutines.launch
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.YearMonth
+import kotlinx.datetime.plus
+import java.time.format.TextStyle as JavaTextStyle
+import java.util.Locale
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun MonthScreen(
+    selectedView: CalendarView,
+    onSelectView: (CalendarView) -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: MonthViewModel = hiltViewModel(),
+) {
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    val month by viewModel.month.collectAsStateWithLifecycle()
+
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+
+    val isOnCurrentMonth = when (val s = state) {
+        is MonthUiState.Success -> s.month == YearMonth(s.today.year, s.today.month)
+        else -> true
+    }
+
+    // Slide direction for the grid transition: +1 = next, -1 = prev, 0 = jump (no slide).
+    var slideDir by remember { mutableIntStateOf(0) }
+
+    val goNext = {
+        slideDir = 1
+        viewModel.goToNext()
+    }
+    val goPrev = {
+        slideDir = -1
+        viewModel.goToPrev()
+    }
+    val jumpToToday = {
+        slideDir = 0
+        viewModel.goToToday()
+    }
+
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        // Open only via the menu button — edge-swipe would fight the month swipe.
+        gesturesEnabled = drawerState.isOpen,
+        drawerContent = {
+            CalendarDrawer(
+                onToday = {
+                    jumpToToday()
+                    scope.launch { drawerState.close() }
+                },
+                onJumpToDate = { scope.launch { drawerState.close() } /* TODO: open date picker */ },
+                onFilter = { scope.launch { drawerState.close() } /* TODO: open filter sheet */ },
+                onSettings = { scope.launch { drawerState.close() } /* TODO: navigate to settings */ },
+            )
+        },
+    ) {
+        Scaffold(
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
+            topBar = {
+                MonthTopBar(
+                    month = month,
+                    selectedView = selectedView,
+                    onCycleView = { onSelectView(selectedView.next()) },
+                    onOpenDrawer = { scope.launch { drawerState.open() } },
+                    scrollBehavior = scrollBehavior,
+                )
+            },
+            floatingActionButton = {
+                AnimatedVisibility(
+                    visible = !isOnCurrentMonth,
+                    enter = scaleIn(),
+                    exit = scaleOut(),
+                ) {
+                    ExtendedFloatingActionButton(
+                        onClick = jumpToToday,
+                        icon = { Icon(Icons.Default.Refresh, contentDescription = null) },
+                        text = { Text(stringResource(R.string.month_today_action)) },
+                    )
+                }
+            },
+        ) { innerPadding ->
+            Column(
+                modifier = Modifier
+                    .padding(innerPadding)
+                    .fillMaxSize(),
+            ) {
+                WeekdayHeader(weekStart = DayOfWeek.MONDAY)
+                MonthContent(
+                    state = state,
+                    slideDir = slideDir,
+                    onSwipeNext = goNext,
+                    onSwipePrev = goPrev,
+                    onRetry = jumpToToday,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun MonthContent(
+    state: MonthUiState,
+    slideDir: Int,
+    onSwipeNext: () -> Unit,
+    onSwipePrev: () -> Unit,
+    onRetry: () -> Unit,
+) {
+    val density = LocalDensity.current
+    val threshold = with(density) { 6.dp.toPx() }
+    var dragAccum by remember { mutableFloatStateOf(0f) }
+    val slideSpec = rememberCalendarSlideSpec()
+
+    val swipeModifier = Modifier.pointerInput(Unit) {
+        detectHorizontalDragGestures(
+            onDragStart = { dragAccum = 0f },
+            onDragEnd = {
+                when {
+                    dragAccum < -threshold -> onSwipeNext()
+                    dragAccum > threshold -> onSwipePrev()
+                }
+                dragAccum = 0f
+            },
+            onDragCancel = { dragAccum = 0f },
+            onHorizontalDrag = { _, drag -> dragAccum += drag },
+        )
+    }
+
+    AnimatedContent(
+        targetState = state,
+        modifier = Modifier.fillMaxSize().then(swipeModifier),
+        contentKey = { s ->
+            when (s) {
+                is MonthUiState.Success -> "success-${s.month}"
+                is MonthUiState.Failure -> "failure-${s.reason}"
+                MonthUiState.Loading -> "loading"
+            }
+        },
+        transitionSpec = { calendarSlideTransition(slideDir, slideSpec) },
+        label = "month-transition",
+    ) { s ->
+        when (s) {
+            MonthUiState.Loading -> MonthGridLoading()
+            is MonthUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onRetry)
+            is MonthUiState.Success -> MonthGrid(state = s, weekStart = DayOfWeek.MONDAY)
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun MonthTopBar(
+    month: YearMonth,
+    selectedView: CalendarView,
+    onCycleView: () -> Unit,
+    onOpenDrawer: () -> Unit,
+    scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
+) {
+    TopAppBar(
+        title = {
+            Text(
+                text = formatMonthYear(month),
+                style = MaterialTheme.typography.titleLarge,
+            )
+        },
+        navigationIcon = {
+            IconButton(onClick = onOpenDrawer) {
+                Icon(
+                    imageVector = Icons.Default.Menu,
+                    contentDescription = stringResource(R.string.month_open_menu),
+                )
+            }
+        },
+        actions = {
+            ViewSwitcherPill(
+                current = selectedView,
+                onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
+            )
+        },
+        scrollBehavior = scrollBehavior,
+    )
+}
+
+@Composable
+private fun WeekdayHeader(weekStart: DayOfWeek) {
+    val locale = currentLocale()
+    val days = remember(weekStart, locale) {
+        (0 until 7).map { offset ->
+            DayOfWeek.entries[((weekStart.ordinal + offset) % 7)]
+        }
+    }
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 8.dp, vertical = 4.dp),
+    ) {
+        days.forEach { dow ->
+            val isWeekend = dow == DayOfWeek.SATURDAY || dow == DayOfWeek.SUNDAY
+            val javaDow = java.time.DayOfWeek.of(dow.ordinal + 1)
+            Text(
+                text = javaDow.getDisplayName(JavaTextStyle.SHORT, locale),
+                style = MaterialTheme.typography.labelMedium,
+                color = if (isWeekend) MaterialTheme.colorScheme.onSurfaceVariant
+                        else MaterialTheme.colorScheme.onSurface,
+                textAlign = TextAlign.Center,
+                modifier = Modifier.weight(1f),
+            )
+        }
+    }
+}
+
+@Composable
+private fun MonthGrid(
+    state: MonthUiState.Success,
+    weekStart: DayOfWeek,
+) {
+    val firstOfMonth = LocalDate(state.month.year, state.month.month, 1)
+    val gridStart = firstOfMonth.startOfGridWeek(weekStart)
+
+    // Show only the weeks the current month actually touches; leading/trailing
+    // days of neighbouring months are left blank rather than rendered.
+    val leadOffset = ((firstOfMonth.dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
+    val daysInMonth =
+        java.time.YearMonth.of(state.month.year, state.month.month.ordinal + 1).lengthOfMonth()
+    val weeks = (leadOffset + daysInMonth + 6) / 7
+
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(horizontal = 8.dp, vertical = 4.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        repeat(weeks) { row ->
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .weight(1f),
+                horizontalArrangement = Arrangement.spacedBy(4.dp),
+            ) {
+                repeat(7) { col ->
+                    val date = gridStart.plus(row * 7 + col, DateTimeUnit.DAY)
+                    val inMonth =
+                        date.month == state.month.month && date.year == state.month.year
+                    if (inMonth) {
+                        DayCard(
+                            date = date,
+                            isToday = date == state.today,
+                            data = state.cells[date],
+                            modifier = Modifier.weight(1f),
+                        )
+                    } else {
+                        Spacer(Modifier.weight(1f))
+                    }
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun DayCard(
+    date: LocalDate,
+    isToday: Boolean,
+    data: DayCellData?,
+    modifier: Modifier = Modifier,
+) {
+    val todayPrefix = stringResource(R.string.month_a11y_today_prefix)
+    val cellLabel = buildString {
+        if (isToday) append(todayPrefix).append(", ")
+        append(date.year).append('-')
+        append((date.month.ordinal + 1).toString().padStart(2, '0')).append('-')
+        append(date.day.toString().padStart(2, '0'))
+        data?.let { append(", ").append(it.count).append(" Events") }
+    }
+
+    // M3 Expressive press feedback: a spatial spring from the active motion
+    // scheme drives a subtle scale, instead of a fixed easing curve.
+    val interactionSource = remember { MutableInteractionSource() }
+    val pressed by interactionSource.collectIsPressedAsState()
+    val scale by animateFloatAsState(
+        targetValue = if (pressed) 0.94f else 1f,
+        animationSpec = MaterialTheme.motionScheme.fastSpatialSpec(),
+        label = "day-card-press",
+    )
+
+    Card(
+        onClick = { /* TODO: open the day view (S3) for this date */ },
+        interactionSource = interactionSource,
+        shape = MaterialTheme.shapes.medium,
+        colors = CardDefaults.cardColors(
+            containerColor = if (isToday) MaterialTheme.colorScheme.primaryContainer
+            else MaterialTheme.colorScheme.surfaceContainerHigh,
+            contentColor = if (isToday) MaterialTheme.colorScheme.onPrimaryContainer
+            else MaterialTheme.colorScheme.onSurface,
+        ),
+        modifier = modifier
+            .fillMaxSize()
+            .graphicsLayer {
+                scaleX = scale
+                scaleY = scale
+            }
+            .semantics { contentDescription = cellLabel },
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(top = 4.dp, bottom = 2.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Text(
+                text = date.day.toString(),
+                style = MaterialTheme.typography.labelLarge,
+                fontWeight = if (isToday) FontWeight.Bold else FontWeight.Normal,
+            )
+            Spacer(Modifier.height(2.dp))
+            EventDotRow(data)
+        }
+    }
+}
+
+@Composable
+private fun EventDotRow(data: DayCellData?) {
+    if (data == null || data.swatches.isEmpty()) {
+        Spacer(Modifier.height(6.dp))
+        return
+    }
+    val dark = isSystemInDarkTheme()
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(2.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        data.swatches.forEach { argb ->
+            Box(
+                modifier = Modifier
+                    .size(6.dp)
+                    .background(pastelize(argb, dark), CircleShape),
+            )
+        }
+        if (data.count > data.swatches.size) {
+            Text(
+                text = "+${data.count - data.swatches.size}",
+                style = MaterialTheme.typography.labelSmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}
+
+@Composable
+private fun MonthGridLoading() {
+    val shape = MaterialTheme.shapes.medium
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(horizontal = 8.dp, vertical = 4.dp),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        repeat(6) {
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .weight(1f),
+                horizontalArrangement = Arrangement.spacedBy(4.dp),
+            ) {
+                repeat(7) {
+                    Box(
+                        modifier = Modifier
+                            .weight(1f)
+                            .fillMaxSize()
+                            .background(
+                                color = MaterialTheme.colorScheme.surfaceContainerHigh,
+                                shape = shape,
+                            ),
+                    )
+                }
+            }
+        }
+    }
+}
+
+private fun formatMonthYear(ym: YearMonth): String {
+    val locale = Locale.getDefault()
+    val name = java.time.Month.of(ym.month.ordinal + 1)
+        .getDisplayName(JavaTextStyle.FULL, locale)
+    return "$name ${ym.year}"
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthUiState.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthUiState.kt
@@ -0,0 +1,28 @@
+package de.jeanlucmakiola.calendula.ui.month
+
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.YearMonth
+
+/**
+ * Per-day aggregation surfaced to the month grid. We only need
+ *   - the total event count (drives the optional "+N" indicator), and
+ *   - up to three calendar colors for the dot row.
+ *
+ * The day cell never holds full event objects — the detail sheet pulls those
+ * lazily.
+ */
+data class DayCellData(
+    val count: Int,
+    val swatches: List<Int>,
+)
+
+sealed interface MonthUiState {
+    data object Loading : MonthUiState
+    data class Failure(val reason: FailureReason) : MonthUiState
+    data class Success(
+        val month: YearMonth,
+        val today: LocalDate,
+        val cells: Map<LocalDate, DayCellData>,
+    ) : MonthUiState
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthViewModel.kt
@@ -0,0 +1,128 @@
+package de.jeanlucmakiola.calendula.ui.month
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.YearMonth
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
+import kotlinx.datetime.minus
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+import kotlin.time.Instant
+import javax.inject.Inject
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+class MonthViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val zone = TimeZone.currentSystemDefault()
+
+    // V1: week starts Monday. DataStore-driven preference comes with Settings.
+    private val weekStart: DayOfWeek = DayOfWeek.MONDAY
+
+    private val todayDate: LocalDate
+        get() = Clock.System.now().toLocalDateTime(zone).date
+
+    private val _month = MutableStateFlow(YearMonth(todayDate.year, todayDate.month))
+    val month: StateFlow<YearMonth> = _month
+
+    val state: StateFlow<MonthUiState> = _month
+        .flatMapLatest { ym ->
+            val range = monthGridRange(ym, weekStart, zone)
+            combine(
+                repository.calendars(),
+                repository.instances(range),
+            ) { calendars, instances ->
+                buildState(ym, calendars, instances)
+            }
+        }
+        .catch { emit(MonthUiState.Failure(FailureReason.ProviderUnavailable)) }
+        .flowOn(io)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = MonthUiState.Loading,
+        )
+
+    fun goToPrev() {
+        _month.value = _month.value.minus(1, DateTimeUnit.MONTH)
+    }
+
+    fun goToNext() {
+        _month.value = _month.value.plus(1, DateTimeUnit.MONTH)
+    }
+
+    fun goToToday() {
+        _month.value = YearMonth(todayDate.year, todayDate.month)
+    }
+
+    private fun buildState(
+        ym: YearMonth,
+        calendars: List<CalendarSource>,
+        instances: List<EventInstance>,
+    ): MonthUiState {
+        if (calendars.isEmpty()) {
+            return MonthUiState.Failure(FailureReason.NoCalendarsConfigured)
+        }
+        val byDay = instances.groupBy { it.start.toLocalDateTime(zone).date }
+            .mapValues { (_, evs) ->
+                DayCellData(
+                    count = evs.size,
+                    swatches = evs.map { it.color }.distinct().take(3),
+                )
+            }
+        return MonthUiState.Success(
+            month = ym,
+            today = todayDate,
+            cells = byDay,
+        )
+    }
+}
+
+/**
+ * The on-screen grid spans 6 weeks anchored on [weekStart]. Includes the
+ * trailing days of the previous month and the leading days of the next month.
+ */
+internal fun monthGridRange(
+    ym: YearMonth,
+    weekStart: DayOfWeek,
+    zone: TimeZone,
+): ClosedRange<Instant> {
+    val firstOfMonth = LocalDate(ym.year, ym.month, 1)
+    val gridStart = firstOfMonth.startOfGridWeek(weekStart)
+    val gridEnd = gridStart.plus(41, DateTimeUnit.DAY)
+    val start = gridStart.atStartOfDayIn(zone)
+    val end = gridEnd.atTime(23, 59, 59).toInstant(zone)
+    return start..end
+}
+
+internal fun LocalDate.startOfGridWeek(weekStart: DayOfWeek): LocalDate {
+    // DayOfWeek.ordinal: MONDAY=0..SUNDAY=6 → identical to ISO ordering.
+    val offset = ((dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
+    return minus(offset, DateTimeUnit.DAY)
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt
@@ -0,0 +1,693 @@
+package de.jeanlucmakiola.calendula.ui.week
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.DrawerValue
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExtendedFloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalNavigationDrawer
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberDrawerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
+import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
+import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
+import de.jeanlucmakiola.calendula.ui.common.next
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.plus
+import java.time.format.TextStyle as JavaTextStyle
+import java.util.Locale
+import kotlin.math.roundToInt
+
+private val HOUR_HEIGHT = 56.dp
+private val GUTTER_WIDTH = 48.dp
+private val MIN_EVENT_HEIGHT = 24.dp
+private val ALL_DAY_ROW_HEIGHT = 24.dp
+private val ALL_DAY_VERTICAL_PADDING = 6.dp
+
+/** Total all-day strip height for a week (0 when there are no all-day events). */
+private fun WeekUiState.Success.allDayStripHeight(): Dp {
+    if (allDaySpans.isEmpty()) return 0.dp
+    val lanes = allDaySpans.maxOf { it.lane } + 1
+    return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun WeekScreen(
+    selectedView: CalendarView,
+    onSelectView: (CalendarView) -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: WeekViewModel = hiltViewModel(),
+) {
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    val weekStart by viewModel.weekStartDate.collectAsStateWithLifecycle()
+
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+
+    // The static header + all-day strip share the app bar's scrolled colour so
+    // the whole top region elevates together once the timeline scrolls under it.
+    val topSectionColor by animateColorAsState(
+        targetValue = if (scrollBehavior.state.overlappedFraction > 0.01f) {
+            MaterialTheme.colorScheme.surfaceContainer
+        } else {
+            MaterialTheme.colorScheme.surface
+        },
+        label = "week-top-section-color",
+    )
+
+    val isOnCurrentWeek = when (val s = state) {
+        is WeekUiState.Success -> s.weekStart == s.today.startOfWeek(DayOfWeek.MONDAY)
+        else -> true
+    }
+
+    // Slide direction for the week transition: +1 = next, -1 = prev, 0 = jump.
+    var slideDir by remember { mutableIntStateOf(0) }
+    val goNext = { slideDir = 1; viewModel.goToNext() }
+    val goPrev = { slideDir = -1; viewModel.goToPrev() }
+    val jumpToToday = { slideDir = 0; viewModel.goToToday() }
+
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        // Open only via the menu button — edge-swipe would fight the week swipe.
+        gesturesEnabled = drawerState.isOpen,
+        drawerContent = {
+            CalendarDrawer(
+                onToday = { jumpToToday(); scope.launch { drawerState.close() } },
+                onJumpToDate = { scope.launch { drawerState.close() } /* TODO: date picker */ },
+                onFilter = { scope.launch { drawerState.close() } /* TODO: filter sheet */ },
+                onSettings = { scope.launch { drawerState.close() } /* TODO: settings */ },
+            )
+        },
+    ) {
+        Scaffold(
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
+            topBar = {
+                WeekTopBar(
+                    weekStart = weekStart,
+                    selectedView = selectedView,
+                    onCycleView = { onSelectView(selectedView.next()) },
+                    onOpenDrawer = { scope.launch { drawerState.open() } },
+                    scrollBehavior = scrollBehavior,
+                )
+            },
+            floatingActionButton = {
+                AnimatedVisibility(
+                    visible = !isOnCurrentWeek,
+                    enter = scaleIn(),
+                    exit = scaleOut(),
+                ) {
+                    ExtendedFloatingActionButton(
+                        onClick = jumpToToday,
+                        icon = { Icon(Icons.Default.Refresh, contentDescription = null) },
+                        text = { Text(stringResource(R.string.week_today_action)) },
+                    )
+                }
+            },
+        ) { innerPadding ->
+            WeekContent(
+                state = state,
+                slideDir = slideDir,
+                topSectionColor = topSectionColor,
+                onSwipeNext = goNext,
+                onSwipePrev = goPrev,
+                onRetry = jumpToToday,
+                modifier = Modifier
+                    .padding(innerPadding)
+                    .fillMaxSize(),
+            )
+        }
+    }
+}
+
+@Composable
+private fun WeekContent(
+    state: WeekUiState,
+    slideDir: Int,
+    topSectionColor: Color,
+    onSwipeNext: () -> Unit,
+    onSwipePrev: () -> Unit,
+    onRetry: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val density = LocalDensity.current
+    val threshold = with(density) { 24.dp.toPx() }
+    var dragAccum by remember { mutableFloatStateOf(0f) }
+    val slideSpec = rememberCalendarSlideSpec()
+
+    // Hoisted above the per-week AnimatedContent so the vertical scroll position
+    // survives week-to-week swipes (e.g. 18:00 stays centred). We only centre on
+    // noon once, on first entry into the week view (i.e. when arriving from the
+    // month/day view), not on every swipe.
+    val scrollState = rememberScrollState()
+    LaunchedEffect(Unit) {
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        val maxV = scrollState.maxValue
+        val target = with(density) {
+            (HOUR_HEIGHT.toPx() * 12 - (HOUR_HEIGHT.toPx() * 24 - maxV) / 2f).roundToInt()
+        }.coerceIn(0, maxV)
+        scrollState.scrollTo(target)
+    }
+
+    // Single, hoisted all-day strip height — shared by the outgoing and incoming
+    // week during a swipe, so the strip slides along but never jumps in height;
+    // it just springs smoothly from the old to the new size.
+    val targetAllDayHeight = (state as? WeekUiState.Success)?.allDayStripHeight() ?: 0.dp
+    val allDayHeight by animateDpAsState(
+        targetValue = targetAllDayHeight,
+        label = "all-day-strip-height",
+    )
+
+    // Whole-page horizontal swipe. It sits one level above the timeline's
+    // vertical scroll: a horizontal drag only crosses *this* detector's slop,
+    // while a vertical drag is consumed by the inner scroll first — so the two
+    // gestures coexist without fighting.
+    val swipeModifier = Modifier.pointerInput(Unit) {
+        detectHorizontalDragGestures(
+            onDragStart = { dragAccum = 0f },
+            onDragEnd = {
+                when {
+                    dragAccum < -threshold -> onSwipeNext()
+                    dragAccum > threshold -> onSwipePrev()
+                }
+                dragAccum = 0f
+            },
+            onDragCancel = { dragAccum = 0f },
+            onHorizontalDrag = { _, drag -> dragAccum += drag },
+        )
+    }
+
+    AnimatedContent(
+        targetState = state,
+        modifier = modifier.then(swipeModifier),
+        contentKey = { s ->
+            when (s) {
+                is WeekUiState.Success -> "success-${s.weekStart}"
+                is WeekUiState.Failure -> "failure-${s.reason}"
+                WeekUiState.Loading -> "loading"
+            }
+        },
+        transitionSpec = { calendarSlideTransition(slideDir, slideSpec) },
+        label = "week-transition",
+    ) { s ->
+        when (s) {
+            WeekUiState.Loading -> WeekLoading()
+            is WeekUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onRetry)
+            is WeekUiState.Success -> WeekSuccess(
+                state = s,
+                topSectionColor = topSectionColor,
+                scrollState = scrollState,
+                allDayHeight = allDayHeight,
+            )
+        }
+    }
+}
+
+@Composable
+private fun WeekSuccess(
+    state: WeekUiState.Success,
+    topSectionColor: Color,
+    scrollState: ScrollState,
+    allDayHeight: Dp,
+) {
+    Column(modifier = Modifier.fillMaxSize()) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(topSectionColor),
+        ) {
+            WeekDayHeader(days = state.days, today = state.today)
+            AllDayStrip(state = state, height = allDayHeight)
+        }
+        // Breathing room between the (colour-shifting) top section and the
+        // scrolling timeline below.
+        Spacer(Modifier.height(8.dp))
+        Timeline(state = state, scrollState = scrollState)
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun WeekTopBar(
+    weekStart: LocalDate,
+    selectedView: CalendarView,
+    onCycleView: () -> Unit,
+    onOpenDrawer: () -> Unit,
+    scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
+) {
+    TopAppBar(
+        title = {
+            Text(
+                text = formatWeekRange(weekStart),
+                style = MaterialTheme.typography.titleLarge,
+            )
+        },
+        navigationIcon = {
+            IconButton(onClick = onOpenDrawer) {
+                Icon(
+                    imageVector = Icons.Default.Menu,
+                    contentDescription = stringResource(R.string.month_open_menu),
+                )
+            }
+        },
+        actions = {
+            ViewSwitcherPill(
+                current = selectedView,
+                onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
+            )
+        },
+        // Match the static top section exactly: plain surface, lifting to
+        // surfaceContainer once content scrolls under the bar.
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surfaceContainer,
+        ),
+        scrollBehavior = scrollBehavior,
+    )
+}
+
+@Composable
+private fun WeekDayHeader(days: List<LocalDate>, today: LocalDate) {
+    val locale = currentLocale()
+    val weekStart = days.first()
+    val weekNumber = remember(weekStart) {
+        java.time.LocalDate.of(weekStart.year, weekStart.month.ordinal + 1, weekStart.day)
+            .get(java.time.temporal.IsoFields.WEEK_OF_WEEK_BASED_YEAR)
+    }
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(top = 4.dp, bottom = 8.dp),
+    ) {
+        // Mirror the day-column layout (empty weekday line + spacer) so the
+        // badge lines up vertically with the date numbers.
+        Column(
+            modifier = Modifier.width(GUTTER_WIDTH),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Text(text = " ", style = MaterialTheme.typography.labelSmall)
+            Spacer(Modifier.height(2.dp))
+            WeekNumberBadge(weekNumber = weekNumber)
+        }
+        days.forEach { date ->
+            val javaDow = java.time.DayOfWeek.of(date.dayOfWeek.ordinal + 1)
+            val isToday = date == today
+            Column(
+                modifier = Modifier.weight(1f),
+                horizontalAlignment = Alignment.CenterHorizontally,
+            ) {
+                Text(
+                    text = javaDow.getDisplayName(JavaTextStyle.SHORT, locale),
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(Modifier.height(2.dp))
+                // Always reserve the 28dp circle slot so the header height is
+                // identical whether or not the week contains today.
+                Box(
+                    modifier = Modifier.size(28.dp),
+                    contentAlignment = Alignment.Center,
+                ) {
+                    if (isToday) {
+                        Surface(
+                            shape = CircleShape,
+                            color = MaterialTheme.colorScheme.primaryContainer,
+                            contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
+                            modifier = Modifier.fillMaxSize(),
+                        ) {
+                            Box(contentAlignment = Alignment.Center) {
+                                Text(
+                                    text = date.day.toString(),
+                                    style = MaterialTheme.typography.titleSmall,
+                                    fontWeight = FontWeight.SemiBold,
+                                )
+                            }
+                        }
+                    } else {
+                        Text(
+                            text = date.day.toString(),
+                            style = MaterialTheme.typography.bodyMedium,
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** Calendar-week badge shown in the header gutter, deliberately set apart with a
+ *  filled box and bold number. */
+@Composable
+private fun WeekNumberBadge(weekNumber: Int, modifier: Modifier = Modifier) {
+    val label = stringResource(R.string.week_number_label)
+    Surface(
+        shape = RoundedCornerShape(8.dp),
+        color = MaterialTheme.colorScheme.secondaryContainer,
+        contentColor = MaterialTheme.colorScheme.onSecondaryContainer,
+        modifier = modifier.semantics { contentDescription = "$label $weekNumber" },
+    ) {
+        Text(
+            text = weekNumber.toString(),
+            style = MaterialTheme.typography.titleSmall,
+            fontWeight = FontWeight.Bold,
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 3.dp),
+        )
+    }
+}
+
+@Composable
+private fun AllDayStrip(state: WeekUiState.Success, height: Dp) {
+    val dark = isSystemInDarkTheme()
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            // Height is hoisted + animated so it slides and resizes smoothly;
+            // padding sits inside it so the content area is lanes * row height.
+            .height(height)
+            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+    ) {
+        // Keep the gutter-width offset so the bars line up with the day columns.
+        Spacer(Modifier.width(GUTTER_WIDTH))
+        // Span bars are positioned absolutely so a multi-day event is one
+        // connected bar across columns rather than a chip per day. clipToBounds
+        // keeps bars from spilling out while the height animates.
+        BoxWithConstraints(
+            modifier = Modifier
+                .weight(1f)
+                .fillMaxHeight()
+                .clipToBounds(),
+        ) {
+            val colWidth = maxWidth / 7
+            state.allDaySpans.forEach { span ->
+                val spanCols = span.endCol - span.startCol + 1
+                AllDayBar(
+                    event = span.event,
+                    dark = dark,
+                    modifier = Modifier
+                        .offset(
+                            x = colWidth * span.startCol,
+                            y = ALL_DAY_ROW_HEIGHT * span.lane,
+                        )
+                        .width(colWidth * spanCols)
+                        .height(ALL_DAY_ROW_HEIGHT)
+                        .padding(horizontal = 1.dp, vertical = 1.dp),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun AllDayBar(event: EventInstance, dark: Boolean, modifier: Modifier = Modifier) {
+    val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
+    Box(
+        modifier = modifier
+            .background(pastelize(event.color, dark), RoundedCornerShape(4.dp))
+            .padding(horizontal = 6.dp, vertical = 2.dp)
+            .semantics { contentDescription = title },
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.labelSmall,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            color = Color.Black.copy(alpha = 0.8f),
+        )
+    }
+}
+
+@Composable
+private fun Timeline(state: WeekUiState.Success, scrollState: ScrollState) {
+    val totalHeight = HOUR_HEIGHT * 24
+    val dark = isSystemInDarkTheme()
+
+    Box(modifier = Modifier.fillMaxSize()) {
+        // Gutter and day columns are two scroll viewports that SHARE one scroll
+        // state, so they stay perfectly aligned. The day-column viewport is a
+        // static, rounded-clipped window — the content scrolls inside it, so the
+        // soft corners are permanent at any scroll position (not just at the
+        // day's start/end).
+        Row(modifier = Modifier.fillMaxSize()) {
+            // Hour gutter (scrolls in sync with the day columns)
+            Column(
+                modifier = Modifier
+                    .width(GUTTER_WIDTH)
+                    .fillMaxHeight()
+                    .verticalScroll(scrollState),
+            ) {
+                (0 until 24).forEach { h ->
+                    Box(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .height(HOUR_HEIGHT),
+                    ) {
+                        if (h > 0) {
+                            Text(
+                                text = "%02d".format(h),
+                                style = MaterialTheme.typography.labelSmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                modifier = Modifier
+                                    .align(Alignment.TopCenter)
+                                    .offset(y = (-6).dp),
+                            )
+                        }
+                    }
+                }
+            }
+            // Day columns: rounded, clipped scroll viewport (permanent corners).
+            Box(
+                modifier = Modifier
+                    .weight(1f)
+                    .fillMaxHeight()
+                    .clip(RoundedCornerShape(16.dp))
+                    .verticalScroll(scrollState),
+            ) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(totalHeight),
+                    horizontalArrangement = Arrangement.spacedBy(2.dp),
+                ) {
+                    state.days.forEach { day ->
+                        DayColumnCard(
+                            blocks = state.timedByDay[day].orEmpty(),
+                            dark = dark,
+                            modifier = Modifier
+                                .weight(1f)
+                                .fillMaxHeight(),
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun DayColumnCard(
+    blocks: List<TimedBlock>,
+    dark: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    Card(
+        // Plain rectangular columns — the soft corners come from the outer
+        // rounded scroll viewport, so inner rounding would look odd at the edges.
+        shape = RectangleShape,
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        ),
+        modifier = modifier,
+    ) {
+        BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
+            val colWidth = maxWidth
+            blocks.forEach { block ->
+                val laneWidth = colWidth / block.laneCount
+                val top = HOUR_HEIGHT * (block.startMin / 60f)
+                val rawHeight = HOUR_HEIGHT * ((block.endMin - block.startMin) / 60f)
+                val height = if (rawHeight < MIN_EVENT_HEIGHT) MIN_EVENT_HEIGHT else rawHeight
+                EventBlock(
+                    block = block,
+                    dark = dark,
+                    modifier = Modifier
+                        .offset(x = laneWidth * block.lane, y = top)
+                        .width(laneWidth)
+                        .height(height)
+                        .padding(horizontal = 1.dp),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun EventBlock(
+    block: TimedBlock,
+    dark: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
+    val timeLabel = "${minToHm(block.startMin)}–${minToHm(block.endMin)}"
+    val showTime = block.endMin - block.startMin >= 45
+    Box(
+        modifier = modifier
+            .background(pastelize(block.event.color, dark), RoundedCornerShape(4.dp))
+            .padding(horizontal = 4.dp, vertical = 2.dp)
+            .semantics { contentDescription = "$title, $timeLabel" },
+    ) {
+        Column {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.labelMedium,
+                maxLines = if (showTime) 1 else 2,
+                overflow = TextOverflow.Ellipsis,
+                color = Color.Black.copy(alpha = 0.85f),
+            )
+            if (showTime) {
+                // Narrow columns can't fit "13:00–14:00" on one line, so let it
+                // wrap to a second line (after the dash) instead of clipping the
+                // end time.
+                Text(
+                    text = timeLabel,
+                    style = MaterialTheme.typography.labelSmall,
+                    maxLines = 2,
+                    overflow = TextOverflow.Ellipsis,
+                    color = Color.Black.copy(alpha = 0.6f),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun WeekLoading() {
+    val totalHeight = HOUR_HEIGHT * 24
+    val scrollState = rememberScrollState()
+    Column(modifier = Modifier.fillMaxSize()) {
+        // Header skeleton
+        Row(modifier = Modifier.fillMaxWidth().padding(8.dp)) {
+            Spacer(Modifier.width(GUTTER_WIDTH))
+            repeat(7) {
+                Box(
+                    modifier = Modifier
+                        .weight(1f)
+                        .padding(horizontal = 2.dp)
+                        .height(36.dp)
+                        .background(
+                            MaterialTheme.colorScheme.surfaceContainer,
+                            RoundedCornerShape(8.dp),
+                        ),
+                )
+            }
+        }
+        Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+            Spacer(Modifier.width(GUTTER_WIDTH))
+            repeat(7) {
+                Box(
+                    modifier = Modifier
+                        .weight(1f)
+                        .height(totalHeight)
+                        .padding(horizontal = 2.dp)
+                        .background(MaterialTheme.colorScheme.surfaceContainer),
+                )
+            }
+        }
+    }
+}
+
+private fun minToHm(min: Int): String =
+    if (min >= MINUTES_PER_DAY) "24:00" else "%02d:%02d".format(min / 60, min % 60)
+
+private fun formatWeekRange(weekStart: LocalDate): String {
+    val locale = Locale.getDefault()
+    val end = weekStart.plus(6, kotlinx.datetime.DateTimeUnit.DAY)
+    val monthName = { d: LocalDate ->
+        java.time.Month.of(d.month.ordinal + 1).getDisplayName(JavaTextStyle.SHORT, locale)
+    }
+    return if (weekStart.month == end.month && weekStart.year == end.year) {
+        "${weekStart.day}.–${end.day}. ${monthName(weekStart)} ${weekStart.year}"
+    } else if (weekStart.year == end.year) {
+        "${weekStart.day}. ${monthName(weekStart)} – ${end.day}. ${monthName(end)} ${end.year}"
+    } else {
+        "${weekStart.day}. ${monthName(weekStart)} ${weekStart.year} – " +
+            "${end.day}. ${monthName(end)} ${end.year}"
+    }
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekUiState.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekUiState.kt
@@ -0,0 +1,57 @@
+package de.jeanlucmakiola.calendula.ui.week
+
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import kotlinx.datetime.LocalDate
+
+/**
+ * One timed event clipped to a single day and assigned a horizontal lane so
+ * overlapping events render side-by-side (spec S2: "Overlap-Events nebeneinander
+ * aufgelöst").
+ *
+ * @param startMin minutes from this day's midnight, clamped to [0, 1440]
+ * @param endMin   minutes from this day's midnight, clamped to [startMin, 1440];
+ *                 equal to [startMin] for instant events (render enforces a
+ *                 minimum tap-target height)
+ * @param lane     0-based column within [laneCount]
+ * @param laneCount number of columns the event's overlap-cluster needs
+ */
+data class TimedBlock(
+    val event: EventInstance,
+    val startMin: Int,
+    val endMin: Int,
+    val lane: Int,
+    val laneCount: Int,
+)
+
+/**
+ * An all-day (or multi-day) event laid out as a single horizontal bar spanning
+ * [startCol]..[endCol] of the visible week, stacked on row [lane] so overlapping
+ * spans don't collide. A multi-day event is one connected bar — not one chip per
+ * day.
+ *
+ * @param startCol first visible covered column, 0..6 (clamped to the week)
+ * @param endCol   last visible covered column, 0..6, inclusive
+ * @param lane     0-based stacking row
+ */
+data class AllDaySpan(
+    val event: EventInstance,
+    val startCol: Int,
+    val endCol: Int,
+    val lane: Int,
+)
+
+sealed interface WeekUiState {
+    data object Loading : WeekUiState
+    data class Failure(val reason: FailureReason) : WeekUiState
+    data class Success(
+        val weekStart: LocalDate,
+        val today: LocalDate,
+        /** The seven days of the week, [weekStart] first. */
+        val days: List<LocalDate>,
+        /** All-day/multi-day events as connected horizontal spans. */
+        val allDaySpans: List<AllDaySpan>,
+        /** Timed events, clipped to each day with lanes resolved. */
+        val timedByDay: Map<LocalDate, List<TimedBlock>>,
+    ) : WeekUiState
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekViewModel.kt
@@ -0,0 +1,227 @@
+package de.jeanlucmakiola.calendula.ui.week
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FailureReason
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
+import kotlinx.datetime.minus
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+import kotlin.time.Instant
+import javax.inject.Inject
+
+const val MINUTES_PER_DAY: Int = 24 * 60
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+class WeekViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val zone = TimeZone.currentSystemDefault()
+
+    // V1: week starts Monday. DataStore-driven preference comes with Settings.
+    private val weekStart: DayOfWeek = DayOfWeek.MONDAY
+
+    private val todayDate: LocalDate
+        get() = Clock.System.now().toLocalDateTime(zone).date
+
+    private val _weekStartDate = MutableStateFlow(todayDate.startOfWeek(weekStart))
+    val weekStartDate: StateFlow<LocalDate> = _weekStartDate
+
+    val state: StateFlow<WeekUiState> = _weekStartDate
+        .flatMapLatest { start ->
+            val range = weekRange(start, zone)
+            combine(
+                repository.calendars(),
+                repository.instances(range),
+            ) { calendars, instances ->
+                buildState(start, calendars, instances)
+            }
+        }
+        .catch { emit(WeekUiState.Failure(FailureReason.ProviderUnavailable)) }
+        .flowOn(io)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = WeekUiState.Loading,
+        )
+
+    fun goToPrev() {
+        _weekStartDate.value = _weekStartDate.value.minus(7, DateTimeUnit.DAY)
+    }
+
+    fun goToNext() {
+        _weekStartDate.value = _weekStartDate.value.plus(7, DateTimeUnit.DAY)
+    }
+
+    fun goToToday() {
+        _weekStartDate.value = todayDate.startOfWeek(weekStart)
+    }
+
+    private fun buildState(
+        start: LocalDate,
+        calendars: List<CalendarSource>,
+        instances: List<EventInstance>,
+    ): WeekUiState {
+        if (calendars.isEmpty()) {
+            return WeekUiState.Failure(FailureReason.NoCalendarsConfigured)
+        }
+        val days = (0 until 7).map { start.plus(it, DateTimeUnit.DAY) }
+        val allDay = instances.filter { it.isAllDay }
+        val timed = instances.filterNot { it.isAllDay }
+        return WeekUiState.Success(
+            weekStart = start,
+            today = todayDate,
+            days = days,
+            allDaySpans = layoutAllDay(allDay, days, zone),
+            timedByDay = days.associateWith { day -> layoutDay(timed, day, zone) },
+        )
+    }
+}
+
+/**
+ * Lay out all-day events as connected horizontal spans across the visible week.
+ * Each event becomes one [AllDaySpan] from its first to its last covered column;
+ * overlapping spans are stacked on separate lanes (greedy first-fit by start).
+ */
+internal fun layoutAllDay(
+    events: List<EventInstance>,
+    days: List<LocalDate>,
+    zone: TimeZone,
+): List<AllDaySpan> {
+    data class Raw(val event: EventInstance, val startCol: Int, val endCol: Int)
+
+    val raw = events
+        .mapNotNull { ev ->
+            val covered = days.indices.filter { ev.coversDay(days[it], zone) }
+            if (covered.isEmpty()) null else Raw(ev, covered.first(), covered.last())
+        }
+        .sortedWith(compareBy({ it.startCol }, { it.endCol }))
+
+    val laneEnd = ArrayList<Int>() // last occupied column per lane
+    return raw.map { r ->
+        var lane = laneEnd.indexOfFirst { it < r.startCol }
+        if (lane == -1) {
+            laneEnd.add(r.endCol)
+            lane = laneEnd.size - 1
+        } else {
+            laneEnd[lane] = r.endCol
+        }
+        AllDaySpan(r.event, r.startCol, r.endCol, lane)
+    }
+}
+
+/** Beginning of the week (at [weekStart]) that contains this date. */
+internal fun LocalDate.startOfWeek(weekStart: DayOfWeek): LocalDate {
+    // DayOfWeek.ordinal: MONDAY=0..SUNDAY=6 → identical to ISO ordering.
+    val offset = ((dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
+    return minus(offset, DateTimeUnit.DAY)
+}
+
+/** Half-open instant range covering the seven days starting at [start]. */
+internal fun weekRange(start: LocalDate, zone: TimeZone): ClosedRange<Instant> {
+    val from = start.atStartOfDayIn(zone)
+    val to = start.plus(6, DateTimeUnit.DAY).atTime(23, 59, 59).toInstant(zone)
+    return from..to
+}
+
+/** True if this event overlaps the calendar [day] in [zone] (any portion). */
+internal fun EventInstance.coversDay(day: LocalDate, zone: TimeZone): Boolean {
+    val dayStart = day.atStartOfDayIn(zone)
+    val dayEnd = day.plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone)
+    return start < dayEnd && end > dayStart
+}
+
+/**
+ * Clip [events] to a single [day] and assign lanes so overlapping events render
+ * side-by-side. Lane count is computed per overlap-cluster (a maximal run of
+ * chained-overlapping events), matching the common phone week-view behaviour.
+ *
+ * All-day events are ignored here — they live in the all-day strip.
+ */
+internal fun layoutDay(
+    events: List<EventInstance>,
+    day: LocalDate,
+    zone: TimeZone,
+): List<TimedBlock> {
+    val dayStart = day.atStartOfDayIn(zone)
+    val dayEnd = day.plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone)
+
+    data class Raw(val event: EventInstance, val startMin: Int, val endMin: Int)
+
+    val raw = events.asSequence()
+        .filterNot { it.isAllDay }
+        .mapNotNull { ev ->
+            if (ev.start == ev.end) {
+                // Instant event: keep only if the point falls inside this day.
+                if (ev.start < dayStart || ev.start >= dayEnd) return@mapNotNull null
+                val m = (ev.start - dayStart).inWholeMinutes.toInt().coerceIn(0, MINUTES_PER_DAY)
+                Raw(ev, m, m)
+            } else {
+                val s = maxOf(ev.start, dayStart)
+                val e = minOf(ev.end, dayEnd)
+                if (e <= s) return@mapNotNull null
+                val startMin = (s - dayStart).inWholeMinutes.toInt().coerceIn(0, MINUTES_PER_DAY)
+                val endMin = (e - dayStart).inWholeMinutes.toInt().coerceIn(startMin, MINUTES_PER_DAY)
+                Raw(ev, startMin, endMin)
+            }
+        }
+        .sortedWith(compareBy({ it.startMin }, { it.endMin }))
+        .toList()
+
+    val result = ArrayList<TimedBlock>(raw.size)
+    var i = 0
+    while (i < raw.size) {
+        // Grow a cluster of chained-overlapping events.
+        var clusterEnd = raw[i].endMin
+        var j = i + 1
+        while (j < raw.size && raw[j].startMin < clusterEnd) {
+            clusterEnd = maxOf(clusterEnd, raw[j].endMin)
+            j++
+        }
+        val cluster = raw.subList(i, j)
+        // Greedy first-fit column assignment (= max overlap depth in the cluster).
+        val laneEnd = ArrayList<Int>()
+        val lanes = IntArray(cluster.size)
+        cluster.forEachIndexed { k, r ->
+            var placed = laneEnd.indexOfFirst { it <= r.startMin }
+            if (placed == -1) {
+                laneEnd.add(r.endMin)
+                placed = laneEnd.size - 1
+            } else {
+                laneEnd[placed] = r.endMin
+            }
+            lanes[k] = placed
+        }
+        val laneCount = laneEnd.size
+        cluster.forEachIndexed { k, r ->
+            result.add(TimedBlock(r.event, r.startMin, r.endMin, lanes[k], laneCount))
+        }
+        i = j
+    }
+    return result
+}
--- a/app/src/main/res/drawable/ic_launcher_foreground.xml
+++ b/app/src/main/res/drawable/ic_launcher_foreground.xml
@@ -1,16 +1,95 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+    Calendula launcher icon foreground.
+
+    Converted from design/icon/calendula_mark.svg (232x232 viewport).
+    Composition: rounded line-art calendar with a stylized "1" inside
+    (referencing kalendae, the Latin word for the first day of the month
+    that is the etymological root of both "calendar" and "calendula"),
+    plus a small Calendula bloom as a badge in the bottom-right corner.
+
+    Strokes render in off-white (#FAF6F0) over the slate background
+    drawable (drawable/ic_launcher_background.xml = @color/ic_launcher_background).
+    The same vector is reused as the <monochrome> slot in the adaptive icon
+    so Android 13+ themed-icon launchers can recolor it from wallpaper.
+-->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="108dp"
    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
+    android:viewportWidth="232"
+    android:viewportHeight="232">
    <!--
-        Stylized "1" centered in the 108x108 viewport.
-        Reference: kalendae (the first day of the month) - etymological root
-        of both "Calendar" and "Calendula".
-        Color is off-white for high contrast on the slate background.
+        Android adaptive icon spec: 108dp canvas.
+
+        Centering Logic:
+        - The calendar body is a 142x142 square centered at (114, 108).
+        - The viewport center is (116, 116).
+        - We use pivot (114, 108) and translate by (2, 8) to align the
+          calendar's geometric center perfectly with the canvas center,
+          ignoring the visual weight of the bloom badge.
+
+        Scale:
+        - Scaled by 0.50 to provide significant padding, preventing a
+          "zoomed in" look on home screens and splash screens.
    -->
+    <group
+        android:pivotX="114"
+        android:pivotY="108"
+        android:scaleX="0.50"
+        android:scaleY="0.50"
+        android:translateX="2"
+        android:translateY="8">
+    <!-- Calendar body (rounded square with horizontal header divider) -->
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="12"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:strokeMiterLimit="12"
+        android:pathData="M43,69H185M185,115V63C185,48.64 173.359,37 159,37H69C54.64,37 43,48.64 43,63V153C43,167.359 54.64,179 69,179H124" />
+    <!-- Numeral "1" inside the calendar body -->
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="12"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:pathData="M103,110L113.999,99V142.428" />
+    <!-- Calendula bloom: 8 petals around a filled center -->
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M163.072,136.714C163.072,142.886 168.214,153.429 170.786,157.929C173.357,153.429 178.5,142.886 178.5,136.714C178.5,130.543 173.357,129 170.786,129C168.214,129 163.072,130.543 163.072,136.714Z" />
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M178.5,186.857C178.5,180.686 173.357,170.143 170.786,165.643C168.214,170.143 163.072,180.686 163.072,186.857C163.072,193.029 168.214,194.572 170.786,194.572C173.357,194.572 178.5,193.029 178.5,186.857Z" />
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M195.857,154.072C189.686,154.072 179.143,159.214 174.643,161.786C179.143,164.357 189.686,169.5 195.857,169.5C202.029,169.5 203.572,164.357 203.572,161.786C203.572,159.214 202.029,154.072 195.857,154.072Z" />
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M145.714,170.008C151.886,170.008 162.429,164.865 166.929,162.294C162.429,159.722 151.886,154.58 145.714,154.58C139.543,154.58 138,159.722 138,162.294C138,164.865 139.543,170.008 145.714,170.008Z" />
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M194.768,174.858C190.404,170.494 179.312,166.676 174.312,165.312C175.676,170.312 179.494,181.404 183.858,185.768C188.222,190.132 192.949,187.586 194.768,185.768C196.586,183.949 199.132,179.222 194.768,174.858Z" />
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M146.804,149.222C151.168,153.586 162.259,157.404 167.26,158.768C165.896,153.767 162.077,142.676 157.714,138.312C153.35,133.948 148.622,136.494 146.804,138.312C144.986,140.13 142.44,144.858 146.804,149.222Z" />
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M183.858,138.312C179.494,142.676 175.676,153.767 174.312,158.768C179.312,157.404 190.404,153.586 194.768,149.222C199.132,144.858 196.586,140.13 194.768,138.312C192.949,136.494 188.222,133.948 183.858,138.312Z" />
+    <path
+        android:strokeColor="#FFFAF6F0"
+        android:strokeWidth="8"
+        android:pathData="M157.714,185.768C162.077,181.404 165.896,170.312 167.26,165.312C162.259,166.676 151.168,170.494 146.804,174.858C142.44,179.222 144.986,183.949 146.804,185.768C148.622,187.586 153.35,190.132 157.714,185.768Z" />
+    <!-- Calendula center disc -->
    <path
        android:fillColor="#FFFAF6F0"
-        android:pathData="M51.5,38 L51.5,38 C49.5,40 46.5,41.5 43,42.5 L43,49 C46.2,48.2 49,47 51.5,45.5 L51.5,72 L43.5,72 L43.5,76 L65.5,76 L65.5,72 L57.5,72 L57.5,38 Z" />
+        android:pathData="M170.786,169C174.77,169 178,165.77 178,161.786C178,157.802 174.77,154.572 170.786,154.572C166.802,154.572 163.572,157.802 163.572,161.786C163.572,165.77 166.802,169 170.786,169Z" />
+    </group>
 </vector>
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -20,10 +20,29 @@
    <string name="permission_open_settings_button">System-Einstellungen öffnen</string>
    <string name="permission_retry_button">Erneut versuchen</string>

-    <!-- Debug-Screen (wegwerfbar — entfällt mit Plan 03) -->
-    <string name="debug_banner">DEBUG — wird mit Plan 03 durch die Monatsansicht ersetzt</string>
-    <string name="debug_calendars_header">Kalender</string>
-    <string name="debug_events_header">Nächste 50 Termine</string>
-    <string name="debug_no_calendars">Keine Kalender eingerichtet. Füge einen über DAVx5 oder die System-Einstellungen hinzu.</string>
-    <string name="debug_no_events">Keine anstehenden Termine in den nächsten 30 Tagen.</string>
+    <!-- Monatsansicht (S1) -->
+    <string name="month_prev">Vorheriger Monat</string>
+    <string name="month_next">Nächster Monat</string>
+    <string name="month_today_action">Heute</string>
+    <string name="month_more_actions">Weitere Aktionen</string>
+    <string name="month_open_menu">Menü öffnen</string>
+    <string name="month_action_filter">Kalender</string>
+    <string name="month_action_jump_to_date">Zu Datum springen…</string>
+    <string name="month_action_settings">Einstellungen</string>
+    <string name="month_a11y_today_prefix">Heute</string>
+
+    <!-- Wochenansicht (S2) -->
+    <string name="week_today_action">Diese Woche</string>
+    <string name="week_number_label">KW</string>
+
+    <!-- Tagesansicht (S3) -->
+    <string name="day_today_action">Heute</string>
+
+    <!-- Geteilte Event-Strings -->
+    <string name="event_untitled">(Ohne Titel)</string>
+
+    <!-- View-Switcher (M1) -->
+    <string name="view_month">Monat</string>
+    <string name="view_week">Woche</string>
+    <string name="view_day">Tag</string>
 </resources>
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -21,10 +21,29 @@
    <string name="permission_open_settings_button">Open system settings</string>
    <string name="permission_retry_button">Try again</string>

-    <!-- Debug screen (wegwerfbar — entfällt mit Plan 03) -->
-    <string name="debug_banner">DEBUG — replaced by month view in Plan 03</string>
-    <string name="debug_calendars_header">Calendars</string>
-    <string name="debug_events_header">Next 50 events</string>
-    <string name="debug_no_calendars">No calendars configured. Add one via DAVx5 or system settings.</string>
-    <string name="debug_no_events">No upcoming events in the next 30 days.</string>
+    <!-- Month view (S1) -->
+    <string name="month_prev">Previous month</string>
+    <string name="month_next">Next month</string>
+    <string name="month_today_action">Today</string>
+    <string name="month_more_actions">More actions</string>
+    <string name="month_open_menu">Open menu</string>
+    <string name="month_action_filter">Calendars</string>
+    <string name="month_action_jump_to_date">Jump to date…</string>
+    <string name="month_action_settings">Settings</string>
+    <string name="month_a11y_today_prefix">Today</string>
+
+    <!-- Week view (S2) -->
+    <string name="week_today_action">This week</string>
+    <string name="week_number_label">Wk</string>
+
+    <!-- Day view (S3) -->
+    <string name="day_today_action">Today</string>
+
+    <!-- Shared event strings -->
+    <string name="event_untitled">(No title)</string>
+
+    <!-- View switcher (M1) -->
+    <string name="view_month">Month</string>
+    <string name="view_week">Week</string>
+    <string name="view_day">Day</string>
 </resources>
--- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/debug/DebugViewModelTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/debug/DebugViewModelTest.kt
@@ -1,114 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.debug
-
-import app.cash.turbine.test
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
-import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.EventDetail
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.test.UnconfinedTestDispatcher
-import kotlinx.coroutines.test.resetMain
-import kotlinx.coroutines.test.runTest
-import kotlinx.coroutines.test.setMain
-import kotlin.time.Instant
-import org.junit.jupiter.api.AfterEach
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class DebugViewModelTest {
-
-    private val testDispatcher = UnconfinedTestDispatcher()
-
-    @BeforeEach
-    fun setUp() {
-        Dispatchers.setMain(testDispatcher)
-    }
-
-    @AfterEach
-    fun tearDown() {
-        Dispatchers.resetMain()
-    }
-
-    private class FakeRepo(
-        val calendarsFlow: MutableStateFlow<List<CalendarSource>> = MutableStateFlow(emptyList()),
-        val instancesFlow: MutableStateFlow<List<EventInstance>> = MutableStateFlow(emptyList()),
-    ) : CalendarRepository {
-        override fun calendars(): Flow<List<CalendarSource>> = calendarsFlow
-        override fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>> = instancesFlow
-        override suspend fun eventDetail(eventId: Long): EventDetail =
-            throw NoSuchEventException(eventId)
-    }
-
-    private fun makeCal(id: Long, name: String = "C $id"): CalendarSource =
-        CalendarSource(id, name, "x@y", "LOCAL", 0xFF112233.toInt(), true)
-
-    private fun makeEvent(id: Long, title: String = "E $id") = EventInstance(
-        instanceId = id, eventId = id, calendarId = 1L,
-        title = title,
-        start = Instant.fromEpochMilliseconds(0L),
-        end = Instant.fromEpochMilliseconds(60_000L),
-        isAllDay = false, color = 0xFF000000.toInt(), location = null,
-    )
-
-    @Test
-    fun `initial state value is Loading before any subscriber`() {
-        val repo = FakeRepo()
-        val vm = DebugViewModel(repo, testDispatcher)
-        assertThat(vm.state.value).isEqualTo(DebugUiState.Loading)
-    }
-
-    @Test
-    fun `Success contains calendars and capped events after subscription`() = runTest {
-        val repo = FakeRepo(
-            calendarsFlow = MutableStateFlow(listOf(makeCal(1L))),
-            instancesFlow = MutableStateFlow(listOf(makeEvent(10L, "X"))),
-        )
-        val vm = DebugViewModel(repo, testDispatcher)
-        vm.state.test {
-            val success = awaitItem() as DebugUiState.Success
-            assertThat(success.calendars.map { it.id }).containsExactly(1L)
-            assertThat(success.nextEvents.map { it.title }).containsExactly("X")
-            cancelAndIgnoreRemainingEvents()
-        }
-    }
-
-    @Test
-    fun `instances are capped at 50`() = runTest {
-        val repo = FakeRepo(
-            calendarsFlow = MutableStateFlow(listOf(makeCal(1L))),
-            instancesFlow = MutableStateFlow((1L..100L).map { makeEvent(it, "E$it") }),
-        )
-        val vm = DebugViewModel(repo, testDispatcher)
-        vm.state.test {
-            val success = awaitItem() as DebugUiState.Success
-            assertThat(success.nextEvents).hasSize(50)
-            assertThat(success.nextEvents.first().instanceId).isEqualTo(1L)
-            assertThat(success.nextEvents.last().instanceId).isEqualTo(50L)
-            cancelAndIgnoreRemainingEvents()
-        }
-    }
-
-    @Test
-    fun `state updates when repository emits new data`() = runTest {
-        val repo = FakeRepo()
-        val vm = DebugViewModel(repo, testDispatcher)
-        vm.state.test {
-            // Empty initial: combine fires once because both StateFlows have initial empty value
-            val empty = awaitItem() as DebugUiState.Success
-            assertThat(empty.calendars).isEmpty()
-            assertThat(empty.nextEvents).isEmpty()
-
-            repo.calendarsFlow.value = listOf(makeCal(1L), makeCal(2L))
-            val updated = awaitItem() as DebugUiState.Success
-            assertThat(updated.calendars.map { it.id }).containsExactly(1L, 2L).inOrder()
-
-            cancelAndIgnoreRemainingEvents()
-        }
-    }
-}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/week/WeekLayoutTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/week/WeekLayoutTest.kt
@@ -0,0 +1,179 @@
+package de.jeanlucmakiola.calendula.ui.week
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atTime
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlin.time.Instant
+import org.junit.jupiter.api.Test
+
+class WeekLayoutTest {
+
+    private val zone = TimeZone.UTC
+
+    // 2026-06-10 is a Wednesday; its Monday-anchored week starts 2026-06-08.
+    private val wed = LocalDate(2026, 6, 10)
+    private val mon = LocalDate(2026, 6, 8)
+    private val weekDays = (0..6).map { mon.plusDays(it) }
+
+    private fun at(date: LocalDate, h: Int, m: Int = 0): Instant =
+        date.atTime(h, m).toInstant(zone)
+
+    private fun event(
+        start: Instant,
+        end: Instant,
+        allDay: Boolean = false,
+        id: Long = 1L,
+        title: String = "E",
+    ) = EventInstance(
+        instanceId = id,
+        eventId = id,
+        calendarId = 1L,
+        title = title,
+        start = start,
+        end = end,
+        isAllDay = allDay,
+        color = 0xFF112233.toInt(),
+        location = null,
+    )
+
+    @Test
+    fun `startOfWeek snaps to monday`() {
+        assertThat(wed.startOfWeek(DayOfWeek.MONDAY)).isEqualTo(mon)
+        assertThat(mon.startOfWeek(DayOfWeek.MONDAY)).isEqualTo(mon)
+    }
+
+    @Test
+    fun `weekRange spans seven days`() {
+        val range = weekRange(mon, zone)
+        assertThat(range.start).isEqualTo(at(mon, 0, 0))
+        // endInclusive is the last second of day 7 (Sunday 2026-06-14)
+        assertThat(range.endInclusive).isEqualTo(LocalDate(2026, 6, 14).atTime(23, 59, 59).toInstant(zone))
+    }
+
+    @Test
+    fun `coversDay is true for any overlap and false otherwise`() {
+        val ev = event(at(wed, 9), at(wed, 10))
+        assertThat(ev.coversDay(wed, zone)).isTrue()
+        assertThat(ev.coversDay(mon, zone)).isFalse()
+
+        val multiDay = event(at(mon, 22), at(wed, 2), allDay = true)
+        assertThat(multiDay.coversDay(mon, zone)).isTrue()
+        assertThat(multiDay.coversDay(LocalDate(2026, 6, 9), zone)).isTrue()
+        assertThat(multiDay.coversDay(wed, zone)).isTrue()
+        assertThat(multiDay.coversDay(LocalDate(2026, 6, 12), zone)).isFalse()
+    }
+
+    @Test
+    fun `single timed event gets one lane`() {
+        val blocks = layoutDay(listOf(event(at(wed, 9), at(wed, 10, 30))), wed, zone)
+        assertThat(blocks).hasSize(1)
+        val b = blocks.single()
+        assertThat(b.startMin).isEqualTo(9 * 60)
+        assertThat(b.endMin).isEqualTo(10 * 60 + 30)
+        assertThat(b.lane).isEqualTo(0)
+        assertThat(b.laneCount).isEqualTo(1)
+    }
+
+    @Test
+    fun `overlapping events resolve to side-by-side lanes`() {
+        val a = event(at(wed, 9), at(wed, 11), id = 1L)
+        val b = event(at(wed, 10), at(wed, 12), id = 2L)
+        val blocks = layoutDay(listOf(a, b), wed, zone).sortedBy { it.lane }
+        assertThat(blocks.map { it.lane }).containsExactly(0, 1)
+        assertThat(blocks.all { it.laneCount == 2 }).isTrue()
+    }
+
+    @Test
+    fun `back-to-back events reuse one lane`() {
+        val a = event(at(wed, 9), at(wed, 10), id = 1L)
+        val b = event(at(wed, 10), at(wed, 11), id = 2L)
+        val blocks = layoutDay(listOf(a, b), wed, zone)
+        assertThat(blocks).hasSize(2)
+        assertThat(blocks.all { it.lane == 0 && it.laneCount == 1 }).isTrue()
+    }
+
+    @Test
+    fun `event spanning midnight is clipped to the day`() {
+        // Starts the previous evening, ends 02:00 on wed.
+        val ev = event(at(mon.plusDays(1), 22), at(wed, 2))
+        val blocks = layoutDay(listOf(ev), wed, zone)
+        assertThat(blocks).hasSize(1)
+        assertThat(blocks.single().startMin).isEqualTo(0)
+        assertThat(blocks.single().endMin).isEqualTo(2 * 60)
+    }
+
+    @Test
+    fun `instant event is kept with zero-length`() {
+        val ev = event(at(wed, 12), at(wed, 12))
+        val blocks = layoutDay(listOf(ev), wed, zone)
+        assertThat(blocks).hasSize(1)
+        assertThat(blocks.single().startMin).isEqualTo(12 * 60)
+        assertThat(blocks.single().endMin).isEqualTo(12 * 60)
+    }
+
+    @Test
+    fun `all-day events are excluded from the timed layout`() {
+        val ev = event(at(wed, 0), at(wed.plusDays(1), 0), allDay = true)
+        assertThat(layoutDay(listOf(ev), wed, zone)).isEmpty()
+    }
+
+    @Test
+    fun `events on other days are dropped`() {
+        val ev = event(at(mon, 9), at(mon, 10))
+        assertThat(layoutDay(listOf(ev), wed, zone)).isEmpty()
+    }
+
+    @Test
+    fun `single-day all-day event is a one-column span`() {
+        // Wed only: start Wed 00:00, end Thu 00:00.
+        val ev = event(at(weekDays[2], 0), at(weekDays[3], 0), allDay = true)
+        val spans = layoutAllDay(listOf(ev), weekDays, zone)
+        assertThat(spans).hasSize(1)
+        val s = spans.single()
+        assertThat(s.startCol).isEqualTo(2)
+        assertThat(s.endCol).isEqualTo(2)
+        assertThat(s.lane).isEqualTo(0)
+    }
+
+    @Test
+    fun `multi-day all-day event becomes one span across columns`() {
+        // Tue..Thu: end Fri 00:00 is exclusive, so Fri is not covered.
+        val ev = event(at(weekDays[1], 0), at(weekDays[4], 0), allDay = true)
+        val s = layoutAllDay(listOf(ev), weekDays, zone).single()
+        assertThat(s.startCol).isEqualTo(1)
+        assertThat(s.endCol).isEqualTo(3)
+    }
+
+    @Test
+    fun `span reaching outside the week is clamped to visible columns`() {
+        // Starts two days before Monday, ends Wed 00:00 → covers Mon..Tue.
+        val ev = event(at(mon.plusDays(-2), 0), at(weekDays[2], 0), allDay = true)
+        val s = layoutAllDay(listOf(ev), weekDays, zone).single()
+        assertThat(s.startCol).isEqualTo(0)
+        assertThat(s.endCol).isEqualTo(1)
+    }
+
+    @Test
+    fun `overlapping all-day spans get separate lanes`() {
+        val a = event(at(weekDays[0], 0), at(weekDays[3], 0), allDay = true, id = 1L) // Mon..Wed
+        val b = event(at(weekDays[1], 0), at(weekDays[4], 0), allDay = true, id = 2L) // Tue..Thu
+        val spans = layoutAllDay(listOf(a, b), weekDays, zone)
+        assertThat(spans.map { it.lane }.toSet()).isEqualTo(setOf(0, 1))
+    }
+
+    @Test
+    fun `disjoint all-day spans reuse one lane`() {
+        val a = event(at(weekDays[0], 0), at(weekDays[1], 0), allDay = true, id = 1L) // Mon
+        val b = event(at(weekDays[3], 0), at(weekDays[4], 0), allDay = true, id = 2L) // Thu
+        val spans = layoutAllDay(listOf(a, b), weekDays, zone)
+        assertThat(spans.all { it.lane == 0 }).isTrue()
+    }
+
+    private fun LocalDate.plusDays(n: Int): LocalDate = plus(n, DateTimeUnit.DAY)
+}
--- a/design/icon/calendula_launcher.svg
+++ b/design/icon/calendula_launcher.svg
@@ -0,0 +1,34 @@
+<svg width="232" height="232" viewBox="0 0 232 232" xmlns="http://www.w3.org/2000/svg">
+<!--
+    Composed Calendula launcher icon (full-bleed), generated to exactly match the
+    Android adaptive icon defined by:
+      - drawable/ic_launcher_background.xml  (solid @color/ic_launcher_background = #5C6B7A)
+      - drawable/ic_launcher_foreground.xml  (off-white #FAF6F0 mark from calendula_mark.svg)
+
+    The adaptive foreground group transform (scaleX/Y=0.50, pivot 114,108,
+    translate 2,8) is reproduced here as the SVG transform "translate(59,62) scale(0.5)"
+    because Android applies it as:  p' = scale*p + pivot*(1-scale) + translate
+      x' = 0.5*x + 114*0.5 + 2 = 0.5*x + 59
+      y' = 0.5*y + 108*0.5 + 8 = 0.5*y + 62
+
+    This is the single source of truth for the F-Droid / store icon.png renders.
+-->
+<rect x="0" y="0" width="232" height="232" fill="#5C6B7A"/>
+<g transform="translate(59,62) scale(0.5)" fill="none" stroke="#FAF6F0">
+  <!-- Calendar body (rounded square with horizontal header divider) -->
+  <path d="M43 69H185M185 115V63C185 48.64 173.359 37 159 37H69C54.64 37 43 48.64 43 63V153C43 167.359 54.64 179 69 179H124" stroke-width="12" stroke-miterlimit="12" stroke-linecap="round" stroke-linejoin="round"/>
+  <!-- Numeral "1" inside the calendar body -->
+  <path d="M103 110L113.999 99V142.428" stroke-width="12" stroke-linecap="round" stroke-linejoin="round"/>
+  <!-- Calendula bloom: 8 petals around a filled center -->
+  <path d="M163.072 136.714C163.072 142.886 168.214 153.429 170.786 157.929C173.357 153.429 178.5 142.886 178.5 136.714C178.5 130.543 173.357 129 170.786 129C168.214 129 163.072 130.543 163.072 136.714Z" stroke-width="8"/>
+  <path d="M178.5 186.857C178.5 180.686 173.357 170.143 170.786 165.643C168.214 170.143 163.072 180.686 163.072 186.857C163.072 193.029 168.214 194.572 170.786 194.572C173.357 194.572 178.5 193.029 178.5 186.857Z" stroke-width="8"/>
+  <path d="M195.857 154.072C189.686 154.072 179.143 159.214 174.643 161.786C179.143 164.357 189.686 169.5 195.857 169.5C202.029 169.5 203.572 164.357 203.572 161.786C203.572 159.214 202.029 154.072 195.857 154.072Z" stroke-width="8"/>
+  <path d="M145.714 170.008C151.886 170.008 162.429 164.865 166.929 162.294C162.429 159.722 151.886 154.58 145.714 154.58C139.543 154.58 138 159.722 138 162.294C138 164.865 139.543 170.008 145.714 170.008Z" stroke-width="8"/>
+  <path d="M194.768 174.858C190.404 170.494 179.312 166.676 174.312 165.312C175.676 170.312 179.494 181.404 183.858 185.768C188.222 190.132 192.949 187.586 194.768 185.768C196.586 183.949 199.132 179.222 194.768 174.858Z" stroke-width="8"/>
+  <path d="M146.804 149.222C151.168 153.586 162.259 157.404 167.26 158.768C165.896 153.767 162.077 142.676 157.714 138.312C153.35 133.948 148.622 136.494 146.804 138.312C144.986 140.13 142.44 144.858 146.804 149.222Z" stroke-width="8"/>
+  <path d="M183.858 138.312C179.494 142.676 175.676 153.767 174.312 158.768C179.312 157.404 190.404 153.586 194.768 149.222C199.132 144.858 196.586 140.13 194.768 138.312C192.949 136.494 188.222 133.948 183.858 138.312Z" stroke-width="8"/>
+  <path d="M157.714 185.768C162.077 181.404 165.896 170.312 167.26 165.312C162.259 166.676 151.168 170.494 146.804 174.858C142.44 179.222 144.986 183.949 146.804 185.768C148.622 187.586 153.35 190.132 157.714 185.768Z" stroke-width="8"/>
+  <!-- Calendula center disc (filled, matches foreground <fillColor> slot) -->
+  <path d="M170.786 169C174.77 169 178 165.77 178 161.786C178 157.802 174.77 154.572 170.786 154.572C166.802 154.572 163.572 157.802 163.572 161.786C163.572 165.77 166.802 169 170.786 169Z" fill="#FAF6F0" stroke="none"/>
+</g>
+</svg>
--- a/design/icon/calendula_mark.svg
+++ b/design/icon/calendula_mark.svg
@@ -0,0 +1,13 @@
+<svg width="232" height="232" viewBox="0 0 232 232" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M43 69H185M185 115V63C185 48.64 173.359 37 159 37H69C54.64 37 43 48.64 43 63V153C43 167.359 54.64 179 69 179H124" stroke="black" stroke-width="12" stroke-miterlimit="12" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M103 110L113.999 99V142.428" stroke="black" stroke-width="12" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M163.072 136.714C163.072 142.886 168.214 153.429 170.786 157.929C173.357 153.429 178.5 142.886 178.5 136.714C178.5 130.543 173.357 129 170.786 129C168.214 129 163.072 130.543 163.072 136.714Z" stroke="black" stroke-width="8"/>
+<path d="M178.5 186.857C178.5 180.686 173.357 170.143 170.786 165.643C168.214 170.143 163.072 180.686 163.072 186.857C163.072 193.029 168.214 194.572 170.786 194.572C173.357 194.572 178.5 193.029 178.5 186.857Z" stroke="black" stroke-width="8"/>
+<path d="M195.857 154.072C189.686 154.072 179.143 159.214 174.643 161.786C179.143 164.357 189.686 169.5 195.857 169.5C202.029 169.5 203.572 164.357 203.572 161.786C203.572 159.214 202.029 154.072 195.857 154.072Z" stroke="black" stroke-width="8"/>
+<path d="M145.714 170.008C151.886 170.008 162.429 164.865 166.929 162.294C162.429 159.722 151.886 154.58 145.714 154.58C139.543 154.58 138 159.722 138 162.294C138 164.865 139.543 170.008 145.714 170.008Z" stroke="black" stroke-width="8"/>
+<path d="M194.768 174.858C190.404 170.494 179.312 166.676 174.312 165.312C175.676 170.312 179.494 181.404 183.858 185.768C188.222 190.132 192.949 187.586 194.768 185.768C196.586 183.949 199.132 179.222 194.768 174.858Z" stroke="black" stroke-width="8"/>
+<path d="M146.804 149.222C151.168 153.586 162.259 157.404 167.26 158.768C165.896 153.767 162.077 142.676 157.714 138.312C153.35 133.948 148.622 136.494 146.804 138.312C144.986 140.13 142.44 144.858 146.804 149.222Z" stroke="black" stroke-width="8"/>
+<path d="M183.858 138.312C179.494 142.676 175.676 153.767 174.312 158.768C179.312 157.404 190.404 153.586 194.768 149.222C199.132 144.858 196.586 140.13 194.768 138.312C192.949 136.494 188.222 133.948 183.858 138.312Z" stroke="black" stroke-width="8"/>
+<path d="M157.714 185.768C162.077 181.404 165.896 170.312 167.26 165.312C162.259 166.676 151.168 170.494 146.804 174.858C142.44 179.222 144.986 183.949 146.804 185.768C148.622 187.586 153.35 190.132 157.714 185.768Z" stroke="black" stroke-width="8"/>
+<path d="M170.786 169C174.77 169 178 165.77 178 161.786C178 157.802 174.77 154.572 170.786 154.572C166.802 154.572 163.572 157.802 163.572 161.786C163.572 165.77 166.802 169 170.786 169Z" fill="black" stroke="black"/>
+</svg>
--- a/fdroid-metadata/de.jeanlucmakiola.calendula/de-DE/icon.png
+++ b/fdroid-metadata/de.jeanlucmakiola.calendula/de-DE/icon.png
--- a/fdroid-metadata/de.jeanlucmakiola.calendula/en-US/icon.png
+++ b/fdroid-metadata/de.jeanlucmakiola.calendula/en-US/icon.png
--- a/gradle/gradle-daemon-jvm.properties
+++ b/gradle/gradle-daemon-jvm.properties
@@ -0,0 +1,13 @@
+#This file is generated by updateDaemonJvm
+toolchainUrl.FREE_BSD.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect
+toolchainUrl.FREE_BSD.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect
+toolchainUrl.LINUX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect
+toolchainUrl.LINUX.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect
+toolchainUrl.MAC_OS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/7083b89563e7ce20943037b8cd2b8cc2/redirect
+toolchainUrl.MAC_OS.X86_64=https\://api.foojay.io/disco/v3.0/ids/060bbb778a1f55ea705fdebd2ccfeab9/redirect
+toolchainUrl.UNIX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect
+toolchainUrl.UNIX.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect
+toolchainUrl.WINDOWS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/d09679dc60fe5aa05ef7d03efdefac20/redirect
+toolchainUrl.WINDOWS.X86_64=https\://api.foojay.io/disco/v3.0/ids/ed4e3bf2f5e7c5d9aabc4cbd8acd555e/redirect
+toolchainVendor=JETBRAINS
+toolchainVersion=21
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,5 +1,5 @@
 [versions]
-agp = "9.1.1"
+agp = "9.2.1"
 kotlin = "2.3.21"
 ksp = "2.3.9"
 hilt = "2.59.2"
@@ -41,6 +41,7 @@ androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-man

 # Material 3 (Expressive lives in this artifact for 1.5+)
 androidx-material3 = { group = "androidx.compose.material3", name = "material3", version.ref = "material3" }
+androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }

 # Hilt
 hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -11,6 +11,9 @@ pluginManagement {
        gradlePluginPortal()
    }
 }
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
+}

 dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
Author	SHA1	Message	Date
Jean-Luc Makiola	d3fbe28843	docs: record v0.3.0 (month/week/day views, view switcher) in CHANGELOG All checks were successful Build and Release to F-Droid / build-and-deploy (push) Successful in 8m43s Details CI / ci (push) Successful in 10m49s Details Build and Release to F-Droid / ci (push) Successful in 6m16s Details Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-10 20:44:22 +02:00
Jean-Luc Makiola	951fb640a6	feat(day): single-column day view, wire into view switcher Day view as a one-column slice of the week view: shared TimedBlock/ AllDaySpan layout, per-day swipe navigation, hoisted noon-centred scroll, animated all-day strip, and a compact top bar showing the full date. - DayUiState / DayViewModel / DayScreen under ui/day - reuse layoutDay/layoutAllDay/coversDay from the week package - add Day to IMPLEMENTED_VIEWS; CalendarHost routes it explicitly - day_today_action strings (en/de) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-10 20:40:02 +02:00
Jean-Luc Makiola	94fa206e2e	refactor(week): polish timeline — rounded viewport, scroll persistence, week badge All checks were successful CI / ci (push) Successful in 11m40s Details - Rounded, permanently-soft day-column scroll viewport via two viewports sharing one scroll state (gutter + columns stay aligned); plain rectangular column cards inside - Vertical scroll position now persists across week swipes; noon-centring only runs on first entry into the week view (from month/day) - All-day strip height is hoisted + animated, shared by both swipe pages, so it slides along and resizes smoothly instead of jumping - Multi-line event time label so the end time isn't clipped in narrow columns; hour labels centred in the gutter - Calendar-week (ISO) badge in the header gutter, aligned with the date numbers; dropped the redundant "All-day" gutter label - Small breathing room between the top section and the timeline Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-10 20:05:40 +02:00
Jean-Luc Makiola	6a90bade8a	feat(ui): month card grid + week timeline, wire view switcher Replace the throwaway debug screen with the first real calendar UI and a functional Month <-> Week switcher, on Material 3 Expressive. Month view (S1): - Material 3 Expressive card-per-day grid; only the current month's weeks render (neighbouring days left blank) - per-day event dots with "+N" overflow, today via primaryContainer - spring-based press feedback from the active motion scheme - swipe + drawer navigation, Loading/Failure/Success states Week view (S2): - vertical time schedule with overlap-resolved lanes (per-day clipping, midnight spanning, instant events) - all-day / multi-day events as connected horizontal spans - single scroll container (gutter + day columns stay aligned), columns bundled in a rounded container, noon-centred on load - top section colour-shifts with the app bar on scroll; swipe navigation, three states Shared / infra: - CalendarHost holds the active view; RootScreen renders it post-permission - ui/common building blocks: CalendarDrawer, CalendarFailure, ViewSwitcherPill, pastelize, observable locale, M3 Expressive slide transition (motionScheme fastSpatialSpec) - unit tests for the week layout (lanes, clipping, all-day spans) - build: compileSdk 37, material3 pinned to 1.5.0-alpha21 for Expressive Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-10 20:05:40 +02:00
Jean-Luc Makiola	0132201cf9	style(icon): regenerate F-Droid icon.png to match launcher exactly All checks were successful CI / ci (push) Successful in 10m41s Details Build and Release to F-Droid / ci (push) Successful in 5m59s Details Build and Release to F-Droid / build-and-deploy (push) Successful in 8m27s Details Re-render both locale catalog icons (512x512) from the same logo as the Android adaptive launcher icon, baking in the foreground group transform (scale 0.5, pivot 114,108, translate 2,8) over the slate background so the F-Droid render is pixel-faithful to the on-device icon. Add design/icon/calendula_launcher.svg as the composed full-bleed source of truth for store/F-Droid renders. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-09 10:38:08 +02:00
Jean-Luc Makiola	b792ddc2f0	style: fix launcher icon scaling and centering, update AGP All checks were successful CI / ci (push) Successful in 9m58s Details	2026-06-08 20:30:40 +02:00
Jean-Luc Makiola	440fa57161	fix(debug): use prefixed composite keys in LazyColumn All checks were successful CI / ci (push) Successful in 9m35s Details Cal.id and Event.instanceId share a numeric range, and the LazyColumn keys both sections — colliding values (e.g. cal-id=4 + event-instance-id=4) crashed with "Key '4' was already used". Additionally, Instances._ID is inherited from the parent Event, so recurring events produce multiple rows with the same instanceId; the start instant disambiguates them.	2026-06-08 20:19:58 +02:00
Jean-Luc Makiola	00b5aeaac7	feat(icon): line-art cal + calendula bloom + numeral "1" All checks were successful CI / ci (push) Successful in 9m42s Details Replaces the simple numeral-only foreground from v0.1.0. The new mark keeps the kalendae reference explicit (a bold "1" inside the calendar body) and adds a small calendula bloom as a badge in the bottom-right corner so the app's "calendula" brand reads at first glance. - design/icon/calendula_mark.svg: source SVG (232x232 viewport, monochrome, lawnicons-style strokes 12/8) - app/src/main/res/drawable/ic_launcher_foreground.xml: regenerated as a VectorDrawable preserving the source path data. Off-white (#FAF6F0) strokes on the existing slate background. Reused as the <monochrome> slot so Android 13+ themed-icon launchers can recolor it from wallpaper. - fdroid-metadata/.../{en-US,de-DE}/icon.png: 512x512 PNG composed from the same source SVG with the slate background baked in, so F-Droid clients show a fully rendered tile in the app catalog. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-06-08 18:24:04 +02:00