feat: Task #94 Global Restart Scheduler

Complete implementation of staggered restart scheduler for Trinity Console.

Database:
- global_restart_config: Node-wide settings (TX1 @ 04:00 UTC, NC1 @ 04:30 UTC)
- server_restart_schedules: Per-server state with sort order
- sync_logs: Audit trail for all sync operations

Backend:
- src/utils/scheduler.js: Stagger calculation with date-fns
- src/lib/ptero-sync.js: Pterodactyl API integration (create/update/delete/audit)
- src/routes/admin/scheduler.js: All CRUD + import + sync + audit routes

Frontend:
- Drag-and-drop server ordering (SortableJS)
- Per-node config cards with base time + interval
- Audit modal to detect and nuke rogue schedules
- Skip toggle for maintenance mode
- Visual sync status indicators

Features:
- Import servers from Pterodactyl discovery
- Recalculate effective times on reorder
- Rate-limited API calls (200ms delay)
- [Trinity] Daily Restart naming convention

Signed-off-by: Claude (Chronicler #61) <claude@firefrostgaming.com>

services/arbiter-3.0/migrations/094_global_restart_scheduler.sql

@@ -0,0 +1,57 @@
+-- Task #94: Global Restart Scheduler
+-- Migration for arbiter_db
+-- Run: psql -U arbiter -d arbiter_db -f 094_global_restart_scheduler.sql
+
+-- 1. Configuration for Node-wide Stagger Logic
+CREATE TABLE IF NOT EXISTS global_restart_config (
+    id SERIAL PRIMARY KEY,
+    node VARCHAR(10) UNIQUE NOT NULL,    -- 'TX1', 'NC1'
+    base_time TIME NOT NULL,             -- e.g., '04:00:00' (UTC)
+    interval_minutes INT DEFAULT 5,      -- Stagger gap
+    is_enabled BOOLEAN DEFAULT true,     -- Global master switch per node
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_by VARCHAR(50)               -- Discord Username
+);
+
+-- 2. Individual Server Execution State
+CREATE TABLE IF NOT EXISTS server_restart_schedules (
+    id SERIAL PRIMARY KEY,
+    server_id VARCHAR(50) UNIQUE NOT NULL,  -- Pterodactyl 8-char short ID
+    server_name VARCHAR(100) NOT NULL,
+    node VARCHAR(10) NOT NULL,
+    sort_order INT NOT NULL DEFAULT 0,      -- Manual boot order
+    effective_time TIME,                    -- Calculated: base + (sort * interval)
+    ptero_schedule_id INT DEFAULT NULL,     -- ID of schedule on Pterodactyl
+    skip_restart BOOLEAN DEFAULT false,     -- Individual "Maintenance Mode"
+    sync_status VARCHAR(20) DEFAULT 'PENDING', -- 'SUCCESS', 'PENDING', 'FAILED'
+    last_error TEXT DEFAULT NULL,           -- API error capture
+    last_synced_at TIMESTAMP NULL,
+    
+    CONSTRAINT fk_node_config 
+        FOREIGN KEY (node) 
+        REFERENCES global_restart_config(node) 
+        ON UPDATE CASCADE
+);
+
+-- 3. Audit Trail for Sync Operations
+CREATE TABLE IF NOT EXISTS sync_logs (
+    id SERIAL PRIMARY KEY,
+    server_id VARCHAR(50) NOT NULL,
+    action VARCHAR(255) NOT NULL,         -- e.g., 'Deleted Rogue Schedule', 'Created Schedule'
+    status VARCHAR(20) NOT NULL,          -- 'SUCCESS', 'FAILED'
+    error_message TEXT DEFAULT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 4. Performance Indexes
+CREATE INDEX IF NOT EXISTS idx_server_node_order ON server_restart_schedules (node, sort_order);
+CREATE INDEX IF NOT EXISTS idx_sync_status ON server_restart_schedules (sync_status);
+CREATE INDEX IF NOT EXISTS idx_sync_logs_server ON sync_logs (server_id);
+CREATE INDEX IF NOT EXISTS idx_sync_logs_created ON sync_logs (created_at);
+
+-- 5. Initial Seed Data
+INSERT INTO global_restart_config (node, base_time, interval_minutes, updated_by)
+VALUES 
+    ('TX1', '04:00:00', 5, 'The Wizard'),
+    ('NC1', '04:30:00', 5, 'The Wizard')
+ON CONFLICT (node) DO NOTHING;

services/arbiter-3.0/src/lib/ptero-sync.js

@@ -0,0 +1,174 @@
+const axios = require('axios');
+const db = require('../database');
+
+const PTERO_URL = 'https://panel.firefrostgaming.com/api/client/servers';
+
+function getHeaders() {
+    return {
+        'Authorization': `Bearer ${process.env.PTERO_CLIENT_KEY}`,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+    };
+}
+
+// Rate limit helper - 200ms between calls
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * Sync a single server's schedule to Pterodactyl
+ */
+async function syncToPterodactyl(serverId) {
+    const result = await db.query('SELECT * FROM server_restart_schedules WHERE server_id = $1', [serverId]);
+    const server = result.rows[0];
+    
+    if (!server) {
+        return { success: false, error: 'Server not found in database' };
+    }
+    
+    const [hour, minute] = server.effective_time.split(':');
+    const pteroUrl = `${PTERO_URL}/${server.server_id}/schedules`;
+    
+    const payload = {
+        name: "[Trinity] Daily Restart",
+        minute, 
+        hour, 
+        day_of_week: "*", 
+        day_of_month: "*", 
+        month: "*",
+        is_active: !server.skip_restart
+    };
+
+    try {
+        let scheduleId = server.ptero_schedule_id;
+
+        if (!scheduleId) {
+            // Create new schedule
+            const res = await axios.post(pteroUrl, payload, { headers: getHeaders() });
+            scheduleId = res.data.attributes.id;
+
+            // Attach the restart task
+            await sleep(200);
+            await axios.post(`${pteroUrl}/${scheduleId}/tasks`, {
+                action: "power", 
+                payload: "restart", 
+                time_offset: 0
+            }, { headers: getHeaders() });
+        } else {
+            // Update existing schedule
+            await axios.post(`${pteroUrl}/${scheduleId}`, payload, { headers: getHeaders() });
+        }
+
+        await db.query(
+            `UPDATE server_restart_schedules 
+             SET ptero_schedule_id = $1, sync_status = $2, last_error = NULL, last_synced_at = NOW() 
+             WHERE server_id = $3`,
+            [scheduleId, 'SUCCESS', server.server_id]
+        );
+        
+        // Log success
+        await db.query(
+            `INSERT INTO sync_logs (server_id, action, status) VALUES ($1, $2, $3)`,
+            [server.server_id, 'Created/Updated Schedule', 'SUCCESS']
+        );
+        
+        return { success: true, scheduleId };
+    } catch (err) {
+        const errorMsg = err.response?.data?.errors?.[0]?.detail || err.message;
+        await db.query(
+            `UPDATE server_restart_schedules 
+             SET sync_status = $1, last_error = $2 
+             WHERE server_id = $3`,
+            ['FAILED', errorMsg, server.server_id]
+        );
+        
+        await db.query(
+            `INSERT INTO sync_logs (server_id, action, status, error_message) VALUES ($1, $2, $3, $4)`,
+            [server.server_id, 'Sync Failed', 'FAILED', errorMsg]
+        );
+        
+        return { success: false, error: errorMsg };
+    }
+}
+
+/**
+ * Find existing restart schedules NOT owned by Trinity
+ */
+async function auditServerSchedules(serverId, serverName) {
+    const pteroUrl = `${PTERO_URL}/${serverId}/schedules`;
+    
+    try {
+        const res = await axios.get(pteroUrl, { headers: getHeaders() });
+        const schedules = res.data.data || [];
+        
+        const rogueSchedules = schedules
+            .filter(s => !s.attributes.name.startsWith('[Trinity]'))
+            .filter(s => {
+                // Check if it looks like a restart schedule
+                const tasks = s.attributes.relationships?.tasks?.data || [];
+                return tasks.some(t => t.attributes?.action === 'power');
+            })
+            .map(s => ({
+                id: s.attributes.id,
+                name: s.attributes.name,
+                cron: `${s.attributes.minute} ${s.attributes.hour} * * *`
+            }));
+        
+        return { serverId, serverName, rogueSchedules };
+    } catch (err) {
+        return { serverId, serverName, rogueSchedules: [], error: err.message };
+    }
+}
+
+/**
+ * Delete a specific schedule from Pterodactyl
+ */
+async function deleteSchedule(serverId, scheduleId, scheduleName) {
+    const pteroUrl = `${PTERO_URL}/${serverId}/schedules/${scheduleId}`;
+    
+    try {
+        await axios.delete(pteroUrl, { headers: getHeaders() });
+        
+        await db.query(
+            `INSERT INTO sync_logs (server_id, action, status) VALUES ($1, $2, $3)`,
+            [serverId, `Deleted Rogue Schedule: ${scheduleName}`, 'SUCCESS']
+        );
+        
+        return { success: true };
+    } catch (err) {
+        const errorMsg = err.response?.data?.errors?.[0]?.detail || err.message;
+        
+        await db.query(
+            `INSERT INTO sync_logs (server_id, action, status, error_message) VALUES ($1, $2, $3, $4)`,
+            [serverId, `Failed to Delete: ${scheduleName}`, 'FAILED', errorMsg]
+        );
+        
+        return { success: false, error: errorMsg };
+    }
+}
+
+/**
+ * Sync all servers for a node
+ */
+async function syncAllForNode(node) {
+    const result = await db.query(
+        'SELECT server_id FROM server_restart_schedules WHERE node = $1 ORDER BY sort_order',
+        [node]
+    );
+    
+    const results = [];
+    for (const row of result.rows) {
+        const syncResult = await syncToPterodactyl(row.server_id);
+        results.push({ serverId: row.server_id, ...syncResult });
+        await sleep(200); // Rate limiting
+    }
+    
+    return results;
+}
+
+module.exports = { 
+    syncToPterodactyl, 
+    auditServerSchedules, 
+    deleteSchedule,
+    syncAllForNode,
+    sleep
+};

services/arbiter-3.0/src/routes/admin/index.js

@@ -9,6 +9,7 @@ const financialsRouter = require('./financials');
 const graceRouter = require('./grace');
 const auditRouter = require('./audit');
 const rolesRouter = require('./roles');
+const schedulerRouter = require('./scheduler');
 
 router.use(requireTrinityAccess);
 
@@ -32,5 +33,6 @@ router.use('/financials', financialsRouter);
 router.use('/grace', graceRouter);
 router.use('/audit', auditRouter);
 router.use('/roles', rolesRouter);
+router.use('/scheduler', schedulerRouter);
 
 module.exports = router;

services/arbiter-3.0/src/routes/admin/scheduler.js

@@ -0,0 +1,307 @@
+const express = require('express');
+const router = express.Router();
+const db = require('../../database');
+const { calculateStagger } = require('../../utils/scheduler');
+const { syncToPterodactyl, auditServerSchedules, deleteSchedule, syncAllForNode, sleep } = require('../../lib/ptero-sync');
+
+// GET /admin/scheduler - Main page
+router.get('/', async (req, res) => {
+    try {
+        // Get config for both nodes
+        const configResult = await db.query('SELECT * FROM global_restart_config ORDER BY node');
+        const configs = configResult.rows;
+        
+        // Get all servers ordered by node and sort_order
+        const serversResult = await db.query(`
+            SELECT s.*, c.base_time, c.interval_minutes 
+            FROM server_restart_schedules s
+            JOIN global_restart_config c ON s.node = c.node
+            ORDER BY s.node, s.sort_order
+        `);
+        
+        res.render('admin/scheduler', {
+            title: 'Global Restart Scheduler',
+            configs,
+            servers: serversResult.rows
+        });
+    } catch (err) {
+        console.error('Scheduler page error:', err);
+        res.status(500).send('Error loading scheduler');
+    }
+});
+
+// GET /admin/scheduler/table-only - HTMX partial refresh
+router.get('/table-only', async (req, res) => {
+    try {
+        const serversResult = await db.query(`
+            SELECT s.*, c.base_time, c.interval_minutes 
+            FROM server_restart_schedules s
+            JOIN global_restart_config c ON s.node = c.node
+            ORDER BY s.node, s.sort_order
+        `);
+        
+        res.render('admin/partials/scheduler-table', { servers: serversResult.rows });
+    } catch (err) {
+        res.status(500).send('Error loading table');
+    }
+});
+
+// POST /admin/scheduler/reorder-servers - Handle drag-and-drop reorder
+router.post('/reorder-servers', async (req, res) => {
+    try {
+        const { orderedIds } = req.body;
+        
+        // Update sort_order for each server
+        for (let i = 0; i < orderedIds.length; i++) {
+            await db.query(
+                'UPDATE server_restart_schedules SET sort_order = $1 WHERE server_id = $2',
+                [i, orderedIds[i]]
+            );
+        }
+        
+        // Recalculate effective times for each node
+        for (const node of ['TX1', 'NC1']) {
+            const configResult = await db.query(
+                'SELECT base_time, interval_minutes FROM global_restart_config WHERE node = $1',
+                [node]
+            );
+            
+            if (configResult.rows.length === 0) continue;
+            
+            const { base_time, interval_minutes } = configResult.rows[0];
+            
+            const serversResult = await db.query(
+                'SELECT server_id FROM server_restart_schedules WHERE node = $1 ORDER BY sort_order',
+                [node]
+            );
+            
+            const servers = serversResult.rows;
+            const staggered = calculateStagger(base_time, interval_minutes, servers);
+            
+            for (const server of staggered) {
+                await db.query(
+                    'UPDATE server_restart_schedules SET effective_time = $1 WHERE server_id = $2',
+                    [server.effective_time, server.server_id]
+                );
+            }
+        }
+        
+        res.json({ success: true });
+    } catch (err) {
+        console.error('Reorder error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// POST /admin/scheduler/update-config - Update node config
+router.post('/update-config', async (req, res) => {
+    try {
+        const { node, base_time, interval_minutes } = req.body;
+        const updatedBy = req.session?.user?.username || 'Unknown';
+        
+        await db.query(
+            `UPDATE global_restart_config 
+             SET base_time = $1, interval_minutes = $2, updated_at = NOW(), updated_by = $3 
+             WHERE node = $4`,
+            [base_time, interval_minutes, updatedBy, node]
+        );
+        
+        // Recalculate effective times for this node
+        const serversResult = await db.query(
+            'SELECT server_id FROM server_restart_schedules WHERE node = $1 ORDER BY sort_order',
+            [node]
+        );
+        
+        const servers = serversResult.rows;
+        const staggered = calculateStagger(base_time, interval_minutes, servers);
+        
+        for (const server of staggered) {
+            await db.query(
+                'UPDATE server_restart_schedules SET effective_time = $1, sync_status = $2 WHERE server_id = $3',
+                [server.effective_time, 'PENDING', server.server_id]
+            );
+        }
+        
+        res.redirect('/admin/scheduler');
+    } catch (err) {
+        console.error('Update config error:', err);
+        res.status(500).send('Error updating config');
+    }
+});
+
+// POST /admin/scheduler/sync/:node - Sync all servers for a node
+router.post('/sync/:node', async (req, res) => {
+    try {
+        const { node } = req.params;
+        const results = await syncAllForNode(node);
+        
+        const success = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+        
+        res.json({ success: true, synced: success, failed });
+    } catch (err) {
+        console.error('Sync error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// GET /admin/scheduler/audit/:node - Audit a node for rogue schedules
+router.get('/audit/:node', async (req, res) => {
+    try {
+        const { node } = req.params;
+        
+        const serversResult = await db.query(
+            'SELECT server_id, server_name FROM server_restart_schedules WHERE node = $1',
+            [node]
+        );
+        
+        const results = [];
+        let totalRogue = 0;
+        
+        for (const server of serversResult.rows) {
+            const auditResult = await auditServerSchedules(server.server_id, server.server_name);
+            if (auditResult.rogueSchedules.length > 0) {
+                results.push(auditResult);
+                totalRogue += auditResult.rogueSchedules.length;
+            }
+            await sleep(200); // Rate limiting
+        }
+        
+        res.render('admin/partials/audit-modal', {
+            node,
+            results,
+            totalRogue,
+            serverCount: results.length
+        });
+    } catch (err) {
+        console.error('Audit error:', err);
+        res.status(500).send('Error running audit');
+    }
+});
+
+// POST /admin/scheduler/audit/nuke/:node - Delete all rogue schedules
+router.post('/audit/nuke/:node', async (req, res) => {
+    try {
+        const { node } = req.params;
+        const nukeData = JSON.parse(req.body.nukeData);
+        
+        let deleted = 0;
+        let failed = 0;
+        
+        for (const item of nukeData) {
+            const result = await deleteSchedule(item.serverId, item.scheduleId, item.scheduleName);
+            if (result.success) {
+                deleted++;
+            } else {
+                failed++;
+            }
+            await sleep(200); // Rate limiting
+        }
+        
+        // Return success message as modal replacement
+        res.send(`
+            <div id="audit-modal" class="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-70 backdrop-blur-sm">
+                <div class="bg-slate-900 border border-green-500 rounded-lg shadow-2xl w-full max-w-md p-6">
+                    <h2 class="text-2xl font-bold text-green-400 mb-4">✓ Cleanup Complete</h2>
+                    <p class="text-slate-300 mb-6">
+                        Deleted <strong class="text-white">${deleted}</strong> rogue schedule(s) on ${node}.
+                        ${failed > 0 ? `<br><span class="text-red-400">${failed} failed.</span>` : ''}
+                    </p>
+                    <div class="flex justify-end">
+                        <button type="button" onclick="document.getElementById('audit-modal').remove(); htmx.ajax('GET', '/admin/scheduler/table-only', '#scheduler-table');" 
+                                class="bg-green-600 hover:bg-green-500 text-white px-6 py-2 rounded transition">Done</button>
+                    </div>
+                </div>
+            </div>
+        `);
+    } catch (err) {
+        console.error('Nuke error:', err);
+        res.status(500).send('Error deleting schedules');
+    }
+});
+
+// POST /admin/scheduler/toggle-skip/:serverId - Toggle skip_restart
+router.post('/toggle-skip/:serverId', async (req, res) => {
+    try {
+        const { serverId } = req.params;
+        
+        await db.query(
+            'UPDATE server_restart_schedules SET skip_restart = NOT skip_restart, sync_status = $1 WHERE server_id = $2',
+            ['PENDING', serverId]
+        );
+        
+        res.json({ success: true });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// POST /admin/scheduler/import-servers - Import servers from Pterodactyl
+router.post('/import-servers', async (req, res) => {
+    try {
+        // Use discovery to get servers
+        const { getMinecraftServers } = require('../../panel/discovery');
+        const servers = await getMinecraftServers();
+        
+        let imported = 0;
+        
+        for (const server of servers) {
+            const node = server.node || 'TX1'; // Default to TX1 if unknown
+            
+            // Check if server already exists
+            const existing = await db.query(
+                'SELECT id FROM server_restart_schedules WHERE server_id = $1',
+                [server.id]
+            );
+            
+            if (existing.rows.length === 0) {
+                // Get current count for this node for sort_order
+                const countResult = await db.query(
+                    'SELECT COUNT(*) as count FROM server_restart_schedules WHERE node = $1',
+                    [node]
+                );
+                const sortOrder = parseInt(countResult.rows[0].count);
+                
+                await db.query(
+                    `INSERT INTO server_restart_schedules (server_id, server_name, node, sort_order)
+                     VALUES ($1, $2, $3, $4)`,
+                    [server.id, server.name, node, sortOrder]
+                );
+                imported++;
+            }
+        }
+        
+        // Recalculate effective times
+        for (const node of ['TX1', 'NC1']) {
+            const configResult = await db.query(
+                'SELECT base_time, interval_minutes FROM global_restart_config WHERE node = $1',
+                [node]
+            );
+            
+            if (configResult.rows.length === 0) continue;
+            
+            const { base_time, interval_minutes } = configResult.rows[0];
+            
+            const serversResult = await db.query(
+                'SELECT server_id FROM server_restart_schedules WHERE node = $1 ORDER BY sort_order',
+                [node]
+            );
+            
+            const staggered = calculateStagger(base_time, interval_minutes, serversResult.rows);
+            
+            for (const server of staggered) {
+                await db.query(
+                    'UPDATE server_restart_schedules SET effective_time = $1 WHERE server_id = $2',
+                    [server.effective_time, server.server_id]
+                );
+            }
+        }
+        
+        res.json({ success: true, imported });
+    } catch (err) {
+        console.error('Import error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+module.exports = router;

services/arbiter-3.0/src/utils/scheduler.js

@@ -0,0 +1,12 @@
+const { addMinutes, format, parse } = require('date-fns');
+
+function calculateStagger(baseTime, interval, servers) {
+    const start = parse(baseTime, 'HH:mm:ss', new Date());
+    
+    return servers.map((server, index) => ({
+        ...server,
+        effective_time: format(addMinutes(start, index * interval), 'HH:mm:ss')
+    }));
+}
+
+module.exports = { calculateStagger };

services/arbiter-3.0/src/views/admin/scheduler.ejs

@@ -0,0 +1,97 @@
+<div class="space-y-6">
+    <!-- Header -->
+    <div class="flex justify-between items-center">
+        <div>
+            <p class="text-gray-500 dark:text-gray-400 mt-1">Manage staggered restart times for all servers</p>
+        </div>
+        <div class="flex gap-3">
+            <button hx-post="/admin/scheduler/import-servers" 
+                    hx-swap="none"
+                    hx-on::after-request="htmx.ajax('GET', '/admin/scheduler/table-only', '#scheduler-table')"
+                    class="bg-gray-600 hover:bg-gray-500 text-white px-4 py-2 rounded transition">
+                ↻ Import Servers
+            </button>
+        </div>
+    </div>
+
+    <!-- Node Configuration Cards -->
+    <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+        <% configs.forEach(config => { %>
+            <div class="bg-white dark:bg-darkcard rounded-lg p-4 border border-gray-200 dark:border-gray-700">
+                <div class="flex justify-between items-center mb-4">
+                    <h2 class="text-xl font-bold <%= config.node === 'TX1' ? 'text-fire' : 'text-frost' %>">
+                        <%= config.node %> Node
+                    </h2>
+                    <div class="flex gap-2">
+                        <button hx-get="/admin/scheduler/audit/<%= config.node %>" 
+                                hx-target="#modal-container"
+                                class="bg-yellow-600 hover:bg-yellow-500 text-white px-3 py-1 rounded text-sm transition">
+                            Audit
+                        </button>
+                        <button hx-post="/admin/scheduler/sync/<%= config.node %>" 
+                                hx-swap="none"
+                                hx-on::after-request="htmx.ajax('GET', '/admin/scheduler/table-only', '#scheduler-table')"
+                                class="bg-green-600 hover:bg-green-500 text-white px-3 py-1 rounded text-sm transition">
+                            Sync All
+                        </button>
+                    </div>
+                </div>
+                <form action="/admin/scheduler/update-config" method="POST" class="flex gap-4 items-end">
+                    <input type="hidden" name="node" value="<%= config.node %>">
+                    <div class="flex-1">
+                        <label class="block text-sm text-gray-500 dark:text-gray-400 mb-1">Base Time (UTC)</label>
+                        <input type="time" name="base_time" value="<%= config.base_time.substring(0,5) %>" 
+                               class="w-full bg-gray-100 dark:bg-darkbg border border-gray-300 dark:border-gray-600 rounded px-3 py-2 text-gray-900 dark:text-white">
+                    </div>
+                    <div class="w-24">
+                        <label class="block text-sm text-gray-500 dark:text-gray-400 mb-1">Interval</label>
+                        <input type="number" name="interval_minutes" value="<%= config.interval_minutes %>" min="1" max="30"
+                               class="w-full bg-gray-100 dark:bg-darkbg border border-gray-300 dark:border-gray-600 rounded px-3 py-2 text-gray-900 dark:text-white">
+                    </div>
+                    <button type="submit" class="bg-gray-600 hover:bg-gray-500 text-white px-4 py-2 rounded transition">
+                        Update
+                    </button>
+                </form>
+                <p class="text-xs text-gray-500 mt-2">
+                    Last updated: <%= config.updated_at ? new Date(config.updated_at).toLocaleString() : 'Never' %> 
+                    by <%= config.updated_by || 'Unknown' %>
+                </p>
+            </div>
+        <% }) %>
+    </div>
+
+    <!-- Server Table -->
+    <div id="scheduler-table" class="bg-white dark:bg-darkcard rounded overflow-hidden border border-gray-200 dark:border-gray-700">
+        <%- include('scheduler/table', { servers: servers }) %>
+    </div>
+
+    <!-- Modal Container -->
+    <div id="modal-container"></div>
+</div>
+
+<!-- SortableJS -->
+<script src="https://cdn.jsdelivr.net/npm/sortablejs@latest/Sortable.min.js"></script>
+<script>
+document.addEventListener("DOMContentLoaded", function() {
+    const tbody = document.getElementById('sortable-servers');
+    
+    if(tbody) {
+        new Sortable(tbody, {
+            handle: '.drag-handle',
+            animation: 150,
+            ghostClass: 'bg-gray-600',
+            
+            onEnd: function (evt) {
+                const newOrder = Array.from(tbody.querySelectorAll('tr')).map(row => row.dataset.id);
+                
+                fetch('/admin/scheduler/reorder-servers', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ orderedIds: newOrder })
+                })
+                .then(() => htmx.ajax('GET', '/admin/scheduler/table-only', '#scheduler-table'));
+            }
+        });
+    }
+});
+</script>

services/arbiter-3.0/src/views/admin/scheduler/audit-modal.ejs

@@ -0,0 +1,56 @@
+<div id="audit-modal" class="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-70 backdrop-blur-sm">
+    <div class="bg-white dark:bg-darkcard border <%= totalRogue > 0 ? 'border-red-500' : 'border-green-500' %> rounded-lg shadow-2xl w-full max-w-2xl p-6 relative">
+        
+        <% if (totalRogue > 0) { %>
+            <h2 class="text-2xl font-bold text-red-500 mb-2">⚠ Conflicts Detected</h2>
+            <p class="text-gray-600 dark:text-gray-300 mb-4">
+                Found <strong class="text-gray-900 dark:text-white"><%= totalRogue %></strong> rogue restart schedule(s) across 
+                <strong class="text-gray-900 dark:text-white"><%= serverCount %></strong> server(s) on <%= node %>. 
+                These must be removed before Trinity can take control.
+            </p>
+
+            <div class="bg-gray-100 dark:bg-darkbg rounded p-4 mb-6 max-h-64 overflow-y-auto border border-gray-200 dark:border-gray-700">
+                <ul class="space-y-3">
+                    <% results.forEach(result => { %>
+                        <li class="border-b border-gray-200 dark:border-gray-700 pb-2 last:border-0">
+                            <span class="text-fire font-semibold"><%= result.serverName %></span>
+                            <ul class="ml-4 mt-1 text-sm text-gray-500 dark:text-gray-400">
+                                <% result.rogueSchedules.forEach(sched => { %>
+                                    <li>- "<%= sched.name %>" (Cron: <%= sched.cron %>)</li>
+                                <% }) %>
+                            </ul>
+                        </li>
+                    <% }) %>
+                </ul>
+            </div>
+
+            <% 
+                const nukePayload = [];
+                results.forEach(r => r.rogueSchedules.forEach(s => nukePayload.push({
+                    serverId: r.serverId, scheduleId: s.id, scheduleName: s.name
+                })));
+            %>
+
+            <form hx-post="/admin/scheduler/audit/nuke/<%= node %>" hx-target="#audit-modal" hx-swap="outerHTML">
+                <input type="hidden" name="nukeData" value='<%- JSON.stringify(nukePayload) %>'>
+                
+                <div class="flex justify-end gap-4 mt-6">
+                    <button type="button" onclick="document.getElementById('audit-modal').remove()" 
+                            class="px-4 py-2 text-gray-500 hover:text-gray-900 dark:hover:text-white transition">Cancel</button>
+                    <button type="submit" 
+                            class="bg-red-600 hover:bg-red-500 text-white px-6 py-2 rounded font-bold transition">
+                        🔥 Nuke <%= totalRogue %> Schedules
+                    </button>
+                </div>
+            </form>
+
+        <% } else { %>
+            <h2 class="text-2xl font-bold text-green-500 mb-2">✓ All Clear</h2>
+            <p class="text-gray-600 dark:text-gray-300 mb-6">No conflicts found on <%= node %>. Trinity is ready to take control.</p>
+            <div class="flex justify-end">
+                <button type="button" onclick="document.getElementById('audit-modal').remove()" 
+                        class="bg-green-600 hover:bg-green-500 text-white px-6 py-2 rounded transition">Close</button>
+            </div>
+        <% } %>
+    </div>
+</div>

services/arbiter-3.0/src/views/admin/scheduler/table.ejs

@@ -0,0 +1,53 @@
+<table class="w-full text-left">
+    <thead class="bg-gray-100 dark:bg-darkbg text-gray-600 dark:text-gray-300">
+        <tr>
+            <th class="p-3 w-10"></th>
+            <th class="p-3">Server</th>
+            <th class="p-3">Node</th>
+            <th class="p-3">Restart Time (UTC)</th>
+            <th class="p-3">Status</th>
+            <th class="p-3">Skip</th>
+        </tr>
+    </thead>
+    <tbody id="sortable-servers">
+        <% if (servers.length === 0) { %>
+            <tr>
+                <td colspan="6" class="p-6 text-center text-gray-500">
+                    No servers imported yet. Click "Import Servers" to populate from Pterodactyl.
+                </td>
+            </tr>
+        <% } else { %>
+            <% servers.forEach((server, i) => { %>
+                <tr class="border-t border-gray-200 dark:border-gray-700 hover:bg-gray-50 dark:hover:bg-gray-800 transition" data-id="<%= server.server_id %>">
+                    <td class="p-3 cursor-grab text-gray-400 hover:text-gray-900 dark:hover:text-white">
+                        <span class="drag-handle text-lg">☰</span>
+                    </td>
+                    <td class="p-3 font-medium"><%= server.server_name %></td>
+                    <td class="p-3">
+                        <span class="px-2 py-1 rounded text-xs font-bold <%= server.node === 'TX1' ? 'bg-fire/20 text-fire' : 'bg-frost/20 text-frost' %>">
+                            <%= server.node %>
+                        </span>
+                    </td>
+                    <td class="p-3 font-mono text-sm"><%= server.effective_time || 'Not set' %></td>
+                    <td class="p-3 text-sm">
+                        <% if (server.sync_status === 'SUCCESS') { %>
+                            <span class="text-green-500" title="Last synced: <%= server.last_synced_at %>">● Synced</span>
+                        <% } else if (server.sync_status === 'FAILED') { %>
+                            <span class="text-red-500" title="<%= server.last_error %>">✕ Error</span>
+                        <% } else { %>
+                            <span class="text-yellow-500">○ Pending</span>
+                        <% } %>
+                    </td>
+                    <td class="p-3">
+                        <button hx-post="/admin/scheduler/toggle-skip/<%= server.server_id %>"
+                                hx-swap="none"
+                                hx-on::after-request="htmx.ajax('GET', '/admin/scheduler/table-only', '#scheduler-table')"
+                                class="px-2 py-1 rounded text-xs <%= server.skip_restart ? 'bg-red-600 text-white' : 'bg-gray-200 dark:bg-gray-700 text-gray-600 dark:text-gray-300' %>">
+                            <%= server.skip_restart ? 'Skipped' : 'Active' %>
+                        </button>
+                    </td>
+                </tr>
+            <% }) %>
+        <% } %>
+    </tbody>
+</table>

services/arbiter-3.0/src/views/layout.ejs

@@ -89,6 +89,9 @@
                 <a href="/admin/roles" class="block px-4 py-2 rounded-md <%= currentPath.startsWith('/roles') ? 'bg-gray-200 dark:bg-gray-700' : 'hover:bg-gray-100 dark:hover:bg-gray-800' %>">
                     🔍 Role Audit
                 </a>
+                <a href="/admin/scheduler" class="block px-4 py-2 rounded-md <%= currentPath.startsWith('/scheduler') ? 'bg-gray-200 dark:bg-gray-700' : 'hover:bg-gray-100 dark:hover:bg-gray-800' %>">
+                    ⏰ Restart Scheduler
+                </a>
             </nav>
             <div class="p-4 border-t border-gray-200 dark:border-gray-700">
                 <div class="flex items-center gap-3">