Unified SLA System Architecture

┌────────────────────────────────────────────────────────────────────────────┐
│                      SLA SYSTEM ARCHITECTURE                           │
└────────────────────────────────────────────────────────────────────────────┘

┌──────────────────┐
│   Frontend      │  User creates Ticket/Incident/Problem
│   (React 19+)    │  → POST /api/tickets
└────────┬─────────┘
         │
         ▼
┌──────────────────────────────────────────────────────────────────────────┐
│   Backend (Node.js + Express)                                         │
│                                                                          │
│  ┌────────────────────────────────────────────────────────────────────┐ │
│  │  TicketMutationService                                          │ │
│  │  • createTicket()                                                  │ │
│  │  • Calls: slaTrackingService.createTracking()                     │ │
│  └───────────────────────────┬────────────────────────────────────────┘ │
│                              │                                           │
│                              ▼                                           │
│  ┌────────────────────────────────────────────────────────────────────┐ │
│  │  SLATrackingService                                             │ │
│  │  • findMatchingPolicy(entityType, categoryId)                     │ │
│  │    - Category-specific policy (if categoryId)                     │ │
│  │    - Default policy for entity type                               │ │
│  │  • extractTargets(policy, priority)                               │ │
│  │    - targets.HIGH = { responseMin: 60, resolutionMin: 480 }       │ │
│  │  • Calculate deadlines via BusinessHoursCalculator               │ │
│  │  • INSERT INTO SLATracking                                         │ │
│  └───────────────────────────┬────────────────────────────────────────┘ │
│                              │                                           │
│                              ▼                                           │
│  ┌────────────────────────────────────────────────────────────────────┐ │
│  │  BusinessHoursCalculator                                        │ │
│  │  • calculateDeadline(startTime, businessMinutes, businessHoursId) │ │
│  │  • If 24/7 mode: addMinutes(startTime, businessMinutes)           │ │
│  │  • If business hours:                                              │ │
│  │    - Iterate days, skip weekends/holidays                          │ │
│  │    - Accumulate business minutes until target reached              │ │
│  │  • Returns deadline (Date)                                         │ │
│  └────────────────────────────────────────────────────────────────────┘ │
│                                                                          │
└──────────────────────────────┬───────────────────────────────────────────┘
                               │
                               ▼
┌────────────────────────────────────────────────────────────────────────────┐
│   PostgreSQL Database                                                    │
│                                                                            │
│   SLATracking:                                                             │
│   • id, entityType, entityId                                               │
│   • slaPolicyId, targetResponseMin, targetResolutionMin                   │
│   • responseDeadline, resolutionDeadline                                   │
│   • responseMet, resolutionMet, responseAt, resolvedAt, breachAt           │
│   • isPaused, pausedAt, pausedTotalSec, pauseHistory                       │
│   • currentEscalationLevel, lastEscalationAt, escalationHistory            │
│   • calculatedStatus, calculatedPercentUsed  (Monitor-gepflegt)            │
│   • excludeFromReporting                     (aus Compliance-Quoten raus)  │
│                                                                            │
│   SLAPolicy:                                                               │
│   • id, name, entityType, targets (JSONB)                                  │
│   • businessHoursId, escalationPolicyId                                    │
│   • categoryIds[], pauseOnStatus[]                                         │
│   • pauseOnIncidentLink, pauseOnChildTicket                                │
│   • isDefault, isActive                                                    │
│                                                                            │
│   BusinessHours:                                                           │
│   • id, name, schedule (JSONB), timezone                                   │
│   • excludeHolidays, holidayCountry, holidayRegion, isDefault              │
│                                                                            │
│   Holiday:                                                                 │
│   • id, name, date, isRecurring, country, region                           │
│                                                                            │
│   EscalationPolicy:                                                        │
│   • id, name, levels (JSONB), repeatConfig (JSONB), isActive               │
│                                                                            │
│   UserAbsence:                                                             │
│   • userId, type, startDate, endDate, substituteId                         │
│   • autoReassign, status, approvedBy, approvedAt                           │
└────────────────────────────────────────────────────────────────────────────┘

         │
         ▼
┌────────────────────────────────────────────────────────────────────────────┐
│   Job-Worker (Background Jobs)                                           │
│                                                                            │
│   ┌────────────────────────────────────────────────────────────────────┐  │
│   │  SLAMonitorAction (built-in cron, interval 2 min + runOnStartup) │  │
│   │  • Fetch active SLA trackings (resolutionMet = null)               │  │
│   │  • Calculate current status (OK/WARNING/BREACH/CRITICAL)           │  │
│   │  • Evaluate escalation policy levels                               │  │
│   │  • Execute escalation actions (NOTIFY/REASSIGN/ESCALATE_PRIORITY)  │  │
│   │  • Repeat reminders after the last level (repeatConfig)            │  │
│   │  • Record escalation in database                                   │  │
│   │  • Publish SLA events to notification system                       │  │
│   └────────────────────────────────────────────────────────────────────┘  │
│                                                                            │
└────────────────────────────────────────────────────────────────────────────┘

         │
         ▼
┌────────────────────────────────────────────────────────────────────────────┐
│   Notification System                                                    │
│   • SLANotificationService → DomainEventBus                               │
│   • SLANotificationService listens to SLA events                          │
│   • Routes to NotificationOrchestrator                                     │
│   • Multi-channel: WEB, EMAIL, TEAMS, WEBEX                                │
└────────────────────────────────────────────────────────────────────────────┘

         │
         ▼
┌────────────────────────────────────────────────────────────────────────────┐
│   Audit System                                                           │
│   • All SLA events logged via getAuditService()                            │
│   • SHA-256 hash chain (tamper-evident)                                    │
│   • Actions: SLA_TRACKING_CREATED, SLA_WARNING/SLA_BREACH, SLA_RESOLUTION_MISSED │
└────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                   SLA CREATION (DETAILED)                       │
└─────────────────────────────────────────────────────────────────────────┘

1. User creates Ticket/Incident/Problem:

POST /api/tickets
{
  "title": "Database connection timeout",
  "priority": "HIGH",
  "categoryId": "database-issues",
  "description": "..."
}

2. TicketMutationService.createTicket():

// Insert ticket into database
const ticket = await prisma.ticket.create({ ... });

// Create SLA tracking
await slaTrackingService.createTracking({
  entityType: 'TICKET',
  entityId: ticket.id,
  priority: ticket.priority,
  categoryId: ticket.categoryId,
  createdAt: ticket.createdAt
});

3. SLATrackingService.createTracking():

Step 3.1: Find Matching SLA Policy
// Try category-specific policy first
let policy = await prisma.slaPolicy.findFirst({
  where: {
    entityType: 'TICKET',
    categoryIds: { has: categoryId },  // Array contains categoryId
    isActive: true
  }
});

// Fallback to default policy
if (!policy) {
  policy = await prisma.slaPolicy.findFirst({
    where: {
      entityType: 'TICKET',
      isDefault: true,
      isActive: true
    }
  });
}

// Throw error if no policy found
if (!policy) {
  throw new Error('No SLA policy found for entity type TICKET');
}

Step 3.2: Extract Targets for Priority
const targets = policy.targets[priority] || policy.targets.default;
// Example: targets = { responseMin: 60, resolutionMin: 480 }

if (!targets) {
  throw new Error(`No SLA targets for priority ${priority}`);
}

Step 3.3: Calculate Deadlines
const responseDeadline = await businessHoursCalculator.calculateDeadline(
  createdAt,
  targets.responseMin,
  policy.businessHoursId
);

const resolutionDeadline = await businessHoursCalculator.calculateDeadline(
  createdAt,
  targets.resolutionMin,
  policy.businessHoursId
);

Step 3.4: Create SLATracking Record
const tracking = await prisma.sLATracking.create({
  data: {
    entityType: 'TICKET',
    entityId: ticket.id,
    slaPolicyId: policy.id,
    targetResponseMin: targets.responseMin,
    targetResolutionMin: targets.resolutionMin,
    responseDeadline,
    resolutionDeadline,
    responseMet: null,       // pending
    resolutionMet: null,     // pending
    responseAt: null,
    resolvedAt: null,
    breachAt: null,
    currentEscalationLevel: 0,
    lastEscalationAt: null,
    escalationHistory: [],
    isPaused: false,
    pausedAt: null,
    pausedTotalSec: 0,
    pauseHistory: []
  }
});

Step 3.5: Audit Log
await auditService.log({
  domain: 'SLA',
  action: 'SLA_TRACKING_CREATED',
  severity: 'INFO',
  entityType: 'TICKET',
  entityId: ticket.id,
  actorId: currentUser.id,
  metadata: {
    policyId: policy.id,
    policyName: policy.name,
    targetResponseMin: targets.responseMin,
    targetResolutionMin: targets.resolutionMin,
    responseDeadline: responseDeadline.toISOString(),
    resolutionDeadline: resolutionDeadline.toISOString()
  }
});

4. Return Response:
{
  "id": "ticket-uuid",
  "title": "Database connection timeout",
  "priority": "HIGH",
  "sla": {
    "id": "tracking-uuid",
    "policyName": "Standard Support SLA",
    "status": "OK",
    "responseDeadline": "2026-01-28T11:00:00Z",
    "resolutionDeadline": "2026-01-28T17:00:00Z"
  }
}

BUSINESS HOURS CALCULATOR LOGIC:

async calculateDeadline(
  startTime: Date,
  businessMinutes: number,
  businessHoursId: string | null
): Promise<Date> {

  // 24/7 Mode (no business hours restriction)
  if (!businessHoursId) {
    return addMinutes(startTime, businessMinutes);
  }

  // Business Hours Mode
  const businessHours = await this.getBusinessHours(businessHoursId);
  // Config cached in-memory for 5 min (schedule/timezone per id)

  let currentTime = startTime;
  let remainingMinutes = businessMinutes;

  // Iterate until all business minutes accumulated
  while (remainingMinutes > 0) {
    const dayOfWeek = currentTime.getDay(); // 0 = Sunday, 1 = Monday, ...
    const dayName = ['sunday', 'monday', 'tuesday', ...][dayOfWeek];
    const daySchedule = businessHours.schedule[dayName];

    // Skip non-working days
    if (!daySchedule || !daySchedule.start || !daySchedule.end) {
      currentTime = startOfNextDay(currentTime);
      continue;
    }

    // Check if holiday
    if (businessHours.excludeHolidays) {
      const isHoliday = await this.isHoliday(
        currentTime,
        businessHours.holidayCountry,
        businessHours.holidayRegion
      );
      // Cached in Redis: key "sla:holidays:{country}:{region}:{year}", TTL 24h

      if (isHoliday) {
        currentTime = startOfNextDay(currentTime);
        continue;
      }
    }

    // Parse working hours (in businessHours.timezone)
    const workStartTime = parseTime(daySchedule.start, businessHours.timezone);
    const workEndTime = parseTime(daySchedule.end, businessHours.timezone);

    // If before work start, jump to work start
    if (currentTime < workStartTime) {
      currentTime = workStartTime;
    }

    // If after work end, jump to next day
    if (currentTime >= workEndTime) {
      currentTime = startOfNextDay(currentTime);
      continue;
    }

    // Calculate working minutes available today
    const minutesUntilEndOfDay = differenceInMinutes(workEndTime, currentTime);
    const minutesToAdd = Math.min(remainingMinutes, minutesUntilEndOfDay);

    // Add minutes to current time
    currentTime = addMinutes(currentTime, minutesToAdd);
    remainingMinutes -= minutesToAdd;

    // If still minutes remaining, move to next day
    if (remainingMinutes > 0) {
      currentTime = startOfNextDay(currentTime);
    }
  }

  return currentTime;
}

EXAMPLE (with visualization):

Input:
• startTime: Friday 14:00
• businessMinutes: 480 (8 hours)
• businessHours: Monday-Friday 09:00-17:00 (8h/day)

Calculation:
┌─────────────────────────────────────────────────┐
│ Friday 14:00 → 17:00 = 180 min (3h) ✅           │
│ Remaining: 480 - 180 = 300 min                  │
├─────────────────────────────────────────────────┤
│ Saturday = SKIP (not in schedule)               │
│ Sunday = SKIP (not in schedule)                 │
├─────────────────────────────────────────────────┤
│ Monday 09:00 → 14:00 = 300 min (5h) ✅           │
│ Remaining: 0 min                                │
└─────────────────────────────────────────────────┘

Result: Monday 14:00 (3 calendar days later!)

shouldRemainPaused(tracking, entityStatus, tx):
  – entityStatus ∈ policy.pauseOnStatus                      → true
  – policy.pauseOnIncidentLink && TICKET with open incident link  → true
  – policy.pauseOnChildTicket && TICKET with open sub-ticket      → true
  – otherwise                                                  → false

PAUSE LOGIC:

// Triggered when status changes to ON_HOLD
async pauseTracking(trackingId: string): Promise<void> {

  const tracking = await prisma.sLATracking.findUnique({
    where: { id: trackingId }
  });

  if (!tracking || tracking.isPaused) {
    return; // Already paused or not found
  }

  const now = new Date();

  // Update tracking record
  await prisma.sLATracking.update({
    where: { id: trackingId },
    data: {
      isPaused: true,
      pausedAt: now,
      pauseHistory: {
        push: {
          action: 'PAUSE',
          timestamp: now.toISOString(),
          reason: 'Status changed to ON_HOLD'
        }
      }
    }
  });

  // Audit log
  await auditService.log({
    domain: 'SLA',
    action: 'SLA_TRACKING_PAUSED',
    severity: 'INFO',
    entityType: tracking.entityType,
    entityId: tracking.entityId,
    metadata: { pausedAt: now.toISOString() }
  });
}

RESUME LOGIC:

// Triggered when status changes from ON_HOLD to IN_PROGRESS
async resumeTracking(trackingId: string): Promise<void> {

  const tracking = await prisma.sLATracking.findUnique({
    where: { id: trackingId },
    include: { slaPolicy: { include: { businessHours: true } } }
  });

  if (!tracking || !tracking.isPaused) {
    return; // Not paused
  }

  const now = new Date();
  const pausedAt = tracking.pausedAt!;

  // Calculate pause duration
  const pauseDurationSec = differenceInSeconds(now, pausedAt);

  // Shift deadlines
  let newResponseDeadline = tracking.responseDeadline;
  let newResolutionDeadline = tracking.resolutionDeadline;

  if (tracking.slaPolicy.businessHoursId) {
    // Business Hours Mode: Shift by business minutes only
    const businessMinutes = await businessHoursCalculator.calculateBusinessMinutes(
      pausedAt,
      now,
      tracking.slaPolicy.businessHoursId
    );

    newResponseDeadline = await businessHoursCalculator.calculateDeadline(
      tracking.responseDeadline,
      businessMinutes,
      tracking.slaPolicy.businessHoursId
    );

    newResolutionDeadline = await businessHoursCalculator.calculateDeadline(
      tracking.resolutionDeadline,
      businessMinutes,
      tracking.slaPolicy.businessHoursId
    );
  } else {
    // 24/7 Mode: Shift by calendar minutes
    newResponseDeadline = addSeconds(tracking.responseDeadline, pauseDurationSec);
    newResolutionDeadline = addSeconds(tracking.resolutionDeadline, pauseDurationSec);
  }

  // Update tracking record
  await prisma.sLATracking.update({
    where: { id: trackingId },
    data: {
      isPaused: false,
      pausedAt: null,
      pausedTotalSec: tracking.pausedTotalSec + pauseDurationSec,
      responseDeadline: newResponseDeadline,
      resolutionDeadline: newResolutionDeadline,
      pauseHistory: {
        push: {
          action: 'RESUME',
          timestamp: now.toISOString(),
          pauseDurationSec,
          oldDeadline: tracking.resolutionDeadline.toISOString(),
          newDeadline: newResolutionDeadline.toISOString()
        }
      }
    }
  });

  // Audit log
  await auditService.log({
    domain: 'SLA',
    action: 'SLA_TRACKING_RESUMED',
    severity: 'INFO',
    entityType: tracking.entityType,
    entityId: tracking.entityId,
    metadata: {
      pauseDurationSec,
      deadlineShiftSec: differenceInSeconds(newResolutionDeadline, tracking.resolutionDeadline)
    }
  });
}

EXAMPLE:

Initial Deadline: Monday 14:00
Paused: Monday 11:00
Resumed: Tuesday 10:00 (24 hours later)

24/7 Mode:
  → Shift by 24 hours (1440 minutes)
  → New Deadline: Tuesday 14:00

Business Hours Mode (09:00-17:00):
  → Pause duration = 24 calendar hours
  → Business minutes = 7 hours (Monday 11:00-17:00 + Tuesday 09:00-10:00)
  → Shift by 7 business hours
  → New Deadline: Tuesday 14:00 + 7h = Wednesday 13:00

→ Business Hours Mode is FAIRER for the customer!

PRIORITY RESET LOGIC:

// Triggered when priority changes
async resetTracking(trackingId: string, newPriority: string): Promise<void> {

  const tracking = await prisma.sLATracking.findUnique({
    where: { id: trackingId },
    include: { slaPolicy: true }
  });

  if (!tracking) {
    throw new Error('SLA tracking not found');
  }

  // Extract new targets for new priority
  const newTargets = tracking.slaPolicy.targets[newPriority]
    || tracking.slaPolicy.targets.default;

  if (!newTargets) {
    throw new Error(`No SLA targets for priority ${newPriority}`);
  }

  const now = new Date();

  // Calculate NEW deadlines from NOW (fresh start)
  const newResponseDeadline = await businessHoursCalculator.calculateDeadline(
    now,
    newTargets.responseMin,
    tracking.slaPolicy.businessHoursId
  );

  const newResolutionDeadline = await businessHoursCalculator.calculateDeadline(
    now,
    newTargets.resolutionMin,
    tracking.slaPolicy.businessHoursId
  );

  // Reset escalation level
  const resetEscalationLevel = 0;

  // Update tracking record
  await prisma.sLATracking.update({
    where: { id: trackingId },
    data: {
      targetResponseMin: newTargets.responseMin,
      targetResolutionMin: newTargets.resolutionMin,
      responseDeadline: newResponseDeadline,
      resolutionDeadline: newResolutionDeadline,
      currentEscalationLevel: resetEscalationLevel,
      breachAt: null,  // Clear breach if any
      escalationHistory: {
        push: {
          action: 'RESET',
          timestamp: now.toISOString(),
          reason: `Priority changed to ${newPriority}`,
          oldTargets: {
            responseMin: tracking.targetResponseMin,
            resolutionMin: tracking.targetResolutionMin
          },
          newTargets: {
            responseMin: newTargets.responseMin,
            resolutionMin: newTargets.resolutionMin
          },
          oldDeadline: tracking.resolutionDeadline.toISOString(),
          newDeadline: newResolutionDeadline.toISOString()
        }
      }
    }
  });

  // Audit log
  await auditService.log({
    domain: 'SLA',
    action: 'SLA_RECALCULATED_FOR_PRIORITY',
    severity: 'WARNING',
    entityType: tracking.entityType,
    entityId: tracking.entityId,
    metadata: {
      newPriority,
      oldTargetResolutionMin: tracking.targetResolutionMin,
      newTargetResolutionMin: newTargets.resolutionMin,
      oldDeadline: tracking.resolutionDeadline.toISOString(),
      newDeadline: newResolutionDeadline.toISOString()
    }
  });
}

WHY RESET?

Szenario:
• Ticket created: Monday 09:00, Priority LOW
• Target: 2880 minutes (48 hours)
• Deadline: Wednesday 09:00
• Elapsed: 24 hours (50% used, status WARNING)

Priority escalated to CRITICAL:
• New Target: 120 minutes (2 hours)
• NEW Deadline: Monday 11:00 (from NOW, not inherited)
• Escalation Level: 0 (reset)

→ Prevents inherited "almost breached" status from the old priority!
→ Gives the team a fair chance with stricter targets!

┌─────────────────────────────────────────────────────────────────────────┐
│              SLA ESCALATION WORKFLOW                              │
└─────────────────────────────────────────────────────────────────────────┘

1. SLA Monitor (Background Job) runs every 2 minutes (built-in template):

┌──────────────────────────────────────────────────────────────────────┐
│  job-worker: SLAMonitorAction                                        │
└──────────────────────────────────────────────────────────────────────┘

Step 1.1: Fetch Active SLA Trackings
const trackings = await loadActiveTrackings(); // resolutionMet = null

Returns all SLAs not yet resolved (active)

Step 1.2: Calculate Current Status for Each
For each tracking:

// Calculate elapsed time (excluding pause time)
const elapsed = differenceInMinutes(NOW, tracking.createdAt);
const elapsedNet = elapsed - (tracking.pausedTotalSec / 60);

// For business hours policies
if (tracking.slaPolicy.businessHoursId) {
  elapsedNet = await businessHoursCalculator.calculateBusinessMinutes(
    tracking.createdAt,
    NOW,
    tracking.slaPolicy.businessHoursId
  ) - (tracking.pausedTotalSec / 60);
}

// Calculate percent used
const percentUsed = (elapsedNet / tracking.targetResolutionMin) * 100;

// Determine status
let status = 'OK';
if (percentUsed >= 100) {
  const minutesAfterBreach = elapsedNet - tracking.targetResolutionMin;
  status = minutesAfterBreach >= 60 ? 'CRITICAL' : 'BREACH';
} else if (percentUsed >= 80) {
  status = 'WARNING';
}

Step 1.3: Evaluate Escalation Policy Levels
const escalationPolicy = tracking.slaPolicy.escalationPolicy;

if (!escalationPolicy || !escalationPolicy.isActive) {
  continue; // No escalation policy
}

for (const level of escalationPolicy.levels) {
  // Skip if already escalated to this level
  if (tracking.currentEscalationLevel >= level.level) {
    continue;
  }

  // Check if trigger condition met
  let triggered = false;

  switch (level.triggerType) {
    case 'PERCENTAGE':
      triggered = percentUsed >= level.triggerValue;
      break;

    case 'BREACH':
      triggered = percentUsed >= 100;
      break;

    case 'TIME_AFTER_BREACH':
      if (tracking.breachAt) {
        const minutesAfterBreach = differenceInMinutes(NOW, tracking.breachAt);
        triggered = minutesAfterBreach >= level.triggerValue;
      }
      break;
  }

  if (!triggered) {
    continue;
  }

  // TRIGGER ESCALATION!
  await executeEscalation(tracking, level, status, percentUsed);
}

Step 1.4: Execute Escalation Actions
async function executeEscalation(tracking, level, status, percentUsed) {

  const actionResults = [];

  for (const action of level.actions) {
    try {
      switch (action.type) {
        case 'NOTIFY':
          await executeNotifyAction(tracking, action, status);
          actionResults.push({ type: 'NOTIFY', success: true });
          break;

        case 'REASSIGN':
          await executeReassignAction(tracking, action);
          actionResults.push({ type: 'REASSIGN', success: true });
          break;

        case 'ESCALATE_PRIORITY':
          await executeEscalatePriorityAction(tracking);
          actionResults.push({ type: 'ESCALATE_PRIORITY', success: true });
          break;
      }
    } catch (error) {
      actionResults.push({ type: action.type, success: false, error: error.message });
    }
  }

  // Record escalation in database
  await recordEscalation(tracking.id, {
    level: level.level,
    trigger: level.triggerType,
    percentUsed,
    status,
    actions: actionResults,
    timestamp: NOW
  });

  // Audit log (status-based action: SLA_WARNING | SLA_BREACH | SLA_CRITICAL)
  await auditService.log({
    domain: 'SLA',
    action: status === 'CRITICAL' ? 'SLA_CRITICAL' : (status === 'BREACH' ? 'SLA_BREACH' : 'SLA_WARNING'),
    severity: status === 'CRITICAL' ? 'CRITICAL' : 'WARNING',
    entityType: tracking.entityType,
    entityId: tracking.entityId,
    metadata: {
      escalationLevel: level.level,
      triggerType: level.triggerType,
      percentUsed,
      status,
      actions: actionResults
    }
  });
}

2. Execute NOTIFY Action:

async function executeNotifyAction(tracking, action, status) {

  // Determine recipients based on notifyTargets
  const recipients = [];

  if (action.notifyTargets.includes('ASSIGNEE')) {
    recipients.push(tracking.entity.assignedToId);
  }

  if (action.notifyTargets.includes('GROUP_LEAD')) {
    recipients.push(...await getGroupLeads(tracking.entity.assignedGroupId));
  }

  if (action.notifyTargets.includes('MANAGER')) {
    // Walks up the manager chain; see "Manager escalation" below
    recipients.push(...await getEscalationChain(tracking.entity.assignedToId));
  }

  if (action.notifyTargets.includes('CUSTOM')) {
    // Explicit user picker in the policy builder
    recipients.push(...action.customUserIds);
  }

  // Publish SLA event → SLANotificationService
  {
    type: status === 'CRITICAL' || status === 'BREACH' ? 'SLA_BREACH' : 'SLA_WARNING',
    trackingId: tracking.id,
    entityType: tracking.entityType,
    entityId: tracking.entityId,
    recipientIds: recipients,
    // NO channels here — the notification type config + user
    // preferences decide the delivery route (in-app/email/…)
    metadata: { percentUsed, deadline: tracking.resolutionDeadline.toISOString() }
  }

  // Recipients are filtered against entity visibility at runtime;
  // dedupe key includes level (and repetition for repeats)
}

3. Execute REASSIGN Action:

async function executeReassignAction(tracking, action) {

  // Target may be a group, a user, or both
  await assignmentService.reassign({
    entityType: tracking.entityType,
    entityId: tracking.entityId,
    groupId: action.reassignToGroupId,   // optional
    userId: action.reassignToUserId,     // optional (must be an active agent)
    reason: 'SLA_ESCALATION'
  });

  // Runs through AssignmentService → Activity, Audit and workload
  // handling identical to a manual reassignment. If both are set,
  // the group is assigned first, then the user.
  // Afterwards fresh entity details are loaded for the notification.
}

4. Execute ESCALATE_PRIORITY Action:

async function executeEscalatePriorityAction(tracking) {

  // Determine new priority (one level up)
  const priorityMap = {
    'LOW': 'MEDIUM',
    'MEDIUM': 'HIGH',
    'HIGH': 'CRITICAL',
    'CRITICAL': 'CRITICAL'  // Already at top
  };

  const currentPriority = tracking.entity.priority;
  const newPriority = priorityMap[currentPriority];

  if (newPriority === currentPriority) {
    return; // Already at top priority
  }

  // Update entity priority
  await escalatePriority({
    entityType: tracking.entityType,
    entityId: tracking.entityId,
    newPriority
  });

  // This triggers SLA reset internally:
  // → New targets for new priority
  // → New deadlines calculated from NOW
  // → Escalation level reset to 0
  // → Fresh start with stricter targets
}

REPEAT CONDITIONS (all must hold):

  repeatConfig.enabled                              repeat switched on  tracking.breachAt != null                         already breached  tracking.resolutionMet == null                    still open  currentEscalationLevel >= last level            ladder exhausted  repeatsDone < repeatConfig.maxRepeats             quota left  repeatsDone < ⌊businessMinutesAfterBreach / intervalMin⌋

Counter: repeatsDone = number of history entries with triggerType REPEAT.Effect: NOTIFY to repeatConfig.notifyTargets, payload like the highest level; history entry { triggerType: "REPEAT", repetition: n }; lastEscalationAt is bumped; the dedupe key carries :r&lt;n&gt;, so each repeat is delivered individually.

┌─────────────────────────────────────────────────────────────────────┐
│                    EVENT-DRIVEN FLOW                            │
└─────────────────────────────────────────────────────────────────────┘

┌──────────────────┐
│  SLA Monitor     │  Detects: SLA at 85% used
│  (Job-Worker)    │
└────────┬─────────┘
         │
         │ Publishes event
         ▼
┌──────────────────────────────────────┐
│  DomainEventBus                    │
│  Event: SLA_WARNING                  │
│  Data: {                             │
│    trackingId, entityId, percentUsed │
│  }                                   │
└────────┬─────────────────────────────┘
         │
         │ Routes to subscribers
         ├────────────────────────┬────────────────────┐
         ▼                        ▼                    ▼
┌──────────────────┐   ┌──────────────────┐   ┌──────────────┐
│ Notification     │   │ Webhook          │   │ Audit        │
│ Adapter          │   │ Dispatcher       │   │ Service      │
└────────┬─────────┘   └────────┬─────────┘   └────────┬─────┘
         │                      │                      │
         ▼                      ▼                      ▼
┌──────────────────┐   ┌──────────────────┐   ┌──────────────┐
│ Multi-Channel    │   │ External System  │   │ Audit Event  │
│ Notification:    │   │ via Webhook      │   │ (SHA-256)    │
│ • WEB            │   │                  │   │              │
│ • EMAIL          │   │                  │   │              │
│ • TEAMS          │   │                  │   │              │
│ • WEBEX          │   │                  │   │              │
└──────────────────┘   └──────────────────┘   └──────────────┘