Phase 10: Command Scheduler

Added comprehensive command scheduling system:

Backend:
- New scheduled_commands database table
- Scheduler processor runs every minute
- Support for three schedule types: interval, hourly, daily
- calculateNextRun() function for intelligent scheduling
- API endpoints: GET, POST, PUT (toggle), DELETE
- Executions automatically created and tracked
- Enable/disable schedules without deleting

Frontend:
- New Scheduler tab in navigation
- Create Schedule modal with worker selection
- Dynamic schedule input based on type
- Schedule list showing status, next/last run times
- Enable/Disable toggle for each schedule
- Delete schedule functionality
- Terminal-themed scheduler UI
- Integration with existing worker and execution systems

Schedule Types:
- Interval: Every X minutes (e.g., 30 for every 30 min)
- Hourly: Every X hours (e.g., 2 for every 2 hours)
- Daily: At specific time (e.g., 03:00 for 3 AM daily)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

public/index.html

@@ -770,6 +770,7 @@
             <button class="tab" onclick="switchTab('workflows')">📋 Workflows</button>
             <button class="tab" onclick="switchTab('executions')">🚀 Executions</button>
             <button class="tab" onclick="switchTab('quickcommand')">⚡ Quick Command</button>
+            <button class="tab" onclick="switchTab('scheduler')">⏰ Scheduler</button>
         </div>
 
         <!-- Dashboard Tab -->
@@ -809,8 +810,46 @@
         <div id="executions" class="tab-content">
             <div class="card">
                 <h3>Execution History</h3>
+
+                <!-- Search and Filter Section -->
+                <div style="background: rgba(0, 255, 65, 0.05); border: 2px solid var(--terminal-green); padding: 15px; margin-bottom: 20px;">
+                    <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 15px;">
+                        <!-- Search Box -->
+                        <div>
+                            <label style="display: block; margin-bottom: 8px; font-weight: 600; color: var(--terminal-amber);">🔍 Search:</label>
+                            <input type="text" id="executionSearch" placeholder="Search by command, execution ID, or workflow name..."
+                                   oninput="filterExecutions()"
+                                   style="width: 100%; padding: 10px; margin: 0;">
+                        </div>
+
+                        <!-- Status Filter -->
+                        <div>
+                            <label style="display: block; margin-bottom: 8px; font-weight: 600; color: var(--terminal-amber);">📊 Status Filter:</label>
+                            <select id="statusFilter" onchange="filterExecutions()" style="width: 100%; padding: 10px; margin: 0;">
+                                <option value="">All Statuses</option>
+                                <option value="running">Running</option>
+                                <option value="completed">Completed</option>
+                                <option value="failed">Failed</option>
+                                <option value="waiting">Waiting</option>
+                            </select>
+                        </div>
+                    </div>
+
+                    <div style="display: flex; gap: 10px; align-items: center;">
+                        <button onclick="clearFilters()" class="small">[ Clear Filters ]</button>
+                        <span id="filterStats" style="color: var(--terminal-green); font-size: 0.9em; font-family: var(--font-mono);"></span>
+                    </div>
+                </div>
+
                 <button onclick="refreshData()">[ 🔄 Refresh ]</button>
                 <button onclick="clearCompletedExecutions()" style="margin-left: 10px;">[ 🗑️ Clear Completed ]</button>
+                <button onclick="toggleCompareMode()" id="compareModeBtn" style="margin-left: 10px;">[ 📊 Compare Mode ]</button>
+                <button onclick="compareSelectedExecutions()" id="compareBtn" style="margin-left: 10px; display: none;">[ ⚖️ Compare Selected ]</button>
+
+                <div id="compareInstructions" style="display: none; background: rgba(255, 176, 0, 0.1); border: 2px solid var(--terminal-amber); padding: 12px; margin: 15px 0; color: var(--terminal-amber);">
+                    Select 2-5 executions to compare their outputs. Click executions to toggle selection.
+                </div>
+
                 <div id="executionList"><div class="loading">Loading...</div></div>
             </div>
         </div>
@@ -865,6 +904,19 @@
                 <div id="quickCommandResult" style="margin-top: 20px;"></div>
             </div>
         </div>
+
+        <!-- Scheduler Tab -->
+        <div id="scheduler" class="tab-content">
+            <div class="card">
+                <h3>⏰ Scheduled Commands</h3>
+                <p style="color: var(--terminal-green); margin-bottom: 20px;">Automate command execution with flexible scheduling</p>
+
+                <button onclick="showCreateSchedule()">[ ➕ Create Schedule ]</button>
+                <button onclick="refreshData()" style="margin-left: 10px;">[ 🔄 Refresh ]</button>
+
+                <div id="scheduleList" style="margin-top: 20px;"><div class="loading">Loading...</div></div>
+            </div>
+        </div>
     </div>
 
     <!-- Create Workflow Modal -->
@@ -916,10 +968,57 @@
         </div>
     </div>
 
+    <!-- Compare Executions Modal -->
+    <div id="compareExecutionsModal" class="modal">
+        <div class="modal-content" style="max-width: 90%; max-height: 90vh;">
+            <h2>⚖️ Execution Comparison</h2>
+            <div id="compareContent" style="max-height: 70vh; overflow-y: auto; padding: 20px;"></div>
+            <button onclick="closeModal('compareExecutionsModal')">[ Close ]</button>
+        </div>
+    </div>
+
+    <!-- Create Schedule Modal -->
+    <div id="createScheduleModal" class="modal">
+        <div class="modal-content">
+            <h2>Create Scheduled Command</h2>
+
+            <label style="display: block; margin-bottom: 8px; font-weight: 600;">Schedule Name:</label>
+            <input type="text" id="scheduleName" placeholder="e.g., Daily System Check">
+
+            <label style="display: block; margin-bottom: 8px; margin-top: 15px; font-weight: 600;">Command:</label>
+            <textarea id="scheduleCommand" placeholder="Enter command to execute"></textarea>
+
+            <label style="display: block; margin-bottom: 8px; margin-top: 15px; font-weight: 600;">Target Workers:</label>
+            <div id="scheduleWorkerList" style="background: var(--bg-primary); border: 2px solid var(--terminal-green); padding: 15px; margin-bottom: 15px; max-height: 150px; overflow-y: auto;">
+                <div class="loading">Loading workers...</div>
+            </div>
+
+            <label style="display: block; margin-bottom: 8px; margin-top: 15px; font-weight: 600;">Schedule Type:</label>
+            <select id="scheduleType" onchange="updateScheduleInput()">
+                <option value="interval">Every X Minutes</option>
+                <option value="hourly">Every X Hours</option>
+                <option value="daily">Daily at Time</option>
+            </select>
+
+            <div id="scheduleInputContainer" style="margin-top: 15px;">
+                <label style="display: block; margin-bottom: 8px; font-weight: 600;">Interval (minutes):</label>
+                <input type="number" id="scheduleValue" placeholder="e.g., 30" min="1">
+            </div>
+
+            <div style="margin-top: 20px;">
+                <button onclick="createSchedule()">[ Create Schedule ]</button>
+                <button onclick="closeModal('createScheduleModal')" style="margin-left: 10px;">[ Cancel ]</button>
+            </div>
+        </div>
+    </div>
+
     <script>
         let currentUser = null;
         let ws = null;
         let workers = [];
+        let allExecutions = []; // Store all loaded executions for filtering
+        let compareMode = false;
+        let selectedExecutions = [];
 
         async function loadUser() {
             try {
@@ -1047,7 +1146,7 @@
             try {
                 const response = await fetch('/api/workflows');
                 const workflows = await response.json();
-                
+
                 const html = workflows.length === 0 ?
                     '<div class="empty">No workflows defined yet</div>' :
                     workflows.map(w => `
@@ -1057,8 +1156,8 @@
                             <div class="timestamp">Created by ${w.created_by || 'Unknown'} on ${new Date(w.created_at).toLocaleString()}</div>
                             <div style="margin-top: 10px;">
                                 <button onclick="executeWorkflow('${w.id}', '${w.name}')">▶️ Execute</button>
-                                ${currentUser && currentUser.isAdmin ? 
+                                ${currentUser && currentUser.isAdmin ?
-                                    `<button class="danger" onclick="deleteWorkflow('${w.id}', '${w.name}')">🗑️ Delete</button>` 
+                                    `<button class="danger" onclick="deleteWorkflow('${w.id}', '${w.name}')">🗑️ Delete</button>`
                                     : ''}
                             </div>
                         </div>
@@ -1069,6 +1168,194 @@
             }
         }
 
+        async function loadSchedules() {
+            try {
+                const response = await fetch('/api/scheduled-commands');
+                const schedules = await response.json();
+
+                const html = schedules.length === 0 ?
+                    '<div class="empty">No scheduled commands yet</div>' :
+                    schedules.map(s => {
+                        const workerIds = JSON.parse(s.worker_ids);
+                        const workerNames = workerIds.map(id => {
+                            const w = workers.find(worker => worker.id === id);
+                            return w ? w.name : id.substring(0, 8);
+                        }).join(', ');
+
+                        let scheduleDesc = '';
+                        if (s.schedule_type === 'interval') {
+                            scheduleDesc = `Every ${s.schedule_value} minutes`;
+                        } else if (s.schedule_type === 'hourly') {
+                            scheduleDesc = `Every ${s.schedule_value} hour(s)`;
+                        } else if (s.schedule_type === 'daily') {
+                            scheduleDesc = `Daily at ${s.schedule_value}`;
+                        }
+
+                        const nextRun = s.next_run ? new Date(s.next_run).toLocaleString() : 'Not scheduled';
+                        const lastRun = s.last_run ? new Date(s.last_run).toLocaleString() : 'Never';
+
+                        return `
+                            <div class="workflow-item" style="opacity: ${s.enabled ? 1 : 0.6};">
+                                <div style="display: flex; justify-content: space-between; align-items: start;">
+                                    <div style="flex: 1;">
+                                        <div class="workflow-name">${s.name}</div>
+                                        <div style="color: var(--terminal-green); font-family: var(--font-mono); font-size: 0.9em; margin: 8px 0;">
+                                            Command: <code>${escapeHtml(s.command)}</code>
+                                        </div>
+                                        <div style="color: var(--terminal-amber); font-size: 0.9em; margin-bottom: 5px;">
+                                            📅 ${scheduleDesc}
+                                        </div>
+                                        <div style="color: var(--text-muted); font-size: 0.85em;">
+                                            Workers: ${workerNames}
+                                        </div>
+                                        <div class="timestamp">
+                                            Last run: ${lastRun} | Next run: ${nextRun}
+                                        </div>
+                                    </div>
+                                    <div style="margin-left: 15px;">
+                                        <span class="status ${s.enabled ? 'online' : 'offline'}" style="font-size: 0.85em;">
+                                            ${s.enabled ? 'ENABLED' : 'DISABLED'}
+                                        </span>
+                                    </div>
+                                </div>
+                                <div style="margin-top: 10px;">
+                                    <button onclick="toggleSchedule('${s.id}')" class="small">
+                                        ${s.enabled ? '⏸️ Disable' : '▶️ Enable'}
+                                    </button>
+                                    <button class="danger small" onclick="deleteSchedule('${s.id}', '${s.name}')">🗑️ Delete</button>
+                                </div>
+                            </div>
+                        `;
+                    }).join('');
+
+                document.getElementById('scheduleList').innerHTML = html;
+            } catch (error) {
+                console.error('Error loading schedules:', error);
+            }
+        }
+
+        function showCreateSchedule() {
+            // Populate worker checkboxes
+            const workerList = document.getElementById('scheduleWorkerList');
+            workerList.innerHTML = workers.length === 0 ?
+                '<div class="empty">No workers available</div>' :
+                workers.map(w => `
+                    <label style="display: block; margin-bottom: 10px; cursor: pointer; padding: 8px; border: 1px solid var(--terminal-green);">
+                        <input type="checkbox" name="scheduleWorkerCheckbox" value="${w.id}" style="width: auto; margin-right: 8px;">
+                        <span class="status ${w.status}" style="padding: 2px 8px; font-size: 0.8em;">[${w.status === 'online' ? '●' : '○'}]</span>
+                        <strong>${w.name}</strong>
+                    </label>
+                `).join('');
+
+            document.getElementById('createScheduleModal').classList.add('show');
+        }
+
+        function updateScheduleInput() {
+            const scheduleType = document.getElementById('scheduleType').value;
+            const container = document.getElementById('scheduleInputContainer');
+
+            if (scheduleType === 'interval') {
+                container.innerHTML = `
+                    <label style="display: block; margin-bottom: 8px; font-weight: 600;">Interval (minutes):</label>
+                    <input type="number" id="scheduleValue" placeholder="e.g., 30" min="1">
+                `;
+            } else if (scheduleType === 'hourly') {
+                container.innerHTML = `
+                    <label style="display: block; margin-bottom: 8px; font-weight: 600;">Every X Hours:</label>
+                    <input type="number" id="scheduleValue" placeholder="e.g., 2" min="1" max="24">
+                `;
+            } else if (scheduleType === 'daily') {
+                container.innerHTML = `
+                    <label style="display: block; margin-bottom: 8px; font-weight: 600;">Time (HH:MM):</label>
+                    <input type="time" id="scheduleValue">
+                `;
+            }
+        }
+
+        async function createSchedule() {
+            const name = document.getElementById('scheduleName').value;
+            const command = document.getElementById('scheduleCommand').value;
+            const scheduleType = document.getElementById('scheduleType').value;
+            const scheduleValue = document.getElementById('scheduleValue').value;
+
+            const selectedWorkers = Array.from(document.querySelectorAll('input[name="scheduleWorkerCheckbox"]:checked')).map(cb => cb.value);
+
+            if (!name || !command || !scheduleValue || selectedWorkers.length === 0) {
+                alert('Please fill in all fields and select at least one worker');
+                return;
+            }
+
+            try {
+                const response = await fetch('/api/scheduled-commands', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        name,
+                        command,
+                        worker_ids: selectedWorkers,
+                        schedule_type: scheduleType,
+                        schedule_value: scheduleValue
+                    })
+                });
+
+                if (response.ok) {
+                    closeModal('createScheduleModal');
+                    showTerminalNotification('Schedule created successfully', 'success');
+                    loadSchedules();
+
+                    // Clear form
+                    document.getElementById('scheduleName').value = '';
+                    document.getElementById('scheduleCommand').value = '';
+                    document.getElementById('scheduleValue').value = '';
+                } else {
+                    const error = await response.json();
+                    showTerminalNotification('Failed to create schedule: ' + error.error, 'error');
+                }
+            } catch (error) {
+                console.error('Error creating schedule:', error);
+                showTerminalNotification('Error creating schedule', 'error');
+            }
+        }
+
+        async function toggleSchedule(scheduleId) {
+            try {
+                const response = await fetch(`/api/scheduled-commands/${scheduleId}/toggle`, {
+                    method: 'PUT'
+                });
+
+                if (response.ok) {
+                    const data = await response.json();
+                    showTerminalNotification(`Schedule ${data.enabled ? 'enabled' : 'disabled'}`, 'success');
+                    loadSchedules();
+                } else {
+                    showTerminalNotification('Failed to toggle schedule', 'error');
+                }
+            } catch (error) {
+                console.error('Error toggling schedule:', error);
+                showTerminalNotification('Error toggling schedule', 'error');
+            }
+        }
+
+        async function deleteSchedule(scheduleId, name) {
+            if (!confirm(`Delete scheduled command: ${name}?`)) return;
+
+            try {
+                const response = await fetch(`/api/scheduled-commands/${scheduleId}`, {
+                    method: 'DELETE'
+                });
+
+                if (response.ok) {
+                    showTerminalNotification('Schedule deleted', 'success');
+                    loadSchedules();
+                } else {
+                    showTerminalNotification('Failed to delete schedule', 'error');
+                }
+            } catch (error) {
+                console.error('Error deleting schedule:', error);
+                showTerminalNotification('Error deleting schedule', 'error');
+            }
+        }
+
         let executionOffset = 0;
         const executionLimit = 50;
 
@@ -1080,6 +1367,13 @@
                 const data = await response.json();
                 const executions = data.executions || data; // Handle old and new API format
 
+                // Store executions for filtering
+                if (append) {
+                    allExecutions = allExecutions.concat(executions);
+                } else {
+                    allExecutions = executions;
+                }
+
                 // Dashboard view (always first 5)
                 if (!append) {
                     const dashHtml = executions.length === 0 ?
@@ -1094,25 +1388,8 @@
                     document.getElementById('dashExecutions').innerHTML = dashHtml;
                 }
 
-                // Full execution list
+                // Apply filters and render
-                const fullHtml = executions.length === 0 ?
+                renderFilteredExecutions();
-                    '<div class="empty">No executions yet</div>' :
-                    executions.map(e => `
-                        <div class="execution-item" onclick="viewExecution('${e.id}')">
-                            <span class="status ${e.status}">${e.status}</span>
-                            <strong>${e.workflow_name || '[Quick Command]'}</strong>
-                            <div class="timestamp">
-                                Started by ${e.started_by} at ${new Date(e.started_at).toLocaleString()}
-                                ${e.completed_at ? ` • Completed at ${new Date(e.completed_at).toLocaleString()}` : ''}
-                            </div>
-                        </div>
-                    `).join('');
-
-                if (append) {
-                    document.getElementById('executionList').innerHTML += fullHtml;
-                } else {
-                    document.getElementById('executionList').innerHTML = fullHtml;
-                }
 
                 // Add "Load More" button if there are more executions
                 if (data.hasMore) {
@@ -1125,6 +1402,290 @@
             }
         }
 
+        function renderFilteredExecutions() {
+            const searchTerm = (document.getElementById('executionSearch')?.value || '').toLowerCase();
+            const statusFilter = document.getElementById('statusFilter')?.value || '';
+
+            // Filter executions
+            let filtered = allExecutions.filter(e => {
+                // Status filter
+                if (statusFilter && e.status !== statusFilter) return false;
+
+                // Search filter (search in workflow name, execution ID, and logs)
+                if (searchTerm) {
+                    const workflowName = (e.workflow_name || '[Quick Command]').toLowerCase();
+                    const executionId = e.id.toLowerCase();
+
+                    // Try to extract command from logs if it's a quick command
+                    let commandText = '';
+                    try {
+                        const logs = typeof e.logs === 'string' ? JSON.parse(e.logs) : e.logs;
+                        if (logs && logs.length > 0 && logs[0].command) {
+                            commandText = logs[0].command.toLowerCase();
+                        }
+                    } catch (err) {
+                        // Ignore parsing errors
+                    }
+
+                    const matchFound = workflowName.includes(searchTerm) ||
+                                      executionId.includes(searchTerm) ||
+                                      commandText.includes(searchTerm);
+
+                    if (!matchFound) return false;
+                }
+
+                return true;
+            });
+
+            // Update filter stats
+            const statsEl = document.getElementById('filterStats');
+            if (statsEl) {
+                if (searchTerm || statusFilter) {
+                    statsEl.textContent = `Showing ${filtered.length} of ${allExecutions.length} executions`;
+                } else {
+                    statsEl.textContent = '';
+                }
+            }
+
+            // Render filtered results
+            const fullHtml = filtered.length === 0 ?
+                '<div class="empty">No executions match your filters</div>' :
+                filtered.map(e => {
+                    const isSelected = selectedExecutions.includes(e.id);
+                    const clickHandler = compareMode ? `toggleExecutionSelection('${e.id}')` : `viewExecution('${e.id}')`;
+                    const selectedStyle = isSelected ? 'background: rgba(255, 176, 0, 0.2); border-left-width: 5px; border-left-color: var(--terminal-amber);' : '';
+
+                    return `
+                        <div class="execution-item" onclick="${clickHandler}" style="${selectedStyle} cursor: pointer;">
+                            ${compareMode && isSelected ? '<span style="color: var(--terminal-amber); margin-right: 8px;">✓</span>' : ''}
+                            <span class="status ${e.status}">${e.status}</span>
+                            <strong>${e.workflow_name || '[Quick Command]'}</strong>
+                            <div class="timestamp">
+                                Started by ${e.started_by} at ${new Date(e.started_at).toLocaleString()}
+                                ${e.completed_at ? ` • Completed at ${new Date(e.completed_at).toLocaleString()}` : ''}
+                            </div>
+                        </div>
+                    `;
+                }).join('');
+
+            document.getElementById('executionList').innerHTML = fullHtml;
+        }
+
+        function filterExecutions() {
+            renderFilteredExecutions();
+        }
+
+        function clearFilters() {
+            document.getElementById('executionSearch').value = '';
+            document.getElementById('statusFilter').value = '';
+            renderFilteredExecutions();
+        }
+
+        function toggleCompareMode() {
+            compareMode = !compareMode;
+            selectedExecutions = [];
+
+            const btn = document.getElementById('compareModeBtn');
+            const compareBtn = document.getElementById('compareBtn');
+            const instructions = document.getElementById('compareInstructions');
+
+            if (compareMode) {
+                btn.textContent = '[ ✗ Exit Compare Mode ]';
+                btn.style.borderColor = 'var(--terminal-amber)';
+                btn.style.color = 'var(--terminal-amber)';
+                compareBtn.style.display = 'inline-block';
+                instructions.style.display = 'block';
+            } else {
+                btn.textContent = '[ 📊 Compare Mode ]';
+                btn.style.borderColor = '';
+                btn.style.color = '';
+                compareBtn.style.display = 'none';
+                instructions.style.display = 'none';
+            }
+
+            renderFilteredExecutions();
+        }
+
+        function toggleExecutionSelection(executionId) {
+            const index = selectedExecutions.indexOf(executionId);
+
+            if (index > -1) {
+                selectedExecutions.splice(index, 1);
+            } else {
+                if (selectedExecutions.length >= 5) {
+                    showTerminalNotification('Maximum 5 executions can be compared', 'error');
+                    return;
+                }
+                selectedExecutions.push(executionId);
+            }
+
+            renderFilteredExecutions();
+
+            // Update compare button text
+            const compareBtn = document.getElementById('compareBtn');
+            if (selectedExecutions.length >= 2) {
+                compareBtn.textContent = `[ ⚖️ Compare Selected (${selectedExecutions.length}) ]`;
+            } else {
+                compareBtn.textContent = '[ ⚖️ Compare Selected ]';
+            }
+        }
+
+        async function compareSelectedExecutions() {
+            if (selectedExecutions.length < 2) {
+                showTerminalNotification('Please select at least 2 executions to compare', 'error');
+                return;
+            }
+
+            // Fetch detailed data for all selected executions
+            const executionDetails = [];
+            for (const execId of selectedExecutions) {
+                try {
+                    const response = await fetch(`/api/executions/${execId}`);
+                    if (response.ok) {
+                        executionDetails.push(await response.json());
+                    }
+                } catch (error) {
+                    console.error('Error fetching execution:', error);
+                }
+            }
+
+            if (executionDetails.length < 2) {
+                showTerminalNotification('Failed to load execution details', 'error');
+                return;
+            }
+
+            // Generate comparison view
+            let comparisonHtml = '<div style="display: grid; gap: 20px;">';
+
+            // Summary table
+            comparisonHtml += `
+                <div style="background: rgba(0, 255, 65, 0.05); border: 2px solid var(--terminal-green); padding: 15px;">
+                    <h3 style="margin-top: 0; color: var(--terminal-amber);">Comparison Summary</h3>
+                    <table style="width: 100%; border-collapse: collapse; font-family: var(--font-mono); font-size: 0.9em;">
+                        <thead>
+                            <tr style="border-bottom: 2px solid var(--terminal-green);">
+                                <th style="text-align: left; padding: 8px; color: var(--terminal-amber);">Execution</th>
+                                <th style="text-align: left; padding: 8px; color: var(--terminal-amber);">Status</th>
+                                <th style="text-align: left; padding: 8px; color: var(--terminal-amber);">Started</th>
+                                <th style="text-align: left; padding: 8px; color: var(--terminal-amber);">Duration</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            ${executionDetails.map((exec, idx) => {
+                                const duration = exec.completed_at ?
+                                    Math.round((new Date(exec.completed_at) - new Date(exec.started_at)) / 1000) + 's' :
+                                    'Running...';
+                                return `
+                                    <tr style="border-bottom: 1px solid #003300;">
+                                        <td style="padding: 8px; color: var(--terminal-green);">Execution ${idx + 1}</td>
+                                        <td style="padding: 8px;"><span class="status ${exec.status}" style="font-size: 0.85em;">${exec.status}</span></td>
+                                        <td style="padding: 8px; color: var(--terminal-green);">${new Date(exec.started_at).toLocaleString()}</td>
+                                        <td style="padding: 8px; color: var(--terminal-green);">${duration}</td>
+                                    </tr>
+                                `;
+                            }).join('')}
+                        </tbody>
+                    </table>
+                </div>
+            `;
+
+            // Side-by-side output comparison
+            comparisonHtml += `
+                <div style="background: rgba(0, 255, 65, 0.05); border: 2px solid var(--terminal-green); padding: 15px;">
+                    <h3 style="margin-top: 0; color: var(--terminal-amber);">Output Comparison</h3>
+                    <div style="display: grid; grid-template-columns: repeat(${executionDetails.length}, 1fr); gap: 15px;">
+                        ${executionDetails.map((exec, idx) => {
+                            const logs = typeof exec.logs === 'string' ? JSON.parse(exec.logs) : exec.logs;
+                            const resultLog = logs.find(l => l.action === 'command_result');
+                            const stdout = resultLog?.stdout || 'No output';
+                            const stderr = resultLog?.stderr || '';
+
+                            return `
+                                <div style="border: 2px solid var(--terminal-green); background: #000;">
+                                    <div style="background: var(--bg-secondary); padding: 10px; border-bottom: 2px solid var(--terminal-green);">
+                                        <strong style="color: var(--terminal-amber);">Execution ${idx + 1}</strong>
+                                        <div style="font-size: 0.85em; color: var(--terminal-green);">
+                                            ${exec.workflow_name || '[Quick Command]'}
+                                        </div>
+                                    </div>
+                                    <div style="padding: 12px;">
+                                        ${stdout ? `
+                                            <div style="margin-bottom: 10px;">
+                                                <div style="color: var(--terminal-amber); font-weight: bold; margin-bottom: 5px;">STDOUT:</div>
+                                                <pre style="margin: 0; color: var(--terminal-green); font-size: 0.85em; max-height: 400px; overflow-y: auto; white-space: pre-wrap;">${escapeHtml(stdout)}</pre>
+                                            </div>
+                                        ` : ''}
+                                        ${stderr ? `
+                                            <div>
+                                                <div style="color: #ff4444; font-weight: bold; margin-bottom: 5px;">STDERR:</div>
+                                                <pre style="margin: 0; color: #ff4444; font-size: 0.85em; max-height: 200px; overflow-y: auto; white-space: pre-wrap;">${escapeHtml(stderr)}</pre>
+                                            </div>
+                                        ` : ''}
+                                    </div>
+                                </div>
+                            `;
+                        }).join('')}
+                    </div>
+                </div>
+            `;
+
+            // Diff analysis (simple line-by-line comparison for 2 executions)
+            if (executionDetails.length === 2) {
+                const logs1 = typeof executionDetails[0].logs === 'string' ? JSON.parse(executionDetails[0].logs) : executionDetails[0].logs;
+                const logs2 = typeof executionDetails[1].logs === 'string' ? JSON.parse(executionDetails[1].logs) : executionDetails[1].logs;
+
+                const result1 = logs1.find(l => l.action === 'command_result');
+                const result2 = logs2.find(l => l.action === 'command_result');
+
+                const stdout1 = result1?.stdout || '';
+                const stdout2 = result2?.stdout || '';
+
+                const lines1 = stdout1.split('\n');
+                const lines2 = stdout2.split('\n');
+                const maxLines = Math.max(lines1.length, lines2.length);
+
+                let diffLines = [];
+                let identicalCount = 0;
+                let differentCount = 0;
+
+                for (let i = 0; i < maxLines; i++) {
+                    const line1 = lines1[i] || '';
+                    const line2 = lines2[i] || '';
+
+                    if (line1 === line2) {
+                        identicalCount++;
+                        diffLines.push(`<div style="color: #666; padding: 2px;">${i+1}: ${escapeHtml(line1) || '(empty)'}</div>`);
+                    } else {
+                        differentCount++;
+                        diffLines.push(`
+                            <div style="background: rgba(255, 176, 0, 0.1); border-left: 3px solid var(--terminal-amber); padding: 2px; margin: 2px 0;">
+                                <div style="color: var(--terminal-green);">${i+1} [Exec 1]: ${escapeHtml(line1) || '(empty)'}</div>
+                                <div style="color: var(--terminal-amber);">${i+1} [Exec 2]: ${escapeHtml(line2) || '(empty)'}</div>
+                            </div>
+                        `);
+                    }
+                }
+
+                comparisonHtml += `
+                    <div style="background: rgba(0, 255, 65, 0.05); border: 2px solid var(--terminal-green); padding: 15px;">
+                        <h3 style="margin-top: 0; color: var(--terminal-amber);">Diff Analysis</h3>
+                        <div style="margin-bottom: 10px; font-family: var(--font-mono); font-size: 0.9em;">
+                            <span style="color: var(--terminal-green);">✓ Identical lines: ${identicalCount}</span> |
+                            <span style="color: var(--terminal-amber);">≠ Different lines: ${differentCount}</span>
+                        </div>
+                        <div style="background: #000; border: 2px solid var(--terminal-green); padding: 10px; max-height: 400px; overflow-y: auto; font-family: var(--font-mono); font-size: 0.85em;">
+                            ${diffLines.join('')}
+                        </div>
+                    </div>
+                `;
+            }
+
+            comparisonHtml += '</div>';
+
+            document.getElementById('compareContent').innerHTML = comparisonHtml;
+            document.getElementById('compareExecutionsModal').classList.add('show');
+        }
+
         async function loadMoreExecutions() {
             executionOffset += executionLimit;
             await loadExecutions(true);
@@ -1729,6 +2290,7 @@
             loadWorkers();
             loadWorkflows();
             loadExecutions();
+            loadSchedules();
         }
 
         // Terminal beep sound (Web Audio API)

server.js

@@ -89,6 +89,24 @@ async function initDatabase() {
       )
     `);
 
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS scheduled_commands (
+        id VARCHAR(36) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        command TEXT NOT NULL,
+        worker_ids JSON NOT NULL,
+        schedule_type VARCHAR(50) NOT NULL,
+        schedule_value VARCHAR(255) NOT NULL,
+        enabled BOOLEAN DEFAULT TRUE,
+        created_by VARCHAR(255),
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        last_run TIMESTAMP NULL,
+        next_run TIMESTAMP NULL,
+        INDEX idx_enabled (enabled),
+        INDEX idx_next_run (next_run)
+      )
+    `);
+
     console.log('Database tables initialized successfully');
   } catch (error) {
     console.error('Database initialization error:', error);
@@ -119,6 +137,95 @@ setInterval(cleanupOldExecutions, 24 * 60 * 60 * 1000);
 // Run cleanup on startup
 cleanupOldExecutions();
 
+// Scheduled Commands Processor
+async function processScheduledCommands() {
+  try {
+    const [schedules] = await pool.query(
+      `SELECT * FROM scheduled_commands
+       WHERE enabled = TRUE
+       AND (next_run IS NULL OR next_run <= NOW())`
+    );
+
+    for (const schedule of schedules) {
+      console.log(`[Scheduler] Running scheduled command: ${schedule.name}`);
+
+      const workerIds = JSON.parse(schedule.worker_ids);
+
+      // Execute command on each worker
+      for (const workerId of workerIds) {
+        const workerWs = workers.get(workerId);
+        if (workerWs && workerWs.readyState === WebSocket.OPEN) {
+          const executionId = generateUUID();
+
+          // Create execution record
+          await pool.query(
+            'INSERT INTO executions (id, workflow_id, status, started_by, started_at, logs) VALUES (?, ?, ?, ?, NOW(), ?)',
+            [executionId, null, 'running', `scheduler:${schedule.name}`, JSON.stringify([{
+              step: 'scheduled_command',
+              action: 'command_sent',
+              worker_id: workerId,
+              command: schedule.command,
+              timestamp: new Date().toISOString()
+            }])]
+          );
+
+          // Send command to worker
+          workerWs.send(JSON.stringify({
+            type: 'execute_command',
+            execution_id: executionId,
+            command: schedule.command,
+            worker_id: workerId,
+            timeout: 300000 // 5 minute timeout for scheduled commands
+          }));
+
+          broadcast({ type: 'execution_started', execution_id: executionId, workflow_id: null });
+        }
+      }
+
+      // Update last_run and calculate next_run
+      const nextRun = calculateNextRun(schedule.schedule_type, schedule.schedule_value);
+      await pool.query(
+        'UPDATE scheduled_commands SET last_run = NOW(), next_run = ? WHERE id = ?',
+        [nextRun, schedule.id]
+      );
+    }
+  } catch (error) {
+    console.error('[Scheduler] Error processing scheduled commands:', error);
+  }
+}
+
+function calculateNextRun(scheduleType, scheduleValue) {
+  const now = new Date();
+
+  if (scheduleType === 'interval') {
+    // Interval in minutes
+    const minutes = parseInt(scheduleValue);
+    return new Date(now.getTime() + minutes * 60000);
+  } else if (scheduleType === 'daily') {
+    // Daily at HH:MM
+    const [hours, minutes] = scheduleValue.split(':').map(Number);
+    const next = new Date(now);
+    next.setHours(hours, minutes, 0, 0);
+
+    // If time has passed today, schedule for tomorrow
+    if (next <= now) {
+      next.setDate(next.getDate() + 1);
+    }
+    return next;
+  } else if (scheduleType === 'hourly') {
+    // Every N hours
+    const hours = parseInt(scheduleValue);
+    return new Date(now.getTime() + hours * 3600000);
+  }
+
+  return null;
+}
+
+// Run scheduler every minute
+setInterval(processScheduledCommands, 60 * 1000);
+// Initial run on startup
+setTimeout(processScheduledCommands, 5000);
+
 // WebSocket connections
 const clients = new Set();
 const workers = new Map(); // Map worker_id -> WebSocket connection
@@ -464,6 +571,70 @@ app.delete('/api/executions/:id', authenticateSSO, async (req, res) => {
   }
 });
 
+// Scheduled Commands API
+app.get('/api/scheduled-commands', authenticateSSO, async (req, res) => {
+  try {
+    const [schedules] = await pool.query(
+      'SELECT * FROM scheduled_commands ORDER BY created_at DESC'
+    );
+    res.json(schedules);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.post('/api/scheduled-commands', authenticateSSO, async (req, res) => {
+  try {
+    const { name, command, worker_ids, schedule_type, schedule_value } = req.body;
+
+    if (!name || !command || !worker_ids || !schedule_type || !schedule_value) {
+      return res.status(400).json({ error: 'Missing required fields' });
+    }
+
+    const id = generateUUID();
+    const nextRun = calculateNextRun(schedule_type, schedule_value);
+
+    await pool.query(
+      `INSERT INTO scheduled_commands
+       (id, name, command, worker_ids, schedule_type, schedule_value, created_by, next_run)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [id, name, command, JSON.stringify(worker_ids), schedule_type, schedule_value, req.user.username, nextRun]
+    );
+
+    res.json({ success: true, id });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.put('/api/scheduled-commands/:id/toggle', authenticateSSO, async (req, res) => {
+  try {
+    const { id } = req.params;
+    const [current] = await pool.query('SELECT enabled FROM scheduled_commands WHERE id = ?', [id]);
+
+    if (current.length === 0) {
+      return res.status(404).json({ error: 'Schedule not found' });
+    }
+
+    const newEnabled = !current[0].enabled;
+    await pool.query('UPDATE scheduled_commands SET enabled = ? WHERE id = ?', [newEnabled, id]);
+
+    res.json({ success: true, enabled: newEnabled });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.delete('/api/scheduled-commands/:id', authenticateSSO, async (req, res) => {
+  try {
+    const { id } = req.params;
+    await pool.query('DELETE FROM scheduled_commands WHERE id = ?', [id]);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
 // Health check (no auth required)
 app.get('/health', async (req, res) => {
   try {