test: add unit tests for attention timer, break scheduler and the whole state machine

.cargo/config.toml

@@ -1,16 +1,19 @@
 # Use lld linker on Linux and Windows for faster linking
-# macOS doesn't support lld, it uses ld64
+# macOS doesn't support lld.
 [target.x86_64-unknown-linux-gnu]
 rustflags = ["-C", "link-arg=-fuse-ld=lld"]
 
 [target.aarch64-unknown-linux-gnu]
 rustflags = ["-C", "link-arg=-fuse-ld=lld"]
 
 [target.x86_64-pc-windows-msvc]
-rustflags = ["-C", "link-arg=-fuse-ld=lld"]
+linker = "rust-lld"
 
 [target.aarch64-pc-windows-msvc]
-rustflags = ["-C", "link-arg=-fuse-ld=lld"]
+linker = "rust-lld"
 
 [env]
 TS_RS_EXPORT_DIR = { value = "src/types/generated", relative = true }
+# workaround needed to prevent `STATUS_ENTRYPOINT_NOT_FOUND` error in tests
+# see https://github.com/tauri-apps/tauri/pull/4383#issuecomment-1212221864
+__TAURI_WORKSPACE__ = "true"

justfile

@@ -34,6 +34,7 @@ alias fif := fix-front
 alias fib := fix-back
 
 alias ta := test-all
+alias tl := test-lib
 alias tfa := test-front-all
 alias tf := test-front
 alias tba := test-back-all
@@ -214,6 +215,13 @@ alias adb := add-dep-back
     cargo test --manifest-path {{ RUST_DIR }}/Cargo.toml --workspace
     echo "✅ Tests complete!"
 
+# Run library tests only
+[group: "test"]
+@test-lib *tests:
+    echo "🧪 Running library tests..."
+    cargo test --manifest-path {{ RUST_DIR }}/Cargo.toml --workspace --lib {{ tests }}
+    echo "✅ Library tests complete!"
+
 # Run all front-end tests
 [group: "test"]
 @test-front-all:

src-tauri/Cargo.toml

@@ -69,6 +69,8 @@ sysinfo = "0.37.2"
 
 [dev-dependencies]
 tempfile = "3.23.0"
+tauri = { version = "2", features = ["test"] }
+tokio = { version = "*", features = ["test-util"] }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-updater = "2"

src-tauri/build.rs

@@ -1,3 +1,35 @@
+// https://github.com/tauri-apps/tauri/issues/13419#issuecomment-3398457618
+// Fix `STATUS_ENTRYPOINT_NOT_FOUND` error on Windows when testing.
 fn main() {
-    tauri_build::build()
+    #[cfg(windows)]
+    {
+        let mut attributes = tauri_build::Attributes::new();
+        attributes = attributes
+            .windows_attributes(tauri_build::WindowsAttributes::new_without_app_manifest());
+        add_manifest();
+        tauri_build::try_build(attributes).unwrap();
+    }
+    #[cfg(not(windows))]
+    {
+        tauri_build::build();
+    }
+}
+
+#[cfg(windows)]
+fn add_manifest() {
+    static WINDOWS_MANIFEST_FILE: &str = "windows-app-manifest.xml";
+
+    let manifest = std::env::current_dir()
+        .expect("Failed to get current directory during build")
+        .join(WINDOWS_MANIFEST_FILE);
+
+    println!("cargo:rerun-if-changed={}", manifest.display());
+    // Embed the Windows application manifest file.
+    println!("cargo:rustc-link-arg=/MANIFEST:EMBED");
+    println!(
+        "cargo:rustc-link-arg=/MANIFESTINPUT:{}",
+        manifest.to_str().unwrap()
+    );
+    // Turn linker warnings into errors.
+    println!("cargo:rustc-link-arg=/WX");
 }

src-tauri/capabilities/default.json

@@ -2,7 +2,7 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
   "description": "Default capabilities for all windows",
-  "windows": ["main", "settings", "break-*"],
+  "windows": ["main", "settings", "break-*", "attention-*"],
   "permissions": [
     "core:default",
     "core:event:allow-listen",

src-tauri/src/cmd.rs

@@ -16,4 +16,4 @@ pub use scheduler::{
 };
 pub use suggestions::{get_suggestions, get_suggestions_for_language, save_suggestions};
 pub use system::{open_config_directory, open_log_directory};
-pub use window::{close_all_break_windows, open_settings_window};
+pub use window::{close_all_prompt_windows, open_settings_window};

src-tauri/src/cmd/window.rs

@@ -8,22 +8,22 @@ pub async fn open_settings_window<R: Runtime>(app: AppHandle<R>) -> Result<(), S
     create_settings_window(&app)
 }
 
-/// Close all break windows with the given payload ID prefix
+/// Close all prompt windows with the given payload ID prefix
 #[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
-pub fn close_all_break_windows<R: Runtime>(
+pub fn close_all_prompt_windows<R: Runtime>(
     app: AppHandle<R>,
     payload_id: &str,
 ) -> Result<(), String> {
-    tracing::debug!("Closing all break windows for payload: {payload_id}");
+    tracing::debug!("Closing all prompt windows for payload: {payload_id}");
 
     // Get all windows
     let windows = app.webview_windows();
 
     // Close all windows that start with the payload_id
     for (label, window) in windows {
         if label.starts_with(payload_id) {
-            tracing::debug!("Closing break window: {label}");
+            tracing::debug!("Closing prompt window: {label}");
             window.close().unwrap_or_else(|e| {
                 tracing::warn!("Failed to close window {label}: {e}");
             });

src-tauri/src/config/models.rs

@@ -27,7 +27,7 @@ pub struct AppConfig {
     pub theme_mode: String,
     /// Shortcut to postpone breaks, e.g., "Ctrl+Shift+X"
     pub postpone_shortcut: String,
-    /// Break window size percentage (0.1 to 1.0, where 1.0 is fullscreen)
+    /// Prompt window size percentage (0.1 to 1.0, where 1.0 is fullscreen)
     pub window_size: f32,
     /// List of schedules
     pub schedules: Vec<ScheduleSettings>,

src-tauri/src/core/suggestions.rs

@@ -12,7 +12,7 @@ use crate::platform::i18n::LANGUAGE_FALLBACK;
 
 /// Settings for displaying suggestions during breaks
 ///
-/// This controls whether suggestions are shown to the user during break windows.
+/// This controls whether suggestions are shown to the user during prompt windows.
 /// The actual suggestion content is managed separately in the [`SuggestionsConfig`].
 #[derive(Serialize, Deserialize, Debug, Clone, TS)]
 #[serde(rename_all = "camelCase")]

src-tauri/src/core/theme.rs

@@ -45,7 +45,7 @@ impl Display for HexColor {
     }
 }
 
-/// Resolved background for break window
+/// Resolved background for prompt window
 #[derive(Debug, Clone, Serialize, Deserialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export, rename_all = "camelCase")]
@@ -248,12 +248,12 @@ impl BackgroundSource {
     }
 }
 
-/// Theme settings for break windows
+/// Theme settings for prompt windows
 #[derive(Serialize, Deserialize, Debug, Clone, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(rename_all = "camelCase")]
 pub struct ThemeSettings {
-    /// Background source for the break window (solid color, image path, or image folder)
+    /// Background source for the prompt window (solid color, image path, or image folder)
     pub background: BackgroundSource,
     /// Text color in hex format
     pub text_color: HexColor,

src-tauri/src/lib.rs

@@ -157,7 +157,7 @@ pub fn run() {
                 // Add DND monitor if enabled
                 if app_config.monitor_dnd {
                     tracing::info!("DND monitoring enabled");
-                    let dnd_monitor = monitors::DndMonitor::new(shared_state.clone());
+                    let dnd_monitor = monitors::DndMonitor::new();
                     monitors.push(Box::new(dnd_monitor));
                 } else {
                     tracing::info!("DND monitoring disabled");
@@ -219,7 +219,7 @@ pub fn run() {
             cmd::suggestions::save_suggestions,
             cmd::system::open_config_directory,
             cmd::system::open_log_directory,
-            cmd::window::close_all_break_windows,
+            cmd::window::close_all_prompt_windows,
             cmd::window::open_settings_window,
         ])
         .build(tauri::generate_context!())

src-tauri/src/monitors.rs

@@ -11,6 +11,7 @@
 //! - **Concrete monitors**: `IdleMonitor`, `DndMonitor`, `AppWhitelistMonitor`
 //! - **Orchestrator**: Runs all monitors in a single task, checking at configured intervals
 //! - **Action conversion**: Converts `MonitorAction` to `Command` for the scheduler
+//! - **Session protection**: Unified session checking to prevent self-interference
 //!
 //! # Monitor Lifecycle
 //!
@@ -19,12 +20,26 @@
 //! 3. **Monitoring Loop**: `check()` is called periodically at the monitor's interval
 //! 4. **Shutdown**: `on_stop()` is called when the monitor stops (currently unused)
 //!
+//! # Session Protection
+//!
+//! During active sessions (break or attention prompts), monitors are typically skipped
+//! to avoid self-interference. For example:
+//!
+//! - A break window may trigger system DND mode
+//! - Without session protection, `DndMonitor` would detect this and pause the scheduler
+//! - This would interrupt the break, causing unexpected behavior
+//!
+//! **Implementation**: The orchestrator checks `SharedState::in_any_session()` before
+//! calling each monitor's `check()` method. Monitors with `skip_during_session() == true`
+//! (the default) are automatically skipped during sessions.
+//!
 //! # Design Patterns
 //!
 //! - **Trait-based polymorphism**: All monitors implement the same interface
 //! - **Event-driven where possible**: `DndMonitor` uses OS events instead of polling
 //! - **Graceful degradation**: Monitors that fail to initialize return `Unavailable`
 //! - **Non-blocking**: All checks must be fast and non-blocking
+//! - **Unified session protection**: Orchestrator handles session checking, not monitors
 //!
 //! # Example
 //!
@@ -292,6 +307,57 @@ pub trait Monitor: Send + Sync {
     fn on_stop(&mut self) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
         Box::pin(async {})
     }
+
+    /// Whether to skip this monitor's checks during active sessions
+    ///
+    /// # Session Protection
+    ///
+    /// During an active session (break window or attention prompt), the scheduler
+    /// is already interacting with the user. Environment changes detected by monitors
+    /// are often **side effects** of the session itself:
+    ///
+    /// - **Break windows** may trigger system DND mode
+    /// - **User leaving computer** during break is expected (goal of break)
+    /// - **Excluded apps** may still be running during break
+    ///
+    /// If monitors send Pause commands during sessions, it can cause:
+    /// - Self-interruption (break window triggers DND → pauses break)
+    /// - Unexpected behavior (user expects break to continue)
+    /// - State machine confusion (pausing an already-active session)
+    ///
+    /// # Default Behavior
+    ///
+    /// Returns `true` by default (skip checks during sessions).
+    /// Most monitors should keep this default.
+    ///
+    /// # When to Override
+    ///
+    /// Only override to return `false` if the monitor needs to detect
+    /// critical system conditions that should interrupt sessions
+    /// (e.g., low battery, system shutdown).
+    ///
+    /// # Implementation Note
+    ///
+    /// Session checking is enforced at the orchestrator level, not in
+    /// individual monitor implementations. This ensures consistent behavior
+    /// and reduces code duplication.
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// // Default: skip during sessions (most monitors)
+    /// fn skip_during_session(&self) -> bool {
+    ///     true
+    /// }
+    ///
+    /// // Override: continue during sessions (rare cases)
+    /// fn skip_during_session(&self) -> bool {
+    ///     false
+    /// }
+    /// ```
+    fn skip_during_session(&self) -> bool {
+        true
+    }
 }
 
 /// Convert a `MonitorAction` to a `Command`

src-tauri/src/monitors/dnd.rs

@@ -17,7 +17,6 @@ use tokio::sync::{Mutex as AsyncMutex, mpsc};
 use super::{Monitor, MonitorAction, MonitorError, MonitorResult};
 use crate::platform::dnd::{DndEvent, DndMonitor as PlatformDndMonitor, INTERVAL_SECS};
 use crate::scheduler::models::PauseReason;
-use crate::scheduler::shared_state::SharedState;
 
 /// Debounce delay in seconds
 ///
@@ -39,22 +38,25 @@ pub struct DndMonitor {
     reported_dnd_state: bool,
     /// When the DND state last changed (for debouncing)
     state_change_time: Option<Instant>,
-    /// Shared scheduler state (for session checking)
-    shared_state: SharedState,
+}
+
+impl Default for DndMonitor {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl DndMonitor {
     /// Create a new DND monitor
     #[must_use]
-    pub fn new(shared_state: SharedState) -> Self {
+    pub fn new() -> Self {
         Self {
             platform_monitor: None,
             event_rx: Arc::new(AsyncMutex::new(None)),
             available: true, // Assume available, will check on start
             current_dnd_state: false,
             reported_dnd_state: false,
             state_change_time: None,
-            shared_state,
         }
     }
 
@@ -110,19 +112,6 @@ impl Monitor for DndMonitor {
                 return Err(MonitorError::Unavailable);
             }
 
-            // Check if in any session (break or attention)
-            // During sessions, we ignore DND changes to prevent self-triggering
-            if self.shared_state.read().in_any_session() {
-                // In session, ignore DND events but drain the channel
-                let mut event_rx_guard = self.event_rx.lock().await;
-                if let Some(rx) = event_rx_guard.as_mut() {
-                    while rx.try_recv().is_ok() {
-                        // Drain events without processing
-                    }
-                }
-                return Ok(MonitorAction::None);
-            }
-
             // Try to receive DND events (non-blocking)
             let mut event_rx_guard = self.event_rx.lock().await;
             if let Some(rx) = event_rx_guard.as_mut() {