refactor(desktop): split kernel_commands/pipeline_commands into modules, add SaaS client libs and gateway modules

Split monolithic kernel_commands.rs (2185 lines) and pipeline_commands.rs (1391 lines)
into focused sub-modules under kernel_commands/ and pipeline_commands/ directories.
Add gateway module (commands, config, io, runtime), health_check, and 15 new
TypeScript client libraries for SaaS relay, auth, admin, telemetry, and kernel
sub-systems (a2a, agent, chat, hands, skills, triggers).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

desktop/src-tauri/src/kernel_commands/scheduled_task.rs

@@ -0,0 +1,124 @@
+//! Scheduled task commands
+//!
+//! Tasks are backed by kernel triggers (Schedule type).
+//! The SchedulerService checks every 60 seconds for due triggers.
+
+use serde::{Deserialize, Serialize};
+use tauri::State;
+
+use super::KernelState;
+
+// ============================================================
+// Scheduled Task Commands
+// ============================================================
+
+/// Request to create a scheduled task (maps to kernel trigger)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateScheduledTaskRequest {
+    pub name: String,
+    pub schedule: String,
+    pub schedule_type: String,
+    pub target: Option<ScheduledTaskTarget>,
+    pub description: Option<String>,
+    pub enabled: Option<bool>,
+}
+
+/// Target for a scheduled task
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScheduledTaskTarget {
+    #[serde(rename = "type")]
+    pub target_type: String,
+    pub id: String,
+}
+
+/// Response for scheduled task creation
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScheduledTaskResponse {
+    pub id: String,
+    pub name: String,
+    pub schedule: String,
+    pub status: String,
+}
+
+/// Create a scheduled task (backed by kernel TriggerManager)
+///
+/// Tasks are automatically executed by the SchedulerService which checks
+/// every 60 seconds for due triggers.
+#[tauri::command]
+pub async fn scheduled_task_create(
+    state: State<'_, KernelState>,
+    request: CreateScheduledTaskRequest,
+) -> Result<ScheduledTaskResponse, String> {
+    let kernel_lock = state.lock().await;
+    let kernel = kernel_lock.as_ref()
+        .ok_or_else(|| "Kernel not initialized".to_string())?;
+
+    // Build TriggerConfig from request
+    let trigger_type = match request.schedule_type.as_str() {
+        "cron" | "schedule" => zclaw_hands::TriggerType::Schedule {
+            cron: request.schedule.clone(),
+        },
+        "interval" => zclaw_hands::TriggerType::Schedule {
+            cron: request.schedule.clone(), // interval as simplified cron
+        },
+        "once" => zclaw_hands::TriggerType::Schedule {
+            cron: request.schedule.clone(),
+        },
+        _ => return Err(format!("Unsupported schedule type: {}", request.schedule_type)),
+    };
+
+    let target_id = request.target.as_ref().map(|t| t.id.clone()).unwrap_or_default();
+    let task_id = format!("sched_{}", chrono::Utc::now().timestamp_millis());
+
+    let config = zclaw_hands::TriggerConfig {
+        id: task_id.clone(),
+        name: request.name.clone(),
+        hand_id: target_id,
+        trigger_type,
+        enabled: request.enabled.unwrap_or(true),
+        max_executions_per_hour: 60,
+    };
+
+    let entry = kernel.create_trigger(config).await
+        .map_err(|e| format!("Failed to create scheduled task: {}", e))?;
+
+    Ok(ScheduledTaskResponse {
+        id: entry.config.id,
+        name: entry.config.name,
+        schedule: request.schedule,
+        status: "active".to_string(),
+    })
+}
+
+/// List all scheduled tasks (kernel triggers of Schedule type)
+#[tauri::command]
+pub async fn scheduled_task_list(
+    state: State<'_, KernelState>,
+) -> Result<Vec<ScheduledTaskResponse>, String> {
+    let kernel_lock = state.lock().await;
+    let kernel = kernel_lock.as_ref()
+        .ok_or_else(|| "Kernel not initialized".to_string())?;
+
+    let triggers = kernel.list_triggers().await;
+    let tasks: Vec<ScheduledTaskResponse> = triggers
+        .into_iter()
+        .filter(|t| matches!(t.config.trigger_type, zclaw_hands::TriggerType::Schedule { .. }))
+        .map(|t| {
+            let schedule = match t.config.trigger_type {
+                zclaw_hands::TriggerType::Schedule { cron } => cron,
+                _ => String::new(),
+            };
+            ScheduledTaskResponse {
+                id: t.config.id,
+                name: t.config.name,
+                schedule,
+                status: if t.config.enabled { "active".to_string() } else { "paused".to_string() },
+            }
+        })
+        .collect();
+
+    Ok(tasks)
+}