feat(tools): harden scheduler speed limiter logs

Modernize the Tools release surfaces for the cross-platform re-release checklist.

- make Speed Limiter presets unit-aware and persist custom removable quick presets

- keep diagnostic logging opt-in on clean installs and honor the saved log state on startup

- stage Scheduler enablement edits without discarding unsaved draft changes

- extend persisted settings and bindings for log opt-in and speed preset state

Verification:

- npm run build

- npm test -- --run src/store/useDownloadStore.test.ts

- cargo test --lib

- cargo test settings --lib

src-tauri/src/ipc.rs

@@ -249,6 +249,8 @@ pub struct PersistedSettings {
     pub approved_download_roots: Vec<String>,
     pub max_concurrent_downloads: usize,
     pub global_speed_limit: String,
+    pub speed_limit_preset_values: Vec<f64>,
+    pub logs_enabled: bool,
     pub is_sidebar_visible: bool,
     pub active_settings_tab: SettingsTab,
     pub scheduler: SchedulerSettings,

src-tauri/src/lib.rs

@@ -4807,15 +4807,40 @@ pub fn run() {
                 *pairing_token = initial_pairing_token;
             }
             app.manage(database);
+            let persisted_settings = crate::settings::load_settings(app.handle()).ok();
+            let logs_enabled = persisted_settings
+                .as_ref()
+                .is_some_and(|settings| settings.logs_enabled);
+            LOG_PAUSED.store(!logs_enabled, std::sync::atomic::Ordering::Relaxed);
+            if logs_enabled {
+                log::info!("=== System Information ===");
+                log::info!(
+                    "OS: {} {}",
+                    sysinfo::System::name().unwrap_or_else(|| "Unknown".to_string()),
+                    sysinfo::System::os_version().unwrap_or_else(|| "Unknown".to_string())
+                );
+                let arch = sysinfo::System::cpu_arch();
+                log::info!(
+                    "Architecture: {}",
+                    if arch.is_empty() { "Unknown" } else { &arch }
+                );
+                log::info!(
+                    "CPU: {} ({} cores)",
+                    sys.cpus().first().map(|c| c.brand()).unwrap_or("Unknown"),
+                    sys.cpus().len()
+                );
+                log::info!("Memory: {} MB total", sys.total_memory() / 1024 / 1024);
+                log::info!("App Version: {}", env!("CARGO_PKG_VERSION"));
+                log::info!("==========================");
+            }
 
             let max_concurrent = {
-                crate::settings::load_settings(app.handle())
+                persisted_settings
+                    .as_ref()
                     .map(|settings| settings.max_concurrent_downloads)
                     .unwrap_or(crate::queue::DEFAULT_MAX_CONCURRENT)
             };
-            let scheduler_settings = Arc::new(RwLock::new(
-                crate::settings::load_settings(app.handle()).ok(),
-            ));
+            let scheduler_settings = Arc::new(RwLock::new(persisted_settings.clone()));
 
             let queue_manager = Arc::new(queue::QueueManager::new(app.handle().clone(), max_concurrent));
             let dispatcher_mgr = Arc::clone(&queue_manager);
@@ -4888,8 +4913,9 @@ pub fn run() {
             }
             crate::scheduler::spawn_scheduler(app.handle().clone(), scheduler_settings);
 
-            let global_speed_limit = crate::settings::load_settings(app.handle())
-                .map(|settings| settings.global_speed_limit)
+            let global_speed_limit = persisted_settings
+                .as_ref()
+                .map(|settings| settings.global_speed_limit.clone())
                 .unwrap_or_default();
 
             let aria2_secret_clone = aria2_secret.clone();

src-tauri/src/settings.rs

@@ -267,6 +267,8 @@ fn default_settings() -> PersistedSettings {
         approved_download_roots: Vec::new(),
         max_concurrent_downloads: 3,
         global_speed_limit: String::new(),
+        speed_limit_preset_values: vec![1.0, 5.0, 10.0],
+        logs_enabled: false,
         is_sidebar_visible: true,
         active_settings_tab: SettingsTab::Downloads,
         scheduler: SchedulerSettings {
@@ -360,6 +362,8 @@ mod tests {
 
         assert_eq!(settings.max_concurrent_downloads, 7);
         assert_eq!(settings.global_speed_limit, "2M");
+        assert_eq!(settings.speed_limit_preset_values, vec![1.0, 5.0, 10.0]);
+        assert!(!settings.logs_enabled);
         assert!(settings.scheduler.enabled);
         assert_eq!(settings.scheduler.start_time, "06:30");
         assert_eq!(settings.scheduler.selected_days, vec![1, 3, 5]);
@@ -381,9 +385,29 @@ mod tests {
 
         assert_eq!(settings.max_concurrent_downloads, 5);
         assert_eq!(settings.global_speed_limit, "512K");
+        assert_eq!(settings.speed_limit_preset_values, vec![1.0, 5.0, 10.0]);
+        assert!(!settings.logs_enabled);
         assert!(!settings.scheduler.enabled);
     }
 
+    #[test]
+    fn decodes_persisted_log_opt_in() {
+        let stored = json!({
+            "state": {
+                "speedLimitPresetValues": [1, 2.5, 8],
+                "logsEnabled": true
+            },
+            "version": 3
+        });
+
+        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();
+
+        assert_eq!(settings.speed_limit_preset_values, vec![1.0, 2.5, 8.0]);
+        assert!(settings.logs_enabled);
+        assert!(!settings.scheduler.enabled);
+        assert!(settings.global_speed_limit.is_empty());
+    }
+
     #[test]
     fn migrates_legacy_location_settings_and_preserves_custom_overrides() {
         let stored = json!({