fix alerting escalation

Author: jbsmith7741

apps/flowlord/cache/sqlite.go

@@ -518,6 +518,38 @@ func (s *SQLite) GetAlertsByDate(date time.Time) ([]AlertRecord, error) {
 	return alerts, nil
 }
 
+// GetAlertsAfterTime retrieves all alerts created after a specific time
+func (s *SQLite) GetAlertsAfterTime(afterTime time.Time) ([]AlertRecord, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	query := `SELECT id, task_id, task_time, task_type, job, msg, created_at
+			FROM alert_records 
+			WHERE created_at > ?
+			ORDER BY created_at ASC`
+
+	rows, err := s.db.Query(query, afterTime.Format("2006-01-02 15:04:05"))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var alerts []AlertRecord
+	for rows.Next() {
+		var alert AlertRecord
+		err := rows.Scan(
+			&alert.ID, &alert.TaskID, &alert.TaskTime, &alert.Type,
+			&alert.Job, &alert.Msg, &alert.CreatedAt,
+		)
+		if err != nil {
+			continue
+		}
+		alerts = append(alerts, alert)
+	}
+
+	return alerts, nil
+}
+
 // BuildCompactSummary processes alerts in memory to create compact summary
 // Groups by TaskType:Job and collects task times for proper date formatting
 func BuildCompactSummary(alerts []AlertRecord) []SummaryLine {

apps/flowlord/taskmaster.go

@@ -459,6 +459,11 @@ func (tm *taskMaster) readFiles(ctx context.Context) {
 func (tm *taskMaster) handleNotifications(taskChan chan task.Task, ctx context.Context) {
 	sendChan := make(chan struct{})
 	var alerts []cache.AlertRecord
+	
+	// Initialize lastAlertTime to today at 00:00:00 (zero hour)
+	now := time.Now()
+	lastAlertTime := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	
 	go func() {
 		dur := tm.slack.MinFrequency
 		for ; ; time.Sleep(dur) {
@@ -467,20 +472,23 @@ func (tm *taskMaster) handleNotifications(taskChan chan task.Task, ctx context.C
 			// Check for incomplete tasks and add them to alerts
 			tm.taskCache.CheckIncompleteTasks()
 
-			// Get all alerts (including newly added incomplete task alerts)
-			alerts, err = tm.taskCache.GetAlertsByDate(time.Now())
+			// Get NEW alerts only - those after the last time we sent
+			alerts, err = tm.taskCache.GetAlertsAfterTime(lastAlertTime)
 			if err != nil {
 				log.Printf("failed to retrieve alerts: %v", err)
 				continue
 			}
 
 			if len(alerts) > 0 {
 				sendChan <- struct{}{}
+				// Update lastAlertTime to now (before we send, so we don't miss any)
+				lastAlertTime = time.Now()
 				if dur *= 2; dur > tm.slack.MaxFrequency {
 					dur = tm.slack.MaxFrequency
 				}
 				log.Println("wait time ", dur)
 			} else if dur != tm.slack.MinFrequency {
+				// No NEW alerts - reset to minimum frequency
 				dur = tm.slack.MinFrequency
 				log.Println("Reset ", dur)
 			}