Overdue background job (time.NewTicker, 1-minute interval)
Two independent passes per tick:

Pass 1 — Notify:
  SELECT id, org_id FROM ff_tasks
  WHERE due_date + (org config overdue_notify_after_hours * interval '1 hour') < now()
    AND status NOT IN ('approved', 'cancelled')
    AND overdue_notified_at IS NULL
  → For each task:
      notify assignees + manager/supervisor (push notification)
      UPDATE ff_tasks SET overdue_notified_at = now() WHERE id = ?

Pass 2 — Escalate:
  SELECT id, org_id, created_by FROM ff_tasks
  WHERE due_date + (org config escalation_after_hours * interval '1 hour') < now()
    AND status NOT IN ('approved', 'cancelled')
    AND escalated_at IS NULL
  → For each task:
      resolve next-role-up from assignee roles (field_team → supervisor → manager → admin)
      notify next-role-up (push notification only — task unchanged)
      UPDATE ff_tasks SET escalated_at = now() WHERE id = ?

ALTER TABLE ff_tasks
  ADD COLUMN overdue_notified_at timestamptz,
  ADD COLUMN escalated_at        timestamptz;

// Auto-reassigning on escalation — changes ownership without human decision
task.AssignedTo = []string{managerID} // wrong — notify only, never reassign
repo.Update(ctx, task)

// Notifying without setting the guard column — causes duplicate notifications
notificationService.Send(ctx, notification)
// forgot: repo.SetEscalatedAt(ctx, task.ID) — will fire again next tick

// Including escalation columns in API response
type TaskResponse struct {
    // ...
    OverdueNotifiedAt *time.Time `json:"overdue_notified_at"` // wrong — internal only
    EscalatedAt       *time.Time `json:"escalated_at"`        // wrong — internal only
}

func (j *OverdueJob) runEscalatePass(ctx context.Context) {
    tasks := j.taskRepo.FindEscalationCandidates(ctx) // escalated_at IS NULL + threshold passed
    for _, task := range tasks {
        nextRole := resolveNextRoleUp(task.AssignedToRoles)
        recipients := j.memberRepo.FindByOrgAndRole(ctx, task.OrgID, nextRole)

        if err := j.notificationService.Send(ctx, Notification{
            Recipients: recipients,
            Type:       "task_escalated",
            TaskID:     task.ID,
        }); err != nil {
            j.logger.Error("escalation notification failed", zap.Error(err))
            continue // do not set escalated_at — retry next tick
        }

        // Only set the guard after successful notification
        j.taskRepo.SetEscalatedAt(ctx, task.ID, time.Now())
        // task.AssignedTo unchanged — manager decides next action
    }
}