added scheduler inspection and display to tweak details

Introduces scheduler (task) inspection to the backend and frontend, including new types and logic for detecting and displaying scheduler mismatches. Updates the backup info and tweak inspection models to include scheduler snapshot and inspection results, and enhances the TweakDetailsModal UI to show scheduler check results alongside registry and service checks.

Author: ehsan18t

src-tauri/src/commands/backup.rs

@@ -11,6 +11,7 @@ pub struct BackupInfo {
     pub windows_version: u32,
     pub registry_values_count: usize,
     pub service_snapshots_count: usize,
+    pub scheduler_snapshots_count: usize,
 }
 
 /// Check if a tweak has a snapshot (is applied)
@@ -36,6 +37,7 @@ pub fn get_backup_info(tweak_id: String) -> Result<Option<BackupInfo>> {
             windows_version: snapshot.windows_version,
             registry_values_count: snapshot.registry_snapshots.len(),
             service_snapshots_count: snapshot.service_snapshots.len(),
+            scheduler_snapshots_count: snapshot.scheduler_snapshots.len(),
         })),
         None => Ok(None),
     }

src-tauri/src/models/inspection.rs

@@ -21,6 +21,16 @@ pub struct ServiceMismatch {
     pub is_match: bool,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SchedulerMismatch {
+    pub task_path: String,
+    pub task_name: String,
+    pub expected_state: String,
+    pub actual_state: Option<String>,
+    pub description: String,
+    pub is_match: bool,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct OptionInspection {
     pub option_index: usize,
@@ -29,6 +39,7 @@ pub struct OptionInspection {
     pub is_pending: bool,
     pub registry_results: Vec<RegistryMismatch>,
     pub service_results: Vec<ServiceMismatch>,
+    pub scheduler_results: Vec<SchedulerMismatch>,
     pub all_match: bool,
 }
 

src-tauri/src/services/backup/inspection.rs

@@ -2,10 +2,10 @@ use super::capture::read_registry_value;
 use super::helpers::values_match;
 use crate::error::Error;
 use crate::models::{
-    OptionInspection, RegistryAction, RegistryMismatch, ServiceMismatch, TweakDefinition,
-    TweakInspection, TweakOption,
+    OptionInspection, RegistryAction, RegistryMismatch, SchedulerAction, SchedulerMismatch,
+    ServiceMismatch, TweakDefinition, TweakInspection, TweakOption,
 };
-use crate::services::{registry_service, service_control};
+use crate::services::{registry_service, scheduler_service, service_control};
 use rayon::prelude::*;
 
 /// Inspect a tweak to find exact system state vs expected state for all options
@@ -53,9 +53,13 @@ fn inspect_option(
     // Check service changes
     let service_results = inspect_service_changes(option)?;
 
+    // Check scheduler changes
+    let scheduler_results = inspect_scheduler_changes(option)?;
+
     // Determine if everything matches
-    let all_match =
-        registry_results.iter().all(|r| r.is_match) && service_results.iter().all(|s| s.is_match);
+    let all_match = registry_results.iter().all(|r| r.is_match)
+        && service_results.iter().all(|s| s.is_match)
+        && scheduler_results.iter().all(|s| s.is_match);
 
     Ok(OptionInspection {
         option_index: index,
@@ -64,6 +68,7 @@ fn inspect_option(
         is_pending,
         registry_results,
         service_results,
+        scheduler_results,
         all_match,
     })
 }
@@ -202,3 +207,117 @@ fn inspect_service_changes(option: &TweakOption) -> Result<Vec<ServiceMismatch>,
 
     Ok(results)
 }
+
+fn inspect_scheduler_changes(option: &TweakOption) -> Result<Vec<SchedulerMismatch>, Error> {
+    let mut results = Vec::new();
+
+    for change in &option.scheduler_changes {
+        // Handle pattern-based task matching
+        if let Some(pattern) = &change.task_name_pattern {
+            // For patterns, we need to list matching tasks and check each one
+            let matching_tasks =
+                scheduler_service::find_tasks_by_pattern(&change.task_path, pattern)
+                    .unwrap_or_default();
+
+            if matching_tasks.is_empty() && change.ignore_not_found {
+                // Skip if no tasks found and ignore_not_found is true
+                continue;
+            }
+
+            for task_info in matching_tasks {
+                let actual_state = match &task_info.state {
+                    scheduler_service::TaskState::Ready => Some("Ready".to_string()),
+                    scheduler_service::TaskState::Disabled => Some("Disabled".to_string()),
+                    scheduler_service::TaskState::Running => Some("Running".to_string()),
+                    scheduler_service::TaskState::NotFound => None,
+                    scheduler_service::TaskState::Unknown(s) => Some(s.clone()),
+                };
+
+                let (expected_state, is_match) = match change.action {
+                    SchedulerAction::Enable => {
+                        let expected = "Ready";
+                        let matches = matches!(
+                            task_info.state,
+                            scheduler_service::TaskState::Ready
+                                | scheduler_service::TaskState::Running
+                        );
+                        (expected, matches)
+                    }
+                    SchedulerAction::Disable => {
+                        let expected = "Disabled";
+                        let matches =
+                            matches!(task_info.state, scheduler_service::TaskState::Disabled);
+                        (expected, matches)
+                    }
+                    SchedulerAction::Delete => {
+                        let expected = "Deleted";
+                        let matches =
+                            matches!(task_info.state, scheduler_service::TaskState::NotFound);
+                        (expected, matches)
+                    }
+                };
+
+                results.push(SchedulerMismatch {
+                    task_path: change.task_path.clone(),
+                    task_name: task_info.name,
+                    expected_state: expected_state.to_string(),
+                    actual_state,
+                    description: format!("{:?} task (pattern: {})", change.action, pattern),
+                    is_match,
+                });
+            }
+        } else if let Some(task_name) = &change.task_name {
+            // Single task inspection
+            let task_state = scheduler_service::get_task_state(&change.task_path, task_name)
+                .unwrap_or(scheduler_service::TaskState::Unknown("Error".to_string()));
+
+            // Handle not found case
+            if matches!(task_state, scheduler_service::TaskState::NotFound)
+                && change.ignore_not_found
+            {
+                continue;
+            }
+
+            let actual_state = match &task_state {
+                scheduler_service::TaskState::Ready => Some("Ready".to_string()),
+                scheduler_service::TaskState::Disabled => Some("Disabled".to_string()),
+                scheduler_service::TaskState::Running => Some("Running".to_string()),
+                scheduler_service::TaskState::NotFound => None,
+                scheduler_service::TaskState::Unknown(s) => Some(s.clone()),
+            };
+
+            let (expected_state, is_match) = match change.action {
+                SchedulerAction::Enable => {
+                    let expected = "Ready";
+                    let matches = matches!(
+                        task_state,
+                        scheduler_service::TaskState::Ready | scheduler_service::TaskState::Running
+                    );
+                    (expected, matches)
+                }
+                SchedulerAction::Disable => {
+                    let expected = "Disabled";
+                    let matches = matches!(task_state, scheduler_service::TaskState::Disabled);
+                    (expected, matches)
+                }
+                SchedulerAction::Delete => {
+                    let expected = "Deleted";
+                    let matches = matches!(task_state, scheduler_service::TaskState::NotFound);
+                    (expected, matches)
+                }
+            };
+
+            results.push(SchedulerMismatch {
+                task_path: change.task_path.clone(),
+                task_name: task_name.clone(),
+                expected_state: expected_state.to_string(),
+                actual_state,
+                description: format!("{:?} task", change.action),
+                is_match,
+            });
+        }
+        // If neither task_name nor task_name_pattern is set, skip this change
+    }
+
+    Ok(results)
+}

src/lib/api/tweaks.ts

@@ -142,6 +142,7 @@ export interface BackupInfo {
   windows_version: number;
   registry_values_count: number;
   service_snapshots_count: number;
+  scheduler_snapshots_count: number;
 }
 
 /**

src/lib/components/TweakDetailsModal.svelte

@@ -98,15 +98,16 @@
 
     const matchedOption = inspection.options.find((o) => o.all_match);
     const totalChecks = inspection.options.reduce(
-      (sum, o) => sum + o.registry_results.length + o.service_results.length,
+      (sum, o) => sum + o.registry_results.length + o.service_results.length + o.scheduler_results.length,
       0,
     );
 
     // Count mismatches for the current/pending option or first option
     const relevantOption = inspection.options.find((o) => o.is_current || o.is_pending) ?? inspection.options[0];
     const mismatches = relevantOption
       ? relevantOption.registry_results.filter((r) => !r.is_match).length +
-        relevantOption.service_results.filter((s) => !s.is_match).length
+        relevantOption.service_results.filter((s) => !s.is_match).length +
+        relevantOption.scheduler_results.filter((s) => !s.is_match).length
       : 0;
 
     return {
@@ -333,7 +334,31 @@
                     </div>
                   {/each}
 
-                  {#if opt.registry_results.length === 0 && opt.service_results.length === 0}
+                  {#each opt.scheduler_results as task}
+                    <div class="flex items-start gap-2 rounded-lg px-2 py-1.5 {task.is_match ? '' : 'bg-error/5'}">
+                      <Icon
+                        icon={task.is_match ? "mdi:check-circle" : "mdi:close-circle"}
+                        width="14"
+                        class="mt-0.5 shrink-0 {task.is_match ? 'text-success' : 'text-error'}"
+                      />
+                      <div class="min-w-0 flex-1 text-xs">
+                        <div class="font-medium text-foreground">Task: {task.task_name}</div>
+                        <div class="truncate text-[10px] text-foreground-muted/70">{task.task_path}</div>
+                        {#if !task.is_match}
+                          <div class="mt-1 flex gap-4 font-mono text-[11px]">
+                            <span class="text-foreground-muted">
+                              Expected: <span class="text-success">{task.expected_state}</span>
+                            </span>
+                            <span class="text-foreground-muted">
+                              Actual: <span class="text-error">{task.actual_state ?? "Not Found"}</span>
+                            </span>
+                          </div>
+                        {/if}
+                      </div>
+                    </div>
+                  {/each}
+
+                  {#if opt.registry_results.length === 0 && opt.service_results.length === 0 && opt.scheduler_results.length === 0}
                     <div class="px-2 py-1.5 text-xs text-foreground-muted italic">
                       No detectable changes for this Windows version
                     </div>
@@ -363,9 +388,13 @@
               — {snapshotInfo.registry_values_count} registry
               {snapshotInfo.registry_values_count === 1 ? "value" : "values"}
               {#if snapshotInfo.service_snapshots_count > 0}
-                and {snapshotInfo.service_snapshots_count}
+                , {snapshotInfo.service_snapshots_count}
                 {snapshotInfo.service_snapshots_count === 1 ? "service" : "services"}
               {/if}
+              {#if snapshotInfo.scheduler_snapshots_count > 0}
+                , {snapshotInfo.scheduler_snapshots_count}
+                {snapshotInfo.scheduler_snapshots_count === 1 ? "task" : "tasks"}
+              {/if}
               captured
             </span>
           </div>

src/lib/types/index.ts

@@ -177,13 +177,23 @@ export interface ServiceMismatch {
   is_match: boolean;
 }
 
+export interface SchedulerMismatch {
+  task_path: string;
+  task_name: string;
+  expected_state: string;
+  actual_state?: string;
+  description: string;
+  is_match: boolean;
+}
+
 export interface OptionInspection {
   option_index: number;
   label: string;
   is_current: boolean;
   is_pending: boolean;
   registry_results: RegistryMismatch[];
   service_results: ServiceMismatch[];
+  scheduler_results: SchedulerMismatch[];
   all_match: boolean;
 }