feat(telegram): exponential backoff in poller error handling

Replaces fixed 5x interval backoff with exponential: interval *
2^consecutiveErrors, capped at 60 * interval. Error counter
resets to zero on successful poll. Prevents hammering the
Telegram API during extended outages while recovering quickly
from transient blips.

Author: molty3000

internal/telegram/poller.go

@@ -7,11 +7,12 @@ import (
 
 // Poller implements long-polling for Telegram updates.
 type Poller struct {
-	Bot      *Bot
-	Offset   int
-	Interval time.Duration
-	Timeout  int
-	log      Logger
+	Bot               *Bot
+	Offset            int
+	Interval          time.Duration
+	Timeout           int
+	consecutiveErrors int
+	log               Logger
 }
 
 // NewPoller creates a new Poller with sensible defaults.
@@ -35,6 +36,22 @@ func (p *Poller) SetLogger(l Logger) {
 	p.log = l
 }
 
+// backoffDuration returns the sleep duration after consecutive poll errors.
+// Formula: interval * 2^errors, capped at 60 * interval.
+// Returns 0 for 0 errors (no backoff needed).
+func (p *Poller) backoffDuration(errors int) time.Duration {
+	if errors <= 0 {
+		return 0
+	}
+	shift := 1 << errors // 2^errors
+	d := p.Interval * time.Duration(shift)
+	max := 60 * p.Interval
+	if d > max {
+		return max
+	}
+	return d
+}
+
 // Poll performs a single long-poll cycle.
 // It calls GetUpdates with the current offset and timeout,
 // advances the offset past the highest update ID received,
@@ -68,7 +85,9 @@ func (p *Poller) Poll(ctx context.Context) ([]Update, error) {
 // Start begins the infinite long-polling loop.
 // It calls Poll() repeatedly, sending each received update to the channel.
 // On empty result (timeout), sleeps for Interval then retries.
-// On error, sleeps for 5*Interval (backoff), logs to stderr, but continues.
+// On error, sleeps with exponential backoff (interval * 2^consecutiveErrors,
+// capped at 60 * interval), logs to the logger, but continues.
+// Backoff resets to zero after a successful poll.
 // When ctx is cancelled, closes the channel and returns ctx.Err().
 func (p *Poller) Start(ctx context.Context, updates chan<- Update) error {
 	defer close(updates)
@@ -88,9 +107,10 @@ func (p *Poller) Start(ctx context.Context, updates chan<- Update) error {
 			default:
 			}
 
-			p.log.Error("poll error", "error", err)
+			p.consecutiveErrors++
+			backoff := p.backoffDuration(p.consecutiveErrors)
+			p.log.Error("poll error", "error", err, "consecutive_errors", p.consecutiveErrors, "backoff", backoff)
 
-			backoff := 5 * p.Interval
 			select {
 			case <-ctx.Done():
 				return ctx.Err()
@@ -99,6 +119,9 @@ func (p *Poller) Start(ctx context.Context, updates chan<- Update) error {
 			continue
 		}
 
+		// Successful poll — reset error counter.
+		p.consecutiveErrors = 0
+
 		if len(result) == 0 {
 			// Timeout — no updates, sleep for Interval and retry.
 			select {

internal/telegram/poller_test.go

@@ -551,3 +551,49 @@ func TestPoller_Start_SendsUpdates(t *testing.T) {
 		t.Error("did not receive expected update from Start")
 	}
 }
+
+// ---------------------------------------------------------------------------
+// Backoff calculation
+// ---------------------------------------------------------------------------
+
+func TestPoller_BackoffDuration(t *testing.T) {
+	p := NewPoller(nil)
+	p.Interval = 1 * time.Second
+
+	tests := []struct {
+		errors int
+		want   time.Duration
+	}{
+		{0, 0},
+		{1, 2 * time.Second},  // 1s * 2^1
+		{2, 4 * time.Second},  // 1s * 2^2
+		{3, 8 * time.Second},  // 1s * 2^3
+		{4, 16 * time.Second}, // 1s * 2^4
+		{5, 32 * time.Second}, // 1s * 2^5
+		{6, 60 * time.Second}, // capped at 60x interval
+		{7, 60 * time.Second}, // stays capped
+	}
+
+	for _, tt := range tests {
+		got := p.backoffDuration(tt.errors)
+		if got != tt.want {
+			t.Errorf("backoffDuration(%d) = %v, want %v", tt.errors, got, tt.want)
+		}
+	}
+}
+
+func TestPoller_BackoffResetsOnSuccess(t *testing.T) {
+	p := NewPoller(nil)
+	p.consecutiveErrors = 5
+
+	// Simulate a successful poll — backoff should be 0.
+	if d := p.backoffDuration(p.consecutiveErrors); d == 0 {
+		t.Error("expected non-zero backoff with 5 errors")
+	}
+
+	// After successful poll, reset.
+	p.consecutiveErrors = 0
+	if d := p.backoffDuration(p.consecutiveErrors); d != 0 {
+		t.Errorf("expected zero backoff after reset, got %v", d)
+	}
+}