diff --git a/Cargo.lock b/Cargo.lock
index c8506de605..bcdd7187ae 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11016,20 +11016,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 
-[[package]]
-name = "mac-notification-sys"
-version = "0.6.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
-dependencies = [
- "cc",
- "log",
- "objc2",
- "objc2-foundation",
- "time",
- "uuid",
-]
-
 [[package]]
 name = "mac_address2"
 version = "2.0.2"
@@ -11752,6 +11738,7 @@ dependencies = [
  "notification-interface",
  "notification-linux",
  "notification-macos",
+ "notification-windows",
  "serde",
  "tracing",
 ]
@@ -11769,14 +11756,14 @@ name = "notification-linux"
 version = "0.1.0"
 dependencies = [
  "gdk",
+ "gdk-pixbuf",
  "glib",
  "gtk",
  "indexmap 2.14.0",
  "notification-interface",
- "open",
  "pango",
  "tokio",
- "uuid",
+ "tracing",
 ]
 
 [[package]]
@@ -11806,6 +11793,16 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "notification-windows"
+version = "0.1.0"
+dependencies = [
+ "indexmap 2.14.0",
+ "notification-interface",
+ "tracing",
+ "windows 0.62.2",
+]
+
 [[package]]
 name = "notification-worker"
 version = "0.1.0"
@@ -11854,20 +11851,6 @@ dependencies = [
  "walkdir",
 ]
 
-[[package]]
-name = "notify-rust"
-version = "4.11.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6442248665a5aa2514e794af3b39661a8e73033b1cc5e59899e1276117ee4400"
-dependencies = [
- "futures-lite",
- "log",
- "mac-notification-sys",
- "serde",
- "tauri-winrt-notification",
- "zbus",
-]
-
 [[package]]
 name = "notify-types"
 version = "2.1.0"
@@ -18986,7 +18969,6 @@ dependencies = [
  "host",
  "intercept",
  "notification",
- "notify-rust",
  "serde",
  "specta",
  "specta-typescript",
@@ -18998,9 +18980,7 @@ dependencies = [
  "tauri-plugin-windows",
  "tauri-specta",
  "thiserror 2.0.18",
- "tokio",
  "tracing",
- "windows 0.62.2",
 ]
 
 [[package]]
@@ -19727,17 +19707,6 @@ dependencies = [
  "toml 0.9.12+spec-1.1.0",
 ]
 
-[[package]]
-name = "tauri-winrt-notification"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed071c670382e85fc2f48ae706492d8c338f4f89bf72520d32f8abfe880aade"
-dependencies = [
- "thiserror 2.0.18",
- "windows 0.61.3",
- "windows-version",
-]
-
 [[package]]
 name = "tcc"
 version = "0.1.0"
diff --git a/crates/notification-interface/src/lib.rs b/crates/notification-interface/src/lib.rs
index 6eafbe7519..a557aea65c 100644
--- a/crates/notification-interface/src/lib.rs
+++ b/crates/notification-interface/src/lib.rs
@@ -1,4 +1,5 @@
 use std::collections::BTreeSet;
+use std::time::{Duration, Instant};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, specta::Type)]
 pub enum NotificationEvent {
@@ -177,6 +178,76 @@ pub struct Notification {
     pub icon: Option<NotificationIcon>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PrimaryAction<'a> {
+    Accept { label: &'a str, destructive: bool },
+    Options(&'a [String]),
+}
+
+#[derive(Debug, Clone)]
+pub struct DismissTimer {
+    total: Duration,
+    remaining: Duration,
+    running_since: Option<Instant>,
+}
+
+impl DismissTimer {
+    pub fn new(total: Duration) -> Self {
+        Self::at(total, Instant::now())
+    }
+
+    pub fn at(total: Duration, now: Instant) -> Self {
+        Self {
+            total,
+            remaining: total,
+            running_since: Some(now),
+        }
+    }
+
+    pub fn total(&self) -> Duration {
+        self.total
+    }
+
+    pub fn is_running(&self) -> bool {
+        self.running_since.is_some()
+    }
+
+    pub fn remaining(&self, now: Instant) -> Duration {
+        match self.running_since {
+            Some(started) => self
+                .remaining
+                .saturating_sub(now.saturating_duration_since(started)),
+            None => self.remaining,
+        }
+    }
+
+    pub fn progress_ratio(&self, now: Instant) -> f64 {
+        if self.total.is_zero() {
+            return 0.0;
+        }
+
+        self.remaining(now).as_secs_f64() / self.total.as_secs_f64()
+    }
+
+    pub fn is_expired(&self, now: Instant) -> bool {
+        self.remaining(now).is_zero()
+    }
+
+    pub fn pause(&mut self, now: Instant) {
+        if let Some(started) = self.running_since.take() {
+            self.remaining = self
+                .remaining
+                .saturating_sub(now.saturating_duration_since(started));
+        }
+    }
+
+    pub fn resume(&mut self, now: Instant) {
+        if self.running_since.is_none() && !self.remaining.is_zero() {
+            self.running_since = Some(now);
+        }
+    }
+}
+
 impl Notification {
     pub fn builder() -> NotificationBuilder {
         NotificationBuilder::default()
@@ -185,6 +256,110 @@ impl Notification {
     pub fn is_persistent(&self) -> bool {
         self.timeout.is_none()
     }
+
+    pub fn is_destructive_action(&self) -> bool {
+        matches!(
+            self.action_variant,
+            Some(NotificationActionVariant::Destructive)
+        )
+    }
+
+    pub fn shows_stop_countdown(&self) -> bool {
+        self.is_destructive_action()
+            && self.action_label.as_deref() == Some("Stop")
+            && self.timeout.is_some_and(|timeout| !timeout.is_zero())
+    }
+
+    pub fn has_options(&self) -> bool {
+        self.options
+            .as_deref()
+            .is_some_and(|options| !options.is_empty())
+    }
+
+    pub fn has_expandable_content(&self) -> bool {
+        if matches!(self.source, Some(NotificationSource::CalendarEvent { .. })) {
+            return false;
+        }
+
+        self.participants
+            .as_ref()
+            .is_some_and(|participants| !participants.is_empty())
+            || self.event_details.is_some()
+    }
+
+    pub fn default_action_label(&self) -> &str {
+        self.action_label.as_deref().unwrap_or("Open Anarlog")
+    }
+
+    pub fn expanded_action_label(&self) -> &str {
+        self.action_label.as_deref().unwrap_or("Accept")
+    }
+
+    pub fn primary_action(&self) -> PrimaryAction<'_> {
+        if let Some(options) = self
+            .options
+            .as_deref()
+            .filter(|options| !options.is_empty())
+        {
+            return PrimaryAction::Options(options);
+        }
+
+        PrimaryAction::Accept {
+            label: self.default_action_label(),
+            destructive: self.is_destructive_action(),
+        }
+    }
+
+    pub fn compact_title(&self) -> &str {
+        self.title.as_str()
+    }
+
+    pub fn expanded_title(&self) -> &str {
+        self.event_details
+            .as_ref()
+            .map(|details| details.what.as_str())
+            .filter(|title| !title.is_empty())
+            .unwrap_or(self.title.as_str())
+    }
+
+    pub fn compact_message(&self, remaining: Option<Duration>) -> String {
+        if self.start_time.is_some() {
+            return match remaining {
+                Some(value) if value.is_zero() => "Started".to_string(),
+                Some(value) => compact_schedule_text(value),
+                None => "Starting soon".to_string(),
+            };
+        }
+
+        if self.shows_stop_countdown() {
+            return stop_countdown_text(remaining.unwrap_or(Duration::ZERO));
+        }
+
+        self.message.clone()
+    }
+}
+
+pub fn compact_schedule_text(remaining: Duration) -> String {
+    let minutes = (remaining.as_secs_f64() / 60.0).ceil().max(1.0) as u64;
+    if minutes == 1 {
+        "Starting in 1 minute".to_string()
+    } else {
+        format!("Starting in {minutes} minutes")
+    }
+}
+
+pub fn expanded_schedule_text(remaining: Duration) -> String {
+    if remaining.is_zero() {
+        return "Started".to_string();
+    }
+
+    let total_seconds = remaining.as_secs();
+    format!("Begins in {}:{:02}", total_seconds / 60, total_seconds % 60)
+}
+
+pub fn stop_countdown_text(remaining: Duration) -> String {
+    let seconds = remaining.as_secs_f64().ceil() as u64;
+    format!("Anarlog will stop listening in {seconds} seconds.")
 }
 
 impl NotificationSource {
@@ -430,4 +605,111 @@ mod tests {
             Some("YES")
         );
     }
+
+    #[test]
+    fn calendar_events_are_not_expandable() {
+        let notification = Notification::builder()
+            .title("Standup")
+            .message("Starting soon")
+            .source(NotificationSource::CalendarEvent {
+                event_id: "evt-1".to_string(),
+            })
+            .participants(vec![Participant {
+                name: Some("Ada".to_string()),
+                email: "ada@example.com".to_string(),
+                status: ParticipantStatus::Accepted,
+            }])
+            .event_details(EventDetails {
+                what: "Standup".to_string(),
+                timezone: None,
+                location: None,
+            })
+            .build();
+
+        assert!(!notification.has_expandable_content());
+    }
+
+    #[test]
+    fn session_notifications_expand_when_event_details_are_present() {
+        let notification = Notification::builder()
+            .title("Design sync")
+            .message("")
+            .source(NotificationSource::Session {
+                session_id: "sess-1".to_string(),
+            })
+            .event_details(EventDetails {
+                what: "Design sync".to_string(),
+                timezone: Some("America/Los_Angeles".to_string()),
+                location: Some("Zoom".to_string()),
+            })
+            .build();
+
+        assert!(notification.has_expandable_content());
+        assert_eq!(notification.expanded_title(), "Design sync");
+    }
+
+    #[test]
+    fn options_override_the_accept_action() {
+        let notification = Notification::builder()
+            .title("Choose a meeting")
+            .message("")
+            .action_label("Ignored")
+            .options(vec!["Design sync".to_string(), "Planning".to_string()])
+            .build();
+
+        assert_eq!(
+            notification.primary_action(),
+            PrimaryAction::Options(&["Design sync".to_string(), "Planning".to_string()])
+        );
+    }
+
+    #[test]
+    fn stop_countdown_copy_matches_macos() {
+        let notification = Notification::builder()
+            .title("Did your meeting end?")
+            .message("Anarlog will stop listening soon.")
+            .action_label("Stop")
+            .action_variant(NotificationActionVariant::Destructive)
+            .timeout(Duration::from_secs(30))
+            .build();
+
+        assert!(notification.shows_stop_countdown());
+        assert_eq!(
+            notification.compact_message(Some(Duration::from_secs_f64(4.2))),
+            "Anarlog will stop listening in 5 seconds."
+        );
+        assert_eq!(
+            compact_schedule_text(Duration::from_secs(90)),
+            "Starting in 2 minutes"
+        );
+        assert_eq!(
+            expanded_schedule_text(Duration::from_secs(75)),
+            "Begins in 1:15"
+        );
+    }
+
+    #[test]
+    fn dismiss_timer_pauses_and_resumes_without_losing_progress() {
+        let start = Instant::now();
+        let mut timer = DismissTimer::at(Duration::from_secs(10), start);
+
+        assert!((timer.progress_ratio(start) - 1.0).abs() < f64::EPSILON);
+
+        let halfway = start + Duration::from_secs(4);
+        timer.pause(halfway);
+        assert!(!timer.is_running());
+        assert_eq!(
+            timer.remaining(halfway + Duration::from_secs(30)),
+            Duration::from_secs(6)
+        );
+
+        let resumed = halfway + Duration::from_secs(8);
+        timer.resume(resumed);
+        assert_eq!(
+            timer.remaining(resumed + Duration::from_secs(2)),
+            Duration::from_secs(4)
+        );
+        assert!((timer.progress_ratio(resumed + Duration::from_secs(2)) - 0.4).abs() < 1e-9);
+        assert!(timer.is_expired(resumed + Duration::from_secs(6)));
+    }
 }
diff --git a/crates/notification-linux/Cargo.toml b/crates/notification-linux/Cargo.toml
index f368513349..35d3a4673d 100644
--- a/crates/notification-linux/Cargo.toml
+++ b/crates/notification-linux/Cargo.toml
@@ -18,9 +18,9 @@ anlg-notification-interface = { workspace = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 gdk = "0.18"
+gdk-pixbuf = "0.18"
 glib = "0.18"
 gtk = "0.18"
 pango = "0.18"
 indexmap = "2.6"
-open = { workspace = true }
-uuid = { workspace = true, features = ["v4"] }
+tracing = { workspace = true }
diff --git a/crates/notification-linux/src/callbacks.rs b/crates/notification-linux/src/callbacks.rs
index bf28aab0ed..b6a947b204 100644
--- a/crates/notification-linux/src/callbacks.rs
+++ b/crates/notification-linux/src/callbacks.rs
@@ -10,35 +10,6 @@ static TIMEOUT_CB: NotificationCallback = Mutex::new(None);
 static OPTION_SELECTED_CB: NotificationOptionCallback = Mutex::new(None);
 static FOOTER_ACTION_CB: NotificationCallback = Mutex::new(None);
 
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) enum PrimaryAction<'a> {
-    Accept { label: &'a str, destructive: bool },
-    Options(&'a [String]),
-}
-
-pub(crate) fn primary_action(
-    notification: &anlg_notification_interface::Notification,
-) -> PrimaryAction<'_> {
-    if let Some(options) = notification
-        .options
-        .as_deref()
-        .filter(|options| !options.is_empty())
-    {
-        return PrimaryAction::Options(options);
-    }
-
-    PrimaryAction::Accept {
-        label: notification
-            .action_label
-            .as_deref()
-            .unwrap_or("Open Anarlog"),
-        destructive: matches!(
-            notification.action_variant,
-            Some(anlg_notification_interface::NotificationActionVariant::Destructive)
-        ),
-    }
-}
-
 pub fn setup_notification_confirm_handler<F>(f: F)
 where
     F: Fn(String) + Send + Sync + 'static,
@@ -123,46 +94,6 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn resolves_linux_primary_actions_from_the_shared_notification_contract() {
-        let default_action = anlg_notification_interface::Notification::builder()
-            .title("Upcoming event")
-            .message("Starting soon")
-            .build();
-        assert_eq!(
-            primary_action(&default_action),
-            PrimaryAction::Accept {
-                label: "Open Anarlog",
-                destructive: false,
-            }
-        );
-
-        let destructive_action = anlg_notification_interface::Notification::builder()
-            .title("Did your meeting end?")
-            .message("Anarlog will stop listening soon.")
-            .action_label("Stop")
-            .action_variant(anlg_notification_interface::NotificationActionVariant::Destructive)
-            .build();
-        assert_eq!(
-            primary_action(&destructive_action),
-            PrimaryAction::Accept {
-                label: "Stop",
-                destructive: true,
-            }
-        );
-
-        let options_action = anlg_notification_interface::Notification::builder()
-            .title("Choose a meeting")
-            .message("")
-            .action_label("Ignored when options are present")
-            .options(vec!["Design sync".to_string(), "Planning".to_string()])
-            .build();
-        assert_eq!(
-            primary_action(&options_action),
-            PrimaryAction::Options(&["Design sync".to_string(), "Planning".to_string()])
-        );
-    }
-
     #[test]
     fn routes_each_linux_notification_action_to_its_registered_handler() {
         let events = Arc::new(Mutex::new(Vec::new()));
diff --git a/crates/notification-linux/src/icon.rs b/crates/notification-linux/src/icon.rs
new file mode 100644
index 0000000000..8b37844c23
--- /dev/null
+++ b/crates/notification-linux/src/icon.rs
@@ -0,0 +1,135 @@
+use gdk_pixbuf::{InterpType, Pixbuf};
+use gtk::IconTheme;
+use gtk::prelude::IconThemeExt;
+
+use anlg_notification_interface::{NotificationIcon, NotificationIconAsset};
+
+const ICON_SIZE: i32 = 28;
+
+pub(crate) fn pixbuf_for_icon(icon: Option<&NotificationIcon>) -> Option<Pixbuf> {
+    match icon {
+        None => default_app_icon(),
+        Some(NotificationIcon::Hidden) => None,
+        Some(NotificationIcon::BundleId { bundle_id }) => {
+            icon_theme_pixbuf(bundle_id).or_else(default_app_icon)
+        }
+        Some(NotificationIcon::SystemSymbol { name }) => {
+            icon_theme_pixbuf(system_symbol_icon_name(name)).or_else(default_app_icon)
+        }
+        Some(NotificationIcon::Path { path }) => pixbuf_from_path(path).or_else(default_app_icon),
+        Some(NotificationIcon::Overlay { base, badge }) => {
+            let base_image = pixbuf_for_asset(base).or_else(default_app_icon)?;
+            match pixbuf_for_asset(badge) {
+                Some(badge_image) => Some(compose_overlay(&base_image, &badge_image)),
+                None => Some(base_image),
+            }
+        }
+    }
+}
+
+fn pixbuf_for_asset(asset: &NotificationIconAsset) -> Option<Pixbuf> {
+    match asset {
+        NotificationIconAsset::AppIcon => default_app_icon(),
+        NotificationIconAsset::Calendar => icon_theme_pixbuf("x-office-calendar")
+            .or_else(|| icon_theme_pixbuf("office-calendar"))
+            .or_else(|| icon_theme_pixbuf("calendar")),
+        NotificationIconAsset::SystemSymbol { name } => {
+            icon_theme_pixbuf(system_symbol_icon_name(name))
+        }
+        NotificationIconAsset::BundleId { bundle_id } => icon_theme_pixbuf(bundle_id),
+        NotificationIconAsset::Path { path } => pixbuf_from_path(path),
+    }
+}
+
+fn pixbuf_from_path(path: &str) -> Option<Pixbuf> {
+    let expanded = expand_home(path);
+    Pixbuf::from_file_at_scale(&expanded, ICON_SIZE, ICON_SIZE, true).ok()
+}
+
+fn expand_home(path: &str) -> String {
+    if let Some(rest) = path.strip_prefix("~/")
+        && let Ok(home) = std::env::var("HOME")
+    {
+        return format!("{home}/{rest}");
+    }
+    path.to_string()
+}
+
+fn default_app_icon() -> Option<Pixbuf> {
+    icon_theme_pixbuf("com.hyprnote.dev")
+        .or_else(|| icon_theme_pixbuf("anarlog"))
+        .or_else(|| icon_theme_pixbuf("hyprnote"))
+        .or_else(|| icon_theme_pixbuf("application-x-executable"))
+}
+
+fn icon_theme_pixbuf(name: &str) -> Option<Pixbuf> {
+    let theme = IconTheme::default()?;
+    if let Ok(Some(pixbuf)) = theme.load_icon(name, ICON_SIZE, gtk::IconLookupFlags::FORCE_SIZE) {
+        return Some(pixbuf);
+    }
+
+    let normalized = name.rsplit('.').next().unwrap_or(name).to_ascii_lowercase();
+    theme
+        .load_icon(&normalized, ICON_SIZE, gtk::IconLookupFlags::FORCE_SIZE)
+        .ok()
+        .flatten()
+}
+
+fn system_symbol_icon_name(name: &str) -> &str {
+    match name {
+        "phone.fill" | "phone" => "phone",
+        "video.fill" | "video" => "camera-web",
+        "calendar" => "x-office-calendar",
+        _ => "dialog-information",
+    }
+}
+
+fn compose_overlay(base: &Pixbuf, badge: &Pixbuf) -> Pixbuf {
+    let Some(dest) = base.copy() else {
+        return base.clone();
+    };
+
+    let badge_size = ((base.width().max(1) as f64) * 0.54).round() as i32;
+    let Some(scaled) = badge.scale_simple(badge_size, badge_size, InterpType::Bilinear) else {
+        return dest;
+    };
+
+    let x = (base.width() - badge_size).max(0);
+    let y = (base.height() - badge_size).max(0);
+    scaled.composite(
+        &dest,
+        x,
+        y,
+        badge_size,
+        badge_size,
+        f64::from(x),
+        f64::from(y),
+        1.0,
+        1.0,
+        InterpType::Bilinear,
+        255,
+    );
+    dest
+}
+
+#[cfg(test)]
+mod tests {
+    use super::expand_home;
+
+    #[test]
+    fn expands_home_prefixed_icon_paths() {
+        let previous = std::env::var("HOME").ok();
+        unsafe {
+            std::env::set_var("HOME", "/home/anarlog");
+        }
+        assert_eq!(
+            expand_home("~/icons/zoom.svg"),
+            "/home/anarlog/icons/zoom.svg"
+        );
+        assert_eq!(expand_home("/usr/share/zoom.png"), "/usr/share/zoom.png");
+        match previous {
+            Some(home) => unsafe { std::env::set_var("HOME", home) },
+            None => unsafe { std::env::remove_var("HOME") },
+        }
+    }
+}
diff --git a/crates/notification-linux/src/impl.rs b/crates/notification-linux/src/impl.rs
index 0436610a7f..0b035f0802 100644
--- a/crates/notification-linux/src/impl.rs
+++ b/crates/notification-linux/src/impl.rs
@@ -1,222 +1,174 @@
 use std::cell::RefCell;
-use std::time::Duration;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
+use gdk::prelude::*;
+use gtk::gdk::NotifyType;
 use gtk::prelude::*;
 use gtk::{
     Align, Box as GtkBox, Button, CssProvider, EventBox, Image, Label, Menu, MenuButton, MenuItem,
-    Orientation, StyleContext, Window, WindowType,
+    Orientation, Overlay, ProgressBar, StyleContext, Window, WindowType,
 };
 use indexmap::IndexMap;
 
+use anlg_notification_interface::{
+    DismissTimer, ParticipantStatus, PrimaryAction, expanded_schedule_text,
+};
+
 use crate::callbacks;
+use crate::icon;
+
+const NOTIFICATION_WIDTH: i32 = 344;
+const COMPACT_HEIGHT: i32 = 64;
+const COMPACT_FOOTER_HEIGHT: i32 = 28;
+const EXPANDED_HEIGHT: i32 = 380;
+const RIGHT_MARGIN: i32 = 15;
+const TOP_MARGIN: i32 = 15;
+const NOTIFICATION_SPACING: i32 = 10;
+const MAX_NOTIFICATIONS: usize = 5;
+const TICK_INTERVAL: Duration = Duration::from_millis(50);
 
 thread_local! {
-    static NOTIFICATION_MANAGER: RefCell<NotificationManager> = RefCell::new(NotificationManager::new());
+    static NOTIFICATION_MANAGER: RefCell<NotificationManager> =
+        RefCell::new(NotificationManager::new());
 }
 
 struct NotificationInstance {
     key: String,
+    payload: anlg_notification_interface::Notification,
     window: Window,
     timeout_source: Option<glib::SourceId>,
+    dismiss_timer: Option<DismissTimer>,
+    is_hovered: bool,
+    is_expanded: bool,
+    message_label: Option<Label>,
+    expanded_timer_label: Option<Label>,
+    progress_bar: Option<ProgressBar>,
+    close_button: Option<Button>,
 }
 
 impl NotificationInstance {
-    fn new(window: Window, key: String) -> Self {
-        Self {
-            key,
-            window,
-            timeout_source: None,
+    fn content_height(payload: &anlg_notification_interface::Notification, expanded: bool) -> i32 {
+        if expanded {
+            EXPANDED_HEIGHT
+        } else if payload.footer.is_some() {
+            COMPACT_HEIGHT + COMPACT_FOOTER_HEIGHT
+        } else {
+            COMPACT_HEIGHT
         }
     }
 
-    fn start_dismiss_timer(&mut self, timeout_seconds: f64) {
+    fn cancel_sources(&mut self) {
         if let Some(source) = self.timeout_source.take() {
             source.remove();
         }
-
-        let key = self.key.clone();
-        let window = self.window.clone();
-        let source = glib::timeout_add_seconds_local_once(timeout_seconds as u32, move || {
-            callbacks::timeout(key.clone());
-            Self::dismiss_window_inner(&window, &key, false);
-            NotificationManager::remove_notification_global(&key, false);
-        });
-        self.timeout_source = Some(source);
-    }
-
-    fn dismiss_window_inner(window: &Window, key: &str, user_action: bool) {
-        if user_action {
-            callbacks::dismiss(key.to_string());
-        }
-
-        window.set_sensitive(false);
-        window.set_opacity(1.0);
-        let window_clone = window.clone();
-        glib::timeout_add_local_once(Duration::from_millis(200), move || {
-            window_clone.close();
-        });
-    }
-
-    fn dismiss_window(window: &Window, key: &str, user_action: bool) {
-        Self::dismiss_window_inner(window, key, user_action);
-        NotificationManager::remove_notification_global(key, true);
     }
-}
 
-struct NotificationManager {
-    active_notifications: IndexMap<String, NotificationInstance>,
-    max_notifications: usize,
-    #[allow(dead_code)]
-    notification_spacing: i32,
-}
-
-impl NotificationManager {
-    fn new() -> Self {
-        Self {
-            active_notifications: IndexMap::new(),
-            max_notifications: 5,
-            notification_spacing: 10,
-        }
+    fn schedule_remaining(&self) -> Option<Duration> {
+        let start_time = self.payload.start_time?;
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs() as i64;
+        Some(Duration::from_secs(
+            start_time.saturating_sub(now).max(0) as u64
+        ))
     }
 
-    fn ensure_gtk(&self) -> bool {
-        match gtk::init() {
-            Ok(_) => true,
-            Err(e) => {
-                eprintln!("[notification-linux] Failed to initialize GTK: {}", e);
-                false
-            }
+    fn compact_remaining(&self, now: Instant) -> Option<Duration> {
+        if self.payload.start_time.is_some() {
+            self.schedule_remaining()
+        } else if self.payload.shows_stop_countdown() {
+            self.dismiss_timer
+                .as_ref()
+                .map(|timer| timer.remaining(now))
+        } else {
+            None
         }
     }
 
-    fn show(&mut self, notification: anlg_notification_interface::Notification) {
-        if !self.ensure_gtk() {
-            return;
+    fn mount(&mut self) {
+        for child in self.window.children() {
+            self.window.remove(&child);
         }
 
-        let key = notification
-            .key
-            .clone()
-            .unwrap_or_else(|| notification.title.clone());
-        let timeout_seconds = notification.timeout.map(|d| d.as_secs_f64()).unwrap_or(0.0);
-
-        while self.active_notifications.len() >= self.max_notifications {
-            if let Some((oldest_id, notif)) = self.active_notifications.get_index(0) {
-                let oldest_id = oldest_id.clone();
-                let window = notif.window.clone();
-                NotificationInstance::dismiss_window_inner(&window, &oldest_id, false);
-                self.remove_notification_locked(&oldest_id, true);
-            } else {
-                break;
-            }
-        }
+        self.message_label = None;
+        self.expanded_timer_label = None;
+        self.progress_bar = None;
+        self.close_button = None;
 
-        let window = Window::new(WindowType::Toplevel);
-        window.set_decorated(false);
-        window.set_resizable(false);
-        window.set_default_size(
-            360,
-            if notification.footer.is_some() {
-                96
-            } else {
-                64
-            },
-        );
-        window.set_keep_above(true);
+        let height = Self::content_height(&self.payload, self.is_expanded);
+        self.window.resize(NOTIFICATION_WIDTH, height);
 
-        self.setup_window_style(&window);
-        self.create_notification_content(&window, &notification, &key);
-        self.position_window(&window);
+        let overlay = Overlay::new();
+        overlay.add(&self.build_root());
 
-        window.show_all();
+        let close_button = Button::with_label("×");
+        close_button.style_context().add_class("close-button");
+        close_button.set_valign(Align::Start);
+        close_button.set_halign(Align::Start);
+        close_button.set_margin_start(6);
+        close_button.set_margin_top(6);
+        let close_key = self.key.clone();
+        close_button.connect_clicked(move |_| {
+            NotificationManager::dismiss_global(&close_key, DismissReason::User);
+        });
+        overlay.add_overlay(&close_button);
+        self.close_button = Some(close_button);
+
+        let hover_box = EventBox::new();
+        hover_box.set_visible_window(false);
+        hover_box.add(&overlay);
+        hover_box.add_events(gdk::EventMask::ENTER_NOTIFY_MASK | gdk::EventMask::LEAVE_NOTIFY_MASK);
+        let hover_key = self.key.clone();
+        hover_box.connect_enter_notify_event(move |_, event| {
+            if event.detail() != NotifyType::Inferior {
+                NotificationManager::set_hovered(&hover_key, true);
+            }
+            glib::Propagation::Proceed
+        });
+        let hover_key = self.key.clone();
+        hover_box.connect_leave_notify_event(move |_, event| {
+            if event.detail() != NotifyType::Inferior {
+                NotificationManager::set_hovered(&hover_key, false);
+            }
+            glib::Propagation::Proceed
+        });
 
-        let mut notif = NotificationInstance::new(window, key.clone());
-        if timeout_seconds > 0.0 {
-            notif.start_dismiss_timer(timeout_seconds);
+        self.window.add(&hover_box);
+        self.window.show_all();
+        if let Some(close_button) = &self.close_button {
+            close_button.set_visible(self.is_hovered);
         }
-        self.active_notifications.insert(key, notif);
-
-        self.reposition_notifications();
     }
 
-    fn setup_window_style(&self, _window: &Window) {
-        let css_provider = CssProvider::new();
-        let _ = css_provider.load_from_data(
-            br#"
-            window {
-                background-color: rgba(255, 255, 255, 0.95);
-                border-radius: 11px;
-                border: 1px solid rgba(0, 0, 0, 0.1);
-                box-shadow: 0 2px 12px rgba(0, 0, 0, 0.22);
-            }
-            .notification-title {
-                font-size: 14px;
-                font-weight: bold;
-                color: #000000;
-            }
-            .notification-message {
-                font-size: 11px;
-                color: #666666;
-            }
-            .close-button {
-                min-width: 15px;
-                min-height: 15px;
-                border-radius: 7.5px;
-                background-color: rgba(0, 0, 0, 0.5);
-                border: 0.5px solid rgba(0, 0, 0, 0.3);
-                color: white;
-                padding: 0;
-                margin: 5px;
-            }
-            .close-button:hover {
-                background-color: rgba(0, 0, 0, 0.6);
+    fn build_root(&mut self) -> GtkBox {
+        let root = GtkBox::new(Orientation::Vertical, 0);
+        if self.is_expanded {
+            root.pack_start(&self.build_expanded(), true, true, 0);
+        } else {
+            root.pack_start(&self.build_compact(), true, true, 0);
+            if self
+                .payload
+                .timeout
+                .is_some_and(|timeout| !timeout.is_zero())
+            {
+                let progress = ProgressBar::new();
+                progress.set_fraction(
+                    self.dismiss_timer
+                        .as_ref()
+                        .map(|timer| timer.progress_ratio(Instant::now()))
+                        .unwrap_or(1.0),
+                );
+                progress.set_show_text(false);
+                root.pack_start(&progress, false, false, 0);
+                self.progress_bar = Some(progress);
             }
-            .action-button {
-                border-radius: 10px;
-                background-color: rgba(242, 242, 242, 0.9);
-                border: 0.5px solid rgba(179, 179, 179, 0.5);
-                color: rgba(26, 26, 26, 1.0);
-                font-size: 14px;
-                font-weight: 600;
-                padding: 6px 11px;
-                min-height: 28px;
-            }
-            .action-button:hover {
-                background-color: rgba(230, 230, 230, 0.9);
-            }
-            .destructive-action-button {
-                background-color: rgba(196, 43, 28, 0.95);
-                color: white;
-            }
-            .destructive-action-button:hover {
-                background-color: rgba(166, 34, 23, 0.95);
-            }
-            .notification-footer {
-                border-top: 1px solid rgba(0, 0, 0, 0.1);
-                padding-top: 4px;
-            }
-            .notification-footer-label {
-                font-size: 10px;
-                color: #666666;
-            }
-            "#,
-        );
-
-        if let Some(screen) = gdk::Screen::default() {
-            StyleContext::add_provider_for_screen(
-                &screen,
-                &css_provider,
-                gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
-            );
         }
+        root
     }
 
-    fn create_notification_content(
-        &self,
-        window: &Window,
-        notification: &anlg_notification_interface::Notification,
-        key: &str,
-    ) {
+    fn build_compact(&mut self) -> GtkBox {
+        let payload = &self.payload;
         let main_box = GtkBox::new(Orientation::Horizontal, 8);
         main_box.set_margin_start(12);
         main_box.set_margin_end(12);
@@ -225,25 +177,32 @@ impl NotificationManager {
         main_box.set_valign(Align::Center);
 
         let content_box = GtkBox::new(Orientation::Horizontal, 8);
-        let icon = Image::from_icon_name(Some("application-x-executable"), gtk::IconSize::Dnd);
-        content_box.pack_start(&icon, false, false, 0);
+        if let Some(pixbuf) = icon::pixbuf_for_icon(payload.icon.as_ref()) {
+            let image = Image::from_pixbuf(Some(&pixbuf));
+            image.set_pixel_size(28);
+            content_box.pack_start(&image, false, false, 0);
+        }
 
         let text_box = GtkBox::new(Orientation::Vertical, 2);
         text_box.set_hexpand(true);
 
-        let title_label = Label::new(Some(&notification.title));
+        let title_label = Label::new(Some(payload.compact_title()));
         title_label.set_halign(Align::Start);
         title_label.set_ellipsize(pango::EllipsizeMode::End);
         title_label.style_context().add_class("notification-title");
         text_box.pack_start(&title_label, false, false, 0);
 
-        let message_label = Label::new(Some(&notification.message));
-        message_label.set_halign(Align::Start);
-        message_label.set_ellipsize(pango::EllipsizeMode::End);
-        message_label
-            .style_context()
-            .add_class("notification-message");
-        text_box.pack_start(&message_label, false, false, 0);
+        let body = payload.compact_message(self.compact_remaining(Instant::now()));
+        if !body.trim().is_empty() {
+            let message_label = Label::new(Some(&body));
+            message_label.set_halign(Align::Start);
+            message_label.set_ellipsize(pango::EllipsizeMode::End);
+            message_label
+                .style_context()
+                .add_class("notification-message");
+            text_box.pack_start(&message_label, false, false, 0);
+            self.message_label = Some(message_label);
+        }
 
         content_box.pack_start(&text_box, true, true, 0);
 
@@ -252,27 +211,25 @@ impl NotificationManager {
         content_event_box.add(&content_box);
         main_box.pack_start(&content_event_box, true, true, 0);
 
-        let options_button = match callbacks::primary_action(notification) {
-            callbacks::PrimaryAction::Options(options) => {
+        let options_button = match payload.primary_action() {
+            PrimaryAction::Options(options) => {
                 let menu = Menu::new();
                 for (index, option) in options.iter().enumerate() {
                     let menu_item = MenuItem::with_label(option);
-                    let option_key = key.to_string();
-                    let option_window = window.clone();
+                    let option_key = self.key.clone();
                     menu_item.connect_activate(move |_| {
                         callbacks::option_selected(option_key.clone(), index as i32);
-                        NotificationInstance::dismiss_window(&option_window, &option_key, false);
+                        NotificationManager::dismiss_global(&option_key, DismissReason::Action);
                     });
                     menu.append(&menu_item);
                 }
 
                 let create_new_item = MenuItem::with_label("Create New Note...");
                 let create_new_index = options.len() as i32;
-                let option_key = key.to_string();
-                let option_window = window.clone();
+                let option_key = self.key.clone();
                 create_new_item.connect_activate(move |_| {
                     callbacks::option_selected(option_key.clone(), create_new_index);
-                    NotificationInstance::dismiss_window(&option_window, &option_key, false);
+                    NotificationManager::dismiss_global(&option_key, DismissReason::Action);
                 });
                 menu.append(&create_new_item);
                 menu.show_all();
@@ -284,7 +241,7 @@ impl NotificationManager {
                 main_box.pack_start(&menu_button, false, false, 0);
                 Some(menu_button)
             }
-            callbacks::PrimaryAction::Accept { label, destructive } => {
+            PrimaryAction::Accept { label, destructive } => {
                 let action_button = Button::with_label(label);
                 action_button.style_context().add_class("action-button");
                 if destructive {
@@ -292,128 +249,570 @@ impl NotificationManager {
                         .style_context()
                         .add_class("destructive-action-button");
                 }
-
-                let action_key = key.to_string();
-                let action_window = window.clone();
+                let action_key = self.key.clone();
                 action_button.connect_clicked(move |_| {
                     callbacks::accept(action_key.clone());
-                    NotificationInstance::dismiss_window(&action_window, &action_key, false);
+                    NotificationManager::dismiss_global(&action_key, DismissReason::Action);
                 });
                 main_box.pack_start(&action_button, false, false, 0);
                 None
             }
         };
 
-        let content_key = key.to_string();
-        let content_window = window.clone();
+        let content_key = self.key.clone();
+        let expandable = payload.has_expandable_content();
         content_event_box.connect_button_press_event(move |_, _| {
             if let Some(options_button) = &options_button {
                 options_button.clicked();
+            } else if expandable {
+                NotificationManager::toggle_expanded_global(&content_key);
             } else {
                 callbacks::confirm(content_key.clone());
-                NotificationInstance::dismiss_window(&content_window, &content_key, false);
+                NotificationManager::dismiss_global(&content_key, DismissReason::Action);
             }
-
             glib::Propagation::Stop
         });
 
-        let close_button = Button::new();
-        close_button.set_label("×");
-        close_button.style_context().add_class("close-button");
-        close_button.set_valign(Align::Start);
-        close_button.set_halign(Align::End);
-
-        let key_clone = key.to_string();
-        let window_clone = window.clone();
-        close_button.connect_clicked(move |_| {
-            NotificationInstance::dismiss_window(&window_clone, &key_clone, true);
-        });
-        main_box.pack_start(&close_button, false, false, 0);
-
-        let root_box = GtkBox::new(Orientation::Vertical, 0);
-        root_box.pack_start(&main_box, true, true, 0);
+        let root = GtkBox::new(Orientation::Vertical, 0);
+        root.pack_start(&main_box, true, true, 0);
 
-        if let Some(footer) = &notification.footer {
+        if let Some(footer) = &payload.footer {
             let footer_box = GtkBox::new(Orientation::Horizontal, 8);
             footer_box.set_margin_start(12);
             footer_box.set_margin_end(12);
             footer_box.set_margin_bottom(5);
             footer_box.style_context().add_class("notification-footer");
 
+            let footer_label_box = GtkBox::new(Orientation::Horizontal, 4);
+            if let Some(pixbuf) = icon::pixbuf_for_icon(footer.icon.as_ref()) {
+                let image = Image::from_pixbuf(Some(&pixbuf));
+                image.set_pixel_size(14);
+                footer_label_box.pack_start(&image, false, false, 0);
+            }
             let footer_label = Label::new(Some(&footer.text));
             footer_label.set_halign(Align::Start);
             footer_label.set_ellipsize(pango::EllipsizeMode::End);
             footer_label
                 .style_context()
                 .add_class("notification-footer-label");
-            footer_box.pack_start(&footer_label, true, true, 0);
+            footer_label_box.pack_start(&footer_label, true, true, 0);
+            footer_box.pack_start(&footer_label_box, true, true, 0);
 
             let footer_button = Button::with_label(&footer.action_label);
-            let footer_key = key.to_string();
-            let footer_window = window.clone();
+            footer_button
+                .style_context()
+                .add_class("footer-action-button");
+            let footer_key = self.key.clone();
             footer_button.connect_clicked(move |_| {
                 callbacks::footer_action(footer_key.clone());
-                NotificationInstance::dismiss_window(&footer_window, &footer_key, false);
+                NotificationManager::dismiss_global(&footer_key, DismissReason::Action);
             });
             footer_box.pack_start(&footer_button, false, false, 0);
-            root_box.pack_start(&footer_box, false, false, 0);
+            root.pack_start(&footer_box, false, false, 0);
         }
 
-        window.add(&root_box);
+        root
     }
 
-    fn position_window(&self, window: &Window) {
-        // Position the window in the top-right corner of the screen
-        // Use the default width we set (360) since window.size() returns 0 before realization
-        const DEFAULT_WINDOW_WIDTH: i32 = 360;
+    fn build_expanded(&mut self) -> GtkBox {
+        let payload = &self.payload;
+        let container = GtkBox::new(Orientation::Vertical, 12);
+        container.set_margin_start(16);
+        container.set_margin_end(16);
+        container.set_margin_top(14);
+        container.set_margin_bottom(14);
+
+        let header = GtkBox::new(Orientation::Horizontal, 8);
+        let title = Label::new(Some(payload.expanded_title()));
+        title.set_halign(Align::Start);
+        title.set_hexpand(true);
+        title.set_ellipsize(pango::EllipsizeMode::End);
+        title.style_context().add_class("notification-title");
+        header.pack_start(&title, true, true, 0);
+
+        let collapse = Button::with_label("Show less");
+        let collapse_key = self.key.clone();
+        collapse.connect_clicked(move |_| {
+            NotificationManager::toggle_expanded_global(&collapse_key);
+        });
+        header.pack_start(&collapse, false, false, 0);
+        container.pack_start(&header, false, false, 0);
 
-        if let Some(screen) = gdk::Screen::default()
-            && let Some(root_window) = screen.root_window()
+        if let Some(participants) = payload
+            .participants
+            .as_ref()
+            .filter(|participants| !participants.is_empty())
         {
-            let screen_width = root_window.width();
-            let x = screen_width - DEFAULT_WINDOW_WIDTH - 20;
-            let y = 50;
-            window.move_(x, y);
+            let list = GtkBox::new(Orientation::Vertical, 4);
+            for participant in participants {
+                let row = GtkBox::new(Orientation::Horizontal, 6);
+                let name = participant.name.clone().unwrap_or_default();
+                let display = if name.is_empty() {
+                    participant.email.clone()
+                } else {
+                    format!("{name} ({})", participant.email)
+                };
+                let label = Label::new(Some(&display));
+                label.set_halign(Align::Start);
+                label.set_hexpand(true);
+                row.pack_start(&label, true, true, 0);
+
+                let (icon, class) = match participant.status {
+                    ParticipantStatus::Accepted => ("✓", "status-accepted"),
+                    ParticipantStatus::Maybe => ("?", "status-maybe"),
+                    ParticipantStatus::Declined => ("✗", "status-declined"),
+                };
+                let status = Label::new(Some(icon));
+                status.style_context().add_class(class);
+                row.pack_start(&status, false, false, 0);
+                list.pack_start(&row, false, false, 0);
+            }
+            container.pack_start(&list, false, false, 0);
+        }
+
+        if let Some(details) = &payload.event_details {
+            container.pack_start(&detail_row("What:", &details.what), false, false, 0);
+            if let Some(timezone) = &details.timezone {
+                container.pack_start(&detail_row("Invitee Time Zone:", timezone), false, false, 0);
+            }
+            if let Some(location) = &details.location {
+                container.pack_start(&detail_row("Where:", location), false, false, 0);
+            }
+        }
+
+        let action_button = Button::with_label(payload.expanded_action_label());
+        action_button.style_context().add_class("action-button");
+        if payload.is_destructive_action() {
+            action_button
+                .style_context()
+                .add_class("destructive-action-button");
         }
+        let action_key = self.key.clone();
+        action_button.connect_clicked(move |_| {
+            callbacks::accept(action_key.clone());
+            NotificationManager::dismiss_global(&action_key, DismissReason::Action);
+        });
+        container.pack_start(&action_button, false, false, 0);
+
+        if payload.start_time.is_some() {
+            let remaining = self.schedule_remaining().unwrap_or_default();
+            let timer = Label::new(Some(&expanded_schedule_text(remaining)));
+            timer.style_context().add_class("notification-message");
+            container.pack_start(&timer, false, false, 0);
+            self.expanded_timer_label = Some(timer);
+        }
+
+        container
     }
+}
 
-    fn reposition_notifications(&mut self) {
-        // TODO: Reposition existing notifications once we implement a GTK4-compatible positioning strategy.
+struct NotificationManager {
+    active_notifications: IndexMap<String, NotificationInstance>,
+}
+
+impl NotificationManager {
+    fn new() -> Self {
+        Self {
+            active_notifications: IndexMap::new(),
+        }
     }
 
-    fn remove_notification_locked(&mut self, key: &str, cancel_timeout: bool) {
-        if let Some(mut notification) = self.active_notifications.swap_remove(key)
-            && cancel_timeout
-            && let Some(source) = notification.timeout_source.take()
-        {
-            source.remove();
+    fn ensure_gtk(&self) -> bool {
+        match gtk::init() {
+            Ok(_) => true,
+            Err(error) => {
+                tracing::error!(%error, "failed_to_initialize_gtk_notifications");
+                false
+            }
         }
+    }
+
+    fn show(&mut self, notification: anlg_notification_interface::Notification) {
+        if !self.ensure_gtk() {
+            return;
+        }
+
+        Self::install_styles();
+
+        let key = notification
+            .key
+            .clone()
+            .unwrap_or_else(|| notification.title.clone());
+
+        if let Some(existing) = self.active_notifications.shift_remove(&key) {
+            Self::close_window(&existing.window);
+        }
+
+        while self.active_notifications.len() >= MAX_NOTIFICATIONS {
+            if let Some((oldest_id, _)) = self.active_notifications.first() {
+                let oldest_id = oldest_id.clone();
+                self.dismiss_key(&oldest_id, DismissReason::Superseded);
+            } else {
+                break;
+            }
+        }
+
+        let window = Window::new(WindowType::Toplevel);
+        window.set_decorated(false);
+        window.set_resizable(false);
+        window.set_accept_focus(false);
+        window.set_skip_taskbar_hint(true);
+        window.set_skip_pager_hint(true);
+        window.set_keep_above(true);
+        window.set_type_hint(gdk::WindowTypeHint::Notification);
+        window.stick();
+        window.set_default_size(
+            NOTIFICATION_WIDTH,
+            NotificationInstance::content_height(&notification, false),
+        );
+        if prefers_dark_theme() {
+            window.style_context().add_class("dark");
+        }
+
+        let timeout = notification.timeout.filter(|timeout| !timeout.is_zero());
+        let mut instance = NotificationInstance {
+            key: key.clone(),
+            payload: notification,
+            window: window.clone(),
+            timeout_source: None,
+            dismiss_timer: timeout.map(DismissTimer::new),
+            is_hovered: false,
+            is_expanded: false,
+            message_label: None,
+            expanded_timer_label: None,
+            progress_bar: None,
+            close_button: None,
+        };
+        self.position_window(
+            &instance.window,
+            NotificationInstance::content_height(&instance.payload, false),
+        );
+        instance.mount();
+        if instance.dismiss_timer.is_some() || instance.payload.start_time.is_some() {
+            self.arm_timer(&mut instance);
+        }
+
+        self.active_notifications.insert(key, instance);
         self.reposition_notifications();
     }
 
-    fn remove_notification_global(key: &str, cancel_timeout: bool) {
-        NOTIFICATION_MANAGER.with(|manager| {
-            manager
-                .borrow_mut()
-                .remove_notification_locked(key, cancel_timeout);
+    fn install_styles() {
+        static INSTALLED: std::sync::Once = std::sync::Once::new();
+        INSTALLED.call_once(|| {
+            let css_provider = CssProvider::new();
+            let _ = css_provider.load_from_data(NOTIFICATION_CSS.as_bytes());
+            if let Some(screen) = gdk::Screen::default() {
+                StyleContext::add_provider_for_screen(
+                    &screen,
+                    &css_provider,
+                    gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+                );
+            }
         });
     }
 
+    fn arm_timer(&mut self, instance: &mut NotificationInstance) {
+        instance.cancel_sources();
+        let key = instance.key.clone();
+        instance.timeout_source = Some(glib::timeout_add_local(TICK_INTERVAL, move || {
+            NotificationManager::tick_global(&key);
+            glib::ControlFlow::Continue
+        }));
+    }
+
+    fn tick(&mut self, key: &str) {
+        let now = Instant::now();
+        let expired = self
+            .active_notifications
+            .get(key)
+            .and_then(|instance| instance.dismiss_timer.as_ref())
+            .is_some_and(|timer| timer.is_running() && timer.is_expired(now));
+        if expired {
+            self.dismiss_key(key, DismissReason::Timeout);
+            return;
+        }
+
+        let Some(instance) = self.active_notifications.get_mut(key) else {
+            return;
+        };
+        if let Some(progress) = &instance.progress_bar
+            && let Some(timer) = &instance.dismiss_timer
+        {
+            progress.set_fraction(timer.progress_ratio(now));
+        }
+        if let Some(label) = &instance.message_label {
+            label.set_text(
+                &instance
+                    .payload
+                    .compact_message(instance.compact_remaining(now)),
+            );
+        }
+        if let Some(label) = &instance.expanded_timer_label {
+            label.set_text(&expanded_schedule_text(
+                instance.schedule_remaining().unwrap_or_default(),
+            ));
+        }
+    }
+
+    fn set_hover(&mut self, key: &str, hovered: bool) {
+        let Some(instance) = self.active_notifications.get_mut(key) else {
+            return;
+        };
+        if instance.is_hovered == hovered {
+            return;
+        }
+        instance.is_hovered = hovered;
+        if let Some(close_button) = &instance.close_button {
+            close_button.set_visible(hovered);
+        }
+        if instance.is_expanded {
+            return;
+        }
+        if let Some(timer) = &mut instance.dismiss_timer {
+            if hovered {
+                timer.pause(Instant::now());
+            } else {
+                timer.resume(Instant::now());
+            }
+        }
+    }
+
+    fn toggle_expanded(&mut self, key: &str) {
+        {
+            let Some(instance) = self.active_notifications.get_mut(key) else {
+                return;
+            };
+            if !instance.payload.has_expandable_content() && !instance.is_expanded {
+                return;
+            }
+            instance.is_expanded = !instance.is_expanded;
+            if let Some(timer) = &mut instance.dismiss_timer {
+                if instance.is_expanded {
+                    timer.pause(Instant::now());
+                } else if !instance.is_hovered {
+                    timer.resume(Instant::now());
+                }
+            }
+            instance.mount();
+        }
+        self.reposition_notifications();
+    }
+
+    fn position_window(&self, window: &Window, height: i32) {
+        if let Some((x, y)) = overlay_origin(self.occupied_height()) {
+            window.move_(x, y);
+        }
+        let _ = height;
+    }
+
+    fn occupied_height(&self) -> i32 {
+        self.active_notifications
+            .values()
+            .map(|instance| {
+                NotificationInstance::content_height(&instance.payload, instance.is_expanded)
+                    + NOTIFICATION_SPACING
+            })
+            .sum()
+    }
+
+    fn reposition_notifications(&mut self) {
+        let mut occupied = 0;
+        let positions: Vec<(String, i32, i32)> = self
+            .active_notifications
+            .iter()
+            .filter_map(|(key, instance)| {
+                let height =
+                    NotificationInstance::content_height(&instance.payload, instance.is_expanded);
+                let (x, y) = overlay_origin(occupied)?;
+                occupied += height + NOTIFICATION_SPACING;
+                Some((key.clone(), x, y))
+            })
+            .collect();
+
+        for (key, x, y) in positions {
+            if let Some(instance) = self.active_notifications.get(&key) {
+                instance.window.move_(x, y);
+            }
+        }
+    }
+
+    fn dismiss_key(&mut self, key: &str, reason: DismissReason) {
+        let Some(mut instance) = self.active_notifications.shift_remove(key) else {
+            return;
+        };
+        instance.cancel_sources();
+        match reason {
+            DismissReason::User => callbacks::dismiss(key.to_string()),
+            DismissReason::Timeout => callbacks::timeout(key.to_string()),
+            DismissReason::Action | DismissReason::Superseded => {}
+        }
+        Self::close_window(&instance.window);
+        self.reposition_notifications();
+    }
+
     fn dismiss_all(&mut self) {
         let keys: Vec<String> = self.active_notifications.keys().cloned().collect();
         for key in keys {
-            if let Some(notif) = self.active_notifications.get(&key) {
-                let window = notif.window.clone();
-                NotificationInstance::dismiss_window_inner(&window, &key, false);
-                self.remove_notification_locked(&key, true);
-            }
+            self.dismiss_key(&key, DismissReason::Superseded);
         }
     }
+
+    fn close_window(window: &Window) {
+        window.set_sensitive(false);
+        let window = window.clone();
+        glib::timeout_add_local_once(Duration::from_millis(200), move || {
+            window.close();
+        });
+    }
+
+    fn dismiss_global(key: &str, reason: DismissReason) {
+        NOTIFICATION_MANAGER.with(|manager| {
+            manager.borrow_mut().dismiss_key(key, reason);
+        });
+    }
+
+    fn tick_global(key: &str) {
+        NOTIFICATION_MANAGER.with(|manager| {
+            manager.borrow_mut().tick(key);
+        });
+    }
+
+    fn set_hovered(key: &str, hovered: bool) {
+        NOTIFICATION_MANAGER.with(|manager| {
+            manager.borrow_mut().set_hover(key, hovered);
+        });
+    }
+
+    fn toggle_expanded_global(key: &str) {
+        NOTIFICATION_MANAGER.with(|manager| {
+            manager.borrow_mut().toggle_expanded(key);
+        });
+    }
+}
+
+#[derive(Clone, Copy)]
+enum DismissReason {
+    User,
+    Timeout,
+    Action,
+    Superseded,
+}
+
+fn overlay_origin(occupied: i32) -> Option<(i32, i32)> {
+    let monitor = gdk::Display::default()?.primary_monitor()?;
+    let geometry = monitor.workarea();
+    Some((
+        geometry.x() + geometry.width() - NOTIFICATION_WIDTH - RIGHT_MARGIN,
+        geometry.y() + TOP_MARGIN + occupied,
+    ))
 }
 
+fn prefers_dark_theme() -> bool {
+    gtk::Settings::default()
+        .map(|settings| settings.is_gtk_application_prefer_dark_theme())
+        .unwrap_or(false)
+}
+
+fn detail_row(label: &str, value: &str) -> GtkBox {
+    let row = GtkBox::new(Orientation::Vertical, 2);
+    let name = Label::new(Some(label));
+    name.set_halign(Align::Start);
+    name.style_context().add_class("notification-footer-label");
+    let content = Label::new(Some(value));
+    content.set_halign(Align::Start);
+    content.set_line_wrap(true);
+    row.pack_start(&name, false, false, 0);
+    row.pack_start(&content, false, false, 0);
+    row
+}
+
+const NOTIFICATION_CSS: &str = r#"
+window {
+    background-color: rgba(255, 255, 255, 0.95);
+    border-radius: 14px;
+    border: 1px solid rgba(0, 0, 0, 0.1);
+}
+window.dark {
+    background-color: rgba(40, 40, 42, 0.94);
+    border: 1px solid rgba(255, 255, 255, 0.12);
+}
+.notification-title {
+    font-size: 14px;
+    font-weight: 600;
+    color: #1a1a1a;
+}
+window.dark .notification-title {
+    color: #f2f2f2;
+}
+.notification-message {
+    font-size: 11px;
+    color: #666666;
+}
+window.dark .notification-message {
+    color: #b3b3b3;
+}
+.close-button {
+    min-width: 22px;
+    min-height: 22px;
+    border-radius: 11px;
+    background-color: rgba(255, 255, 255, 0.72);
+    border: 0.5px solid rgba(0, 0, 0, 0.18);
+    color: rgba(0, 0, 0, 0.62);
+    padding: 0;
+    font-weight: 600;
+}
+.close-button:hover {
+    background-color: rgba(255, 255, 255, 0.9);
+}
+.action-button {
+    border-radius: 10px;
+    background-color: rgba(242, 242, 242, 0.9);
+    border: 0.5px solid rgba(179, 179, 179, 0.5);
+    color: rgba(26, 26, 26, 1.0);
+    font-size: 12px;
+    font-weight: 600;
+    padding: 6px 11px;
+    min-height: 28px;
+}
+.action-button:hover {
+    background-color: rgba(230, 230, 230, 0.9);
+}
+.destructive-action-button {
+    background-color: rgba(196, 43, 28, 0.95);
+    color: white;
+}
+.destructive-action-button:hover {
+    background-color: rgba(166, 34, 23, 0.95);
+}
+.notification-footer {
+    border-top: 1px solid rgba(0, 0, 0, 0.1);
+    padding-top: 4px;
+}
+.notification-footer-label {
+    font-size: 10px;
+    color: #666666;
+}
+.footer-action-button {
+    padding: 0 4px;
+    min-height: 20px;
+    font-size: 10px;
+    font-weight: 600;
+}
+.status-accepted { color: #248a3d; }
+.status-maybe { color: #c93400; }
+.status-declined { color: #c42b1c; }
+progressbar trough {
+    min-height: 3px;
+    background-color: transparent;
+}
+progressbar progress {
+    min-height: 3px;
+    background-color: rgba(102, 153, 230, 0.7);
+}
+"#;
+
 pub fn show(notification: &anlg_notification_interface::Notification) {
     let notification = notification.clone();
-
     glib::MainContext::default().invoke(move || {
         NOTIFICATION_MANAGER.with(|manager| {
             manager.borrow_mut().show(notification);
diff --git a/crates/notification-linux/src/lib.rs b/crates/notification-linux/src/lib.rs
index d4a6254885..425c018284 100644
--- a/crates/notification-linux/src/lib.rs
+++ b/crates/notification-linux/src/lib.rs
@@ -3,6 +3,9 @@ pub use anlg_notification_interface::*;
 #[cfg(any(target_os = "linux", test))]
 mod callbacks;
 
+#[cfg(target_os = "linux")]
+mod icon;
+
 #[cfg(target_os = "linux")]
 mod r#impl;
 
diff --git a/crates/notification-windows/AGENTS.md b/crates/notification-windows/AGENTS.md
new file mode 100644
index 0000000000..566c8d8434
--- /dev/null
+++ b/crates/notification-windows/AGENTS.md
@@ -0,0 +1,5 @@
+# notification-windows
+
+Custom always-on-top overlay notifications for Windows, matching the macOS collapsed/expanded notification surface.
+
+The overlay is a layered Win32 popup window (not a system toast) so click, dismiss, timeout, options, footer, and expand behavior can map to the shared notification callbacks.
diff --git a/crates/notification-windows/Cargo.toml b/crates/notification-windows/Cargo.toml
new file mode 100644
index 0000000000..0d89c57848
--- /dev/null
+++ b/crates/notification-windows/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "notification-windows"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anlg-notification-interface = { workspace = true }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+indexmap = "2.6"
+tracing = { workspace = true }
+windows = { workspace = true, features = ["Win32_Foundation", "Win32_Graphics_Dwm", "Win32_Graphics_Gdi", "Win32_System_LibraryLoader", "Win32_System_Threading", "Win32_UI_HiDpi", "Win32_UI_Input_KeyboardAndMouse", "Win32_UI_Shell", "Win32_UI_WindowsAndMessaging"] }
diff --git a/crates/notification-windows/src/callbacks.rs b/crates/notification-windows/src/callbacks.rs
new file mode 100644
index 0000000000..99c59a494a
--- /dev/null
+++ b/crates/notification-windows/src/callbacks.rs
@@ -0,0 +1,139 @@
+#![cfg_attr(not(target_os = "windows"), allow(dead_code))]
+
+use std::sync::Mutex;
+
+type NotificationCallback = Mutex<Option<Box<dyn Fn(String) + Send + Sync>>>;
+type NotificationOptionCallback = Mutex<Option<Box<dyn Fn(String, i32) + Send + Sync>>>;
+
+static CONFIRM_CB: NotificationCallback = Mutex::new(None);
+static ACCEPT_CB: NotificationCallback = Mutex::new(None);
+static DISMISS_CB: NotificationCallback = Mutex::new(None);
+static TIMEOUT_CB: NotificationCallback = Mutex::new(None);
+static OPTION_SELECTED_CB: NotificationOptionCallback = Mutex::new(None);
+static FOOTER_ACTION_CB: NotificationCallback = Mutex::new(None);
+
+pub fn setup_notification_confirm_handler<F>(f: F)
+where
+    F: Fn(String) + Send + Sync + 'static,
+{
+    *CONFIRM_CB.lock().unwrap() = Some(Box::new(f));
+}
+
+pub fn setup_notification_accept_handler<F>(f: F)
+where
+    F: Fn(String) + Send + Sync + 'static,
+{
+    *ACCEPT_CB.lock().unwrap() = Some(Box::new(f));
+}
+
+pub fn setup_notification_dismiss_handler<F>(f: F)
+where
+    F: Fn(String) + Send + Sync + 'static,
+{
+    *DISMISS_CB.lock().unwrap() = Some(Box::new(f));
+}
+
+pub fn setup_notification_timeout_handler<F>(f: F)
+where
+    F: Fn(String) + Send + Sync + 'static,
+{
+    *TIMEOUT_CB.lock().unwrap() = Some(Box::new(f));
+}
+
+pub fn setup_notification_option_selected_handler<F>(f: F)
+where
+    F: Fn(String, i32) + Send + Sync + 'static,
+{
+    *OPTION_SELECTED_CB.lock().unwrap() = Some(Box::new(f));
+}
+
+pub fn setup_notification_footer_action_handler<F>(f: F)
+where
+    F: Fn(String) + Send + Sync + 'static,
+{
+    *FOOTER_ACTION_CB.lock().unwrap() = Some(Box::new(f));
+}
+
+pub(crate) fn confirm(key: String) {
+    if let Some(cb) = CONFIRM_CB.lock().unwrap().as_ref() {
+        cb(key);
+    }
+}
+
+pub(crate) fn accept(key: String) {
+    if let Some(cb) = ACCEPT_CB.lock().unwrap().as_ref() {
+        cb(key);
+    }
+}
+
+pub(crate) fn dismiss(key: String) {
+    if let Some(cb) = DISMISS_CB.lock().unwrap().as_ref() {
+        cb(key);
+    }
+}
+
+pub(crate) fn timeout(key: String) {
+    if let Some(cb) = TIMEOUT_CB.lock().unwrap().as_ref() {
+        cb(key);
+    }
+}
+
+pub(crate) fn option_selected(key: String, index: i32) {
+    if let Some(cb) = OPTION_SELECTED_CB.lock().unwrap().as_ref() {
+        cb(key, index);
+    }
+}
+
+pub(crate) fn footer_action(key: String) {
+    if let Some(cb) = FOOTER_ACTION_CB.lock().unwrap().as_ref() {
+        cb(key);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::{Arc, Mutex};
+
+    use super::*;
+
+    #[test]
+    fn routes_each_windows_notification_action_to_its_registered_handler() {
+        let events = Arc::new(Mutex::new(Vec::new()));
+        let record = |event: &'static str| {
+            let events = events.clone();
+            move |key: String| events.lock().unwrap().push(format!("{event}:{key}"))
+        };
+
+        setup_notification_confirm_handler(record("confirm"));
+        setup_notification_accept_handler(record("accept"));
+        setup_notification_dismiss_handler(record("dismiss"));
+        setup_notification_timeout_handler(record("timeout"));
+        setup_notification_footer_action_handler(record("footer"));
+        let option_events = events.clone();
+        setup_notification_option_selected_handler(move |key, index| {
+            option_events
+                .lock()
+                .unwrap()
+                .push(format!("option:{key}:{index}"));
+        });
+
+        confirm("meeting".to_string());
+        accept("meeting".to_string());
+        dismiss("meeting".to_string());
+        timeout("meeting".to_string());
+        option_selected("meeting".to_string(), 2);
+        footer_action("meeting".to_string());
+
+        assert_eq!(
+            *events.lock().unwrap(),
+            vec![
+                "confirm:meeting".to_string(),
+                "accept:meeting".to_string(),
+                "dismiss:meeting".to_string(),
+                "timeout:meeting".to_string(),
+                "option:meeting:2".to_string(),
+                "footer:meeting".to_string(),
+            ]
+        );
+    }
+}
diff --git a/crates/notification-windows/src/impl.rs b/crates/notification-windows/src/impl.rs
new file mode 100644
index 0000000000..5c5b941b55
--- /dev/null
+++ b/crates/notification-windows/src/impl.rs
@@ -0,0 +1,856 @@
+use std::sync::mpsc::{self, Receiver, Sender};
+use std::sync::{Mutex, OnceLock};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+use indexmap::IndexMap;
+use windows::Win32::Foundation::{COLORREF, HWND, LPARAM, LRESULT, POINT, RECT, WPARAM};
+use windows::Win32::Graphics::Dwm::{
+    DWM_WINDOW_CORNER_PREFERENCE, DWMWA_WINDOW_CORNER_PREFERENCE, DWMWCP_ROUND,
+    DwmSetWindowAttribute,
+};
+use windows::Win32::Graphics::Gdi::{
+    CLEARTYPE_QUALITY, CLIP_DEFAULT_PRECIS, CreateFontW, CreateSolidBrush, DEFAULT_CHARSET,
+    DEFAULT_PITCH, DRAW_TEXT_FORMAT, DT_END_ELLIPSIS, DT_LEFT, DT_SINGLELINE, DT_TOP, DT_VCENTER,
+    DT_WORDBREAK, DeleteObject, DrawTextW, FW_NORMAL, FW_SEMIBOLD, FillRect, HDC, HFONT,
+    InvalidateRect, OUT_DEFAULT_PRECIS, SelectObject, SetBkMode, SetTextColor, TRANSPARENT,
+};
+use windows::Win32::System::LibraryLoader::GetModuleHandleW;
+use windows::Win32::System::Threading::GetCurrentThreadId;
+use windows::Win32::UI::HiDpi::GetDpiForWindow;
+use windows::Win32::UI::Input::KeyboardAndMouse::{TME_LEAVE, TRACKMOUSEEVENT, TrackMouseEvent};
+use windows::Win32::UI::Shell::ExtractIconExW;
+use windows::Win32::UI::WindowsAndMessaging::{
+    AppendMenuW, BeginPaint, CS_HREDRAW, CS_VREDRAW, CreatePopupMenu, CreateWindowExW, DI_NORMAL,
+    DefWindowProcW, DestroyIcon, DestroyMenu, DestroyWindow, DispatchMessageW, DrawIconEx,
+    EndPaint, GetCursorPos, GetMessageW, HICON, IDC_ARROW, IDI_APPLICATION, IMAGE_ICON, KillTimer,
+    LR_LOADFROMFILE, LWA_ALPHA, LoadCursorW, LoadIconW, LoadImageW, MF_STRING, MSG, PAINTSTRUCT,
+    PostThreadMessageW, RegisterClassExW, SPI_GETWORKAREA, SW_SHOWNOACTIVATE, SWP_NOACTIVATE,
+    SWP_NOZORDER, SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS, SetLayeredWindowAttributes, SetTimer,
+    SetWindowPos, ShowWindow, SystemParametersInfoW, TPM_LEFTALIGN, TPM_RETURNCMD, TPM_RIGHTBUTTON,
+    TrackPopupMenu, TranslateMessage, WM_APP, WM_DESTROY, WM_LBUTTONUP, WM_MOUSELEAVE,
+    WM_MOUSEMOVE, WM_PAINT, WM_TIMER, WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE,
+    WS_EX_TOOLWINDOW, WS_EX_TOPMOST, WS_POPUP,
+};
+use windows::core::{PCWSTR, w};
+
+use anlg_notification_interface::{
+    DismissTimer, Notification, NotificationIcon, PrimaryAction, expanded_schedule_text,
+};
+
+use crate::callbacks;
+use crate::layout::{HitTarget, MAX_NOTIFICATIONS, NotificationLayout, stacked_origin};
+
+const CLASS_NAME: windows::core::PCWSTR = w!("AnarlogNotification");
+const TIMER_ID: usize = 1;
+
+enum Command {
+    Show(Notification),
+    DismissAll,
+}
+
+static COMMANDS: OnceLock<Mutex<Option<Sender<Command>>>> = OnceLock::new();
+static THREAD_ID: OnceLock<Mutex<u32>> = OnceLock::new();
+
+struct NotificationInstance {
+    key: String,
+    payload: Notification,
+    hwnd: HWND,
+    layout: NotificationLayout,
+    dismiss_timer: Option<DismissTimer>,
+    is_hovered: bool,
+    is_expanded: bool,
+    tracking_leave: bool,
+    icon: Option<HICON>,
+}
+
+struct NotificationManager {
+    active: IndexMap<String, NotificationInstance>,
+}
+
+impl NotificationManager {
+    fn new() -> Self {
+        Self {
+            active: IndexMap::new(),
+        }
+    }
+
+    fn show(&mut self, notification: Notification) {
+        let key = notification
+            .key
+            .clone()
+            .unwrap_or_else(|| notification.title.clone());
+        if let Some(existing) = self.active.shift_remove(&key) {
+            unsafe {
+                let _ = DestroyWindow(existing.hwnd);
+            }
+            destroy_icon(existing.icon);
+        }
+        while self.active.len() >= MAX_NOTIFICATIONS {
+            if let Some(oldest) = self.active.keys().next().cloned() {
+                self.dismiss(&oldest, DismissReason::Superseded);
+            } else {
+                break;
+            }
+        }
+
+        let layout = NotificationLayout::compact(&notification);
+        let occupied = self.occupied_height();
+        let (work_x, work_y, work_width, _) = work_area();
+        let (x, y) = stacked_origin(work_x, work_y, work_width, occupied);
+        let hwnd = match create_overlay_window(x, y, layout.width, layout.height) {
+            Some(hwnd) => hwnd,
+            None => return,
+        };
+        let icon = load_notification_icon(notification.icon.as_ref());
+        let timeout = notification.timeout.filter(|timeout| !timeout.is_zero());
+        let instance = NotificationInstance {
+            key: key.clone(),
+            payload: notification,
+            hwnd,
+            layout,
+            dismiss_timer: timeout.map(DismissTimer::new),
+            is_hovered: false,
+            is_expanded: false,
+            tracking_leave: false,
+            icon,
+        };
+        unsafe {
+            let _ = SetTimer(Some(hwnd), TIMER_ID, 50, None);
+            let _ = ShowWindow(hwnd, SW_SHOWNOACTIVATE);
+        }
+        self.active.insert(key, instance);
+        self.reposition();
+    }
+
+    fn occupied_height(&self) -> i32 {
+        self.active
+            .values()
+            .map(|instance| instance.layout.height + crate::layout::NOTIFICATION_SPACING)
+            .sum()
+    }
+
+    fn reposition(&mut self) {
+        let (work_x, work_y, work_width, _) = work_area();
+        let mut occupied = 0;
+        for instance in self.active.values() {
+            let (x, y) = stacked_origin(work_x, work_y, work_width, occupied);
+            occupied += instance.layout.height + crate::layout::NOTIFICATION_SPACING;
+            unsafe {
+                let _ = SetWindowPos(
+                    instance.hwnd,
+                    None,
+                    x,
+                    y,
+                    instance.layout.width,
+                    instance.layout.height,
+                    SWP_NOACTIVATE | SWP_NOZORDER,
+                );
+            }
+        }
+    }
+
+    fn dismiss(&mut self, key: &str, reason: DismissReason) {
+        let Some(instance) = self.active.shift_remove(key) else {
+            return;
+        };
+        match reason {
+            DismissReason::User => callbacks::dismiss(key.to_string()),
+            DismissReason::Timeout => callbacks::timeout(key.to_string()),
+            DismissReason::Action | DismissReason::Superseded => {}
+        }
+        unsafe {
+            let _ = KillTimer(Some(instance.hwnd), TIMER_ID);
+            let _ = DestroyWindow(instance.hwnd);
+        }
+        destroy_icon(instance.icon);
+        self.reposition();
+    }
+
+    fn dismiss_all(&mut self) {
+        let keys: Vec<String> = self.active.keys().cloned().collect();
+        for key in keys {
+            self.dismiss(&key, DismissReason::Superseded);
+        }
+    }
+
+    fn instance_by_hwnd_mut(&mut self, hwnd: HWND) -> Option<&mut NotificationInstance> {
+        self.active
+            .values_mut()
+            .find(|instance| instance.hwnd == hwnd)
+    }
+
+    fn tick(&mut self, hwnd: HWND) {
+        let now = Instant::now();
+        let key = self.instance_by_hwnd_mut(hwnd).and_then(|instance| {
+            instance
+                .dismiss_timer
+                .as_ref()
+                .filter(|timer| timer.is_running() && timer.is_expired(now))
+                .map(|_| instance.key.clone())
+        });
+        if let Some(key) = key {
+            self.dismiss(&key, DismissReason::Timeout);
+            return;
+        }
+        if let Some(instance) = self.instance_by_hwnd_mut(hwnd) {
+            unsafe {
+                let _ = InvalidateRect(Some(instance.hwnd), None, false);
+            }
+        }
+    }
+
+    fn set_hover(&mut self, hwnd: HWND, hovered: bool) {
+        let Some(instance) = self.instance_by_hwnd_mut(hwnd) else {
+            return;
+        };
+        if instance.is_hovered == hovered {
+            return;
+        }
+        instance.is_hovered = hovered;
+        if !instance.is_expanded
+            && let Some(timer) = &mut instance.dismiss_timer
+        {
+            if hovered {
+                timer.pause(Instant::now());
+            } else {
+                timer.resume(Instant::now());
+            }
+        }
+        unsafe {
+            let _ = InvalidateRect(Some(hwnd), None, false);
+        }
+    }
+
+    fn handle_click(&mut self, hwnd: HWND, x: i32, y: i32) {
+        let Some(instance) = self.instance_by_hwnd_mut(hwnd) else {
+            return;
+        };
+        let target = instance.layout.action_hit(&instance.payload, x, y);
+        let key = instance.key.clone();
+        match target {
+            HitTarget::Close => self.dismiss(&key, DismissReason::User),
+            HitTarget::Action => {
+                callbacks::accept(key.clone());
+                self.dismiss(&key, DismissReason::Action);
+            }
+            HitTarget::Options => self.show_options_menu(hwnd),
+            HitTarget::Footer => {
+                callbacks::footer_action(key.clone());
+                self.dismiss(&key, DismissReason::Action);
+            }
+            HitTarget::Collapse => self.toggle_expanded(hwnd),
+            HitTarget::Body => {
+                let Some(instance) = self.instance_by_hwnd_mut(hwnd) else {
+                    return;
+                };
+                if instance.payload.has_options() {
+                    self.show_options_menu(hwnd);
+                } else if instance.payload.has_expandable_content() || instance.is_expanded {
+                    self.toggle_expanded(hwnd);
+                } else {
+                    callbacks::confirm(key.clone());
+                    self.dismiss(&key, DismissReason::Action);
+                }
+            }
+        }
+    }
+
+    fn toggle_expanded(&mut self, hwnd: HWND) {
+        let Some(instance) = self.instance_by_hwnd_mut(hwnd) else {
+            return;
+        };
+        if !instance.payload.has_expandable_content() && !instance.is_expanded {
+            return;
+        }
+        instance.is_expanded = !instance.is_expanded;
+        instance.layout = NotificationLayout::for_state(&instance.payload, instance.is_expanded);
+        if let Some(timer) = &mut instance.dismiss_timer {
+            if instance.is_expanded {
+                timer.pause(Instant::now());
+            } else if !instance.is_hovered {
+                timer.resume(Instant::now());
+            }
+        }
+        self.reposition();
+        unsafe {
+            let _ = InvalidateRect(Some(hwnd), None, false);
+        }
+    }
+
+    fn show_options_menu(&mut self, hwnd: HWND) {
+        let Some(instance) = self.instance_by_hwnd_mut(hwnd) else {
+            return;
+        };
+        let PrimaryAction::Options(options) = instance.payload.primary_action() else {
+            return;
+        };
+        let options = options.to_vec();
+        let key = instance.key.clone();
+        let menu = unsafe { CreatePopupMenu().ok() };
+        let Some(menu) = menu else {
+            return;
+        };
+        for (index, option) in options.iter().enumerate() {
+            let mut text = wide(option);
+            unsafe {
+                let _ = AppendMenuW(
+                    menu,
+                    MF_STRING,
+                    index as usize + 1,
+                    PCWSTR(text.as_mut_ptr()),
+                );
+            }
+        }
+        let mut create_new = wide("Create New Note...");
+        unsafe {
+            let _ = AppendMenuW(
+                menu,
+                MF_STRING,
+                options.len() + 1,
+                PCWSTR(create_new.as_mut_ptr()),
+            );
+        }
+        let mut cursor = POINT::default();
+        unsafe {
+            let _ = GetCursorPos(&mut cursor);
+            let selected = TrackPopupMenu(
+                menu,
+                TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD,
+                cursor.x,
+                cursor.y,
+                None,
+                hwnd,
+                None,
+            );
+            let _ = DestroyMenu(menu);
+            if selected.0 > 0 {
+                callbacks::option_selected(key.clone(), selected.0 - 1);
+                self.dismiss(&key, DismissReason::Action);
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+enum DismissReason {
+    User,
+    Timeout,
+    Action,
+    Superseded,
+}
+
+thread_local! {
+    static MANAGER: std::cell::RefCell<NotificationManager> =
+        std::cell::RefCell::new(NotificationManager::new());
+}
+
+fn ensure_ui_thread() {
+    static START: std::sync::Once = std::sync::Once::new();
+    START.call_once(|| {
+        let (tx, rx) = mpsc::channel();
+        let (ready_tx, ready_rx) = mpsc::channel();
+        *COMMANDS.get_or_init(|| Mutex::new(None)).lock().unwrap() = Some(tx);
+        std::thread::Builder::new()
+            .name("notification-windows".into())
+            .spawn(move || ui_thread(rx, ready_tx))
+            .expect("failed to start Windows notification thread");
+        let _ = ready_rx.recv();
+    });
+}
+
+fn ui_thread(rx: Receiver<Command>, ready: Sender<()>) {
+    unsafe {
+        let _ = THREAD_ID
+            .get_or_init(|| Mutex::new(0))
+            .lock()
+            .map(|mut id| *id = GetCurrentThreadId());
+        register_class();
+        let _ = ready.send(());
+        loop {
+            let mut msg = MSG::default();
+            let status = GetMessageW(&mut msg, None, 0, 0);
+            if status.0 <= 0 {
+                break;
+            }
+            if msg.message == WM_APP {
+                while let Ok(command) = rx.try_recv() {
+                    MANAGER.with(|manager| match command {
+                        Command::Show(notification) => manager.borrow_mut().show(notification),
+                        Command::DismissAll => manager.borrow_mut().dismiss_all(),
+                    });
+                }
+                continue;
+            }
+            let _ = TranslateMessage(&msg);
+            DispatchMessageW(&msg);
+        }
+    }
+}
+
+fn send_command(command: Command) {
+    ensure_ui_thread();
+    if let Some(tx) = COMMANDS
+        .get()
+        .and_then(|lock| lock.lock().ok().and_then(|guard| guard.clone()))
+    {
+        let _ = tx.send(command);
+    }
+    if let Some(thread_id) = THREAD_ID
+        .get()
+        .and_then(|lock| lock.lock().ok().map(|id| *id))
+        .filter(|id| *id != 0)
+    {
+        unsafe {
+            let _ = PostThreadMessageW(thread_id, WM_APP, WPARAM(0), LPARAM(0));
+        }
+    }
+}
+
+unsafe fn register_class() {
+    let hinstance = GetModuleHandleW(None).unwrap_or_default();
+    let class = WNDCLASSEXW {
+        cbSize: std::mem::size_of::<WNDCLASSEXW>() as u32,
+        style: CS_HREDRAW | CS_VREDRAW,
+        lpfnWndProc: Some(wndproc),
+        hInstance: hinstance.into(),
+        hCursor: LoadCursorW(None, IDC_ARROW).unwrap_or_default(),
+        lpszClassName: CLASS_NAME,
+        ..Default::default()
+    };
+    let _ = RegisterClassExW(&class);
+}
+
+fn create_overlay_window(x: i32, y: i32, width: i32, height: i32) -> Option<HWND> {
+    unsafe {
+        let hinstance = GetModuleHandleW(None).ok()?;
+        let hwnd = CreateWindowExW(
+            WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_LAYERED,
+            CLASS_NAME,
+            w!(""),
+            WS_POPUP,
+            x,
+            y,
+            width,
+            height,
+            None,
+            None,
+            Some(hinstance.into()),
+            None,
+        )
+        .ok()?;
+        let _ = SetLayeredWindowAttributes(hwnd, COLORREF(0), 242, LWA_ALPHA);
+        let preference = DWMWCP_ROUND;
+        let _ = DwmSetWindowAttribute(
+            hwnd,
+            DWMWA_WINDOW_CORNER_PREFERENCE,
+            &preference as *const DWM_WINDOW_CORNER_PREFERENCE as *const std::ffi::c_void,
+            std::mem::size_of::<DWM_WINDOW_CORNER_PREFERENCE>() as u32,
+        );
+        Some(hwnd)
+    }
+}
+
+unsafe extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+    match msg {
+        WM_PAINT => {
+            paint(hwnd);
+            LRESULT(0)
+        }
+        WM_LBUTTONUP => {
+            let x = loword(lparam);
+            let y = hiword(lparam);
+            MANAGER.with(|manager| manager.borrow_mut().handle_click(hwnd, x, y));
+            LRESULT(0)
+        }
+        WM_MOUSEMOVE => {
+            MANAGER.with(|manager| {
+                let mut manager = manager.borrow_mut();
+                if let Some(instance) = manager.instance_by_hwnd_mut(hwnd)
+                    && !instance.tracking_leave
+                {
+                    instance.tracking_leave = true;
+                    let mut event = TRACKMOUSEEVENT {
+                        cbSize: std::mem::size_of::<TRACKMOUSEEVENT>() as u32,
+                        dwFlags: TME_LEAVE,
+                        hwndTrack: hwnd,
+                        dwHoverTime: 0,
+                    };
+                    let _ = TrackMouseEvent(&mut event);
+                }
+                manager.set_hover(hwnd, true);
+            });
+            LRESULT(0)
+        }
+        WM_MOUSELEAVE => {
+            MANAGER.with(|manager| {
+                let mut manager = manager.borrow_mut();
+                if let Some(instance) = manager.instance_by_hwnd_mut(hwnd) {
+                    instance.tracking_leave = false;
+                }
+                manager.set_hover(hwnd, false);
+            });
+            LRESULT(0)
+        }
+        WM_TIMER => {
+            MANAGER.with(|manager| manager.borrow_mut().tick(hwnd));
+            LRESULT(0)
+        }
+        WM_DESTROY => LRESULT(0),
+        _ => unsafe { DefWindowProcW(hwnd, msg, wparam, lparam) },
+    }
+}
+
+fn paint(hwnd: HWND) {
+    unsafe {
+        let mut ps = PAINTSTRUCT::default();
+        let hdc = BeginPaint(hwnd, &mut ps);
+        MANAGER.with(|manager| {
+            if let Some(instance) = manager
+                .borrow()
+                .active
+                .values()
+                .find(|instance| instance.hwnd == hwnd)
+            {
+                draw_notification(hdc, instance);
+            }
+        });
+        let _ = EndPaint(hwnd, &ps);
+    }
+}
+
+fn draw_notification(hdc: HDC, instance: &NotificationInstance) {
+    unsafe {
+        let bg = CreateSolidBrush(rgb(245, 245, 247));
+        let bounds = RECT {
+            left: 0,
+            top: 0,
+            right: instance.layout.width,
+            bottom: instance.layout.height,
+        };
+        let _ = FillRect(hdc, &bounds, bg);
+        let _ = DeleteObject(bg.into());
+        SetBkMode(hdc, TRANSPARENT);
+        SetTextColor(hdc, rgb(26, 26, 26));
+
+        let dpi = GetDpiForWindow(instance.hwnd).max(96);
+        if let (Some(icon), Some(icon_rect)) = (instance.icon, instance.layout.icon) {
+            let _ = DrawIconEx(
+                hdc,
+                icon_rect.x,
+                icon_rect.y,
+                icon,
+                icon_rect.width,
+                icon_rect.height,
+                0,
+                None,
+                DI_NORMAL,
+            );
+        }
+
+        let title_font = create_font(14, true, dpi);
+        let body_font = create_font(11, false, dpi);
+        let previous = SelectObject(hdc, title_font.into());
+        draw_label(
+            hdc,
+            instance.layout.title,
+            instance.payload.compact_title(),
+            DT_LEFT | DT_SINGLELINE | DT_END_ELLIPSIS,
+        );
+        let _ = SelectObject(hdc, body_font.into());
+        SetTextColor(hdc, rgb(102, 102, 102));
+        let body = if instance.is_expanded {
+            expanded_body(&instance.payload, instance.schedule_remaining())
+        } else {
+            instance
+                .payload
+                .compact_message(instance.compact_remaining(Instant::now()))
+        };
+        draw_label(
+            hdc,
+            instance.layout.message,
+            &body,
+            if instance.is_expanded {
+                DT_LEFT | DT_TOP | DT_WORDBREAK
+            } else {
+                DT_LEFT | DT_SINGLELINE | DT_END_ELLIPSIS
+            },
+        );
+
+        if let Some(action) = instance.layout.action {
+            let (label, destructive) = match instance.payload.primary_action() {
+                PrimaryAction::Options(_) if !instance.is_expanded => ("Options", false),
+                PrimaryAction::Options(_) => (
+                    instance.payload.expanded_action_label(),
+                    instance.payload.is_destructive_action(),
+                ),
+                PrimaryAction::Accept { label, destructive } => (label, destructive),
+            };
+            let brush = CreateSolidBrush(if destructive {
+                rgb(196, 43, 28)
+            } else {
+                rgb(230, 230, 230)
+            });
+            let rect = rect_from(action);
+            let _ = FillRect(hdc, &rect, brush);
+            let _ = DeleteObject(brush.into());
+            SetTextColor(
+                hdc,
+                if destructive {
+                    rgb(255, 255, 255)
+                } else {
+                    rgb(26, 26, 26)
+                },
+            );
+            draw_label(hdc, action, label, DT_VCENTER | DT_SINGLELINE);
+        }
+
+        if let Some(collapse) = instance.layout.collapse {
+            SetTextColor(hdc, rgb(26, 26, 26));
+            draw_label(hdc, collapse, "Show less", DT_VCENTER | DT_SINGLELINE);
+        }
+
+        if let Some(footer) = instance.layout.footer_action {
+            if let Some(footer_payload) = &instance.payload.footer {
+                SetTextColor(hdc, rgb(26, 26, 26));
+                draw_label(
+                    hdc,
+                    crate::layout::Rect {
+                        x: 12,
+                        y: footer.y,
+                        width: footer.x - 20,
+                        height: footer.height,
+                    },
+                    &footer_payload.text,
+                    DT_LEFT | DT_SINGLELINE | DT_END_ELLIPSIS | DT_VCENTER,
+                );
+                draw_label(
+                    hdc,
+                    footer,
+                    &footer_payload.action_label,
+                    DT_VCENTER | DT_SINGLELINE,
+                );
+            }
+        }
+
+        if let Some(progress) = instance.layout.progress
+            && let Some(timer) = &instance.dismiss_timer
+        {
+            let ratio = timer.progress_ratio(Instant::now()).clamp(0.0, 1.0);
+            let brush = CreateSolidBrush(rgb(102, 153, 230));
+            let width = ((progress.width as f64) * ratio).round() as i32;
+            let rect = RECT {
+                left: progress.x,
+                top: progress.y,
+                right: progress.x + width.max(0),
+                bottom: progress.bottom(),
+            };
+            let _ = FillRect(hdc, &rect, brush);
+            let _ = DeleteObject(brush.into());
+        }
+
+        if instance.is_hovered {
+            let brush = CreateSolidBrush(rgb(255, 255, 255));
+            let rect = rect_from(instance.layout.close);
+            let _ = FillRect(hdc, &rect, brush);
+            let _ = DeleteObject(brush.into());
+            SetTextColor(hdc, rgb(0, 0, 0));
+            draw_label(hdc, instance.layout.close, "×", DT_VCENTER | DT_SINGLELINE);
+        }
+
+        let _ = SelectObject(hdc, previous);
+        let _ = DeleteObject(title_font.into());
+        let _ = DeleteObject(body_font.into());
+    }
+}
+
+fn expanded_body(notification: &Notification, remaining: Option<Duration>) -> String {
+    let mut lines = Vec::new();
+    if let Some(details) = &notification.event_details {
+        lines.push(format!("What: {}", details.what));
+        if let Some(timezone) = &details.timezone {
+            lines.push(format!("Invitee Time Zone: {timezone}"));
+        }
+        if let Some(location) = &details.location {
+            lines.push(format!("Where: {location}"));
+        }
+    }
+    if let Some(participants) = &notification.participants {
+        for participant in participants {
+            let name = participant.name.clone().unwrap_or_default();
+            let display = if name.is_empty() {
+                participant.email.clone()
+            } else {
+                format!("{name} ({})", participant.email)
+            };
+            lines.push(display);
+        }
+    }
+    if let Some(remaining) = remaining {
+        lines.push(expanded_schedule_text(remaining));
+    }
+    if lines.is_empty() {
+        notification.message.clone()
+    } else {
+        lines.join("\n")
+    }
+}
+
+impl NotificationInstance {
+    fn schedule_remaining(&self) -> Option<Duration> {
+        let start_time = self.payload.start_time?;
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs() as i64;
+        Some(Duration::from_secs(
+            start_time.saturating_sub(now).max(0) as u64
+        ))
+    }
+
+    fn compact_remaining(&self, now: Instant) -> Option<Duration> {
+        if self.payload.start_time.is_some() {
+            self.schedule_remaining()
+        } else if self.payload.shows_stop_countdown() {
+            self.dismiss_timer
+                .as_ref()
+                .map(|timer| timer.remaining(now))
+        } else {
+            None
+        }
+    }
+}
+
+fn draw_label(hdc: HDC, rect: crate::layout::Rect, text: &str, format: DRAW_TEXT_FORMAT) {
+    let mut wide_text = wide(text);
+    let mut bounds = rect_from(rect);
+    unsafe {
+        let _ = DrawTextW(hdc, &mut wide_text, &mut bounds, format);
+    }
+}
+
+fn create_font(size: i32, bold: bool, dpi: u32) -> HFONT {
+    unsafe {
+        CreateFontW(
+            -((size * dpi as i32) / 96),
+            0,
+            0,
+            0,
+            if bold {
+                FW_SEMIBOLD.0 as i32
+            } else {
+                FW_NORMAL.0 as i32
+            },
+            0,
+            0,
+            0,
+            DEFAULT_CHARSET,
+            OUT_DEFAULT_PRECIS,
+            CLIP_DEFAULT_PRECIS,
+            CLEARTYPE_QUALITY,
+            DEFAULT_PITCH.0 as u32,
+            w!("Segoe UI"),
+        )
+    }
+}
+
+fn rect_from(rect: crate::layout::Rect) -> RECT {
+    RECT {
+        left: rect.x,
+        top: rect.y,
+        right: rect.right(),
+        bottom: rect.bottom(),
+    }
+}
+
+fn rgb(r: u32, g: u32, b: u32) -> COLORREF {
+    COLORREF(r | (g << 8) | (b << 16))
+}
+
+fn wide(text: &str) -> Vec<u16> {
+    text.encode_utf16().chain(std::iter::once(0)).collect()
+}
+
+fn loword(lparam: LPARAM) -> i32 {
+    (lparam.0 as u16) as i16 as i32
+}
+
+fn hiword(lparam: LPARAM) -> i32 {
+    ((lparam.0 >> 16) as u16) as i16 as i32
+}
+
+fn work_area() -> (i32, i32, i32, i32) {
+    let mut rect = RECT {
+        left: 0,
+        top: 0,
+        right: 1920,
+        bottom: 1080,
+    };
+    unsafe {
+        let _ = SystemParametersInfoW(
+            SPI_GETWORKAREA,
+            0,
+            Some(&mut rect as *mut RECT as *mut std::ffi::c_void),
+            SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS(0),
+        );
+    }
+    (
+        rect.left,
+        rect.top,
+        rect.right - rect.left,
+        rect.bottom - rect.top,
+    )
+}
+
+fn load_notification_icon(icon: Option<&NotificationIcon>) -> Option<HICON> {
+    match icon {
+        Some(NotificationIcon::Hidden) => None,
+        Some(NotificationIcon::Path { path }) => load_icon_from_path(path).or_else(load_app_icon),
+        _ => load_app_icon(),
+    }
+}
+
+fn load_icon_from_path(path: &str) -> Option<HICON> {
+    let wide_path = wide(path);
+    unsafe {
+        LoadImageW(
+            None,
+            PCWSTR(wide_path.as_ptr()),
+            IMAGE_ICON,
+            28,
+            28,
+            LR_LOADFROMFILE,
+        )
+        .ok()
+        .map(|handle| HICON(handle.0))
+    }
+}
+
+fn load_app_icon() -> Option<HICON> {
+    let exe = std::env::current_exe().ok()?;
+    let wide_path = wide(&exe.to_string_lossy());
+    let mut large = HICON::default();
+    unsafe {
+        if ExtractIconExW(PCWSTR(wide_path.as_ptr()), 0, Some(&mut large), None, 1) > 0
+            && !large.is_invalid()
+        {
+            return Some(large);
+        }
+        LoadIconW(None, IDI_APPLICATION).ok()
+    }
+}
+
+fn destroy_icon(icon: Option<HICON>) {
+    if let Some(icon) = icon {
+        unsafe {
+            let _ = DestroyIcon(icon);
+        }
+    }
+}
+
+pub fn show(notification: &Notification) {
+    send_command(Command::Show(notification.clone()));
+}
+
+pub fn dismiss_all() {
+    send_command(Command::DismissAll);
+}
diff --git a/crates/notification-windows/src/layout.rs b/crates/notification-windows/src/layout.rs
new file mode 100644
index 0000000000..3c961eac0b
--- /dev/null
+++ b/crates/notification-windows/src/layout.rs
@@ -0,0 +1,297 @@
+#![cfg_attr(not(target_os = "windows"), allow(dead_code))]
+
+use anlg_notification_interface::{Notification, PrimaryAction};
+
+pub const NOTIFICATION_WIDTH: i32 = 344;
+pub const COMPACT_HEIGHT: i32 = 64;
+pub const COMPACT_FOOTER_HEIGHT: i32 = 28;
+pub const EXPANDED_HEIGHT: i32 = 380;
+pub const RIGHT_MARGIN: i32 = 15;
+pub const TOP_MARGIN: i32 = 15;
+pub const NOTIFICATION_SPACING: i32 = 10;
+pub const MAX_NOTIFICATIONS: usize = 5;
+pub const CLOSE_BUTTON_SIZE: i32 = 22;
+pub const ICON_SIZE: i32 = 28;
+pub const ACTION_BUTTON_WIDTH: i32 = 108;
+pub const ACTION_BUTTON_HEIGHT: i32 = 28;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Rect {
+    pub x: i32,
+    pub y: i32,
+    pub width: i32,
+    pub height: i32,
+}
+
+impl Rect {
+    pub fn contains(self, x: i32, y: i32) -> bool {
+        x >= self.x && y >= self.y && x < self.x + self.width && y < self.y + self.height
+    }
+
+    pub fn right(self) -> i32 {
+        self.x + self.width
+    }
+
+    pub fn bottom(self) -> i32 {
+        self.y + self.height
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum HitTarget {
+    Close,
+    Action,
+    Options,
+    Footer,
+    Collapse,
+    Body,
+}
+
+#[derive(Debug, Clone)]
+pub struct NotificationLayout {
+    pub width: i32,
+    pub height: i32,
+    pub close: Rect,
+    pub icon: Option<Rect>,
+    pub title: Rect,
+    pub message: Rect,
+    pub action: Option<Rect>,
+    pub footer_action: Option<Rect>,
+    pub collapse: Option<Rect>,
+    pub progress: Option<Rect>,
+}
+
+impl NotificationLayout {
+    pub fn compact(notification: &Notification) -> Self {
+        let has_footer = notification.footer.is_some();
+        let height = if has_footer {
+            COMPACT_HEIGHT + COMPACT_FOOTER_HEIGHT
+        } else {
+            COMPACT_HEIGHT
+        };
+        let has_icon = !matches!(
+            notification.icon,
+            Some(anlg_notification_interface::NotificationIcon::Hidden)
+        );
+        let icon = has_icon.then_some(Rect {
+            x: 12,
+            y: (COMPACT_HEIGHT - ICON_SIZE) / 2,
+            width: ICON_SIZE,
+            height: ICON_SIZE,
+        });
+        let text_x = if has_icon { 48 } else { 12 };
+        let action = match notification.primary_action() {
+            PrimaryAction::Accept { .. } | PrimaryAction::Options(_) => Some(Rect {
+                x: NOTIFICATION_WIDTH - ACTION_BUTTON_WIDTH - 12,
+                y: (COMPACT_HEIGHT - ACTION_BUTTON_HEIGHT) / 2,
+                width: ACTION_BUTTON_WIDTH,
+                height: ACTION_BUTTON_HEIGHT,
+            }),
+        };
+        let text_right = action
+            .map(|rect| rect.x - 8)
+            .unwrap_or(NOTIFICATION_WIDTH - 12);
+        let text_width = (text_right - text_x).max(48);
+
+        Self {
+            width: NOTIFICATION_WIDTH,
+            height,
+            close: Rect {
+                x: 6,
+                y: 6,
+                width: CLOSE_BUTTON_SIZE,
+                height: CLOSE_BUTTON_SIZE,
+            },
+            icon,
+            title: Rect {
+                x: text_x,
+                y: 12,
+                width: text_width,
+                height: 18,
+            },
+            message: Rect {
+                x: text_x,
+                y: 32,
+                width: text_width,
+                height: 16,
+            },
+            action,
+            footer_action: has_footer.then_some(Rect {
+                x: NOTIFICATION_WIDTH - 72,
+                y: COMPACT_HEIGHT + 4,
+                width: 60,
+                height: 20,
+            }),
+            collapse: None,
+            progress: notification
+                .timeout
+                .filter(|timeout| !timeout.is_zero())
+                .map(|_| Rect {
+                    x: 12,
+                    y: height - 5,
+                    width: NOTIFICATION_WIDTH - 24,
+                    height: 3,
+                }),
+        }
+    }
+
+    pub fn expanded(_notification: &Notification) -> Self {
+        Self {
+            width: NOTIFICATION_WIDTH,
+            height: EXPANDED_HEIGHT,
+            close: Rect {
+                x: 6,
+                y: 6,
+                width: CLOSE_BUTTON_SIZE,
+                height: CLOSE_BUTTON_SIZE,
+            },
+            icon: None,
+            title: Rect {
+                x: 16,
+                y: 14,
+                width: NOTIFICATION_WIDTH - 120,
+                height: 22,
+            },
+            message: Rect {
+                x: 16,
+                y: 48,
+                width: NOTIFICATION_WIDTH - 32,
+                height: 240,
+            },
+            action: Some(Rect {
+                x: 16,
+                y: EXPANDED_HEIGHT - 72,
+                width: NOTIFICATION_WIDTH - 32,
+                height: 36,
+            }),
+            footer_action: None,
+            collapse: Some(Rect {
+                x: NOTIFICATION_WIDTH - 96,
+                y: 14,
+                width: 80,
+                height: 24,
+            }),
+            progress: None,
+        }
+    }
+
+    pub fn for_state(notification: &Notification, expanded: bool) -> Self {
+        if expanded {
+            Self::expanded(notification)
+        } else {
+            Self::compact(notification)
+        }
+    }
+
+    pub fn hit_test(&self, x: i32, y: i32) -> HitTarget {
+        if self.close.contains(x, y) {
+            return HitTarget::Close;
+        }
+        if self.collapse.is_some_and(|rect| rect.contains(x, y)) {
+            return HitTarget::Collapse;
+        }
+        if self.action.is_some_and(|rect| rect.contains(x, y)) {
+            return HitTarget::Action;
+        }
+        if self.footer_action.is_some_and(|rect| rect.contains(x, y)) {
+            return HitTarget::Footer;
+        }
+        HitTarget::Body
+    }
+
+    pub fn action_hit(&self, notification: &Notification, x: i32, y: i32) -> HitTarget {
+        match self.hit_test(x, y) {
+            HitTarget::Action if notification.has_options() && self.collapse.is_none() => {
+                HitTarget::Options
+            }
+            target => target,
+        }
+    }
+}
+
+pub fn stacked_origin(work_x: i32, work_y: i32, work_width: i32, occupied: i32) -> (i32, i32) {
+    (
+        work_x + work_width - NOTIFICATION_WIDTH - RIGHT_MARGIN,
+        work_y + TOP_MARGIN + occupied,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anlg_notification_interface::{EventDetails, NotificationSource};
+    use std::time::Duration;
+
+    fn compact_notification() -> Notification {
+        Notification::builder()
+            .title("Upcoming event")
+            .message("Starting soon")
+            .timeout(Duration::from_secs(8))
+            .build()
+    }
+
+    #[test]
+    fn compact_layout_keeps_actions_and_progress_in_bounds() {
+        let notification = compact_notification();
+        let layout = NotificationLayout::compact(&notification);
+        assert_eq!(layout.height, COMPACT_HEIGHT);
+        assert!(layout.close.contains(10, 10));
+        assert_eq!(layout.hit_test(10, 10), HitTarget::Close);
+        assert_eq!(
+            layout.action_hit(
+                &notification,
+                layout.action.unwrap().x + 4,
+                layout.action.unwrap().y + 4
+            ),
+            HitTarget::Action
+        );
+        assert!(layout.progress.is_some());
+    }
+
+    #[test]
+    fn options_map_the_primary_button_to_the_options_hit_target() {
+        let notification = Notification::builder()
+            .title("Choose a meeting")
+            .message("")
+            .options(vec!["Design sync".to_string()])
+            .build();
+        let layout = NotificationLayout::compact(&notification);
+        let action = layout.action.unwrap();
+        assert_eq!(
+            layout.action_hit(&notification, action.x + 2, action.y + 2),
+            HitTarget::Options
+        );
+    }
+
+    #[test]
+    fn expanded_layout_exposes_collapse_and_accept_targets() {
+        let notification = Notification::builder()
+            .title("Design sync")
+            .message("")
+            .source(NotificationSource::Session {
+                session_id: "sess".to_string(),
+            })
+            .event_details(EventDetails {
+                what: "Design sync".to_string(),
+                timezone: None,
+                location: None,
+            })
+            .build();
+        let layout = NotificationLayout::expanded(&notification);
+        assert_eq!(layout.height, EXPANDED_HEIGHT);
+        assert_eq!(
+            layout.hit_test(layout.collapse.unwrap().x + 1, 16),
+            HitTarget::Collapse
+        );
+        assert_eq!(
+            layout.hit_test(layout.action.unwrap().x + 8, layout.action.unwrap().y + 8),
+            HitTarget::Action
+        );
+    }
+
+    #[test]
+    fn stacks_notifications_from_the_work_area_top_right() {
+        assert_eq!(stacked_origin(0, 0, 1920, 0), (1561, 15));
+        assert_eq!(stacked_origin(0, 0, 1920, 74), (1561, 89));
+    }
+}
diff --git a/crates/notification-windows/src/lib.rs b/crates/notification-windows/src/lib.rs
new file mode 100644
index 0000000000..e1a4980a1b
--- /dev/null
+++ b/crates/notification-windows/src/lib.rs
@@ -0,0 +1,16 @@
+pub use anlg_notification_interface::*;
+
+mod callbacks;
+mod layout;
+
+#[cfg(target_os = "windows")]
+mod r#impl;
+
+pub use callbacks::{
+    setup_notification_accept_handler, setup_notification_confirm_handler,
+    setup_notification_dismiss_handler, setup_notification_footer_action_handler,
+    setup_notification_option_selected_handler, setup_notification_timeout_handler,
+};
+
+#[cfg(target_os = "windows")]
+pub use r#impl::{dismiss_all, show};
diff --git a/crates/notification/Cargo.toml b/crates/notification/Cargo.toml
index 887a2e0da8..ce39ab0b35 100644
--- a/crates/notification/Cargo.toml
+++ b/crates/notification/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [features]
 default = ["legacy"]
-legacy = ["dep:anlg-notification-macos", "dep:anlg-notification-linux"]
+legacy = ["dep:anlg-notification-macos", "dep:anlg-notification-linux", "dep:anlg-notification-windows"]
 
 [dependencies]
 serde = { workspace = true, features = ["derive"] }
@@ -18,3 +18,6 @@ anlg-notification-macos = { path = "../notification-macos", package = "notificat
 
 [target.'cfg(target_os = "linux")'.dependencies]
 anlg-notification-linux = { path = "../notification-linux", package = "notification-linux", optional = true }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+anlg-notification-windows = { path = "../notification-windows", package = "notification-windows", optional = true }
diff --git a/crates/notification/src/lib.rs b/crates/notification/src/lib.rs
index 899fab7b87..959efd1bf5 100644
--- a/crates/notification/src/lib.rs
+++ b/crates/notification/src/lib.rs
@@ -144,6 +144,9 @@ fn show_inner(notification: &anlg_notification_interface::Notification) {
 
     #[cfg(all(feature = "legacy", target_os = "linux"))]
     anlg_notification_linux::show(notification);
+
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    anlg_notification_windows::show(notification);
 }
 
 pub fn show(notification: &anlg_notification_interface::Notification) {
@@ -192,6 +195,9 @@ pub fn clear() {
 
     #[cfg(all(feature = "legacy", target_os = "linux"))]
     anlg_notification_linux::dismiss_all();
+
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    anlg_notification_windows::dismiss_all();
 }
 
 pub fn setup_dismiss_handler<F>(f: F)
@@ -216,6 +222,14 @@ where
         });
     }
 
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    {
+        let f = f.clone();
+        anlg_notification_windows::setup_notification_dismiss_handler(move |key| {
+            f(get_context(&key));
+        });
+    }
+
     let _ = f;
 }
 
@@ -241,6 +255,14 @@ where
         });
     }
 
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    {
+        let f = f.clone();
+        anlg_notification_windows::setup_notification_confirm_handler(move |key| {
+            f(get_context(&key));
+        });
+    }
+
     let _ = f;
 }
 
@@ -266,6 +288,14 @@ where
         });
     }
 
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    {
+        let f = f.clone();
+        anlg_notification_windows::setup_notification_accept_handler(move |key| {
+            f(get_context(&key));
+        });
+    }
+
     let _ = f;
 }
 
@@ -291,6 +321,14 @@ where
         });
     }
 
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    {
+        let f = f.clone();
+        anlg_notification_windows::setup_notification_timeout_handler(move |key| {
+            f(get_context(&key));
+        });
+    }
+
     let _ = f;
 }
 
@@ -316,6 +354,14 @@ where
         });
     }
 
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    {
+        let f = f.clone();
+        anlg_notification_windows::setup_notification_option_selected_handler(move |key, index| {
+            f(get_context(&key), index);
+        });
+    }
+
     let _ = f;
 }
 
@@ -341,6 +387,14 @@ where
         });
     }
 
+    #[cfg(all(feature = "legacy", target_os = "windows"))]
+    {
+        let f = f.clone();
+        anlg_notification_windows::setup_notification_footer_action_handler(move |key| {
+            f(get_context(&key));
+        });
+    }
+
     let _ = f;
 }
 
diff --git a/plugins/notification/Cargo.toml b/plugins/notification/Cargo.toml
index f60a778d9a..74345cd0f7 100644
--- a/plugins/notification/Cargo.toml
+++ b/plugins/notification/Cargo.toml
@@ -28,7 +28,6 @@ specta = { workspace = true }
 strum = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 
-tokio = { workspace = true, features = ["time"] }
 tracing = { workspace = true }
 
 tauri = { workspace = true, features = ["test"] }
@@ -37,7 +36,3 @@ tauri-specta = { workspace = true, features = ["derive", "typescript"] }
 apalis = { workspace = true }
 apalis-cron = { workspace = true }
 chrono = { workspace = true }
-
-[target.'cfg(target_os = "windows")'.dependencies]
-notify-rust = { workspace = true }
-windows = { workspace = true, features = ["UI_Notifications"] }
diff --git a/plugins/notification/src/error.rs b/plugins/notification/src/error.rs
index 171233a8bc..7ed3f5578e 100644
--- a/plugins/notification/src/error.rs
+++ b/plugins/notification/src/error.rs
@@ -2,12 +2,8 @@ use serde::{Serialize, ser::Serializer};
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[cfg(target_os = "windows")]
-    #[error("failed to show Windows notification: {0}")]
-    WindowsNotification(#[from] notify_rust::error::Error),
-    #[cfg(target_os = "windows")]
-    #[error("failed to clear Windows notifications: {0}")]
-    WindowsNotificationHistory(#[from] windows::core::Error),
+    #[error("{0}")]
+    Message(String),
 }
 
 impl Serialize for Error {
diff --git a/plugins/notification/src/ext.rs b/plugins/notification/src/ext.rs
index a28a54da01..74a328188c 100644
--- a/plugins/notification/src/ext.rs
+++ b/plugins/notification/src/ext.rs
@@ -1,119 +1,5 @@
 use crate::error::Error;
 
-#[cfg(target_os = "windows")]
-use crate::events::NotificationEvent;
-
-#[cfg(any(target_os = "windows", test))]
-use std::collections::HashMap;
-#[cfg(any(target_os = "windows", test))]
-use std::path::Path;
-#[cfg(any(target_os = "windows", test))]
-use std::sync::{Mutex, OnceLock};
-#[cfg(any(target_os = "windows", test))]
-use std::time::{Duration, Instant};
-
-#[cfg(any(target_os = "windows", test))]
-static RECENT_WINDOWS_NOTIFICATIONS: OnceLock<Mutex<HashMap<String, Instant>>> = OnceLock::new();
-
-#[cfg(target_os = "windows")]
-static WINDOWS_NOTIFICATION_TIMEOUTS: OnceLock<Mutex<WindowsNotificationTimeouts>> =
-    OnceLock::new();
-
-#[cfg(any(target_os = "windows", test))]
-const WINDOWS_DEDUPE_WINDOW: Duration = Duration::from_mins(1);
-#[cfg(any(target_os = "windows", test))]
-const MAX_RECENT_WINDOWS_NOTIFICATIONS: usize = 256;
-#[cfg(any(target_os = "windows", test))]
-const MAX_ACTIVE_WINDOWS_NOTIFICATION_TIMEOUTS: usize = 64;
-
-#[cfg(any(target_os = "windows", test))]
-#[derive(Default)]
-struct WindowsNotificationTimeouts {
-    active: HashMap<String, WindowsNotificationTimeout>,
-    next_generation: u64,
-}
-
-#[cfg(any(target_os = "windows", test))]
-struct WindowsNotificationTimeout {
-    generation: u64,
-    task: Option<tokio::task::AbortHandle>,
-}
-
-#[cfg(any(target_os = "windows", test))]
-impl WindowsNotificationTimeouts {
-    fn schedule(&mut self, key: &str, timeout: Option<Duration>) -> Option<(u64, Duration)> {
-        let Some(timeout) = timeout.filter(|timeout| !timeout.is_zero()) else {
-            self.cancel(key);
-            return None;
-        };
-
-        Some((self.register(key), timeout))
-    }
-
-    fn register(&mut self, key: &str) -> u64 {
-        self.cancel(key);
-        while self.active.len() >= MAX_ACTIVE_WINDOWS_NOTIFICATION_TIMEOUTS {
-            let Some(oldest_key) = self
-                .active
-                .iter()
-                .min_by_key(|(_, timeout)| timeout.generation)
-                .map(|(key, _)| key.clone())
-            else {
-                break;
-            };
-            self.cancel(&oldest_key);
-        }
-        self.next_generation = self.next_generation.wrapping_add(1);
-        self.active.insert(
-            key.to_string(),
-            WindowsNotificationTimeout {
-                generation: self.next_generation,
-                task: None,
-            },
-        );
-        self.next_generation
-    }
-
-    fn attach_task(&mut self, key: &str, generation: u64, task: tokio::task::AbortHandle) {
-        let Some(timeout) = self.active.get_mut(key) else {
-            task.abort();
-            return;
-        };
-
-        if timeout.generation != generation {
-            task.abort();
-            return;
-        }
-
-        timeout.task = Some(task);
-    }
-
-    fn take_if_current(&mut self, key: &str, generation: u64) -> bool {
-        if self.active.get(key).map(|timeout| timeout.generation) != Some(generation) {
-            return false;
-        }
-
-        self.active.remove(key);
-        true
-    }
-
-    fn cancel(&mut self, key: &str) {
-        if let Some(timeout) = self.active.remove(key)
-            && let Some(task) = timeout.task
-        {
-            task.abort();
-        }
-    }
-
-    fn clear(&mut self) {
-        for (_, timeout) in self.active.drain() {
-            if let Some(task) = timeout.task {
-                task.abort();
-            }
-        }
-    }
-}
-
 pub struct Notification<'a, R: tauri::Runtime, M: tauri::Manager<R>> {
     manager: &'a M,
     _runtime: std::marker::PhantomData<fn() -> R>,
@@ -122,217 +8,19 @@ pub struct Notification<'a, R: tauri::Runtime, M: tauri::Manager<R>> {
 impl<'a, R: tauri::Runtime, M: tauri::Manager<R>> Notification<'a, R, M> {
     #[tracing::instrument(skip(self))]
     pub fn show(&self, v: anlg_notification::Notification) -> Result<(), Error> {
-        #[cfg(target_os = "windows")]
-        if should_show_windows_notification(v.key.as_deref()) {
-            show_windows_notification(self.manager, &v)?;
-            schedule_windows_notification_timeout(self.manager, &v);
-        }
-
-        #[cfg(not(target_os = "windows"))]
+        let _ = self.manager;
         anlg_notification::show(&v);
-
         Ok(())
     }
 
     #[tracing::instrument(skip(self))]
     pub fn clear(&self) -> Result<(), Error> {
         let _ = self.manager;
-
-        #[cfg(target_os = "windows")]
-        {
-            cancel_windows_notification_timeouts();
-            clear_windows_notifications(self.manager)?;
-        }
-
-        #[cfg(not(target_os = "windows"))]
         anlg_notification::clear();
-
         Ok(())
     }
 }
 
-#[cfg(any(target_os = "windows", test))]
-fn should_show_windows_notification(key: Option<&str>) -> bool {
-    let Some(key) = key else {
-        return true;
-    };
-
-    let recent = RECENT_WINDOWS_NOTIFICATIONS.get_or_init(|| Mutex::new(HashMap::new()));
-    let mut recent = recent.lock().unwrap_or_else(|error| error.into_inner());
-    if !register_recent_windows_notification(&mut recent, key, Instant::now()) {
-        tracing::info!(key, "skipping_notification");
-        return false;
-    }
-
-    true
-}
-
-#[cfg(any(target_os = "windows", test))]
-fn register_recent_windows_notification(
-    recent: &mut HashMap<String, Instant>,
-    key: &str,
-    now: Instant,
-) -> bool {
-    recent.retain(|_, timestamp| now.duration_since(*timestamp) < WINDOWS_DEDUPE_WINDOW);
-    if recent.contains_key(key) {
-        return false;
-    }
-
-    while recent.len() >= MAX_RECENT_WINDOWS_NOTIFICATIONS {
-        let Some(oldest) = recent
-            .iter()
-            .min_by_key(|(_, timestamp)| *timestamp)
-            .map(|(key, _)| key.clone())
-        else {
-            break;
-        };
-        recent.remove(&oldest);
-    }
-
-    recent.insert(key.to_string(), now);
-    true
-}
-
-#[cfg(target_os = "windows")]
-fn windows_notification_timeouts() -> &'static Mutex<WindowsNotificationTimeouts> {
-    WINDOWS_NOTIFICATION_TIMEOUTS.get_or_init(|| Mutex::new(WindowsNotificationTimeouts::default()))
-}
-
-#[cfg(target_os = "windows")]
-fn schedule_windows_notification_timeout<R: tauri::Runtime, M: tauri::Manager<R>>(
-    manager: &M,
-    notification: &anlg_notification::Notification,
-) {
-    use tauri_specta::Event;
-
-    let Some(key) = notification.key.clone() else {
-        return;
-    };
-
-    let app = manager.app_handle().clone();
-    let source = notification.source.clone();
-    let mut timeouts = windows_notification_timeouts()
-        .lock()
-        .unwrap_or_else(|error| error.into_inner());
-    let Some((generation, timeout)) = timeouts.schedule(&key, notification.timeout) else {
-        return;
-    };
-    let task_key = key.clone();
-
-    let task = tauri::async_runtime::spawn(async move {
-        tokio::time::sleep(timeout).await;
-
-        let should_emit = windows_notification_timeouts()
-            .lock()
-            .unwrap_or_else(|error| error.into_inner())
-            .take_if_current(&task_key, generation);
-        if !should_emit {
-            return;
-        }
-
-        if let Err(error) = (NotificationEvent::Timeout {
-            key: task_key,
-            source,
-        })
-        .emit(&app)
-        {
-            tracing::warn!(%error, "failed_to_emit_windows_notification_timeout");
-        }
-    });
-    timeouts.attach_task(&key, generation, task.inner().abort_handle());
-}
-
-#[cfg(target_os = "windows")]
-fn cancel_windows_notification_timeouts() {
-    windows_notification_timeouts()
-        .lock()
-        .unwrap_or_else(|error| error.into_inner())
-        .clear();
-}
-
-#[cfg(any(target_os = "windows", test))]
-fn is_cargo_target_profile_dir(path: &Path) -> bool {
-    let Some(profile) = path.file_name().and_then(|name| name.to_str()) else {
-        return false;
-    };
-
-    if !matches!(profile, "debug" | "release") {
-        return false;
-    }
-
-    let Some(parent) = path.parent() else {
-        return false;
-    };
-
-    parent.file_name().is_some_and(|name| name == "target")
-        || parent
-            .parent()
-            .and_then(Path::file_name)
-            .is_some_and(|name| name == "target")
-}
-
-#[cfg(any(target_os = "windows", test))]
-fn windows_app_id<'a>(
-    identifier: &'a str,
-    is_dev: bool,
-    executable: Option<&Path>,
-) -> Option<&'a str> {
-    if is_dev {
-        return None;
-    }
-
-    let executable_dir = executable?.parent()?;
-
-    (!is_cargo_target_profile_dir(executable_dir)).then_some(identifier)
-}
-
-#[cfg(target_os = "windows")]
-fn show_windows_notification<R: tauri::Runtime, M: tauri::Manager<R>>(
-    manager: &M,
-    notification: &anlg_notification::Notification,
-) -> Result<(), Error> {
-    let mut toast = notify_rust::Notification::new();
-    toast
-        .summary(&notification.title)
-        .body(&notification.message)
-        .timeout(
-            notification
-                .timeout
-                .map(notify_rust::Timeout::from)
-                .unwrap_or(notify_rust::Timeout::Never),
-        );
-
-    let executable = tauri::utils::platform::current_exe().ok();
-    if let Some(app_id) = windows_app_id(
-        &manager.config().identifier,
-        tauri::is_dev(),
-        executable.as_deref(),
-    ) {
-        toast.app_id(app_id);
-    }
-
-    toast.show()?;
-    Ok(())
-}
-
-#[cfg(target_os = "windows")]
-fn clear_windows_notifications<R: tauri::Runtime, M: tauri::Manager<R>>(
-    manager: &M,
-) -> Result<(), Error> {
-    let executable = tauri::utils::platform::current_exe().ok();
-    let Some(app_id) = windows_app_id(
-        &manager.config().identifier,
-        tauri::is_dev(),
-        executable.as_deref(),
-    ) else {
-        return Ok(());
-    };
-
-    windows::UI::Notifications::ToastNotificationManager::History()?
-        .ClearWithId(&windows::core::HSTRING::from(app_id))?;
-    Ok(())
-}
-
 pub trait NotificationPluginExt<R: tauri::Runtime> {
     fn notification(&self) -> Notification<'_, R, Self>
     where
@@ -350,209 +38,3 @@ impl<R: tauri::Runtime, T: tauri::Manager<R>> NotificationPluginExt<R> for T {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn windows_notifications_without_keys_are_not_deduplicated() {
-        assert!(should_show_windows_notification(None));
-        assert!(should_show_windows_notification(None));
-    }
-
-    #[test]
-    fn windows_notifications_with_duplicate_keys_are_suppressed() {
-        let key = "windows-notification-test-duplicate-key";
-
-        assert!(should_show_windows_notification(Some(key)));
-        assert!(!should_show_windows_notification(Some(key)));
-    }
-
-    #[test]
-    fn recent_windows_notifications_stay_bounded() {
-        let now = Instant::now();
-        let mut recent = HashMap::new();
-        for index in 0..MAX_RECENT_WINDOWS_NOTIFICATIONS {
-            recent.insert(
-                format!("notification-{index}"),
-                now - Duration::from_millis(index as u64 + 1),
-            );
-        }
-
-        assert!(register_recent_windows_notification(
-            &mut recent,
-            "newest",
-            now,
-        ));
-        assert_eq!(recent.len(), MAX_RECENT_WINDOWS_NOTIFICATIONS);
-        assert!(recent.contains_key("newest"));
-        assert!(!recent.contains_key(&format!(
-            "notification-{}",
-            MAX_RECENT_WINDOWS_NOTIFICATIONS - 1
-        )));
-    }
-
-    #[test]
-    fn development_windows_notifications_use_the_fallback_app_id() {
-        let executable = Path::new("C:/Users/anarlog/Anarlog.exe");
-
-        assert_eq!(
-            windows_app_id("com.hyprnote.dev", true, Some(executable)),
-            None
-        );
-    }
-
-    #[test]
-    fn direct_cargo_builds_use_the_fallback_app_id() {
-        for profile in ["debug", "release"] {
-            let executable = Path::new("C:/repo/target")
-                .join(profile)
-                .join("Anarlog.exe");
-
-            assert_eq!(
-                windows_app_id("com.hyprnote.dev", false, Some(&executable)),
-                None
-            );
-        }
-    }
-
-    #[test]
-    fn target_triple_cargo_builds_use_the_fallback_app_id() {
-        for profile in ["debug", "release"] {
-            let executable = Path::new("C:/repo/target")
-                .join("x86_64-pc-windows-msvc")
-                .join(profile)
-                .join("Anarlog.exe");
-
-            assert_eq!(
-                windows_app_id("com.hyprnote.dev", false, Some(&executable)),
-                None
-            );
-        }
-    }
-
-    #[test]
-    fn installed_windows_notifications_use_the_configured_app_id() {
-        let executable = Path::new("C:/Users/anarlog/AppData/Local/Anarlog/Anarlog.exe");
-
-        assert_eq!(
-            windows_app_id("com.hyprnote.stable", false, Some(executable)),
-            Some("com.hyprnote.stable")
-        );
-    }
-
-    #[test]
-    fn windows_notification_timeout_only_fires_for_the_current_generation() {
-        let mut timeouts = WindowsNotificationTimeouts::default();
-        let first = timeouts.register("meeting");
-        let second = timeouts.register("meeting");
-
-        assert!(!timeouts.take_if_current("meeting", first));
-        assert!(timeouts.take_if_current("meeting", second));
-        assert!(!timeouts.take_if_current("meeting", second));
-    }
-
-    #[test]
-    fn clearing_windows_notification_timeouts_invalidates_pending_generations() {
-        let mut timeouts = WindowsNotificationTimeouts::default();
-        let meeting_generation = timeouts.register("meeting");
-        let mic_generation = timeouts.register("mic");
-
-        timeouts.clear();
-
-        assert!(!timeouts.take_if_current("meeting", meeting_generation));
-        assert!(!timeouts.take_if_current("mic", mic_generation));
-    }
-
-    #[test]
-    fn cancelling_a_windows_notification_timeout_invalidates_its_generation() {
-        let mut timeouts = WindowsNotificationTimeouts::default();
-        let generation = timeouts.register("meeting");
-
-        timeouts.cancel("meeting");
-
-        assert!(!timeouts.take_if_current("meeting", generation));
-    }
-
-    #[test]
-    fn zero_windows_notification_timeout_cancels_without_scheduling() {
-        let mut timeouts = WindowsNotificationTimeouts::default();
-        let generation = timeouts.register("meeting");
-
-        assert_eq!(timeouts.schedule("meeting", Some(Duration::ZERO)), None);
-        assert!(!timeouts.take_if_current("meeting", generation));
-    }
-
-    #[test]
-    fn persistent_windows_notification_cancels_an_older_timeout() {
-        let mut timeouts = WindowsNotificationTimeouts::default();
-        let (generation, _) = timeouts
-            .schedule("meeting", Some(Duration::from_secs(30)))
-            .unwrap();
-
-        assert_eq!(timeouts.schedule("meeting", None), None);
-        assert!(!timeouts.take_if_current("meeting", generation));
-    }
-
-    #[test]
-    fn replacing_a_windows_notification_aborts_its_timeout_task() {
-        tauri::async_runtime::block_on(async {
-            let mut timeouts = WindowsNotificationTimeouts::default();
-            let generation = timeouts.register("meeting");
-            let task = tauri::async_runtime::spawn(std::future::pending::<()>());
-            timeouts.attach_task("meeting", generation, task.inner().abort_handle());
-
-            timeouts.register("meeting");
-
-            assert!(task.await.is_err());
-        });
-    }
-
-    #[test]
-    fn clearing_windows_notifications_aborts_all_timeout_tasks() {
-        tauri::async_runtime::block_on(async {
-            let mut timeouts = WindowsNotificationTimeouts::default();
-            let meeting_generation = timeouts.register("meeting");
-            let meeting_task = tauri::async_runtime::spawn(std::future::pending::<()>());
-            timeouts.attach_task(
-                "meeting",
-                meeting_generation,
-                meeting_task.inner().abort_handle(),
-            );
-            let mic_generation = timeouts.register("mic");
-            let mic_task = tauri::async_runtime::spawn(std::future::pending::<()>());
-            timeouts.attach_task("mic", mic_generation, mic_task.inner().abort_handle());
-
-            timeouts.clear();
-
-            assert!(meeting_task.await.is_err());
-            assert!(mic_task.await.is_err());
-        });
-    }
-
-    #[test]
-    fn windows_notification_timeouts_evict_and_abort_the_oldest_task_at_capacity() {
-        tauri::async_runtime::block_on(async {
-            let mut timeouts = WindowsNotificationTimeouts::default();
-            let oldest_generation = timeouts.register("oldest");
-            let oldest_task = tauri::async_runtime::spawn(std::future::pending::<()>());
-            timeouts.attach_task(
-                "oldest",
-                oldest_generation,
-                oldest_task.inner().abort_handle(),
-            );
-
-            for index in 0..MAX_ACTIVE_WINDOWS_NOTIFICATION_TIMEOUTS {
-                timeouts.register(&format!("notification-{index}"));
-            }
-
-            assert_eq!(
-                timeouts.active.len(),
-                MAX_ACTIVE_WINDOWS_NOTIFICATION_TIMEOUTS
-            );
-            assert!(!timeouts.active.contains_key("oldest"));
-            assert!(oldest_task.await.is_err());
-        });
-    }
-}