Add recurring input-required alerts with incident reset

Author: emperorhan

cmd/ralphctl/telegram_command.go

@@ -1132,6 +1132,8 @@ func newScopedStatusNotifyHandler(controlDir string, paths ralph.Paths, scope st
 	}
 }
 
+const telegramInputRequiredReminderInterval = 30 * time.Minute
+
 func hasFleetProjects(controlDir string) (bool, error) {
 	cfg, err := ralph.LoadFleetConfig(controlDir)
 	if err != nil {
@@ -1143,6 +1145,7 @@ func hasFleetProjects(controlDir string) (bool, error) {
 func newFleetStatusNotifyHandler(controlDir string, defaultPaths ralph.Paths, retryThreshold, permThreshold int) ralph.TelegramNotifyHandler {
 	initialized := false
 	prevByProject := map[string]ralph.Status{}
+	lastInputRequiredAlertAt := map[string]time.Time{}
 	return func(ctx context.Context) ([]string, error) {
 		_ = ctx
 
@@ -1189,14 +1192,24 @@ func newFleetStatusNotifyHandler(controlDir string, defaultPaths ralph.Paths, re
 			if !initialized {
 				continue
 			}
-			prev, ok := prevByProject[target.ID]
-			if !ok {
-				continue
-			}
+			prev := prevByProject[target.ID]
 			alerts = append(alerts, buildStatusAlerts(prev, current, retryThreshold, permThreshold)...)
+			now := time.Now().UTC()
+			lastAt := lastInputRequiredAlertAt[target.ID]
+			if shouldSendInputRequiredAlert(prev, current, lastAt, now) {
+				alerts = append(alerts, buildInputRequiredAlert(current.ProjectDir))
+				lastInputRequiredAlertAt[target.ID] = now
+			} else if !ralph.IsInputRequiredStatus(current) {
+				delete(lastInputRequiredAlertAt, target.ID)
+			}
 		}
 
 		prevByProject = currByProject
+		for projectID := range lastInputRequiredAlertAt {
+			if _, ok := currByProject[projectID]; !ok {
+				delete(lastInputRequiredAlertAt, projectID)
+			}
+		}
 		if !initialized {
 			initialized = true
 			return nil, nil
@@ -1208,6 +1221,7 @@ func newFleetStatusNotifyHandler(controlDir string, defaultPaths ralph.Paths, re
 func newStatusNotifyHandler(paths ralph.Paths, retryThreshold, permThreshold int) ralph.TelegramNotifyHandler {
 	initialized := false
 	prev := ralph.Status{}
+	lastInputRequiredAlertAt := time.Time{}
 	return func(ctx context.Context) ([]string, error) {
 		_ = ctx
 		current, err := ralph.GetStatus(paths)
@@ -1220,6 +1234,13 @@ func newStatusNotifyHandler(paths ralph.Paths, retryThreshold, permThreshold int
 			return nil, nil
 		}
 		alerts := buildStatusAlerts(prev, current, retryThreshold, permThreshold)
+		now := time.Now().UTC()
+		if shouldSendInputRequiredAlert(prev, current, lastInputRequiredAlertAt, now) {
+			alerts = append(alerts, buildInputRequiredAlert(current.ProjectDir))
+			lastInputRequiredAlertAt = now
+		} else if !ralph.IsInputRequiredStatus(current) {
+			lastInputRequiredAlertAt = time.Time{}
+		}
 		prev = current
 		return alerts, nil
 	}
@@ -1280,16 +1301,34 @@ func buildStatusAlerts(prev, current ralph.Status, retryThreshold, permThreshold
 			valueOrDash(compactSingleLine(current.LastFailureCause, 160)),
 		))
 	}
-	if ralph.IsInputRequiredStatus(current) && !ralph.IsInputRequiredStatus(prev) {
-		out = append(out, fmt.Sprintf(
-			"[ralph alert][input_required]\n- project: %s\n- message: no queued work. add issue (`./ralph new ...`) or run PRD wizard (`/prd start -> /prd refine -> /prd apply`)",
-			project,
-		))
-	}
 
 	return out
 }
 
+func shouldSendInputRequiredAlert(prev, current ralph.Status, lastSentAt, now time.Time) bool {
+	if !ralph.IsInputRequiredStatus(current) {
+		return false
+	}
+	if !ralph.IsInputRequiredStatus(prev) {
+		return true
+	}
+	if lastSentAt.IsZero() {
+		return true
+	}
+	return now.Sub(lastSentAt) >= telegramInputRequiredReminderInterval
+}
+
+func buildInputRequiredAlert(project string) string {
+	p := strings.TrimSpace(project)
+	if p == "" {
+		p = "(unknown-project)"
+	}
+	return fmt.Sprintf(
+		"[ralph alert][input_required]\n- project: %s\n- message: no queued work. add issue (`./ralph new ...`) or run PRD wizard (`/prd start -> /prd refine -> /prd apply`)",
+		p,
+	)
+}
+
 func startTelegramDaemon(paths ralph.Paths, runArgs []string) (string, error) {
 	if err := ralph.EnsureLayout(paths); err != nil {
 		return "", err

cmd/ralphctl/telegram_command_test.go

@@ -295,7 +295,7 @@ func TestBuildStatusAlertsSkipsStuckWhenNoWork(t *testing.T) {
 	}
 }
 
-func TestBuildStatusAlertsInputRequiredTransition(t *testing.T) {
+func TestShouldSendInputRequiredAlertOnTransition(t *testing.T) {
 	t.Parallel()
 
 	prev := ralph.Status{
@@ -311,10 +311,78 @@ func TestBuildStatusAlertsInputRequiredTransition(t *testing.T) {
 		Blocked:    0,
 	}
 
-	alerts := buildStatusAlerts(prev, curr, 2, 3)
-	joined := strings.Join(alerts, "\n")
-	if !strings.Contains(joined, "[input_required]") {
-		t.Fatalf("input_required alert should be emitted on transition: %q", joined)
+	if !shouldSendInputRequiredAlert(prev, curr, time.Time{}, time.Now().UTC()) {
+		t.Fatalf("input_required alert should be emitted on transition")
+	}
+}
+
+func TestShouldSendInputRequiredAlertReminderInterval(t *testing.T) {
+	t.Parallel()
+
+	prev := ralph.Status{
+		ProjectDir: "/tmp/p",
+		QueueReady: 0,
+		InProgress: 0,
+		Blocked:    0,
+	}
+	curr := prev
+	now := time.Now().UTC()
+
+	if shouldSendInputRequiredAlert(prev, curr, now.Add(-5*time.Minute), now) {
+		t.Fatalf("input_required reminder should be suppressed before interval")
+	}
+	if !shouldSendInputRequiredAlert(prev, curr, now.Add(-telegramInputRequiredReminderInterval-time.Minute), now) {
+		t.Fatalf("input_required reminder should be emitted after interval")
+	}
+}
+
+func TestShouldSendInputRequiredAlertReentrySendsOncePerIncident(t *testing.T) {
+	t.Parallel()
+
+	working := ralph.Status{
+		ProjectDir: "/tmp/p",
+		QueueReady: 1,
+		InProgress: 0,
+		Blocked:    0,
+	}
+	idle := ralph.Status{
+		ProjectDir: "/tmp/p",
+		QueueReady: 0,
+		InProgress: 0,
+		Blocked:    0,
+	}
+	now := time.Now().UTC()
+
+	// Incident #1: working -> idle should alert immediately.
+	if !shouldSendInputRequiredAlert(working, idle, time.Time{}, now) {
+		t.Fatalf("first incident should emit input_required alert")
+	}
+
+	// While still idle, suppress until reminder interval.
+	if shouldSendInputRequiredAlert(idle, idle, now, now.Add(5*time.Minute)) {
+		t.Fatalf("same incident should not emit again before reminder interval")
+	}
+
+	// Recovered: idle -> working should not emit.
+	if shouldSendInputRequiredAlert(idle, working, now, now.Add(10*time.Minute)) {
+		t.Fatalf("recovery should not emit input_required alert")
+	}
+
+	// Incident #2: working -> idle should emit again immediately, even if last alert was recent.
+	if !shouldSendInputRequiredAlert(working, idle, now, now.Add(11*time.Minute)) {
+		t.Fatalf("reentry incident should emit input_required alert immediately")
+	}
+}
+
+func TestBuildInputRequiredAlert(t *testing.T) {
+	t.Parallel()
+
+	msg := buildInputRequiredAlert("/tmp/project")
+	if !strings.Contains(msg, "[input_required]") {
+		t.Fatalf("alert tag missing: %q", msg)
+	}
+	if !strings.Contains(msg, "/tmp/project") {
+		t.Fatalf("project path missing: %q", msg)
 	}
 }