Upload folder using huggingface_hub

Frontend/src/App.jsx

@@ -54,6 +54,7 @@ import AdminUsers from "./admin/pages/AdminUsers";
 import AdminAnalytics from "./admin/pages/AdminAnalytics";
 import AdminProfile from "./admin/pages/AdminProfile";
 import AdminSettings from "./admin/pages/AdminSettings";
+import SLAPage from "./admin/pages/SLAPage";
 import MasterBugReports from "./master-admin/pages/MasterBugReports";
 
 // Feature Pages
@@ -78,7 +79,6 @@ import MasterAdminDashboard from "./master-admin/pages/MasterAdminDashboard";
 import PendingAdminRequests from "./master-admin/pages/PendingAdminRequests";
 import AllCompanies from "./master-admin/pages/AllCompanies";
 import AllAdmins from "./master-admin/pages/AllAdmins";
-import Changelog from "./pages/Changelog";
 
 
 function TitleUpdater() {
@@ -96,6 +96,7 @@ function TitleUpdater() {
     else if (path.startsWith('/admin/analytics')) title = 'Analytics | Admin';
     else if (path.startsWith('/admin/profile')) title = 'Admin Profile';
     else if (path.startsWith('/admin/settings')) title = 'Settings | Admin';
+    else if (path.startsWith('/admin/sla')) title = 'SLA Monitor | Admin';
     // Master Admin Routes
     else if (path.startsWith('/master-admin/dashboard')) title = 'Master Dashboard';
     else if (path.startsWith('/master-admin/admin-requests')) title = 'Pending Requests | Master Admin';
@@ -191,6 +192,7 @@ function AppLayout() {
             <Route path="/admin/analytics" element={<AdminAnalytics />} />
             <Route path="/admin/profile" element={<AdminProfile />} />
             <Route path="/admin/settings" element={<AdminSettings />} />
+            <Route path="/admin/sla" element={<SLAPage />} />
           </Route>
         </Route>
 
@@ -206,11 +208,6 @@ function App() {
 
   useEffect(() => {
     initialize();
-    // Dark mode initialize
-    const saved = localStorage.getItem('theme');
-    if (saved === 'dark') {
-      document.documentElement.classList.add('dark');
-    }
   }, [initialize]);
 
   return (
@@ -237,9 +234,6 @@ function App() {
         <Route path="/features/priority" element={<PriorityDetectionFeature />} />
         <Route path="/features/resolution" element={<SmartResolutionFeature />} />
 
-        {/* Resources Pages */}
-        <Route path="/changelog" element={<Changelog />} />
-        
         {/* Legal Pages */}
         <Route path="/terms" element={<TermsOfService />} />
         <Route path="/privacy" element={<PrivacyPolicy />} />

Frontend/src/admin/components/AdminSidebar.jsx

@@ -10,7 +10,8 @@ import {
     LogOut,
     Activity,
     ChevronLeft,
-    ChevronRight
+    ChevronRight,
+    Clock
 } from 'lucide-react';
 import useAuthStore from '../../store/authStore';
 
@@ -21,6 +22,7 @@ const AdminSidebar = ({ isMobile, onClose, isCollapsed, onToggleCollapse }) => {
         { label: 'Users', path: '/admin/users', icon: Users },
         { label: 'Analytics', path: '/admin/analytics', icon: BarChart3 },
         { label: 'Profile', path: '/admin/profile', icon: UserCircle },
+        { label: 'SLA Monitor', path: '/admin/sla', icon: Clock },
     ];
 
     const { logout } = useAuthStore();

Frontend/src/admin/components/SLABadge.jsx

@@ -1,12 +1,12 @@
 import React, { useState, useEffect } from 'react';
 import { Clock, AlertTriangle, ShieldCheck } from 'lucide-react';
 
-// SLA resolution limits in milliseconds based on priority.
+// SLA time limits in milliseconds based on priority
 const SLA_LIMITS = {
-    critical: 4 * 60 * 60 * 1000,
-    high: 12 * 60 * 60 * 1000,
-    medium: 24 * 60 * 60 * 1000,
-    low: 72 * 60 * 60 * 1000,
+    critical: 2 * 60 * 60 * 1000,   // 2 hours
+    high: 4 * 60 * 60 * 1000,   // 4 hours
+    medium: 8 * 60 * 60 * 1000,   // 8 hours
+    low: 24 * 60 * 60 * 1000,  // 24 hours
 };
 
 function formatDuration(ms) {
@@ -19,47 +19,36 @@ function formatDuration(ms) {
 }
 
 /**
- * SLABadge — shows SLA status for a ticket.
+ * SLABadge — shows SLA status for a ticket based on its priority and creation time.
  * 
  * Props:
  *  - priority: string ('critical' | 'high' | 'medium' | 'low')
  *  - createdAt: string (ISO date string)
- *  - slaBreachAt: string (ISO date string) — preferred persisted deadline
- *  - slaStatus: string ('ACTIVE' | 'WARNING' | 'BREACHED')
  *  - status: string — if ticket is resolved/closed, show "Met" without countdown
  *  - compact: bool — if true, shows just the badge with no label text
  */
-export default function SLABadge({ priority, createdAt, slaBreachAt, slaStatus, status, compact = false }) {
+export default function SLABadge({ priority, createdAt, status, compact = false }) {
     const [remaining, setRemaining] = useState(null);
 
-    const normalizedStatus = status?.toLowerCase();
-    const normalizedSlaStatus = slaStatus?.toUpperCase();
-    const isResolved = ['resolved', 'closed', 'auto-resolved', 'auto resolved'].includes(normalizedStatus);
+    const isResolved = ['resolved', 'closed', 'auto-resolved'].includes(status?.toLowerCase());
 
     useEffect(() => {
-        if (isResolved) return;
-        if (normalizedSlaStatus === 'BREACHED') {
-            setRemaining(-1);
-            return;
-        }
+        if (isResolved || !priority || !createdAt) return;
 
-        const priorityKey = priority?.toLowerCase?.() || 'medium';
+        const priorityKey = priority.toLowerCase();
         const limit = SLA_LIMITS[priorityKey] || SLA_LIMITS.medium;
-        const deadlineMs = slaBreachAt
-            ? new Date(slaBreachAt).getTime()
-            : new Date(createdAt).getTime() + limit;
-
-        if (!Number.isFinite(deadlineMs)) return;
+        const createdMs = new Date(createdAt).getTime();
 
         const calculate = () => {
-            const rem = deadlineMs - Date.now();
+            const elapsed = Date.now() - createdMs;
+            const rem = limit - elapsed;
             setRemaining(rem);
         };
 
         calculate();
         const timer = setInterval(calculate, 60 * 1000); // update every minute
         return () => clearInterval(timer);
-    }, [priority, createdAt, slaBreachAt, normalizedSlaStatus, isResolved]);
+    }, [priority, createdAt, isResolved]);
 
     if (isResolved) {
         return (

Frontend/src/admin/components/SLADashboard.jsx

@@ -0,0 +1,376 @@
+/**
+ * SLA Dashboard Widget — Real-time SLA monitoring panel
+ *
+ * Displays:
+ *   - Active vs breached vs warning counts
+ *   - Breach rate percentage
+ *   - Per-priority breakdown
+ *   - Recent escalations
+ *   - Trend indicators
+ */
+
+import React, { useState, useEffect, useMemo } from 'react';
+import {
+  Clock,
+  AlertTriangle,
+  ShieldCheck,
+  TrendingUp,
+  TrendingDown,
+  AlertCircle,
+  Activity,
+  RefreshCw,
+  ArrowUpRight,
+  ChevronRight,
+  Users,
+  Gauge,
+} from 'lucide-react';
+
+const PRIORITY_COLORS = {
+  critical: { bg: '#FEF2F2', text: '#DC2626', border: '#FECACA', dot: '#DC2626' },
+  high: { bg: '#FFF7ED', text: '#EA580C', border: '#FED7AA', dot: '#EA580C' },
+  medium: { bg: '#FEFCE8', text: '#CA8A04', border: '#FDE68A', dot: '#CA8A04' },
+  low: { bg: '#F0FDF4', text: '#16A34A', border: '#BBF7D0', dot: '#16A34A' },
+};
+
+const API_BASE = import.meta.env.VITE_API_URL || 'https://helpdesk-ai-backend-iq0w.onrender.com';
+
+/**
+ * Fetch SLA dashboard stats from the backend.
+ */
+async function fetchSLAStats() {
+  const res = await fetch(`${API_BASE}/sla/stats`, {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Fetch recent escalations.
+ */
+async function fetchEscalations(limit = 10) {
+  const res = await fetch(`${API_BASE}/sla/escalations?limit=${limit}`, {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Format seconds to human-readable duration.
+ */
+function formatDuration(seconds) {
+  if (!seconds && seconds !== 0) return '—';
+  if (seconds <= 0) return 'Overdue';
+  const hrs = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  if (hrs > 0) return `${hrs}h ${mins}m`;
+  return `${mins}m`;
+}
+
+/**
+ * Main SLA Dashboard Component
+ */
+export default function SLADashboard({ compact = false, onViewAll }) {
+  const [stats, setStats] = useState(null);
+  const [escalations, setEscalations] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [refreshing, setRefreshing] = useState(false);
+
+  const fetchData = async () => {
+    try {
+      setRefreshing(true);
+      const [statsData, escData] = await Promise.all([
+        fetchSLAStats(),
+        fetchEscalations(compact ? 5 : 10),
+      ]);
+      setStats(statsData);
+      setEscalations(escData?.escalations || escData || []);
+      setError(null);
+    } catch (err) {
+      console.error('[SLA-Dashboard] Fetch error:', err);
+      setError(err.message);
+    } finally {
+      setLoading(false);
+      setRefreshing(false);
+    }
+  };
+
+  useEffect(() => { fetchData(); }, []);
+
+  // Auto-refresh every 60 seconds
+  useEffect(() => {
+    const interval = setInterval(fetchData, 60_000);
+    return () => clearInterval(interval);
+  }, []);
+
+  // ── KPIs ──────────────────────────────────────────────────────────────────
+
+  const kpis = useMemo(() => {
+    if (!stats) return [];
+    return [
+      {
+        label: 'Active Tickets',
+        value: stats.active ?? 0,
+        icon: Activity,
+        color: '#3b82f6',
+        bg: '#EFF6FF',
+        border: '#BFDBFE',
+        subtitle: 'Being monitored',
+      },
+      {
+        label: 'SLA Warnings',
+        value: stats.warning ?? 0,
+        icon: AlertTriangle,
+        color: '#F59E0B',
+        bg: '#FEFCE8',
+        border: '#FDE68A',
+        subtitle: 'Nearing breach',
+        pulse: (stats.warning ?? 0) > 0,
+      },
+      {
+        label: 'SLA Breached',
+        value: stats.breached ?? 0,
+        icon: AlertCircle,
+        color: '#DC2626',
+        bg: '#FEF2F2',
+        border: '#FECACA',
+        subtitle: 'Requires immediate action',
+        pulse: (stats.breached ?? 0) > 0,
+      },
+      {
+        label: 'Breach Rate',
+        value: stats.breach_rate != null ? `${stats.breach_rate}%` : '0%',
+        icon: Gauge,
+        color: (stats.breach_rate ?? 0) > 10 ? '#DC2626' : '#16A34A',
+        bg: (stats.breach_rate ?? 0) > 10 ? '#FEF2F2' : '#F0FDF4',
+        border: (stats.breach_rate ?? 0) > 10 ? '#FECACA' : '#BBF7D0',
+        subtitle: 'Of total tickets',
+      },
+    ];
+  }, [stats]);
+
+  // ── Loading state ─────────────────────────────────────────────────────────
+
+  if (loading) {
+    return (
+      <div className="py-16 text-center">
+        <RefreshCw size={32} className="animate-spin mx-auto mb-4 text-emerald-500" />
+        <p className="text-sm text-gray-400 font-semibold uppercase tracking-wider">
+          Loading SLA Dashboard...
+        </p>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="py-16 text-center" style={{ border: '2px dashed #FECACA', borderRadius: '16px' }}>
+        <AlertCircle size={40} className="mx-auto mb-3 text-red-400" />
+        <h3 className="text-sm font-bold text-red-600 mb-1">Connection Error</h3>
+        <p className="text-xs text-gray-500">{error}</p>
+        <button
+          onClick={fetchData}
+          className="mt-4 px-4 py-2 bg-red-50 text-red-600 border border-red-200 rounded-lg text-xs font-bold uppercase tracking-wider hover:bg-red-100 transition-colors"
+        >
+          Retry
+        </button>
+      </div>
+    );
+  }
+
+  // ── Empty state ───────────────────────────────────────────────────────────
+
+  if (!stats || (stats.active === 0 && stats.breached === 0)) {
+    return (
+      <div className="py-16 text-center" style={{ border: '2px dashed #D1FAE5', borderRadius: '16px' }}>
+        <ShieldCheck size={40} className="mx-auto mb-3 text-emerald-400" />
+        <h3 className="text-sm font-bold text-emerald-700 mb-1">All SLA Targets Met</h3>
+        <p className="text-xs text-gray-500">No active SLA violations.</p>
+      </div>
+    );
+  }
+
+  // ── Render ────────────────────────────────────────────────────────────────
+
+  return (
+    <div className="space-y-6">
+      {/* Header with refresh */}
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <Clock size={18} className="text-emerald-500" />
+          <h3 className="text-sm font-bold text-gray-800">SLA Monitoring</h3>
+        </div>
+        <button
+          onClick={fetchData}
+          disabled={refreshing}
+          className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-semibold text-gray-500 bg-gray-50 border border-gray-200 rounded-lg hover:bg-gray-100 transition-colors disabled:opacity-50"
+        >
+          <RefreshCw size={12} className={refreshing ? 'animate-spin' : ''} />
+          {refreshing ? 'Refreshing...' : 'Refresh'}
+        </button>
+      </div>
+
+      {/* KPI Cards */}
+      <div className={`grid gap-4 ${compact ? 'grid-cols-2' : 'grid-cols-2 lg:grid-cols-4'}`}>
+        {kpis.map((kpi, idx) => (
+          <div
+            key={idx}
+            className="rounded-xl p-4 border transition-all hover:shadow-md"
+            style={{
+              background: kpi.bg,
+              borderColor: kpi.border,
+            }}
+          >
+            <div className="flex items-center justify-between mb-3">
+              <kpi.icon size={20} style={{ color: kpi.color }} />
+              <div
+                className={`w-2 h-2 rounded-full ${kpi.pulse ? 'animate-pulse' : ''}`}
+                style={{ background: kpi.color }}
+              />
+            </div>
+            <p className="text-2xl font-bold" style={{ color: kpi.color }}>
+              {kpi.value}
+            </p>
+            <p className="text-xs font-semibold text-gray-600 mt-1">{kpi.label}</p>
+            <p className="text-[10px] text-gray-400 mt-0.5">{kpi.subtitle}</p>
+          </div>
+        ))}
+      </div>
+
+      {/* Per-Priority Breakdown */}
+      {stats?.by_priority && !compact && (
+        <div className="rounded-2xl border border-gray-100 bg-white p-5">
+          <h4 className="text-xs font-bold text-gray-500 uppercase tracking-wider mb-4">
+            SLA Breakdown by Priority
+          </h4>
+          <div className="space-y-3">
+            {Object.entries(stats.by_priority).map(([priority, data]) => {
+              const colors = PRIORITY_COLORS[priority] || PRIORITY_COLORS.medium;
+              const total = data.total || 0;
+              const breached = data.breached || 0;
+              const warning = data.warning || 0;
+              const healthy = total - breached - warning;
+              const breachPct = total > 0 ? Math.round((breached / total) * 100) : 0;
+
+              return (
+                <div key={priority} className="flex items-center gap-3">
+                  <span
+                    className="text-[10px] font-bold uppercase tracking-wider min-w-[60px]"
+                    style={{ color: colors.text }}
+                  >
+                    {priority}
+                  </span>
+                  <div className="flex-1 h-2.5 rounded-full bg-gray-100 overflow-hidden flex">
+                    {healthy > 0 && (
+                      <div
+                        className="h-full transition-all duration-500"
+                        style={{
+                          width: `${total > 0 ? (healthy / total) * 100 : 0}%`,
+                          background: '#16A34A',
+                        }}
+                      />
+                    )}
+                    {warning > 0 && (
+                      <div
+                        className="h-full transition-all duration-500"
+                        style={{
+                          width: `${total > 0 ? (warning / total) * 100 : 0}%`,
+                          background: '#F59E0B',
+                        }}
+                      />
+                    )}
+                    {breached > 0 && (
+                      <div
+                        className="h-full transition-all duration-500"
+                        style={{
+                          width: `${total > 0 ? (breached / total) * 100 : 0}%`,
+                          background: '#DC2626',
+                        }}
+                      />
+                    )}
+                  </div>
+                  <span className="text-xs font-semibold text-gray-600 min-w-[40px] text-right">
+                    {total}
+                  </span>
+                  {breachPct > 0 && (
+                    <span className="text-[10px] font-bold text-red-500 min-w-[36px] text-right">
+                      {breachPct}%
+                    </span>
+                  )}
+                </div>
+              );
+            })}
+          </div>
+        </div>
+      )}
+
+      {/* Recent Escalations */}
+      {escalations.length > 0 && !compact && (
+        <div className="rounded-2xl border border-gray-100 bg-white p-5">
+          <div className="flex items-center justify-between mb-4">
+            <h4 className="text-xs font-bold text-gray-500 uppercase tracking-wider">
+              Recent Escalations
+            </h4>
+            {onViewAll && (
+              <button
+                onClick={onViewAll}
+                className="text-xs font-semibold text-emerald-600 hover:text-emerald-700 flex items-center gap-1"
+              >
+                View All <ChevronRight size={12} />
+              </button>
+            )}
+          </div>
+          <div className="space-y-2">
+            {escalations.slice(0, compact ? 3 : 5).map((esc, idx) => {
+              const status = esc.sla_status || 'breached';
+              const level = esc.escalation_level || 0;
+              const isBreached = status === 'breached';
+              return (
+                <div
+                  key={esc.id || idx}
+                  className="flex items-center justify-between p-3 rounded-xl border transition-colors hover:bg-gray-50"
+                  style={{
+                    borderColor: isBreached ? '#FECACA' : '#FDE68A',
+                    background: isBreached ? '#FFFBFB' : '#FFFEF9',
+                  }}
+                >
+                  <div className="flex items-center gap-3 min-w-0">
+                    <div
+                      className="w-8 h-8 rounded-lg flex items-center justify-center flex-shrink-0"
+                      style={{ background: isBreached ? '#FEF2F2' : '#FEFCE8' }}
+                    >
+                      {isBreached
+                        ? <AlertCircle size={14} className="text-red-500" />
+                        : <AlertTriangle size={14} className="text-amber-500" />
+                      }
+                    </div>
+                    <div className="min-w-0">
+                      <p className="text-xs font-semibold text-gray-800 truncate">
+                        {esc.ticket_subject || `Ticket #${(esc.ticket_id || '').toString().slice(0, 8)}`}
+                      </p>
+                      <p className="text-[10px] text-gray-400">
+                        L{level} · {esc.assigned_team || 'Unassigned'}
+                        {esc.remaining_seconds != null && ` · ${formatDuration(esc.remaining_seconds)}`}
+                      </p>
+                    </div>
+                  </div>
+                  <span
+                    className={`text-[10px] font-bold px-2 py-1 rounded-full uppercase tracking-wider flex-shrink-0 ${
+                      isBreached
+                        ? 'bg-red-50 text-red-600 border border-red-200'
+                        : 'bg-amber-50 text-amber-600 border border-amber-200'
+                    }`}
+                  >
+                    {status}
+                  </span>
+                </div>
+              );
+            })}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

Frontend/src/admin/pages/SLAPage.jsx

@@ -0,0 +1,538 @@
+/**
+ * SLAPage — Dedicated SLA Monitoring & Management Page
+ *
+ * Features:
+ *   - Real-time SLA dashboard with KPIs
+ *   - Per-priority breakdown visualization
+ *   - Active violations list with escalation tracking
+ *   - Escalation timeline / audit log
+ *   - Alert configuration panel
+ */
+
+import React, { useState, useEffect, useMemo, useCallback } from 'react';
+import {
+  Clock,
+  AlertTriangle,
+  AlertCircle,
+  ShieldCheck,
+  RefreshCw,
+  ChevronDown,
+  ChevronUp,
+  Filter,
+  Bell,
+  Settings,
+  ExternalLink,
+  Gauge,
+  Activity,
+  Users,
+  TrendingUp,
+} from 'lucide-react';
+import SLADashboard from '../components/SLADashboard';
+import SLABadge from '../components/SLABadge';
+
+const API_BASE = import.meta.env.VITE_API_URL || 'https://helpdesk-ai-backend-iq0w.onrender.com';
+
+// ── Data fetching helpers ────────────────────────────────────────────────────
+
+async function fetchSLATickets(status = 'all') {
+  const params = status !== 'all' ? `?status=${status}` : '';
+  const res = await fetch(`${API_BASE}/sla/tickets${params}`, {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+
+async function fetchEscalations(limit = 50) {
+  const res = await fetch(`${API_BASE}/sla/escalations?limit=${limit}`, {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+
+async function fetchSLAPolicies() {
+  const res = await fetch(`${API_BASE}/sla/policies`, {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+
+// ── Status styles ────────────────────────────────────────────────────────────
+
+const STATUS_STYLES = {
+  breached: { bg: '#FEF2F2', text: '#DC2626', border: '#FECACA', icon: AlertCircle, label: 'Breached' },
+  warning: { bg: '#FEFCE8', text: '#CA8A04', border: '#FDE68A', icon: AlertTriangle, label: 'Warning' },
+  active: { bg: '#F0FDF4', text: '#16A34A', border: '#BBF7D0', icon: Activity, label: 'Active' },
+  met: { bg: '#F1F5F9', text: '#64748B', border: '#E2E8F0', icon: ShieldCheck, label: 'SLA Met' },
+};
+
+const PRIORITY_STYLES = {
+  critical: { bg: '#FEF2F2', text: '#DC2626', border: '#FECACA' },
+  high: { bg: '#FFF7ED', text: '#EA580C', border: '#FED7AA' },
+  medium: { bg: '#FEFCE8', text: '#CA8A04', border: '#FDE68A' },
+  low: { bg: '#F0FDF4', text: '#16A34A', border: '#BBF7D0' },
+};
+
+function formatDuration(seconds) {
+  if (seconds == null) return '—';
+  if (seconds <= 0) return 'Overdue';
+  const hrs = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  if (hrs > 0) return `${hrs}h ${mins}m`;
+  return `${mins}m`;
+}
+
+function formatDate(iso) {
+  if (!iso) return '—';
+  const d = new Date(iso);
+  const now = new Date();
+  const diffMs = now - d;
+  const diffMin = Math.floor(diffMs / 60000);
+  if (diffMin < 1) return 'Just now';
+  if (diffMin < 60) return `${diffMin}m ago`;
+  const diffHr = Math.floor(diffMin / 60);
+  if (diffHr < 24) return `${diffHr}h ago`;
+  return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });
+}
+
+// ── SLAPage Component ────────────────────────────────────────────────────────
+
+export default function SLAPage() {
+  const [activeTab, setActiveTab] = useState('dashboard');
+  const [tickets, setTickets] = useState([]);
+  const [escalations, setEscalations] = useState([]);
+  const [policies, setPolicies] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [filterStatus, setFilterStatus] = useState('all');
+  const [filterPriority, setFilterPriority] = useState('all');
+  const [expandedEsc, setExpandedEsc] = useState(null);
+
+  // ── Data Loading ────────────────────────────────────────────────────────────
+
+  const loadData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const [ticketData, escData, policyData] = await Promise.all([
+        fetchSLATickets(filterStatus),
+        fetchEscalations(),
+        fetchSLAPolicies(),
+      ]);
+      setTickets(Array.isArray(ticketData) ? ticketData : ticketData?.tickets || []);
+      setEscalations(Array.isArray(escData) ? escData : escData?.escalations || []);
+      setPolicies(Array.isArray(policyData) ? policyData : policyData?.policies || []);
+    } catch (err) {
+      console.error('[SLAPage] Fetch error:', err);
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [filterStatus]);
+
+  useEffect(() => { loadData(); }, [loadData]);
+
+  // ── Filtered tickets ────────────────────────────────────────────────────────
+
+  const filteredTickets = useMemo(() => {
+    let result = tickets;
+    if (filterPriority !== 'all') {
+      result = result.filter(t => (t.priority || '').toLowerCase() === filterPriority);
+    }
+    // Sort by severity: breached first, then warning, then active
+    const order = { breached: 0, warning: 1, active: 2, met: 3 };
+    result = [...result].sort((a, b) => {
+      const aOrder = order[a.sla_status] ?? 99;
+      const bOrder = order[b.sla_status] ?? 99;
+      return aOrder - bOrder;
+    });
+    return result;
+  }, [tickets, filterPriority]);
+
+  // ── Stats card component ────────────────────────────────────────────────────
+
+  const StatCard = ({ label, value, icon: Icon, color, bg, border, subtitle, pulse }) => (
+    <div
+      className="rounded-xl p-5 border transition-all hover:shadow-md"
+      style={{ background: bg, borderColor: border }}
+    >
+      <div className="flex items-center justify-between mb-3">
+        <Icon size={22} style={{ color }} />
+        {pulse && <span className="w-2.5 h-2.5 rounded-full bg-red-500 animate-pulse" />}
+      </div>
+      <p className="text-3xl font-bold" style={{ color }}>{value}</p>
+      <p className="text-sm font-semibold text-gray-600 mt-1">{label}</p>
+      {subtitle && <p className="text-xs text-gray-400 mt-0.5">{subtitle}</p>}
+    </div>
+  );
+
+  // ── Tab navigation ──────────────────────────────────────────────────────────
+
+  const tabs = [
+    { id: 'dashboard', label: 'Dashboard', icon: Gauge },
+    { id: 'violations', label: 'Violations', icon: AlertTriangle },
+    { id: 'escalations', label: 'Escalations', icon: Bell },
+    { id: 'policies', label: 'SLA Policies', icon: Settings },
+  ];
+
+  // ── Render filters bar ──────────────────────────────────────────────────────
+
+  const FiltersBar = () => (
+    <div className="flex flex-wrap items-center gap-3">
+      <div className="flex items-center gap-2 px-3 py-1.5 bg-white border border-gray-200 rounded-lg">
+        <Filter size={14} className="text-gray-400" />
+        <select
+          value={filterStatus}
+          onChange={e => setFilterStatus(e.target.value)}
+          className="text-xs font-semibold text-gray-600 bg-transparent border-none outline-none cursor-pointer"
+        >
+          <option value="all">All Status</option>
+          <option value="breached">Breached</option>
+          <option value="warning">Warning</option>
+          <option value="active">Active</option>
+          <option value="met">Met</option>
+        </select>
+      </div>
+      <div className="flex items-center gap-2 px-3 py-1.5 bg-white border border-gray-200 rounded-lg">
+        <Filter size={14} className="text-gray-400" />
+        <select
+          value={filterPriority}
+          onChange={e => setFilterPriority(e.target.value)}
+          className="text-xs font-semibold text-gray-600 bg-transparent border-none outline-none cursor-pointer"
+        >
+          <option value="all">All Priorities</option>
+          <option value="critical">Critical</option>
+          <option value="high">High</option>
+          <option value="medium">Medium</option>
+          <option value="low">Low</option>
+        </select>
+      </div>
+      <button
+        onClick={loadData}
+        className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-semibold text-gray-500 bg-white border border-gray-200 rounded-lg hover:bg-gray-50 transition-colors"
+      >
+        <RefreshCw size={12} /> Refresh
+      </button>
+    </div>
+  );
+
+  // ── Render: Dashboard Tab ───────────────────────────────────────────────────
+
+  const renderDashboard = () => <SLADashboard />;
+
+  // ── Render: Violations Tab ──────────────────────────────────────────────────
+
+  const renderViolations = () => {
+    if (loading) {
+      return (
+        <div className="py-24 text-center">
+          <RefreshCw size={32} className="animate-spin mx-auto mb-4 text-emerald-500" />
+          <p className="text-sm text-gray-400 font-semibold">Loading violations...</p>
+        </div>
+      );
+    }
+
+    const activeViolations = filteredTickets.filter(
+      t => t.sla_status === 'breached' || t.sla_status === 'warning'
+    );
+
+    if (activeViolations.length === 0) {
+      return (
+        <div className="py-24 text-center" style={{ border: '2px dashed #D1FAE5', borderRadius: '16px' }}>
+          <ShieldCheck size={48} className="mx-auto mb-3 text-emerald-400" />
+          <h3 className="text-lg font-bold text-emerald-700">No Active Violations</h3>
+          <p className="text-sm text-gray-500 mt-1">All tickets within SLA limits.</p>
+        </div>
+      );
+    }
+
+    return (
+      <div className="space-y-3">
+        {activeViolations.map(ticket => {
+          const pStyle = PRIORITY_STYLES[ticket.priority?.toLowerCase()] || PRIORITY_STYLES.medium;
+          const sStyle = STATUS_STYLES[ticket.sla_status] || STATUS_STYLES.active;
+
+          return (
+            <div
+              key={ticket.id}
+              className="flex items-center justify-between p-4 rounded-xl border bg-white transition-all hover:shadow-md"
+              style={{ borderColor: sStyle.border }}
+            >
+              <div className="flex items-center gap-4 min-w-0 flex-1">
+                <sStyle.icon size={20} style={{ color: sStyle.text }} className="flex-shrink-0" />
+                <div className="min-w-0 flex-1">
+                  <div className="flex items-center gap-2">
+                    <span className="text-sm font-semibold text-gray-800 truncate">
+                      {ticket.subject || ticket.summary || 'Untitled'}
+                    </span>
+                    <span
+                      className="text-[10px] font-bold px-2 py-0.5 rounded uppercase"
+                      style={{ background: pStyle.bg, color: pStyle.text, border: `1px solid ${pStyle.border}` }}
+                    >
+                      {ticket.priority || 'MEDIUM'}
+                    </span>
+                  </div>
+                  <div className="flex items-center gap-3 mt-1">
+                    <span className="text-xs text-gray-400">
+                      #{((ticket.ticket_id || ticket.id) || '').toString().slice(0, 8)}
+                    </span>
+                    <span className="text-xs text-gray-400">{ticket.assigned_team || 'Unassigned'}</span>
+                    <span className="text-xs text-gray-400">
+                      {formatDuration(ticket.remaining_seconds)}
+                    </span>
+                  </div>
+                </div>
+              </div>
+              <div className="flex items-center gap-2 flex-shrink-0">
+                <SLABadge
+                  priority={ticket.priority}
+                  createdAt={ticket.created_at}
+                  status={ticket.status}
+                  compact
+                />
+                <a
+                  href={`/admin/ticket/${ticket.ticket_id || ticket.id}`}
+                  className="p-2 text-gray-400 hover:text-emerald-500 transition-colors"
+                >
+                  <ExternalLink size={14} />
+                </a>
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    );
+  };
+
+  // ── Render: Escalations Tab ─────────────────────────────────────────────────
+
+  const renderEscalations = () => {
+    if (loading) {
+      return (
+        <div className="py-24 text-center">
+          <RefreshCw size={32} className="animate-spin mx-auto mb-4 text-emerald-500" />
+          <p className="text-sm text-gray-400 font-semibold">Loading escalations...</p>
+        </div>
+      );
+    }
+
+    if (escalations.length === 0) {
+      return (
+        <div className="py-24 text-center" style={{ border: '2px dashed #E5E7EB', borderRadius: '16px' }}>
+          <Bell size={40} className="mx-auto mb-3 text-gray-300" />
+          <h3 className="text-sm font-bold text-gray-500">No Escalations Logged</h3>
+          <p className="text-xs text-gray-400 mt-1">All tickets resolved within SLA.</p>
+        </div>
+      );
+    }
+
+    return (
+      <div className="space-y-2">
+        {escalations.map((esc, idx) => {
+          const isBreached = esc.sla_status === 'breached';
+          const isExpanded = expandedEsc === (esc.id || idx);
+          const level = esc.escalation_level || 0;
+
+          return (
+            <div
+              key={esc.id || idx}
+              className="rounded-xl border bg-white overflow-hidden transition-all"
+              style={{ borderColor: isBreached ? '#FECACA' : '#E5E7EB' }}
+            >
+              <button
+                onClick={() => setExpandedEsc(isExpanded ? null : (esc.id || idx))}
+                className="w-full flex items-center justify-between p-4 text-left hover:bg-gray-50 transition-colors"
+              >
+                <div className="flex items-center gap-3 min-w-0 flex-1">
+                  <div
+                    className="w-9 h-9 rounded-lg flex items-center justify-center flex-shrink-0"
+                    style={{ background: isBreached ? '#FEF2F2' : '#FEFCE8' }}
+                  >
+                    {isBreached
+                      ? <AlertCircle size={16} className="text-red-500" />
+                      : <AlertTriangle size={16} className="text-amber-500" />
+                    }
+                  </div>
+                  <div className="min-w-0 flex-1">
+                    <p className="text-sm font-semibold text-gray-800 truncate">
+                      {esc.ticket_subject || `Ticket #${((esc.ticket_id || '') + '').slice(0, 8)}`}
+                    </p>
+                    <div className="flex items-center gap-2 mt-0.5">
+                      <span className="text-[10px] font-bold uppercase px-1.5 py-0.5 rounded"
+                        style={{
+                          background: isBreached ? '#FEF2F2' : '#FEFCE8',
+                          color: isBreached ? '#DC2626' : '#CA8A04',
+                        }}
+                      >
+                        L{level}
+                      </span>
+                      <span className="text-xs text-gray-400">{esc.assigned_team || 'Unassigned'}</span>
+                      <span className="text-xs text-gray-400">{formatDate(esc.triggered_at)}</span>
+                    </div>
+                  </div>
+                </div>
+                <div className="flex items-center gap-2 flex-shrink-0">
+                  <span
+                    className={`text-[10px] font-bold px-2 py-1 rounded-full uppercase ${
+                      isBreached ? 'bg-red-50 text-red-600' : 'bg-amber-50 text-amber-600'
+                    }`}
+                  >
+                    {esc.sla_status}
+                  </span>
+                  {isExpanded ? <ChevronUp size={14} className="text-gray-400" /> : <ChevronDown size={14} className="text-gray-400" />}
+                </div>
+              </button>
+
+              {isExpanded && (
+                <div className="px-4 pb-4 pt-0 border-t border-gray-100 bg-gray-50/50">
+                  <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mt-3">
+                    <div>
+                      <p className="text-[10px] font-semibold text-gray-400 uppercase">Status</p>
+                      <p className="text-xs font-bold text-gray-700 mt-1">{esc.sla_status}</p>
+                    </div>
+                    <div>
+                      <p className="text-[10px] font-semibold text-gray-400 uppercase">Level</p>
+                      <p className="text-xs font-bold text-gray-700 mt-1">{level}</p>
+                    </div>
+                    <div>
+                      <p className="text-[10px] font-semibold text-gray-400 uppercase">Remaining</p>
+                      <p className="text-xs font-bold text-gray-700 mt-1">{formatDuration(esc.remaining_seconds)}</p>
+                    </div>
+                    <div>
+                      <p className="text-[10px] font-semibold text-gray-400 uppercase">Priority</p>
+                      <p className="text-xs font-bold text-gray-700 mt-1">{esc.priority || 'N/A'}</p>
+                    </div>
+                  </div>
+                  {esc.notification_channels && esc.notification_channels.length > 0 && (
+                    <div className="mt-3 flex items-center gap-2">
+                      <span className="text-[10px] font-semibold text-gray-400 uppercase">Channels:</span>
+                      {esc.notification_channels.map((ch, i) => (
+                        <span
+                          key={i}
+                          className={`text-[10px] font-bold px-2 py-0.5 rounded-full ${
+                            ch.includes('OK') ? 'bg-emerald-50 text-emerald-600' : 'bg-red-50 text-red-500'
+                          }`}
+                        >
+                          {ch}
+                        </span>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    );
+  };
+
+  // ── Render: Policies Tab ────────────────────────────────────────────────────
+
+  const renderPolicies = () => {
+    if (policies.length === 0) {
+      return (
+        <div className="py-16 text-center" style={{ border: '2px dashed #E5E7EB', borderRadius: '16px' }}>
+          <Settings size={40} className="mx-auto mb-3 text-gray-300" />
+          <h3 className="text-sm font-bold text-gray-500">Default Policies Active</h3>
+          <p className="text-xs text-gray-400 mt-1">Custom policies can be configured from the database.</p>
+        </div>
+      );
+    }
+
+    return (
+      <div className="overflow-x-auto">
+        <table className="w-full border-collapse">
+          <thead>
+            <tr style={{ background: '#F8FAFC', borderBottom: '1px solid #E2E8F0' }}>
+              <th className="text-[10px] font-bold text-gray-500 uppercase tracking-wider p-4 text-left">Priority</th>
+              <th className="text-[10px] font-bold text-gray-500 uppercase tracking-wider p-4 text-left">Max Hours</th>
+              <th className="text-[10px] font-bold text-gray-500 uppercase tracking-wider p-4 text-left">Warning At</th>
+              <th className="text-[10px] font-bold text-gray-500 uppercase tracking-wider p-4 text-left">Auto Escalate</th>
+              <th className="text-[10px] font-bold text-gray-500 uppercase tracking-wider p-4 text-left">L2 Escalation</th>
+              <th className="text-[10px] font-bold text-gray-500 uppercase tracking-wider p-4 text-left">L3 Escalation</th>
+            </tr>
+          </thead>
+          <tbody>
+            {policies.map((p, idx) => {
+              const colors = PRIORITY_STYLES[p.priority] || PRIORITY_STYLES.medium;
+              return (
+                <tr key={p.id || idx} className="border-b border-gray-100 hover:bg-gray-50 transition-colors">
+                  <td className="p-4">
+                    <span
+                      className="text-xs font-bold uppercase px-3 py-1 rounded-full"
+                      style={{ background: colors.bg, color: colors.text, border: `1px solid ${colors.border}` }}
+                    >
+                      {p.priority}
+                    </span>
+                  </td>
+                  <td className="p-4 text-sm font-semibold text-gray-700">{p.max_hours}h</td>
+                  <td className="p-4 text-sm font-semibold text-gray-700">{Math.round((p.warning_pct || 0.75) * 100)}%</td>
+                  <td className="p-4">
+                    <span
+                      className={`text-xs font-bold px-2 py-0.5 rounded ${
+                        p.auto_escalate ? 'bg-emerald-50 text-emerald-600' : 'bg-gray-100 text-gray-500'
+                      }`}
+                    >
+                      {p.auto_escalate ? 'Yes' : 'No'}
+                    </span>
+                  </td>
+                  <td className="p-4 text-sm text-gray-600">{p.l2_after_minutes > 0 ? `${p.l2_after_minutes}m` : 'Immediate'}</td>
+                  <td className="p-4 text-sm text-gray-600">{p.l3_after_minutes > 0 ? `${p.l3_after_minutes}m` : '—'}</td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      </div>
+    );
+  };
+
+  // ── Main Render ────────────────────────────────────────────────────────────
+
+  return (
+    <div style={{ background: '#F8FAF9', minHeight: '100vh', paddingBottom: '60px' }} className="space-y-8 -m-6 p-6 md:-m-10 md:p-10">
+      {/* Header */}
+      <div className="flex flex-col md:flex-row md:items-center justify-between gap-4">
+        <div>
+          <h1 className="text-2xl font-extrabold text-gray-900" style={{ fontFamily: 'Syne, sans-serif' }}>
+            SLA Monitor
+          </h1>
+          <p className="text-sm text-gray-500 mt-1 flex items-center gap-2">
+            <span className="w-2 h-2 rounded-full bg-emerald-500 inline-block animate-pulse" />
+            Service-Level Agreement Management
+          </p>
+        </div>
+        <FiltersBar />
+      </div>
+
+      {/* Tab Navigation */}
+      <div className="flex gap-1 p-1 bg-white rounded-xl border border-gray-100 w-fit">
+        {tabs.map(tab => (
+          <button
+            key={tab.id}
+            onClick={() => setActiveTab(tab.id)}
+            className={`flex items-center gap-2 px-4 py-2 rounded-lg text-xs font-bold uppercase tracking-wider transition-all ${
+              activeTab === tab.id
+                ? 'bg-emerald-500 text-white shadow-sm'
+                : 'text-gray-500 hover:text-gray-700 hover:bg-gray-50'
+            }`}
+          >
+            <tab.icon size={14} />
+            {tab.label}
+          </button>
+        ))}
+      </div>
+
+      {/* Tab Content */}
+      <div>
+        {activeTab === 'dashboard' && renderDashboard()}
+        {activeTab === 'violations' && renderViolations()}
+        {activeTab === 'escalations' && renderEscalations()}
+        {activeTab === 'policies' && renderPolicies()}
+      </div>
+    </div>
+  );
+}

Frontend/src/components/shared/DuplicateWarningBanner.jsx

@@ -0,0 +1,256 @@
+/**
+ * DuplicateWarningBanner — Animated warning card shown when a potential
+ * duplicate ticket is detected during ticket creation.
+ *
+ * Features:
+ *   - Animated slide-in warning with similarity score
+ *   - Link to parent ticket
+ *   - "Subscribe to existing" vs "Create anyway" actions
+ *   - Matches the HELPDESK.AI design system (glass morphism, gradient)
+ */
+
+import React, { useState, useEffect } from 'react';
+import { useNavigate } from 'react-router-dom';
+import {
+  AlertTriangle,
+  Copy,
+  Eye,
+  Bell,
+  X,
+  ExternalLink,
+  ChevronDown,
+  ChevronUp,
+  Users,
+  Clock,
+  ArrowRight,
+  Send,
+} from 'lucide-react';
+
+/**
+ * Format similarity as percentage with color.
+ */
+function formatSimilarity(score) {
+  if (score == null) return '—';
+  const pct = Math.round(score * 100);
+  if (pct >= 95) return { value: `${pct}%`, color: '#DC2626' };
+  if (pct >= 85) return { value: `${pct}%`, color: '#EA580C' };
+  if (pct >= 75) return { value: `${pct}%`, color: '#CA8A04' };
+  return { value: `${pct}%`, color: '#16A34A' };
+}
+
+/**
+ * Format an ISO date string to a relative time.
+ */
+function formatDate(iso) {
+  if (!iso) return '';
+  const d = new Date(iso);
+  const now = new Date();
+  const diffMs = now - d;
+  const diffHr = Math.floor(diffMs / (1000 * 60 * 60));
+  if (diffHr < 1) return 'just now';
+  if (diffHr < 24) return `${diffHr}h ago`;
+  return `${Math.floor(diffHr / 24)}d ago`;
+}
+
+/**
+ * DuplicateWarningBanner
+ *
+ * Props:
+ *   - duplicate: { is_duplicate, duplicate_ticket_id, parent_subject, similarity, candidates }
+ *   - onSubscribe: () => void — User wants to subscribe to existing ticket
+ *   - onCreateAnyway: () => void — User wants to create ticket regardless
+ *   - onDismiss: () => void — Dismiss warning
+ *   - ticketId: string — ID of the current ticket being created
+ */
+export default function DuplicateWarningBanner({
+  duplicate,
+  onSubscribe,
+  onCreateAnyway,
+  onDismiss,
+  ticketId,
+}) {
+  const navigate = useNavigate();
+  const [expanded, setExpanded] = useState(false);
+  const [visible, setVisible] = useState(false);
+
+  // Animate in on mount
+  useEffect(() => {
+    const timer = setTimeout(() => setVisible(true), 100);
+    return () => clearTimeout(timer);
+  }, []);
+
+  if (!duplicate || !duplicate.is_duplicate) return null;
+
+  const { similarity, parent_subject, duplicate_ticket_id, candidates } = duplicate;
+  const sim = formatSimilarity(similarity);
+  const extraCandidates = (candidates || []).filter(
+    c => c.id !== duplicate_ticket_id
+  );
+
+  return (
+    <div
+      className={`transition-all duration-500 ease-out ${
+        visible ? 'opacity-100 translate-y-0' : 'opacity-0 translate-y-4'
+      }`}
+    >
+      <div
+        className="rounded-2xl border-2 overflow-hidden"
+        style={{
+          borderColor: '#FECACA',
+          background: 'linear-gradient(135deg, #FFF5F5 0%, #FFFBEB 100%)',
+          boxShadow: '0 8px 32px rgba(239, 68, 68, 0.1)',
+        }}
+      >
+        {/* Warning Header */}
+        <div className="p-5 flex items-start gap-4">
+          {/* Icon */}
+          <div
+            className="w-12 h-12 rounded-xl flex items-center justify-center flex-shrink-0 animate-pulse"
+            style={{ background: '#FEF2F2', border: '1px solid #FECACA' }}
+          >
+            <AlertTriangle size={22} className="text-red-500" />
+          </div>
+
+          {/* Content */}
+          <div className="flex-1 min-w-0">
+            <div className="flex items-start justify-between gap-2">
+              <div>
+                <h3 className="text-base font-bold text-gray-900 flex items-center gap-2">
+                  <Copy size={16} className="text-amber-500" />
+                  Potential Duplicate Detected
+                </h3>
+                <p className="text-sm text-gray-600 mt-1">
+                  A similar issue was recently reported by your teammate.
+                </p>
+              </div>
+              {onDismiss && (
+                <button
+                  onClick={onDismiss}
+                  className="p-1.5 rounded-lg text-gray-400 hover:text-gray-600 hover:bg-gray-100 transition-colors flex-shrink-0"
+                >
+                  <X size={16} />
+                </button>
+              )}
+            </div>
+
+            {/* Match Info Card */}
+            <div
+              className="mt-4 rounded-xl p-4 border"
+              style={{ background: '#FFFFFF', borderColor: '#FEE2E2' }}
+            >
+              <div className="flex items-center justify-between">
+                <div className="flex items-center gap-3 min-w-0 flex-1">
+                  {/* Similarity Badge */}
+                  <div
+                    className="flex flex-col items-center px-3 py-2 rounded-lg"
+                    style={{ background: similarity >= 0.85 ? '#FEF2F2' : '#FFFBEB' }}
+                  >
+                    <span
+                      className="text-lg font-extrabold"
+                      style={{ color: sim.color }}
+                    >
+                      {sim.value}
+                    </span>
+                    <span className="text-[9px] font-semibold text-gray-400 uppercase tracking-wider">
+                      Match
+                    </span>
+                  </div>
+
+                  {/* Parent Ticket Info */}
+                  <div className="min-w-0 flex-1">
+                    {parent_subject && (
+                      <p className="text-sm font-semibold text-gray-800 truncate">
+                        {parent_subject}
+                      </p>
+                    )}
+                    <p className="text-xs text-gray-500 mt-0.5">
+                      Ticket #{((duplicate_ticket_id || '') + '').slice(0, 8).toUpperCase()}
+                    </p>
+                  </div>
+                </div>
+
+                {/* View Parent Ticket */}
+                <a
+                  href={`/admin/ticket/${duplicate_ticket_id}`}
+                  className="flex items-center gap-1.5 px-3 py-2 text-xs font-bold text-blue-600 bg-blue-50 border border-blue-200 rounded-lg hover:bg-blue-100 transition-colors flex-shrink-0"
+                >
+                  <Eye size={14} />
+                  View
+                </a>
+              </div>
+
+              {/* Extra candidates */}
+              {extraCandidates.length > 0 && (
+                <div className="mt-3 pt-3 border-t border-gray-100">
+                  <button
+                    onClick={() => setExpanded(!expanded)}
+                    className="flex items-center gap-1.5 text-xs font-semibold text-gray-500 hover:text-gray-700 transition-colors"
+                  >
+                    {expanded ? <ChevronUp size={14} /> : <ChevronDown size={14} />}
+                    {extraCandidates.length} more similar ticket{extraCandidates.length > 1 ? 's' : ''}
+                  </button>
+
+                  {expanded && (
+                    <div className="mt-2 space-y-1.5">
+                      {extraCandidates.map((c, idx) => (
+                        <div
+                          key={c.id || idx}
+                          className="flex items-center justify-between p-2 rounded-lg bg-gray-50"
+                        >
+                          <div className="flex items-center gap-2 min-w-0">
+                            <span
+                              className="text-[10px] font-bold px-1.5 py-0.5 rounded"
+                              style={{
+                                background: c.similarity >= 0.85 ? '#FEF2F2' : '#FEFCE8',
+                                color: c.similarity >= 0.85 ? '#DC2626' : '#CA8A04',
+                              }}
+                            >
+                              {Math.round(c.similarity * 100)}%
+                            </span>
+                            <span className="text-xs text-gray-700 truncate">
+                              {c.subject || `#${((c.id || '') + '').slice(0, 8)}`}
+                            </span>
+                          </div>
+                          <span className="text-[10px] text-gray-400 flex-shrink-0">
+                            {c.assigned_team || ''}
+                          </span>
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              )}
+            </div>
+
+            {/* Action Buttons */}
+            <div className="flex flex-wrap items-center gap-3 mt-4">
+              {onSubscribe && (
+                <button
+                  onClick={onSubscribe}
+                  className="flex items-center gap-2 px-5 py-2.5 text-sm font-bold text-white rounded-xl transition-all hover:shadow-lg active:scale-[0.98]"
+                  style={{ background: 'linear-gradient(135deg, #16A34A, #15803D)' }}
+                >
+                  <Bell size={16} />
+                  Subscribe to Existing Ticket
+                  <ArrowRight size={16} />
+                </button>
+              )}
+              {onCreateAnyway && (
+                <button
+                  onClick={onCreateAnyway}
+                  className="flex items-center gap-2 px-4 py-2.5 text-sm font-semibold text-gray-600 bg-white border border-gray-200 rounded-xl hover:bg-gray-50 hover:border-gray-300 transition-all"
+                >
+                  <Send size={14} />
+                  Create Anyway
+                </button>
+              )}
+              <p className="text-[10px] text-gray-400 ml-auto">
+                AI-powered semantic match · all-MiniLM-L6-v2
+              </p>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

backend/main.py

@@ -12,6 +12,7 @@ import datetime
 import traceback
 import warnings
 import logging
+import hashlib
 from contextlib import asynccontextmanager
 
 # Suppress harmless PyTorch CPU pin_memory warning
@@ -60,13 +61,8 @@ from backend.services.onnx_service import onnx_classifier
 from backend.services.ner_service import NERService
 from backend.services.duplicate_service import DuplicateService
 from backend.services.rag_service import RagService
-from backend.services.sla_service import (
-    calculate_sla_breach_at,
-    calculate_sla_response_at,
-    classify_sla_status,
-    load as load_sla_service,
-    run_sla_escalation_loop,
-)
+from backend.services.sla_engine import SLAEngine, compute_sla_breach_at, get_sla_policy
+from backend.services.semantic_duplicate_service import SemanticDuplicateService
 
 
 # ---------------------------------------------------------------------------
@@ -154,13 +150,13 @@ def classify_ticket_text(text: str) -> dict:
             "category": "Unknown", "subcategory": "Unknown", "priority": "Medium",
             "auto_resolve": False, "assigned_team": "General Support", "confidence": 0.0,
         }
+
 class TicketRequest(BaseModel):
     text: str
     image_base64: str = ""
     image_text: str = "" # Keep for backward compatibility
     user_id: str | None = None
     company: str | None = None
-    company_id: str | None = None
     image_url: str | None = None
     confidence_threshold: float = 0.20
     duplicate_sensitivity: float = 0.85
@@ -180,10 +176,6 @@ class TicketSaveRequest(BaseModel):
     image_url: str | None = None
     company: str | None = None
     company_id: str | None = None
-    description_vector: list[float] | None = None
-    is_potential_duplicate: bool = False
-    parent_ticket_id: str | None = None
-    sla_response_due_at: str | None = None
     sla_breach_at: str
     sla_status: str | None = None
     escalation_level: int = 0
@@ -199,8 +191,6 @@ class TicketSaveRequest(BaseModel):
 class DuplicateInfo(BaseModel):
     is_duplicate: bool
     duplicate_ticket_id: str | None = None
-    parent_ticket_id: str | None = None
-    is_potential_duplicate: bool = False
     similarity: float = 0.0
 
 
@@ -222,8 +212,6 @@ class TicketResponse(BaseModel):
     entities: list[EntityInfo]
     duplicate_ticket: DuplicateInfo
     confidence: float
-    is_potential_duplicate: bool = False
-    parent_ticket_id: str | None = None
     needs_review: bool = False
     reasoning: str = ""
     decision_factors: list[str] = []
@@ -232,7 +220,6 @@ class TicketResponse(BaseModel):
     highlights: list[str] = []
     timeline: dict = {} # Map of step_name: timestamp
     env_metadata: dict = {} # IP, Hostname, Browser/OS
-    sla_breach_at: str | None = None
     version: str = "2.1.0-Neural-Diagnostic"
 
 
@@ -300,6 +287,8 @@ classifier_service = ClassifierService()
 ner_service = NERService()
 duplicate_service = DuplicateService()
 rag_service = RagService()
+sla_engine = SLAEngine(supabase_client=None)  # Will be reassigned after supabase init
+semantic_dupe_service = SemanticDuplicateService(supabase_client=None)  # wired in lifespan
 
 try:
     from backend.services.gemini_service import GeminiService
@@ -347,45 +336,29 @@ async def lifespan(app: FastAPI):
     else:
         print("[Startup] Gemini Service: NOT LOADED (Import failed)")
 
-    print("[Startup] Classifier V2 Shadow: Ready.")
-    print(f"[Startup] ONNX MiniLM Fallback: {'READY' if getattr(onnx_classifier, '_loaded', False) else 'DEGRADED (artifacts missing)'}")
-    print("[Startup] Ready.")
-    # Strict health checks: fail loudly when core model assets are unavailable.
-    # Set ALLOW_DEGRADED_STARTUP=1 to permit degraded startup for local/dev convenience.
-    try:
-        strict_mode = os.environ.get("ALLOW_DEGRADED_STARTUP", "0") != "1"
-    except Exception:
-        strict_mode = True
+    # Wire services with supabase client
+    sla_engine.supabase = supabase
+    semantic_dupe_service.supabase = supabase
 
-    classifier_loaded_flag = getattr(classifier_service, "_loaded", False)
-    ner_loaded_flag = getattr(ner_service, "_loaded", False)
+    # Pre-load embedding model so first ticket save is fast
+    try:
+        semantic_dupe_service.load()
+        print(f"[Startup] Semantic Duplicate Detection: {'Loaded' if semantic_dupe_service._loaded else 'Failed (model missing)'}")
+    except Exception as e:
+        print(f"[Startup] Semantic Duplicate Detection load error: {e}")
+    print(f"[Startup] SLA Engine: {'Initialized' if supabase else 'Offline (no DB)'}")
 
-    if strict_mode and not classifier_loaded_flag:
-        raise RuntimeError("[Startup-FATAL] Classifier assets not loaded. Set ALLOW_DEGRADED_STARTUP=1 to bypass.")
+    # Start background SLA checker as an async task (every 5 minutes)
+    if supabase:
+        from backend.sla_checker import sla_checker_loop_async
+        asyncio.create_task(sla_checker_loop_async(supabase, interval_seconds=300))
+        print("[Startup] SLA background checker started (interval=300s)")
 
-    sla_task = None
-    try:
-        if supabase and os.environ.get("SLA_ESCALATION_ENABLED", "true").lower() == "true":
-            notification_router = None
-            try:
-                from backend.services.notification_routing import load as load_notification_router
-                notification_router = load_notification_router()
-            except Exception as e:
-                print(f"[WARNING] Notification router not loaded for SLA service: {e}")
-            sla_service = load_sla_service(supabase, notification_router)
-            interval = int(os.environ.get("SLA_ESCALATION_INTERVAL_SECONDS", "300"))
-            sla_task = asyncio.create_task(run_sla_escalation_loop(sla_service, interval_seconds=interval))
-            print(f"[Startup] SLA escalation loop enabled ({interval}s interval).")
-
-        yield
-    finally:
-        if sla_task:
-            sla_task.cancel()
-            try:
-                await sla_task
-            except asyncio.CancelledError:
-                pass
-        print("[Shutdown] Cleaning up ...")
+    print("[Startup] Classifier V2 Shadow: Ready.")
+    print(f"[Startup] ONNX MiniLM Fallback: {'READY' if getattr(onnx_classifier, '_loaded', False) else 'DEGRADED (artifacts missing)'}")
+    print("[Startup] Ready.")
+    yield
+    print("[Shutdown] Cleaning up ...")
 
 
 # ---------------------------------------------------------------------------
@@ -514,29 +487,18 @@ async def health_check():
 @app.get("/ready", response_model=ReadinessResponse)
 async def readiness_check():
     require_supabase = os.environ.get("REQUIRE_SUPABASE", "false").lower() == "true"
-    allow_degraded = os.environ.get("ALLOW_DEGRADED_STARTUP", "0") == "1"
-    
     checks = {
         "api": True,
         "classifier_loaded": classifier_service._loaded,
         "ner_loaded": ner_service._loaded,
-        "duplicate_index_loaded": duplicate_service.is_available(),
-        "rag_loaded": rag_service.is_available(),
+        "duplicate_index_loaded": duplicate_service._loaded,
+        "rag_loaded": rag_service._loaded,
     }
     if require_supabase:
         checks["supabase_configured"] = supabase is not None
 
-    # In degraded mode, duplicate and RAG services are optional
-    if allow_degraded:
-        required_checks = {k: v for k, v in checks.items() if k not in ["duplicate_index_loaded", "rag_loaded"]}
-        all_required_pass = all(required_checks.values())
-        
-        if all_required_pass:
-            return ReadinessResponse(status="ready", checks=checks)
-    else:
-        # Strict mode: all checks must pass
-        if all(checks.values()):
-            return ReadinessResponse(status="ready", checks=checks)
+    if all(checks.values()):
+        return ReadinessResponse(status="ready", checks=checks)
 
     return JSONResponse(
         status_code=503,
@@ -677,31 +639,6 @@ async def get_tickets(company_id: str | None = None):
     res = query.execute()
     return res.data
 
-@app.get("/tickets/search")
-async def search_tickets(q: str | None = None, company_id: str | None = None, limit: int = 50, offset: int = 0):
-    """Search tickets using tenant-safe full-text search."""
-    if not supabase:
-        raise HTTPException(status_code=500, detail="Database connection not initialized")
-
-    if not q:
-        raise HTTPException(status_code=400, detail="Search query is required")
-    if not company_id:
-        raise HTTPException(status_code=400, detail="company_id is required for tenant-safe search")
-
-    try:
-        result = supabase.rpc(
-            "search_tickets",
-            {
-                "query_text": q,
-                "company_id": company_id,
-                "limit_rows": limit,
-                "offset_rows": offset,
-            },
-        ).execute()
-        return result.data or []
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Search failed: {e}")
-
 @app.post("/tickets/save")
 async def save_ticket(request_body: TicketSaveRequest):
     """
@@ -753,38 +690,28 @@ async def save_ticket(request_body: TicketSaveRequest):
         if not final_data.get("company") and profile.get("company"):
             final_data["company"] = profile["company"]
 
-        priority = final_data.get("priority")
-        if not final_data.get("sla_response_due_at"):
-            final_data["sla_response_due_at"] = calculate_sla_response_at(priority).isoformat().replace("+00:00", "Z")
-        if not final_data.get("sla_breach_at"):
-            final_data["sla_breach_at"] = calculate_sla_breach_at(priority).isoformat().replace("+00:00", "Z")
-        final_data["sla_status"] = final_data.get("sla_status") or classify_sla_status(final_data.get("sla_breach_at"))
-        final_data["escalation_level"] = int(final_data.get("escalation_level") or 0)
-
-        logger.info(f"Tenant linkage: user_id={request_body.user_id}, company_id={final_data.get('company_id')}")
-
-        duplicate_text = (request_body.description or "").strip() or (request_body.subject or "").strip()
-        duplicate_threshold = get_duplicate_threshold(final_data.get("company_id"), 0.85)
-        duplicate_result = {
-            "is_duplicate": False,
-            "duplicate_ticket_id": None,
-            "parent_ticket_id": None,
-            "is_potential_duplicate": False,
-            "similarity": 0.0,
-        }
+        user_hash = hashlib.sha256(str(request_body.user_id).encode()).hexdigest()[:8]
+        logger.info(f"Tenant linkage: user_hash={user_hash}, company_id={final_data.get('company_id')}")
 
-        if duplicate_text:
-            duplicate_result = detect_semantic_duplicate(
-                duplicate_text,
-                company_id=final_data.get("company_id"),
-                threshold=duplicate_threshold,
-            )
-            final_data["description_vector"] = duplicate_service.generate_embedding(duplicate_text)
-        else:
-            final_data["description_vector"] = None
 
-        final_data["is_potential_duplicate"] = duplicate_result.get("is_potential_duplicate", False)
-        final_data["parent_ticket_id"] = duplicate_result.get("parent_ticket_id")
+        # Semantic duplicate check BEFORE inserting the ticket
+        # This allows us to warn the user before confirming
+        duplicate_check_result = None
+        try:
+            dupe_text = (request_body.description or request_body.subject or "").strip()
+            if dupe_text:
+                duplicate_check_result = await semantic_dupe_service.check_duplicate(
+                    text=dupe_text,
+                    company_id=final_data.get("company_id"),
+                )
+                if duplicate_check_result["is_duplicate"]:
+                    logger.info(
+                        f"[DUPLICATE] Ticket flagged as potential duplicate of "
+                        f"{duplicate_check_result['duplicate_ticket_id']} "
+                        f"(similarity: {duplicate_check_result['similarity']})"
+                    )
+        except Exception as e:
+            logger.warning(f"[DUPLICATE] Semantic check error (non-fatal): {e}")
 
         # --- Sanitize payload to only include valid Supabase DB columns ---
         # Extra AI telemetry and non-existent schema fields are merged into the metadata JSONB column
@@ -815,19 +742,29 @@ async def save_ticket(request_body: TicketSaveRequest):
             
         ticket_id = res.data[0]["id"]
 
-        duplicate_indexed = True
-        duplicate_index_warning = None
+        # If duplicate detected, link parent ticket
+        if duplicate_check_result and duplicate_check_result["is_duplicate"]:
+            try:
+                supabase.table("tickets").update({
+                    "is_potential_duplicate": True,
+                    "parent_ticket_id": duplicate_check_result["duplicate_ticket_id"],
+                }).eq("id", ticket_id).execute()
+            except Exception as e:
+                logger.warning(f"[DUPLICATE] Failed to link parent ticket: {e}")
+
+        # Index the new ticket's embedding for future duplicate checks
+        embedding_indexed = False
+        description_text = (request_body.description or "").strip()
+        subject_text = (request_body.subject or "").strip()
+        duplicate_text = description_text or subject_text
         if duplicate_text:
             try:
+                # Both: old in-memory index (for backward compat) and new pgvector index
                 duplicate_service.add_ticket(str(ticket_id), duplicate_text)
+                asyncio.create_task(semantic_dupe_service.index_ticket(ticket_id, duplicate_text))
+                embedding_indexed = True
             except Exception as index_error:
-                duplicate_indexed = False
-                duplicate_index_warning = "Duplicate index update failed."
-                print(f"[WARNING] {duplicate_index_warning} ticket_id={ticket_id} error={index_error}")
-        else:
-            duplicate_indexed = False
-            duplicate_index_warning = "Duplicate index update skipped: no description or subject text was provided."
-            print(f"[WARNING] {duplicate_index_warning}")
+                logger.warning(f"[INDEX] Failed to index ticket {ticket_id}: {index_error}")
         
         # Add initial system diagnostic message
         msg = "Our Neural Engine has successfully triaged your issue and routed it to the designated team."
@@ -845,12 +782,14 @@ async def save_ticket(request_body: TicketSaveRequest):
         response = {
             "status": "success",
             "ticket_id": ticket_id,
-            "duplicate_indexed": duplicate_indexed,
-            "is_potential_duplicate": final_data["is_potential_duplicate"],
-            "parent_ticket_id": final_data["parent_ticket_id"],
+            "duplicate_indexed": embedding_indexed,
         }
-        if duplicate_index_warning:
-            response["duplicate_index_warning"] = duplicate_index_warning
+        if duplicate_check_result and duplicate_check_result["is_duplicate"]:
+            response["duplicate_warning"] = True
+            response["parent_ticket_id"] = duplicate_check_result["duplicate_ticket_id"]
+            response["parent_subject"] = duplicate_check_result.get("parent_subject")
+            response["similarity"] = duplicate_check_result["similarity"]
+            response["candidates"] = duplicate_check_result.get("candidates", [])
         return response
 
     except Exception as e:
@@ -920,11 +859,6 @@ async def analyze_ticket(request_body: TicketRequest, request: Request):
     Main endpoint for analyzing a new ticket using the cascade of local AI models.
     """
     text = request_body.text
-
-    settings = get_system_settings(request_body.company_id)
-    confidence_threshold = settings["ai_confidence_threshold"]
-    duplicate_sensitivity = settings["duplicate_sensitivity"]
-    enable_auto_resolve = settings["enable_auto_resolve"]
     
     # Grab client metadata
     client_ip = request.client.host if request.client else "unknown"
@@ -1047,21 +981,10 @@ async def analyze_only(request_body: TicketRequest):
     timeline["metadata_harvested"] = get_now_ist()
 
     # --- Duplicate detection ---
-    duplicate_threshold = get_duplicate_threshold(request_body.company_id, duplicate_sensitivity)
     try:
-        dup_result = detect_semantic_duplicate(
-            text,
-            company_id=request_body.company_id,
-            threshold=duplicate_threshold,
-        )
+        dup_result = duplicate_service.check_duplicate(text, threshold=request_body.duplicate_sensitivity)
     except Exception:
-        dup_result = {
-            "is_duplicate": False,
-            "duplicate_ticket_id": None,
-            "parent_ticket_id": None,
-            "is_potential_duplicate": False,
-            "similarity": 0.0,
-        }
+        dup_result = {"is_duplicate": False, "duplicate_ticket_id": None, "similarity": 0.0}
 
     # --- RAG Knowledge Base Check ---
     rag_match = None
@@ -1077,7 +1000,7 @@ async def analyze_only(request_body: TicketRequest):
 
     # --- Reasoning ---
     decision_factors = []
-    if classification["confidence"] > confidence_threshold:
+    if classification["confidence"] > request_body.confidence_threshold:
         decision_factors.append(f"High confidence match for '{classification['subcategory']}'")
     if entities:
         decision_factors.append(f"Detected entities: {', '.join([e['text'] for e in entities[:2]])}")
@@ -1087,14 +1010,6 @@ async def analyze_only(request_body: TicketRequest):
         decision_factors.append(f"Found solution article: '{rag_match['title']}'")
 
     reasoning = f"Categorized as '{classification['category']}' - {classification['subcategory']}."
-    if (
-        enable_auto_resolve
-        and classification["confidence"] >= confidence_threshold
-        and classification["auto_resolve"]
-    ):
-        classification["auto_resolve"] = True
-    else:
-        classification["auto_resolve"] = False
     if classification["auto_resolve"]:
         reasoning += " Flagged for AI auto-resolution via Knowledge Base." if rag_match else " Flagged for auto-resolution."
     
@@ -1104,8 +1019,10 @@ async def analyze_only(request_body: TicketRequest):
     if gemini_service and gemini_service._initialized:
         summary = gemini_service.get_summary(text)
     
-    # Convert priority to the SLA resolution target timestamp for preview.
-    sla_breach_dt = calculate_sla_breach_at(classification["priority"])
+    # Convert priority to SLA breached timestamp (for preview)
+    hours_map = {"Critical": 2, "High": 8, "Medium": 24, "Low": 72}
+    sla_hours = hours_map.get(classification["priority"], 72)
+    sla_breach_dt = datetime.datetime.utcnow() + datetime.timedelta(hours=sla_hours)
 
     return TicketResponse(
         ticket_id=str(uuid.uuid4()), # Temporary ID
@@ -1118,7 +1035,7 @@ async def analyze_only(request_body: TicketRequest):
         entities=[EntityInfo(**e) for e in entities],
         duplicate_ticket=DuplicateInfo(**dup_result),
         confidence=classification["confidence"],
-        needs_review=classification["confidence"] < confidence_threshold,
+        needs_review=classification["confidence"] < 0.20,
         reasoning=reasoning,
         decision_factors=decision_factors,
         image_description=gemini_analysis["image_description"],
@@ -1126,9 +1043,7 @@ async def analyze_only(request_body: TicketRequest):
         highlights=[e.get("text", "") for e in entities], # Use entity texts as highlights for now
         timeline=timeline,
         env_metadata=env_metadata,
-        is_potential_duplicate=dup_result.get("is_potential_duplicate", False),
-        parent_ticket_id=dup_result.get("parent_ticket_id"),
-        sla_breach_at=sla_breach_dt.isoformat().replace("+00:00", "Z")
+        sla_breach_at=sla_breach_dt.isoformat() + "Z"
     )
 
 @app.post("/ai/analyze_stream")
@@ -1147,11 +1062,7 @@ async def analyze_stream(request_body: TicketRequest):
             "model_version": "3.0.0-PRO",
             "api_endpoint": "/ai/analyze_stream"
         }
-        timeline = {"received": get_now_ist()} 
-        settings = get_system_settings(request_body.company_id)
-        confidence_threshold = settings["ai_confidence_threshold"]
-        duplicate_sensitivity = settings["duplicate_sensitivity"]
-        enable_auto_resolve = settings["enable_auto_resolve"]
+        timeline = {"received": get_now_ist()}
 
         # 1. Reading
         yield f"data: {json.dumps({'step': 'Reading your message', 'status': 'in_progress'})}\n\n"
@@ -1187,20 +1098,9 @@ async def analyze_stream(request_body: TicketRequest):
         yield f"data: {json.dumps({'step': 'Checking duplicate issues', 'status': 'in_progress'})}\n\n"
         await asyncio.sleep(0.2)
         try:
-            duplicate_threshold = get_duplicate_threshold(request_body.company_id, duplicate_sensitivity)
-            dup_result = detect_semantic_duplicate(
-                text,
-                company_id=request_body.company_id,
-                threshold=duplicate_threshold,
-            )
+            dup_result = duplicate_service.check_duplicate(text, threshold=request_body.duplicate_sensitivity)
         except Exception:
-            dup_result = {
-                "is_duplicate": False,
-                "duplicate_ticket_id": None,
-                "parent_ticket_id": None,
-                "is_potential_duplicate": False,
-                "similarity": 0.0,
-            }
+            dup_result = {"is_duplicate": False, "duplicate_ticket_id": None, "similarity": 0.0}
 
         # 5. RAG / Solutions
         yield f"data: {json.dumps({'step': 'Finding possible solutions', 'status': 'in_progress'})}\n\n"
@@ -1216,7 +1116,7 @@ async def analyze_stream(request_body: TicketRequest):
             pass
 
         decision_factors = []
-        if classification["confidence"] > confidence_threshold:
+        if classification["confidence"] > request_body.confidence_threshold:
             decision_factors.append(f"High confidence match for '{classification['subcategory']}'")
         if entities:
             decision_factors.append(f"Detected entities: {', '.join([e['text'] for e in entities[:2]])}")
@@ -1225,8 +1125,6 @@ async def analyze_stream(request_body: TicketRequest):
         if rag_match:
             decision_factors.append(f"Found solution article: '{rag_match['title']}'")
 
-        if not enable_auto_resolve:
-            classification["auto_resolve"] = False
         reasoning = f"Categorized as '{classification['category']}' - {classification['subcategory']}."
         if classification["auto_resolve"]:
             reasoning += " Flagged for AI auto-resolution via Knowledge Base." if rag_match else " Flagged for auto-resolution."
@@ -1236,7 +1134,9 @@ async def analyze_stream(request_body: TicketRequest):
         if gemini_service and gemini_service._initialized:
             summary = gemini_service.get_summary(text)
         
-        sla_breach_dt = calculate_sla_breach_at(classification["priority"])
+        hours_map = {"Critical": 2, "High": 8, "Medium": 24, "Low": 72}
+        sla_hours = hours_map.get(classification["priority"], 72)
+        sla_breach_dt = datetime.datetime.utcnow() + datetime.timedelta(hours=sla_hours)
 
         ticket_response_dict = {
             "ticket_id": str(uuid.uuid4()),
@@ -1249,7 +1149,7 @@ async def analyze_stream(request_body: TicketRequest):
             "entities": [e for e in entities],
             "duplicate_ticket": dup_result,
             "confidence": classification["confidence"],
-            "needs_review": classification["confidence"] < confidence_threshold,
+            "needs_review": classification["confidence"] < 0.20,
             "reasoning": reasoning,
             "decision_factors": decision_factors,
             "image_description": gemini_analysis["image_description"],
@@ -1257,9 +1157,7 @@ async def analyze_stream(request_body: TicketRequest):
             "highlights": [e.get("text", "") for e in entities],
             "timeline": timeline,
             "env_metadata": env_metadata,
-            "is_potential_duplicate": dup_result.get("is_potential_duplicate", False),
-            "parent_ticket_id": dup_result.get("parent_ticket_id"),
-            "sla_breach_at": sla_breach_dt.isoformat().replace("+00:00", "Z")
+            "sla_breach_at": sla_breach_dt.isoformat() + "Z"
         }
 
         # 6. Final Result
@@ -1267,7 +1165,7 @@ async def analyze_stream(request_body: TicketRequest):
 
     return StreamingResponse(event_generator(), media_type="text/event-stream")
 
-@app.post("/ai/analyze_ticket/legacy")
+@app.post("/ai/analyze_ticket")
 async def legacy_analyze_and_save(request_body: TicketRequest):
     """
     BACKWARD COMPATIBILITY: Strictly performs analysis only. 
@@ -1291,3 +1189,258 @@ async def analyze_ticket_v2(request: TicketRequest):
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+# ---------------------------------------------------------------------------
+# SLA Engine Endpoints
+# ---------------------------------------------------------------------------
+
+class SLAStatsResponse(BaseModel):
+    total: int = 0
+    active: int = 0
+    breached: int = 0
+    warning: int = 0
+    met: int = 0
+    breach_rate: float = 0.0
+    by_priority: dict = {}
+
+
+@app.get("/sla/stats", response_model=SLAStatsResponse)
+async def sla_stats():
+    """Get aggregated SLA dashboard statistics across all tickets."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not connected")
+    stats = await sla_engine.get_dashboard_stats()
+    if "error" in stats:
+        raise HTTPException(status_code=500, detail=stats["error"])
+    return stats
+
+
+class SLATicketInfo(BaseModel):
+    id: str
+    ticket_id: str | None = None
+    subject: str | None = None
+    summary: str | None = None
+    priority: str = "medium"
+    status: str | None = None
+    assigned_team: str | None = None
+    sla_status: str = "active"
+    escalation_level: int = 0
+    remaining_seconds: int = 0
+    created_at: str | None = None
+    sla_breach_at: str | None = None
+    sla_warning_at: str | None = None
+    last_escalated_at: str | None = None
+
+
+@app.get("/sla/tickets")
+async def sla_tickets(
+    status: str | None = None,
+    priority: str | None = None,
+    limit: int = 100,
+    offset: int = 0,
+):
+    """
+    List tickets with SLA status. Filter by sla_status and/or priority.
+    """
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not connected")
+
+    query = (
+        supabase.table("tickets")
+        .select("id, ticket_id, subject, summary, priority, status, assigned_team, sla_status, escalation_level, remaining_seconds, created_at, sla_breach_at, sla_warning_at, last_escalated_at")
+        .order("created_at", desc=True)
+    )
+
+    if status and status != "all":
+        query = query.eq("sla_status", status)
+    if priority and priority != "all":
+        query = query.eq("priority", priority.capitalize())
+
+    query = query.range(offset, offset + limit - 1)
+    res = query.execute()
+    return {"tickets": res.data or [], "total": len(res.data or [])}
+
+
+class EscalationLogEntry(BaseModel):
+    id: str
+    ticket_id: str | None = None
+    ticket_subject: str = ""
+    priority: str = "medium"
+    sla_status: str = ""
+    escalation_level: int = 0
+    remaining_seconds: int = 0
+    assigned_team: str = ""
+    notification_channels: list = []
+    triggered_at: str | None = None
+    resolved_at: str | None = None
+    notes: str = ""
+
+
+@app.get("/sla/escalations")
+async def sla_escalations(limit: int = 50, offset: int = 0):
+    """Fetch escalation log history."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not connected")
+
+    try:
+        res = (
+            supabase.table("escalation_logs")
+            .select("*")
+            .order("triggered_at", desc=True)
+            .range(offset, offset + limit - 1)
+            .execute()
+        )
+        return {"escalations": res.data or [], "total": len(res.data or [])}
+    except Exception as e:
+        # Table might not exist yet
+        print(f"[SLA] Escalation logs query failed: {e}")
+        return {"escalations": [], "total": 0}
+
+
+class SLAPolicyInfo(BaseModel):
+    id: str
+    priority: str
+    max_hours: int
+    warning_pct: float
+    auto_escalate: bool
+    l2_after_minutes: int
+    l3_after_minutes: int
+
+
+@app.get("/sla/policies")
+async def sla_policies():
+    """Get configured SLA policies."""
+    if not supabase:
+        # Return defaults from code
+        policies = []
+        for pri, cfg in sla_engine.SLA_POLICIES.items() if hasattr(sla_engine, 'SLA_POLICIES') else SLA_POLICIES.items():
+            policies.append({
+                "priority": pri,
+                "max_hours": cfg["max_hours"],
+                "warning_pct": cfg["warning_pct"],
+                "auto_escalate": cfg["auto_escalate_on_breach"],
+                "l2_after_minutes": cfg["l2_escalation_mins"],
+                "l3_after_minutes": cfg["l3_escalation_mins"],
+            })
+        return {"policies": policies}
+
+    try:
+        res = supabase.table("sla_policies").select("*").execute()
+        return {"policies": res.data or []}
+    except Exception as e:
+        print(f"[SLA] Policies query failed: {e}")
+        return {"policies": []}
+
+
+@app.post("/sla/check")
+async def trigger_sla_check():
+    """Manually trigger an SLA evaluation cycle (admin)."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not connected")
+    
+    asyncio.create_task(sla_engine.check_all_active_tickets())
+    return {"status": "triggered", "message": "SLA check cycle started in background"}
+
+
+# ---------------------------------------------------------------------------
+# Semantic Duplicate Detection Endpoints
+# ---------------------------------------------------------------------------
+
+@app.post("/ai/check_duplicate")
+async def check_duplicate_endpoint(
+    body: TicketRequest,
+    company_id: str | None = None,
+):
+    """
+    Check a ticket text for potential duplicates using semantic vector search.
+    Returns top candidates with similarity scores.
+    """
+    text = (body.text or "").strip()
+    if not text:
+        raise HTTPException(status_code=400, detail="No text provided")
+
+    threshold = body.duplicate_sensitivity if hasattr(body, 'duplicate_sensitivity') else None
+    result = await semantic_dupe_service.check_duplicate(
+        text=text,
+        company_id=company_id or body.company,
+        threshold=threshold,
+    )
+    return result
+
+
+@app.post("/ai/reindex_embeddings")
+async def reindex_embeddings():
+    """Re-generate vector embeddings for all tickets."""
+    result = await semantic_dupe_service.reindex_all()
+    return result
+
+
+@app.get("/system/settings")
+async def get_system_settings():
+    """Fetch all system settings."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not connected")
+    try:
+        res = supabase.table("system_settings").select("*").execute()
+        settings = {}
+        for row in res.data or []:
+            settings[row["key"]] = row["value"]
+        return settings
+    except Exception as e:
+        logger.warning(f"[SETTINGS] Query failed: {e}")
+        return {}
+
+
+@app.patch("/system/settings")
+async def update_system_settings(body: dict):
+    """Update a specific system setting."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not connected")
+    key = body.get("key")
+    value = body.get("value")
+    if not key or value is None:
+        raise HTTPException(status_code=400, detail="key and value required")
+    try:
+        supabase.table("system_settings").upsert({
+            "key": key,
+            "value": value,
+            "updated_at": datetime.datetime.utcnow().isoformat() + "Z",
+        }).execute()
+        return {"status": "updated", "key": key}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/sla/tickets/{ticket_id}")
+async def sla_ticket_detail(ticket_id: str):
+    """Get detailed SLA info for a specific ticket."""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not connected")
+
+    # Fetch ticket
+    res = supabase.table("tickets").select("*").eq("id", ticket_id).single().execute()
+    if not res.data:
+        raise HTTPException(status_code=404, detail="Ticket not found")
+
+    ticket = res.data
+    result = sla_engine.evaluate_ticket(ticket)
+
+    # Fetch escalation history for this ticket
+    try:
+        esc_res = (
+            supabase.table("escalation_logs")
+            .select("*")
+            .eq("ticket_id", ticket_id)
+            .order("triggered_at", desc=True)
+            .execute()
+        )
+        escalations = esc_res.data or []
+    except Exception:
+        escalations = []
+
+    return {
+        "ticket": ticket,
+        "sla_evaluation": result,
+        "escalations": escalations,
+    }

backend/services/semantic_duplicate_service.py

@@ -0,0 +1,260 @@
+"""
+Semantic Duplicate Detection Service — pgvector-powered cosine similarity search.
+
+Enhances the existing in-memory DuplicateService with Supabase pgvector integration:
+  1. Store embeddings in the tickets table (description_vector column)
+  2. Use match_tickets RPC for company-scoped similarity search
+  3. Dynamic sensitivity from system_settings table
+  4. Auto-flag duplicates during ticket save flow
+
+Usage:
+    service = SemanticDuplicateService(supabase_client)
+    result = await service.check_duplicate(text, company_id, threshold_override)
+    await service.index_ticket(ticket_id, text)
+"""
+
+import os
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Default threshold (0.0-1.0, higher = stricter)
+DEFAULT_SENSITIVITY = 0.85
+
+
+class SemanticDuplicateService:
+    """
+    Duplicate detection backed by pgvector in Supabase.
+
+    Falls back to in-memory DuplicateService if the vector DB is unavailable,
+    but the primary path is via the match_tickets RPC function.
+    """
+
+    def __init__(self, supabase_client=None):
+        self.supabase = supabase_client
+        self._model = None
+        self._loaded = False
+
+    def load(self):
+        """Lazy-load the sentence-transformers model (called once)."""
+        if self._loaded:
+            return
+        try:
+            from sentence_transformers import SentenceTransformer
+            self._model = SentenceTransformer("all-MiniLM-L6-v2")
+            self._loaded = True
+            logger.info("[SemanticDuplicate] Model loaded (all-MiniLM-L6-v2)")
+        except ImportError:
+            logger.warning("[SemanticDuplicate] sentence-transformers not installed")
+        except Exception as e:
+            logger.error(f"[SemanticDuplicate] Model load error: {e}")
+
+    @property
+    def model(self):
+        if not self._loaded:
+            self.load()
+        return self._model
+
+    # ------------------------------------------------------------------
+    # Embedding generation
+    # ------------------------------------------------------------------
+
+    def generate_embedding(self, text: str) -> list[float] | None:
+        """
+        Generate a 384-dimensional embedding vector for the given text.
+        Returns None if the model isn't loaded.
+        """
+        if not self.model:
+            return None
+        try:
+            return self.model.encode(text).tolist()
+        except Exception as e:
+            logger.error(f"[SemanticDuplicate] Embedding error: {e}")
+            return None
+
+    # ------------------------------------------------------------------
+    # Dynamic threshold from system_settings
+    # ------------------------------------------------------------------
+
+    async def get_sensitivity(self) -> float:
+        """
+        Fetch the duplicate detection sensitivity from system_settings.
+        Falls back to DEFAULT_SENSITIVITY.
+        """
+        if not self.supabase:
+            return DEFAULT_SENSITIVITY
+        try:
+            res = self.supabase.table("system_settings") \
+                .select("value") \
+                .eq("key", "duplicate_detection") \
+                .single() \
+                .execute()
+            if res.data:
+                return float(res.data["value"].get("sensitivity", DEFAULT_SENSITIVITY))
+        except Exception as e:
+            logger.warning(f"[SemanticDuplicate] Failed to fetch sensitivity: {e}")
+        return DEFAULT_SENSITIVITY
+
+    # ------------------------------------------------------------------
+    # Duplicate check via pgvector RPC
+    # ------------------------------------------------------------------
+
+    async def check_duplicate(
+        self,
+        text: str,
+        company_id: str | None = None,
+        threshold: float | None = None,
+        max_candidates: int = 5,
+    ) -> dict:
+        """
+        Check text against existing tickets using pgvector cosine similarity.
+
+        Args:
+            text: The ticket description/subject text.
+            company_id: Tenant company UUID for scoped search.
+            threshold: Override threshold (0.0-1.0). Uses dynamic setting if None.
+            max_candidates: Max similar tickets to return.
+
+        Returns:
+            {
+                "is_duplicate": bool,
+                "duplicate_ticket_id": str | None,
+                "similarity": float,
+                "candidates": [...]  # top candidates with scores
+            }
+        """
+        # Generate embedding
+        embedding = self.generate_embedding(text)
+        if embedding is None:
+            logger.warning("[SemanticDuplicate] No embedding — falling back to no match")
+            return {
+                "is_duplicate": False,
+                "duplicate_ticket_id": None,
+                "similarity": 0.0,
+                "candidates": [],
+            }
+
+        active_threshold = threshold if threshold is not None else await self.get_sensitivity()
+
+        # Perform vector search
+        if self.supabase:
+            try:
+                result = self.supabase.rpc(
+                    "match_tickets",
+                    {
+                        "query_vector": embedding,
+                        "match_threshold": active_threshold,
+                        "match_count": max_candidates,
+                        "tenant_company_id": company_id,
+                    },
+                ).execute()
+
+                candidates = result.data or []
+            except Exception as e:
+                logger.warning(f"[SemanticDuplicate] RPC call failed: {e}")
+                candidates = []
+        else:
+            candidates = []
+
+        if not candidates:
+            return {
+                "is_duplicate": False,
+                "duplicate_ticket_id": None,
+                "similarity": 0.0,
+                "candidates": [],
+            }
+
+        best = candidates[0]
+        similarity = float(best.get("similarity", 0.0))
+        is_dup = similarity >= active_threshold
+
+        return {
+            "is_duplicate": is_dup,
+            "duplicate_ticket_id": best.get("id") if is_dup else None,
+            "similarity": round(similarity, 4),
+            "parent_subject": best.get("subject") or best.get("summary") if is_dup else None,
+            "candidates": [
+                {
+                    "id": c["id"],
+                    "subject": c.get("subject") or c.get("summary"),
+                    "similarity": round(float(c.get("similarity", 0)), 4),
+                    "status": c.get("status"),
+                    "assigned_team": c.get("assigned_team"),
+                    "created_at": c.get("created_at"),
+                }
+                for c in candidates[:3]
+            ],
+        }
+
+    # ------------------------------------------------------------------
+    # Index a ticket — generate embedding and store it
+    # ------------------------------------------------------------------
+
+    async def index_ticket(self, ticket_id: str, text: str) -> bool:
+        """
+        Generate embedding for a ticket and update the description_vector column.
+        Returns True on success.
+        """
+        embedding = self.generate_embedding(text)
+        if embedding is None:
+            logger.warning(f"[SemanticDuplicate] Cannot index ticket {ticket_id}: no embedding")
+            return False
+
+        if not self.supabase:
+            logger.warning("[SemanticDuplicate] No Supabase — skipping index")
+            return False
+
+        try:
+            self.supabase.table("tickets") \
+                .update({"description_vector": embedding}) \
+                .eq("id", ticket_id) \
+                .execute()
+            logger.info(f"[SemanticDuplicate] Indexed ticket {ticket_id} ({len(text)} chars)")
+            return True
+        except Exception as e:
+            logger.error(f"[SemanticDuplicate] Index error for {ticket_id}: {e}")
+            return False
+
+    # ------------------------------------------------------------------
+    # Batch re-index — regenerate all embeddings
+    # ------------------------------------------------------------------
+
+    async def reindex_all(self, batch_size: int = 50) -> dict:
+        """
+        Re-generate embeddings for all tickets that don't have them.
+        Useful for initial migration or after model update.
+        """
+        if not self.supabase:
+            return {"indexed": 0, "errors": 0}
+
+        total_indexed = 0
+        total_errors = 0
+        offset = 0
+
+        while True:
+            res = self.supabase.table("tickets") \
+                .select("id, subject, description, summary") \
+                .is_("description_vector", "null") \
+                .range(offset, offset + batch_size - 1) \
+                .execute()
+
+            batch = res.data or []
+            if not batch:
+                break
+
+            for ticket in batch:
+                text = (ticket.get("description") or ticket.get("subject") or ticket.get("summary") or "").strip()
+                if not text:
+                    continue
+                success = await self.index_ticket(ticket["id"], text)
+                if success:
+                    total_indexed += 1
+                else:
+                    total_errors += 1
+
+            offset += batch_size
+
+        logger.info(f"[SemanticDuplicate] Re-index complete: {total_indexed} indexed, {total_errors} errors")
+        return {"indexed": total_indexed, "errors": total_errors}

backend/services/sla_engine.py

@@ -0,0 +1,534 @@
+"""
+SLA Engine — Service-Level Agreement monitoring, breach detection,
+and multi-channel escalation for HELPDESK.AI.
+
+Architecture:
+  - SLA policies defined per priority tier
+  - Background checker evaluates ticket SLA in batches
+  - Escalation matrix drives notification routing
+  - Multi-channel dispatch (Email / Slack / Teams / Webhook)
+"""
+
+import os
+import json
+import logging
+import datetime
+from typing import Any
+from enum import Enum
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+class SLAStatus(str, Enum):
+    ACTIVE = "active"
+    WARNING = "warning"
+    BREACHED = "breached"
+    MET = "met"
+    PAUSED = "paused"  # ticket on hold
+
+class EscalationLevel(int, Enum):
+    NONE = 0
+    LEVEL_1 = 1   # Warning → notify assigned team
+    LEVEL_2 = 2   # Breach → escalate to L2 / manager
+    LEVEL_3 = 3   # Extended breach → escalate to L3 / senior / admin
+
+class ChannelType(str, Enum):
+    EMAIL = "email"
+    SLACK = "slack"
+    TEAMS = "teams"
+    WEBHOOK = "webhook"
+
+# ---------------------------------------------------------------------------
+# SLA Policy definitions
+# ---------------------------------------------------------------------------
+
+SLAMetric = dict[str, Any]  # {"max_hours": N, "warning_pct": 0.75, "l2_escalation_after_mins": M, ...}
+
+SLA_POLICIES: dict[str, SLAMetric] = {
+    "critical": {
+        "max_hours": 2,
+        "max_seconds": 2 * 3600,
+        "warning_pct": 0.75,               # warn at 75% of SLA
+        "warning_label": "1.5h remaining",
+        "l2_escalation_mins": 0,            # escalate to L2 immediately on breach
+        "l3_escalation_mins": 120,          # escalate to L3 after 2h of breach
+        "auto_escalate_on_breach": True,
+    },
+    "high": {
+        "max_hours": 4,
+        "max_seconds": 4 * 3600,
+        "warning_pct": 0.75,
+        "warning_label": "3h remaining",
+        "l2_escalation_mins": 30,
+        "l3_escalation_mins": 240,
+        "auto_escalate_on_breach": True,
+    },
+    "medium": {
+        "max_hours": 8,
+        "max_seconds": 8 * 3600,
+        "warning_pct": 0.75,
+        "warning_label": "6h remaining",
+        "l2_escalation_mins": 60,
+        "l3_escalation_mins": 480,
+        "auto_escalate_on_breach": True,
+    },
+    "low": {
+        "max_hours": 24,
+        "max_seconds": 24 * 3600,
+        "warning_pct": 0.75,
+        "warning_label": "18h remaining",
+        "l2_escalation_mins": 120,
+        "l3_escalation_mins": 1440,
+        "auto_escalate_on_breach": False,   # low priority: no auto-escalation
+    },
+}
+
+# ---------------------------------------------------------------------------
+# Escalation contact mapping (configured via env / DB)
+# ---------------------------------------------------------------------------
+
+def _load_escalation_channels() -> list[dict]:
+    """Load channel config from JSON file or env vars."""
+    channels_raw = os.environ.get("SLA_CHANNELS", "[]")
+    try:
+        return json.loads(channels_raw)
+    except json.JSONDecodeError:
+        return []
+
+def _load_team_escalation_contacts() -> dict:
+    """Load team escalation contacts."""
+    contacts_raw = os.environ.get("SLA_ESCALATION_CONTACTS", "{}")
+    try:
+        return json.loads(contacts_raw)
+    except json.JSONDecodeError:
+        return {}
+
+# ---------------------------------------------------------------------------
+# Core SLA Engine
+# ---------------------------------------------------------------------------
+
+class SLAEngine:
+    """
+    Evaluates ticket SLA status, detects breaches, and dispatches escalations.
+    
+    Usage:
+        engine = SLAEngine(supabase_client)
+        await engine.check_all_active_tickets()
+    """
+
+    def __init__(self, supabase_client=None):
+        self.supabase = supabase_client
+        self.channels = _load_escalation_channels()
+        self.contacts = _load_team_escalation_contacts()
+
+    # ------------------------------------------------------------------
+    # SLA Evaluation per ticket
+    # ------------------------------------------------------------------
+
+    def evaluate_ticket(self, ticket: dict) -> dict:
+        """
+        Evaluate a single ticket's SLA status.
+        
+        Returns dict with:
+          - sla_status: SLAStatus value
+          - remaining_seconds: seconds until breach (negative if breached)
+          - elapsed_pct: percentage of SLA time elapsed
+          - escalation_level: EscalationLevel value
+          - needs_notification: bool
+          - policy: the applied SLA policy
+        """
+        priority_key = (ticket.get("priority") or "medium").lower().strip()
+        policy = SLA_POLICIES.get(priority_key, SLA_POLICIES["medium"])
+
+        # Resolve the start time: use sla_started_at if set, else created_at
+        start_str = ticket.get("sla_started_at") or ticket.get("created_at")
+        if not start_str:
+            return self._default_eval(policy)
+
+        try:
+            created_dt = datetime.datetime.fromisoformat(start_str.replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            return self._default_eval(policy)
+
+        # If ticket is resolved / closed, SLA is "met"
+        status = (ticket.get("status") or "").lower()
+        if any(s in status for s in ["resolv", "closed", "auto-resolv"]):
+            return {
+                "sla_status": SLAStatus.MET,
+                "remaining_seconds": 0,
+                "elapsed_pct": 1.0,
+                "escalation_level": EscalationLevel.NONE,
+                "needs_notification": False,
+                "policy": policy,
+            }
+
+        # Calculate elapsed time
+        now = datetime.datetime.now(datetime.timezone.utc)
+        elapsed = (now - created_dt).total_seconds()
+        max_sec = policy["max_seconds"]
+        elapsed_pct = elapsed / max_sec if max_sec > 0 else 0
+
+        # Determine SLA status
+        if elapsed >= max_sec:
+            sla_status = SLAStatus.BREACHED
+            remaining_seconds = -(elapsed - max_sec)
+        elif elapsed >= max_sec * policy["warning_pct"]:
+            sla_status = SLAStatus.WARNING
+            remaining_seconds = max_sec - elapsed
+        else:
+            sla_status = SLAStatus.ACTIVE
+            remaining_seconds = max_sec - elapsed
+
+        # Determine escalation level
+        escalation_level = EscalationLevel.NONE
+        if sla_status == SLAStatus.BREACHED:
+            breach_duration = elapsed - max_sec
+            if breach_duration >= policy["l3_escalation_mins"] * 60:
+                escalation_level = EscalationLevel.LEVEL_3
+            elif breach_duration >= policy["l2_escalation_mins"] * 60:
+                escalation_level = EscalationLevel.LEVEL_2
+            else:
+                escalation_level = EscalationLevel.LEVEL_2  # breach = at least L2
+        elif sla_status == SLAStatus.WARNING:
+            escalation_level = EscalationLevel.LEVEL_1
+
+        needs_notification = (
+            sla_status in (SLAStatus.WARNING, SLAStatus.BREACHED)
+            and escalation_level.value > (ticket.get("escalation_level") or 0)
+        )
+
+        return {
+            "sla_status": sla_status.value,
+            "remaining_seconds": round(remaining_seconds),
+            "elapsed_pct": round(elapsed_pct, 4),
+            "escalation_level": escalation_level.value,
+            "needs_notification": needs_notification,
+            "policy": policy,
+        }
+
+    def _default_eval(self, policy: dict) -> dict:
+        return {
+            "sla_status": SLAStatus.ACTIVE.value,
+            "remaining_seconds": policy["max_seconds"],
+            "elapsed_pct": 0.0,
+            "escalation_level": 0,
+            "needs_notification": False,
+            "policy": policy,
+        }
+
+    # ------------------------------------------------------------------
+    # Batch check — evaluate all active tickets
+    # ------------------------------------------------------------------
+
+    async def check_all_active_tickets(self) -> list[dict]:
+        """
+        Fetches all active (non-resolved) tickets from Supabase,
+        evaluates SLA, updates DB records, and triggers notifications.
+        
+        Returns list of escalated tickets that need notification dispatch.
+        """
+        if not self.supabase:
+            logger.warning("[SLA] No Supabase client — skipping SLA check.")
+            return []
+
+        try:
+            res = self.supabase.table("tickets") \
+                .select("*") \
+                .not_.ilike("status", "%resolv%") \
+                .not_.ilike("status", "%closed%") \
+                .execute()
+        except Exception as e:
+            logger.error(f"[SLA] Failed to fetch tickets: {e}")
+            return []
+
+        tickets = res.data or []
+        escalated: list[dict] = []
+
+        for ticket in tickets:
+            result = self.evaluate_ticket(ticket)
+            update_fields = {
+                "sla_status": result["sla_status"],
+                "remaining_seconds": result["remaining_seconds"],
+                "escalation_level": result["escalation_level"],
+                "sla_updated_at": datetime.datetime.utcnow().isoformat() + "Z",
+            }
+
+            # If breached and not yet marked as breached, set breached timestamp
+            if result["sla_status"] == SLAStatus.BREACHED.value and not ticket.get("sla_breach_at"):
+                update_fields["sla_breach_at"] = datetime.datetime.utcnow().isoformat() + "Z"
+
+            # If warning and not yet notified, mark warning time
+            if result["sla_status"] == SLAStatus.WARNING.value and not ticket.get("sla_warning_at"):
+                update_fields["sla_warning_at"] = datetime.datetime.utcnow().isoformat() + "Z"
+
+            # If needs notification, prepare escalation record
+            if result["needs_notification"]:
+                update_fields["last_escalated_at"] = datetime.datetime.utcnow().isoformat() + "Z"
+                escalated.append({
+                    "ticket": ticket,
+                    "sla_result": result,
+                })
+
+            # Update ticket in DB
+            try:
+                self.supabase.table("tickets") \
+                    .update(update_fields) \
+                    .eq("id", ticket["id"]) \
+                    .execute()
+            except Exception as e:
+                logger.error(f"[SLA] Failed to update ticket {ticket.get('id')}: {e}")
+
+        # Log escalations to escalation_logs table
+        for item in escalated:
+            self._log_escalation(item["ticket"], item["sla_result"])
+
+        logger.info(
+            f"[SLA] Checked {len(tickets)} tickets "
+            f"— {len(escalated)} escalated."
+        )
+        return escalated
+
+    # ------------------------------------------------------------------
+    # Escalation logging
+    # ------------------------------------------------------------------
+
+    def _log_escalation(self, ticket: dict, result: dict):
+        """Insert an escalation event into the escalation_logs table."""
+        if not self.supabase:
+            return
+        try:
+            self.supabase.table("escalation_logs").insert({
+                "ticket_id": ticket["id"],
+                "ticket_subject": ticket.get("subject") or ticket.get("summary", ""),
+                "priority": ticket.get("priority", "medium"),
+                "sla_status": result["sla_status"],
+                "escalation_level": result["escalation_level"],
+                "remaining_seconds": result["remaining_seconds"],
+                "assigned_team": ticket.get("assigned_team", ""),
+                "triggered_at": datetime.datetime.utcnow().isoformat() + "Z",
+                "notification_channels": [],  # populated by notifier
+            }).execute()
+        except Exception as e:
+            logger.error(f"[SLA] Failed to log escalation: {e}")
+
+    # ------------------------------------------------------------------
+    # Multi-channel notification dispatch
+    # ------------------------------------------------------------------
+
+    async def dispatch_notifications(self, escalated_items: list[dict]):
+        """
+        Dispatch SLA alerts across configured channels.
+        Each item: { ticket, sla_result }
+        """
+        for item in escalated_items:
+            ticket = item["ticket"]
+            result = item["sla_result"]
+            channels = self._resolve_channels(ticket, result)
+
+            for channel in channels:
+                success = await self._send_to_channel(channel, ticket, result)
+                if success:
+                    logger.info(
+                        f"[SLA] Notification sent via {channel['type']} "
+                        f"for ticket {ticket.get('id')}"
+                    )
+
+    def _resolve_channels(self, ticket: dict, result: dict) -> list[dict]:
+        """Determine which channels to send to based on escalation level."""
+        level = result["escalation_level"]
+        active_channels = [c for c in self.channels if c.get("enabled", True)]
+
+        # Filter by minimum escalation level
+        eligible = [
+            c for c in active_channels
+            if c.get("min_level", 0) <= level
+        ]
+
+        return eligible
+
+    async def _send_to_channel(self, channel: dict, ticket: dict, result: dict) -> bool:
+        """Send an SLA notification through a specific channel."""
+        channel_type = channel.get("type", "webhook")
+        payload = self._build_payload(ticket, result, channel_type)
+
+        try:
+            import aiohttp
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    channel["url"],
+                    json=payload,
+                    headers=channel.get("headers", {"Content-Type": "application/json"}),
+                    timeout=aiohttp.ClientTimeout(total=10),
+                ) as resp:
+                    return resp.status < 500
+        except ImportError:
+            logger.warning("[SLA] aiohttp not installed — using requests (sync).")
+            import requests
+            try:
+                resp = requests.post(
+                    channel["url"],
+                    json=payload,
+                    headers=channel.get("headers", {"Content-Type": "application/json"}),
+                    timeout=10,
+                )
+                return resp.status_code < 500
+            except Exception as e:
+                logger.error(f"[SLA] Channel send failed ({channel_type}): {e}")
+                return False
+        except Exception as e:
+            logger.error(f"[SLA] Channel send failed ({channel_type}): {e}")
+            return False
+
+    def _build_payload(self, ticket: dict, result: dict, channel_type: str) -> dict:
+        """Build a channel-specific notification payload."""
+        priority = (ticket.get("priority") or "medium").upper()
+        ticket_id = str(ticket.get("id", "???"))[:8].upper()
+        subject = ticket.get("subject") or ticket.get("summary") or "Untitled"
+
+        base = {
+            "title": f"[SLA {result['sla_status'].upper()}] Ticket #{ticket_id}",
+            "subject": subject,
+            "priority": priority,
+            "status": result["sla_status"],
+            "escalation_level": result["escalation_level"],
+            "remaining_seconds": result["remaining_seconds"],
+            "ticket_url": f"https://helpdeskaiv1.vercel.app/admin/ticket/{ticket['id']}",
+            "assigned_team": ticket.get("assigned_team", "Unassigned"),
+            "timestamp": datetime.datetime.utcnow().isoformat() + "Z",
+        }
+
+        if channel_type == ChannelType.SLACK:
+            color = "#ef4444" if result["sla_status"] == "breached" else "#f59e0b"
+            return {
+                "attachments": [{
+                    "color": color,
+                    "title": base["title"],
+                    "text": f"*Ticket:* <{base['ticket_url']}|#{ticket_id}> — {subject}\n"
+                            f"*Priority:* {priority} | *Team:* {base['assigned_team']}\n"
+                            f"*Remaining:* {self._fmt_remaining(result['remaining_seconds'])}",
+                    "footer": "HELPDESK.AI SLA Engine",
+                    "ts": int(datetime.datetime.utcnow().timestamp()),
+                }]
+            }
+
+        elif channel_type == ChannelType.TEAMS:
+            fact_section = {
+                "facts": [
+                    {"name": "Ticket", "value": f"[#{ticket_id}]({base['ticket_url']})"},
+                    {"name": "Subject", "value": subject},
+                    {"name": "Priority", "value": priority},
+                    {"name": "Team", "value": base["assigned_team"]},
+                    {"name": "SLA Status", "value": result["sla_status"].upper()},
+                    {"name": "Escalation Level", "value": str(result["escalation_level"])},
+                ]
+            }
+            return {
+                "@type": "MessageCard",
+                "@context": "https://schema.org/extensions",
+                "summary": base["title"],
+                "themeColor": color if result["sla_status"] == "breached" else "f59e0b",
+                "sections": [{
+                    "activityTitle": base["title"],
+                    "activitySubtitle": subject,
+                    **fact_section,
+                }],
+            }
+
+        elif channel_type == ChannelType.EMAIL:
+            return {
+                "type": "SLA_ALERT",
+                "to": channel.get("to", "support@helpdeskai.com"),
+                "subject": base["title"],
+                "template_data": {
+                    "title": f"SLA {result['sla_status'].upper()}: Ticket #{ticket_id}",
+                    "badge": f"🚨 Escalation Level {result['escalation_level']}",
+                    "mainText": f"Priority {priority} ticket \"{subject}\" has reached SLA status: {result['sla_status']}.",
+                    "refLabel": "Time Remaining",
+                    "refValue": self._fmt_remaining(result["remaining_seconds"]),
+                    "ctaText": "View Ticket",
+                    "ctaUrl": base["ticket_url"],
+                }
+            }
+
+        # Generic webhook fallback
+        return base
+
+    @staticmethod
+    def _fmt_remaining(seconds: int) -> str:
+        """Format seconds into human-readable remaining time."""
+        if seconds <= 0:
+            return "OVERDUE"
+        hrs = seconds // 3600
+        mins = (seconds % 3600) // 60
+        if hrs > 0:
+            return f"{hrs}h {mins}m"
+        return f"{mins}m"
+
+    # ------------------------------------------------------------------
+    # SLA Dashboard stats
+    # ------------------------------------------------------------------
+
+    async def get_dashboard_stats(self) -> dict:
+        """Aggregate SLA statistics for dashboard display."""
+        if not self.supabase:
+            return {"error": "No database connection"}
+
+        try:
+            res = self.supabase.table("tickets") \
+                .select("id, priority, sla_status, status, escalation_level") \
+                .execute()
+        except Exception as e:
+            return {"error": str(e)}
+
+        tickets = res.data or []
+        total = len(tickets)
+        active_tickets = [t for t in tickets if not any(
+            s in (t.get("status") or "").lower() for s in ["resolv", "closed"]
+        )]
+
+        counts = {
+            "total": total,
+            "active": len(active_tickets),
+            "breached": sum(1 for t in tickets if t.get("sla_status") == "breached"),
+            "warning": sum(1 for t in tickets if t.get("sla_status") == "warning"),
+            "met": sum(1 for t in tickets if t.get("sla_status") == "met"),
+            "by_priority": {},
+            "breach_rate": 0,
+        }
+
+        if total > 0:
+            counts["breach_rate"] = round(counts["breached"] / total * 100, 1)
+
+        for p in ["critical", "high", "medium", "low"]:
+            ptickets = [t for t in active_tickets if (t.get("priority") or "").lower() == p]
+            counts["by_priority"][p] = {
+                "total": len(ptickets),
+                "breached": sum(1 for t in ptickets if t.get("sla_status") == "breached"),
+                "warning": sum(1 for t in ptickets if t.get("sla_status") == "warning"),
+            }
+
+        return counts
+
+
+# ---------------------------------------------------------------------------
+# Standalone helper — get policy for a priority
+# ---------------------------------------------------------------------------
+
+def get_sla_policy(priority: str) -> SLAMetric:
+    """Get the SLA policy for a given priority string."""
+    return SLA_POLICIES.get(priority.lower().strip(), SLA_POLICIES["medium"])
+
+
+def compute_sla_breach_at(priority: str, from_time: datetime.datetime | None = None) -> str:
+    """
+    Compute the ISO datetime when this ticket's SLA would breach.
+    Returns ISO string.
+    """
+    policy = get_sla_policy(priority)
+    start = from_time or datetime.datetime.now(datetime.timezone.utc)
+    breach = start + datetime.timedelta(hours=policy["max_hours"])
+    return breach.isoformat()

backend/sla_checker.py

@@ -0,0 +1,162 @@
+"""
+SLA Background Checker — Periodic worker that evaluates ticket SLAs
+and dispatches multi-channel escalation notifications.
+
+Run as a standalone process:
+    python backend/sla_checker.py
+
+Or import and use the start_background_checker() function.
+"""
+
+import os
+import sys
+import time
+import json
+import asyncio
+import logging
+import datetime
+from pathlib import Path
+
+# ── Project Path ──────────────────────────────────────────────────────────
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+# ── Logging ────────────────────────────────────────────────────────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format="[SLA-Checker %(asctime)s] %(levelname)s %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger("sla-checker")
+
+# ── Load env ───────────────────────────────────────────────────────────────
+from dotenv import load_dotenv
+env_path = Path(__file__).parent / '.env'
+load_dotenv(dotenv_path=env_path)
+
+
+def create_supabase_client():
+    """Create a Supabase client using service role key."""
+    try:
+        from supabase import create_client
+        url = os.environ.get("SUPABASE_URL")
+        key = os.environ.get("SUPABASE_SERVICE_KEY")
+        if not url or not key:
+            logger.error("SUPABASE_URL or SUPABASE_SERVICE_KEY not set")
+            return None
+        return create_client(url, key)
+    except ImportError:
+        logger.warning("supabase-py not installed — running in dry-run mode")
+        return None
+    except Exception as e:
+        logger.error(f"Failed to create Supabase client: {e}")
+        return None
+
+
+async def run_sla_check(supabase=None, dry_run: bool = False) -> dict:
+    """
+    Execute one full SLA check cycle.
+    Returns a summary dict with counts.
+    """
+    from backend.services.sla_engine import SLAEngine
+
+    engine = SLAEngine(supabase_client=supabase)
+    logger.info("Starting SLA check cycle...")
+
+    if dry_run:
+        logger.info("DRY RUN mode — no DB updates will be made.")
+
+    if supabase and not dry_run:
+        escalated = await engine.check_all_active_tickets()
+        if escalated:
+            logger.info(f"Dispatching notifications for {len(escalated)} escalated tickets...")
+            await engine.dispatch_notifications(escalated)
+        stats = await engine.get_dashboard_stats()
+        logger.info(f"SLA stats: {json.dumps(stats)}")
+        return {"checked": len(escalated) if escalated else 0, "stats": stats}
+    else:
+        logger.warning("No Supabase client — cannot run SLA check.")
+        return {"checked": 0, "stats": {}}
+
+
+def run_sla_check_sync(supabase=None, dry_run: bool = False) -> dict:
+    """Synchronous wrapper for run_sla_check."""
+    return asyncio.run(run_sla_check(supabase, dry_run))
+
+
+def background_checker_loop(interval_minutes: int = 5, dry_run: bool = False):
+    """
+    Run the SLA check in an infinite loop.
+    
+    Args:
+        interval_minutes: How often to check (default 5 min).
+        dry_run: If True, only log what would be done.
+    """
+    supabase = create_supabase_client()
+    logger.info(
+        f"SLA Background Checker started "
+        f"(interval={interval_minutes}m, dry_run={dry_run})"
+    )
+
+    while True:
+        try:
+            result = run_sla_check_sync(supabase, dry_run)
+            logger.info(f"Cycle complete: {json.dumps(result)}")
+        except Exception as e:
+            logger.error(f"Cycle failed: {e}", exc_info=True)
+
+        logger.info(f"Sleeping for {interval_minutes} minutes...")
+        time.sleep(interval_minutes * 60)
+
+
+# # ── FastAPI lifespan integration ──────────────────────────────────────
+# Use this inside lifespan() to start the checker as a background task:
+#
+#   task = asyncio.create_task(sla_checker_loop_async(app.state.supabase))
+#
+# (Not a standalone asyncio loop to avoid blocking the server.)
+
+async def sla_checker_loop_async(
+    supabase,
+    interval_seconds: int = 300,
+):
+    """Async SLA checker loop — suitable for FastAPI lifespan background task."""
+    from backend.services.sla_engine import SLAEngine
+    engine = SLAEngine(supabase_client=supabase)
+    logger.info(f"SLA background async checker started (interval={interval_seconds}s)")
+
+    while True:
+        try:
+            escalated = await engine.check_all_active_tickets()
+            if escalated:
+                await engine.dispatch_notifications(escalated)
+            logger.info(f"Async SLA check: {len(escalated)} escalations triggered")
+        except Exception as e:
+            logger.error(f"Async SLA check error: {e}")
+
+        await asyncio.sleep(interval_seconds)
+
+
+# ── CLI entry point ──────────────────────────────────────────────────────
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="SLA Breach & Escalation Checker")
+    parser.add_argument(
+        "--interval", type=int, default=5,
+        help="Check interval in minutes (default: 5)"
+    )
+    parser.add_argument(
+        "--dry-run", action="store_true",
+        help="Log evaluations without updating the database"
+    )
+    parser.add_argument(
+        "--once", action="store_true",
+        help="Run a single check cycle and exit"
+    )
+    args = parser.parse_args()
+
+    if args.once:
+        supabase = create_supabase_client()
+        result = run_sla_check_sync(supabase, args.dry_run)
+        print(json.dumps(result, indent=2))
+    else:
+        background_checker_loop(args.interval, args.dry_run)

supabase/functions/sla-notifier/index.ts

@@ -0,0 +1,343 @@
+import { serve } from "https://deno.land/std@0.177.0/http/server.ts"
+import { createClient } from "https://esm.sh/@supabase/supabase-js@2.42.0"
+
+/**
+ * SLA Notifier — Multi-channel notification dispatcher for SLA breaches.
+ *
+ * Triggered by Supabase Database webhook when:
+ *   1. A ticket's sla_status changes to 'breached' or 'warning'
+ *   2. An escalation_logs row is inserted
+ *
+ * Supported channels:
+ *   - Email (via Resend)
+ *   - Slack (incoming webhook)
+ *   - Microsoft Teams (incoming webhook)
+ *   - Generic webhook
+ */
+
+const SUPABASE_URL = Deno.env.get("SUPABASE_URL") || ""
+const SUPABASE_SERVICE_KEY = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") || ""
+const RESEND_API_KEY = Deno.env.get("RESEND_API_KEY") || ""
+const FROM_EMAIL = "HELPDESK.AI SLA <bonthalamadhavi1@gmail.com>"
+
+// ── Channel configuration from environment ────────────────────────────────
+// Format: JSON array of channel objects
+// SLA_CHANNELS=[{"type":"slack","url":"https://hooks.slack.com/...","enabled":true,"min_level":1}]
+const SLA_CHANNELS_RAW = Deno.env.get("SLA_CHANNELS") || "[]"
+let SLA_CHANNELS: any[] = []
+try {
+  SLA_CHANNELS = JSON.parse(SLA_CHANNELS_RAW)
+} catch { /* use empty */ }
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function formatDuration(seconds: number): string {
+  if (seconds <= 0) return "OVERDUE"
+  const hrs = Math.floor(seconds / 3600)
+  const mins = Math.floor((seconds % 3600) / 60)
+  if (hrs > 0) return `${hrs}h ${mins}m`
+  return `${mins}m`
+}
+
+function getColor(status: string): string {
+  if (status === "breached") return "#ef4444"  // red
+  if (status === "warning") return "#f59e0b"   // amber
+  return "#10b981"  // green
+}
+
+// ── Channel dispatchers ────────────────────────────────────────────────────
+
+async function sendEmail(payload: any): Promise<boolean> {
+  if (!RESEND_API_KEY) {
+    console.warn("[SLA-Notifier] No RESEND_API_KEY configured — skipping email.")
+    return false
+  }
+
+  const templateData = payload.template_data || {}
+  const recipient = payload.to || "support@helpdeskai.com"
+
+  const themeColor = "#ef4444"
+  const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body style="margin:0;padding:0;background-color:#f1f5f9;font-family:sans-serif;">
+  <table width="100%" border="0" cellspacing="0" cellpadding="0" style="background-color:#f1f5f9;padding:40px 20px;">
+    <tr>
+      <td align="center">
+        <table width="100%" border="0" cellspacing="0" cellpadding="0" style="max-width:600px;background-color:#ffffff;border-radius:24px;overflow:hidden;box-shadow:0 10px 40px rgba(0,0,0,0.05);">
+          <tr>
+            <td style="background: linear-gradient(135deg, #dc2626 0%, #991b1b 100%); padding: 40px; text-align: center;">
+              <h1 style="color:#ffffff; margin:0; font-size:28px; font-weight:900;">HELPDESK<span style="color:#fca5a5;">.AI</span></h1>
+              <p style="color:#fecaca; margin:8px 0 0; font-size:14px;">SLA Alert System</p>
+            </td>
+          </tr>
+          <tr>
+            <td style="padding: 24px 40px; border-bottom: 1px solid #f1f5f9; background-color: #fef2f2; text-align: center;">
+              <div style="display:inline-block; padding: 8px 16px; background-color: #fef2f2; border-radius: 999px; border: 1px solid #fecaca;">
+                <p style="margin:0; color:#991b1b; font-size:12px; font-weight:800; text-transform:uppercase;">${templateData.badge || "SLA NOTIFICATION"}</p>
+              </div>
+            </td>
+          </tr>
+          <tr>
+            <td style="padding: 40px;">
+              <h2 style="color:#0f172a; font-size:24px; margin: 0 0 16px;">${templateData.title || "SLA Alert"}</h2>
+              <p style="color:#64748b; font-size:16px; line-height:1.7; margin: 0 0 32px;">${templateData.mainText || ""}</p>
+              
+              <div style="background-color: #0f172a; border-radius: 20px; padding: 32px; text-align:center; margin-bottom: 32px;">
+                <p style="margin:0; color:rgba(255,255,255,0.4); font-size:10px; font-weight:800; text-transform:uppercase;">${templateData.refLabel || "Status"}</p>
+                <h2 style="margin:8px 0 0; color:#ffffff; font-size:32px; font-weight:900; letter-spacing:0.1em;">${templateData.refValue || ""}</h2>
+              </div>
+
+              <div align="center">
+                <a href="${templateData.ctaUrl || "https://helpdeskaiv1.vercel.app/admin/tickets"}" style="display:inline-block; background-color:#dc2626; color:#ffffff; padding: 18px 40px; border-radius: 16px; text-decoration:none; font-size:14px; font-weight:900;">
+                  ${templateData.ctaText || "View in Dashboard"} →
+                </a>
+              </div>
+            </td>
+          </tr>
+          <tr>
+            <td style="background-color:#f8fafc; padding:32px; text-align:center; border-top: 1px solid #f1f5f9;">
+              <p style="margin:0; color:#94a3b8; font-size:12px;">© 2026 HELPDESK.AI SLA Engine</p>
+            </td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+  </table>
+</body>
+</html>`
+
+  try {
+    const res = await fetch("https://api.resend.com/emails", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${RESEND_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        from: FROM_EMAIL,
+        to: [recipient],
+        subject: payload.subject || "[SLA Alert] HELPDESK.AI",
+        html: html,
+      }),
+    })
+    const data = await res.json()
+    console.log(`[SLA-Notifier] Email sent to ${recipient}: ${res.status}`, data)
+    return res.status < 500
+  } catch (err) {
+    console.error("[SLA-Notifier] Email send error:", err)
+    return false
+  }
+}
+
+async function sendSlack(payload: any): Promise<boolean> {
+  try {
+    const res = await fetch(payload.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload.body || {}),
+    })
+    console.log(`[SLA-Notifier] Slack sent: ${res.status}`)
+    return res.ok
+  } catch (err) {
+    console.error("[SLA-Notifier] Slack error:", err)
+    return false
+  }
+}
+
+async function sendTeams(payload: any): Promise<boolean> {
+  try {
+    const res = await fetch(payload.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload.body || {}),
+    })
+    console.log(`[SLA-Notifier] Teams sent: ${res.status}`)
+    return res.ok
+  } catch (err) {
+    console.error("[SLA-Notifier] Teams error:", err)
+    return false
+  }
+}
+
+async function sendWebhook(payload: any): Promise<boolean> {
+  try {
+    const res = await fetch(payload.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload.body || {}),
+    })
+    console.log(`[SLA-Notifier] Webhook sent: ${res.status}`)
+    return res.ok
+  } catch (err) {
+    console.error("[SLA-Notifier] Webhook error:", err)
+    return false
+  }
+}
+
+// ── Build a Slack-compatible attachment ────────────────────────────────────
+
+function buildSlackMessage(ticket: any, slaResult: any): any {
+  const status = slaResult?.sla_status || "breached"
+  const level = slaResult?.escalation_level || 1
+  const color = getColor(status)
+  const ticketId = (ticket?.id || "???").toString().slice(0, 8).toUpperCase()
+  const subject = ticket?.subject || ticket?.summary || "Untitled"
+  const priority = (ticket?.priority || "medium").toUpperCase()
+  const team = ticket?.assigned_team || "Unassigned"
+
+  return {
+    attachments: [{
+      color,
+      title: `[SLA ${status.toUpperCase()}] Ticket #${ticketId}`,
+      text: [
+        `*Ticket:* #${ticketId} — ${subject}`,
+        `*Priority:* ${priority} | *Team:* ${team}`,
+        `*Escalation Level:* ${level}`,
+        `*Time Remaining:* ${formatDuration(slaResult?.remaining_seconds || 0)}`,
+      ].join("\n"),
+      footer: "HELPDESK.AI SLA Engine",
+      ts: Math.floor(Date.now() / 1000),
+    }],
+  }
+}
+
+function buildTeamsMessage(ticket: any, slaResult: any): any {
+  const ticketId = (ticket?.id || "???").toString().slice(0, 8).toUpperCase()
+  const color = getColor(slaResult?.sla_status || "breached")
+  return {
+    "@type": "MessageCard",
+    "@context": "https://schema.org/extensions",
+    summary: `[SLA ${(slaResult?.sla_status || "").toUpperCase()}] Ticket #${ticketId}`,
+    themeColor: color,
+    sections: [{
+      activityTitle: `SLA Alert: Ticket #${ticketId}`,
+      activitySubtitle: ticket?.subject || ticket?.summary || "",
+      facts: [
+        { name: "Status", value: (slaResult?.sla_status || "").toUpperCase() },
+        { name: "Priority", value: (ticket?.priority || "medium").toUpperCase() },
+        { name: "Level", value: String(slaResult?.escalation_level || 0) },
+        { name: "Team", value: ticket?.assigned_team || "Unassigned" },
+        { name: "Remaining", value: formatDuration(slaResult?.remaining_seconds || 0) },
+      ],
+    }],
+  }
+}
+
+// ── Main handler ───────────────────────────────────────────────────────────
+
+serve(async (req: Request) => {
+  try {
+    const payload = await req.json()
+
+    // Support both webhook trigger and direct API call
+    const { type, record, ticket, sla_result, channel_urls } = payload
+    const isWebhook = type === "INSERT" && record?.table === "escalation_logs"
+
+    if (isWebhook || type === "SLA_ALERT") {
+      const escalationRecord = isWebhook ? record : payload
+      const targetTicket = ticket || escalationRecord
+
+      // Determine which channels to use
+      const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_KEY)
+
+      // Build common notification payload
+      const ticketId = (targetTicket.id || targetTicket.ticket_id || "???").toString().slice(0, 8)
+      const status = sla_result?.sla_status || escalationRecord.sla_status || "breached"
+      const level = sla_result?.escalation_level || escalationRecord.escalation_level || 1
+      const subject = targetTicket.subject || targetTicket.ticket_subject || "Untitled"
+
+      // Dispatch to configured channels
+      const results: string[] = []
+
+      for (const channel of SLA_CHANNELS) {
+        if (!channel.enabled) continue
+        if ((channel.min_level || 0) > level) continue
+
+        const channelType = channel.type || "webhook"
+        let success = false
+
+        switch (channelType) {
+          case "email": {
+            const emailPayload = {
+              to: channel.to || "support@helpdeskai.com",
+              subject: `[SLA ${status.toUpperCase()}] Ticket #${ticketId}`,
+              template_data: {
+                title: `${status.toUpperCase()}: Ticket #${ticketId}`,
+                badge: `🚨 Escalation Level ${level}`,
+                mainText: `Priority ${(targetTicket.priority || "medium").toUpperCase()} ticket "${subject}" has reached SLA status: ${status}.`,
+                refLabel: "Time Remaining",
+                refValue: formatDuration(sla_result?.remaining_seconds || 0),
+                ctaText: "View Ticket",
+                ctaUrl: `https://helpdeskaiv1.vercel.app/admin/ticket/${targetTicket.id || ""}`,
+              },
+            }
+            success = await sendEmail(emailPayload)
+            break
+          }
+          case "slack":
+            success = await sendSlack({
+              url: channel.url,
+              body: buildSlackMessage(targetTicket, sla_result),
+            })
+            break
+          case "teams":
+            success = await sendTeams({
+              url: channel.url,
+              body: buildTeamsMessage(targetTicket, sla_result),
+            })
+            break
+          case "webhook":
+          default:
+            success = await sendWebhook({
+              url: channel.url,
+              body: {
+                type: "sla_alert",
+                ticket_id: targetTicket.id || targetTicket.ticket_id,
+                sla_status: status,
+                escalation_level: level,
+                subject,
+                remaining_seconds: sla_result?.remaining_seconds || 0,
+                timestamp: new Date().toISOString(),
+              },
+            })
+            break
+        }
+
+        results.push(`${channelType}:${success ? "OK" : "FAIL"}`)
+      }
+
+      // Log dispatched channels back to the escalation_logs record
+      if (isWebhook && escalationRecord.id) {
+        try {
+          await supabase
+            .from("escalation_logs")
+            .update({ notification_channels: results })
+            .eq("id", escalationRecord.id)
+        } catch { /* non-fatal */ }
+      }
+
+      return new Response(JSON.stringify({
+        status: "dispatched",
+        channels: results,
+        ticket_id: targetTicket.id || targetTicket.ticket_id,
+      }), { status: 200 })
+    }
+
+    // Health check
+    if (type === "HEALTH") {
+      return new Response(JSON.stringify({
+        status: "ok",
+        channels_configured: SLA_CHANNELS.length,
+      }), { status: 200 })
+    }
+
+    return new Response(JSON.stringify({ status: "ignored", reason: "unknown_type" }), { status: 200 })
+  } catch (err: any) {
+    console.error("[SLA-Notifier] Error:", err.message)
+    return new Response(JSON.stringify({ error: err.message }), { status: 500 })
+  }
+})

supabase/migrations/20260401000000_sla_engine.sql

@@ -0,0 +1,204 @@
+-- SLA Engine — Database schema for SLA breach detection and escalation
+-- Part of Issue #75: SLA Breach & Automated Multi-Channel Escalation Engine
+
+-- =========================================================================
+-- 1. Extend the tickets table with SLA columns
+-- =========================================================================
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS sla_status text 
+    DEFAULT 'active'
+    CHECK (sla_status IN ('active', 'warning', 'breached', 'met', 'paused'));
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS sla_policy text
+    DEFAULT 'medium'
+    CHECK (sla_policy IN ('critical', 'high', 'medium', 'low'));
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS sla_breach_at timestamptz;
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS sla_warning_at timestamptz;
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS sla_started_at timestamptz;
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS sla_updated_at timestamptz;
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS escalation_level integer 
+    DEFAULT 0 
+    CHECK (escalation_level >= 0 AND escalation_level <= 3);
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS last_escalated_at timestamptz;
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS remaining_seconds integer 
+    DEFAULT 0;
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS channel_notified text[] 
+    DEFAULT '{}';
+
+-- =========================================================================
+-- 2. Escalation Logs — audit trail for every SLA escalation event
+-- =========================================================================
+
+CREATE TABLE IF NOT EXISTS public.escalation_logs (
+    id uuid DEFAULT gen_random_uuid() PRIMARY KEY,
+    ticket_id uuid REFERENCES public.tickets(id) ON DELETE CASCADE,
+    ticket_subject text NOT NULL DEFAULT '',
+    priority text NOT NULL DEFAULT 'medium',
+    sla_status text NOT NULL CHECK (sla_status IN ('active', 'warning', 'breached', 'met', 'paused')),
+    escalation_level integer NOT NULL DEFAULT 0,
+    remaining_seconds integer NOT NULL DEFAULT 0,
+    assigned_team text NOT NULL DEFAULT '',
+    notification_channels text[] DEFAULT '{}',
+    triggered_at timestamptz NOT NULL DEFAULT now(),
+    resolved_at timestamptz,
+    notes text DEFAULT ''
+);
+
+-- Index for fast dashboard queries
+CREATE INDEX IF NOT EXISTS idx_escalation_logs_ticket_id ON public.escalation_logs(ticket_id);
+CREATE INDEX IF NOT EXISTS idx_escalation_logs_triggered_at ON public.escalation_logs(triggered_at DESC);
+CREATE INDEX IF NOT EXISTS idx_escalation_logs_sla_status ON public.escalation_logs(sla_status);
+
+-- Enable RLS
+ALTER TABLE public.escalation_logs ENABLE ROW LEVEL SECURITY;
+
+-- Admins can read all escalation logs
+CREATE POLICY "Admins can read escalation logs" ON public.escalation_logs
+    FOR SELECT
+    USING (
+        EXISTS (
+            SELECT 1 FROM public.profiles
+            WHERE profiles.id = auth.uid()
+            AND (profiles.role = 'admin' OR profiles.role = 'master_admin')
+        )
+    );
+
+-- Service role and triggers can insert
+CREATE POLICY "Service role can insert escalation logs" ON public.escalation_logs
+    FOR INSERT
+    WITH CHECK (true);
+
+-- =========================================================================
+-- 3. SLA Policies — configurable SLA definitions (optional override table)
+-- =========================================================================
+
+CREATE TABLE IF NOT EXISTS public.sla_policies (
+    id uuid DEFAULT gen_random_uuid() PRIMARY KEY,
+    priority text NOT NULL UNIQUE CHECK (priority IN ('critical', 'high', 'medium', 'low')),
+    max_hours integer NOT NULL DEFAULT 8,
+    warning_pct numeric(4,3) NOT NULL DEFAULT 0.750,
+    auto_escalate boolean NOT NULL DEFAULT true,
+    l2_after_minutes integer NOT NULL DEFAULT 0,
+    l3_after_minutes integer NOT NULL DEFAULT 120,
+    company_id uuid REFERENCES public.companies(id) ON DELETE CASCADE,
+    is_custom boolean DEFAULT false,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz
+);
+
+-- Insert default SLA policies
+INSERT INTO public.sla_policies (priority, max_hours, warning_pct, auto_escalate, l2_after_minutes, l3_after_minutes)
+VALUES
+    ('critical', 2, 0.750, true, 0, 120),
+    ('high',     4, 0.750, true, 30, 240),
+    ('medium',   8, 0.750, true, 60, 480),
+    ('low',     24, 0.750, false, 120, 1440)
+ON CONFLICT (priority) DO NOTHING;
+
+ALTER TABLE public.sla_policies ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "Anyone can read sla_policies" ON public.sla_policies
+    FOR SELECT USING (true);
+
+CREATE POLICY "Master admins can manage sla_policies" ON public.sla_policies
+    FOR ALL
+    USING (
+        EXISTS (
+            SELECT 1 FROM public.profiles
+            WHERE profiles.id = auth.uid()
+            AND profiles.role = 'master_admin'
+        )
+    );
+
+-- =========================================================================
+-- 4. Indexes on tickets for SLA queries
+-- =========================================================================
+
+CREATE INDEX IF NOT EXISTS idx_tickets_sla_status ON public.tickets(sla_status);
+CREATE INDEX IF NOT EXISTS idx_tickets_escalation_level ON public.tickets(escalation_level);
+CREATE INDEX IF NOT EXISTS idx_tickets_sla_breach_at ON public.tickets(sla_breach_at);
+CREATE INDEX IF NOT EXISTS idx_tickets_priority_sla ON public.tickets(priority, sla_status);
+
+-- =========================================================================
+-- 5. Trigger: auto-set sla_policy when priority changes
+-- =========================================================================
+
+CREATE OR REPLACE FUNCTION public.auto_set_sla_policy()
+RETURNS trigger AS $$
+BEGIN
+    NEW.sla_policy := LOWER(NEW.priority);
+    -- If SLA hasn't started yet, start it now
+    IF NEW.sla_started_at IS NULL THEN
+        NEW.sla_started_at := now();
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS trg_auto_set_sla_policy ON public.tickets;
+CREATE TRIGGER trg_auto_set_sla_policy
+    BEFORE INSERT OR UPDATE OF priority ON public.tickets
+    FOR EACH ROW
+    EXECUTE FUNCTION public.auto_set_sla_policy();
+
+-- =========================================================================
+-- 6. Trigger: log when sla_status changes to breached
+-- =========================================================================
+
+CREATE OR REPLACE FUNCTION public.log_sla_breach()
+RETURNS trigger AS $$
+BEGIN
+    IF NEW.sla_status = 'breached' AND (OLD.sla_status IS DISTINCT FROM 'breached') THEN
+        INSERT INTO public.escalation_logs (
+            ticket_id, ticket_subject, priority, sla_status,
+            escalation_level, remaining_seconds, assigned_team,
+            notification_channels, triggered_at
+        ) VALUES (
+            NEW.id,
+            COALESCE(NEW.subject, NEW.summary, ''),
+            NEW.priority,
+            'breached',
+            COALESCE(NEW.escalation_level, 1),
+            COALESCE(NEW.remaining_seconds, 0),
+            COALESCE(NEW.assigned_team, ''),
+            '{}',
+            now()
+        );
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS trg_log_sla_breach ON public.tickets;
+CREATE TRIGGER trg_log_sla_breach
+    AFTER UPDATE OF sla_status ON public.tickets
+    FOR EACH ROW
+    WHEN (NEW.sla_status = 'breached')
+    EXECUTE FUNCTION public.log_sla_breach();
+
+-- =========================================================================
+-- 7. Grant permissions
+-- =========================================================================
+
+GRANT ALL ON TABLE public.escalation_logs TO authenticated;
+GRANT ALL ON TABLE public.escalation_logs TO service_role;
+GRANT SELECT ON TABLE public.sla_policies TO authenticated;
+GRANT ALL ON TABLE public.sla_policies TO service_role;

supabase/migrations/20260402000000_semantic_duplicates.sql

@@ -0,0 +1,140 @@
+-- Semantic Duplicate Detection — pgvector-powered ticket similarity search
+-- Issue #74: AI-Driven Semantic Duplicate Ticket Detection with Vector Embeddings
+
+-- =========================================================================
+-- 1. Enable pgvector extension
+-- =========================================================================
+
+CREATE EXTENSION IF NOT EXISTS vector WITH SCHEMA extensions;
+
+-- =========================================================================
+-- 2. Add vector column to tickets table
+-- =========================================================================
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS description_vector vector(384);
+
+-- Index for fast cosine similarity queries (IVFFlat is good for <100K rows)
+CREATE INDEX IF NOT EXISTS idx_tickets_description_vector
+  ON public.tickets
+  USING ivfflat (description_vector vector_cosine_ops)
+  WITH (lists = 100);
+
+-- =========================================================================
+-- 3. Similarity search RPC — company-scoped cosine similarity
+-- =========================================================================
+
+-- Drop existing if present
+DROP FUNCTION IF EXISTS match_tickets;
+
+CREATE OR REPLACE FUNCTION match_tickets(
+    query_vector vector(384),
+    match_threshold float DEFAULT 0.70,
+    match_count int DEFAULT 5,
+    tenant_company_id uuid DEFAULT NULL
+)
+RETURNS TABLE(
+    id uuid,
+    ticket_id text,
+    subject text,
+    summary text,
+    description text,
+    priority text,
+    status text,
+    assigned_team text,
+    company_id uuid,
+    similarity float,
+    created_at timestamptz
+)
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    RETURN QUERY
+    SELECT
+        t.id,
+        t.ticket_id,
+        t.subject,
+        t.summary,
+        t.description,
+        t.priority,
+        t.status,
+        t.assigned_team,
+        t.company_id,
+        1 - (t.description_vector <=> query_vector) AS similarity,
+        t.created_at
+    FROM public.tickets t
+    WHERE
+        t.description_vector IS NOT NULL
+        AND (1 - (t.description_vector <=> query_vector)) > match_threshold
+        AND (tenant_company_id IS NULL OR t.company_id = tenant_company_id)
+        -- Exclude resolved/closed tickets from duplicate matching
+        AND (t.status IS NULL OR (
+            LOWER(t.status) NOT LIKE '%resolv%'
+            AND LOWER(t.status) NOT LIKE '%closed%'
+        ))
+    ORDER BY t.description_vector <=> query_vector
+    LIMIT match_count;
+END;
+$$;
+
+-- =========================================================================
+-- 4. System settings table for dynamic duplicate_sensitivity
+-- =========================================================================
+
+CREATE TABLE IF NOT EXISTS public.system_settings (
+    id uuid DEFAULT gen_random_uuid() PRIMARY KEY,
+    key text NOT NULL UNIQUE,
+    value jsonb NOT NULL DEFAULT '{}'::jsonb,
+    description text DEFAULT '',
+    updated_at timestamptz DEFAULT now()
+);
+
+-- Insert default duplicate sensitivity
+INSERT INTO public.system_settings (key, value, description)
+VALUES (
+    'duplicate_detection',
+    '{"sensitivity": 0.85, "enabled": true, "max_candidates": 5}'::jsonb,
+    'Duplicate detection configuration: sensitivity (0.0-1.0), enabled, max_candidates'
+)
+ON CONFLICT (key) DO NOTHING;
+
+-- =========================================================================
+-- 5. Add parent_ticket_id for linking duplicates
+-- =========================================================================
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS parent_ticket_id uuid REFERENCES public.tickets(id) ON DELETE SET NULL;
+
+ALTER TABLE public.tickets
+  ADD COLUMN IF NOT EXISTS is_potential_duplicate boolean DEFAULT false;
+
+-- Index for finding duplicate chains
+CREATE INDEX IF NOT EXISTS idx_tickets_parent_ticket_id ON public.tickets(parent_ticket_id);
+
+-- =========================================================================
+-- 6. RLS for system_settings
+-- =========================================================================
+
+ALTER TABLE public.system_settings ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "Anyone can read system settings" ON public.system_settings
+    FOR SELECT USING (true);
+
+CREATE POLICY "Master admins can manage system settings" ON public.system_settings
+    FOR ALL
+    USING (
+        EXISTS (
+            SELECT 1 FROM public.profiles
+            WHERE profiles.id = auth.uid()
+            AND profiles.role = 'master_admin'
+        )
+    );
+
+-- =========================================================================
+-- 7. Grant permissions
+-- =========================================================================
+
+GRANT ALL ON ALL FUNCTIONS IN SCHEMA public TO authenticated;
+GRANT ALL ON ALL FUNCTIONS IN SCHEMA public TO service_role;
+GRANT ALL ON TABLE public.system_settings TO authenticated;
+GRANT ALL ON TABLE public.system_settings TO service_role;