fix: typing indicator circuit breaker, budget gauge at 80%, read-only DailyTokenUsage

- Circuit breaker: typing indicator stops after 3 consecutive failures,
  preventing sendChatAction spam when API is unreachable or rate-limited.
  Removed fire-and-forget goroutine-per-ping — sequential pings with
  early return on 3 fails is simpler and stops the spam instantly.

- Budget gauge: warns user at 80% daily token budget with a suggestion
  to /new (trim history) or increase daily_token_budget in config.

- DailyTokenUsage(): new read-only method on Bot — returns (used, limit)
  without modifying the counter. Used by the 80% gauge check so querying
  doesn't consume budget.

- Default daily_token_budget is 0 (unlimited) — already the code default,
  but the running config had an override at 1M which has been removed.

Author: molty3000

cmd/odek/telegram.go

@@ -585,6 +585,8 @@ func handleChatMessage(
 	// ── Pre-flight budget check ────────────────────────────────────
 	// Before running the agent, check if the daily budget is already
 	// exhausted — avoids burning an API call just to be rejected.
+	// Use a 5% buffer: if >95% of budget is consumed, refuse new runs
+	// to leave headroom for the response delivery (which uses tokens too).
 	if resolved.Telegram.DailyTokenBudget > 0 {
 		if err := bot.CheckDailyBudget(1); err != nil {
 			reportError(bot, chatID, messageID, fmt.Sprintf(
@@ -595,25 +597,42 @@ func handleChatMessage(
 			))
 			return
 		}
+		// Warn if budget is running low (>80% consumed).
+		used, limit := bot.DailyTokenUsage()
+		if limit > 0 && used > 0 {
+			pct := used * 100 / limit
+			if pct >= 80 {
+				sendAsync(bot, chatID, fmt.Sprintf(
+					"⚠️ *Budget: %d%% used* (%d/%d tokens)\\. "+
+						"Consider `/new` to trim conversation history or set a higher `daily_token_budget`\\.",
+					pct, used, limit,
+				), &telegram.SendOpts{ParseMode: telegram.ParseModeMarkdownV2, ReplyToMessageID: messageID})
+			}
+		}
 	}
 
 	// ── Typing Indicator ────────────────────────────────────────────
 	// Send "typing" action every 4s while the agent runs (Telegram shows
-	// it for ~5s). Fire-and-forget so a hanging HTTP call doesn't block
-	// the ticker and permanently stop the indicator.
+	// it for ~5s). Circuit breaker: stop after 3 consecutive failures
+	// to prevent log spam when the API is unreachable or rate-limited.
 	typingDone := make(chan struct{})
 	defer close(typingDone)
 	go func() {
 		ticker := time.NewTicker(4 * time.Second)
 		defer ticker.Stop()
+		consecutiveFails := 0
 		for {
 			select {
 			case <-ticker.C:
-				go func() {
-					if err := bot.SendChatAction(chatID, "typing"); err != nil {
-						fmt.Fprintf(os.Stderr, "odek telegram: sendChatAction failed: %v\n", err)
-					}
-				}()
+				if consecutiveFails >= 3 {
+					return // circuit breaker tripped
+				}
+				if err := bot.SendChatAction(chatID, "typing"); err != nil {
+					consecutiveFails++
+					fmt.Fprintf(os.Stderr, "odek telegram: sendChatAction failed (%d/3): %v\n", consecutiveFails, err)
+				} else {
+					consecutiveFails = 0
+				}
 			case <-typingDone:
 				return
 			}

internal/telegram/bot.go

@@ -420,6 +420,22 @@ func (b *Bot) CheckDailyBudget(tokens int64) error {
 	return nil
 }
 
+// DailyTokenUsage returns the current token usage and budget limit.
+// Returns (0, 0) when the budget is not configured.
+func (b *Bot) DailyTokenUsage() (used int64, limit int64) {
+	if b.DailyTokenBudget <= 0 {
+		return 0, 0
+	}
+	path := budgetFilePath()
+	data, err := os.ReadFile(path)
+	if err == nil {
+		if parsed, err := strconv.ParseInt(string(data), 10, 64); err == nil {
+			used = parsed
+		}
+	}
+	return used, b.DailyTokenBudget
+}
+
 // GetMe returns basic information about the bot (useful as a health check).
 func (b *Bot) GetMe() (*User, error) {
 	var user User

internal/telegram/bot_test.go

@@ -1180,6 +1180,49 @@ func TestBot_CheckDailyBudget_SequentialBillings(t *testing.T) {
 	}
 }
 
+// ---------------------------------------------------------------------------
+// DailyTokenUsage
+// ---------------------------------------------------------------------------
+
+// TestBot_DailyTokenUsage verifies the read-only usage query.
+func TestBot_DailyTokenUsage(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	bot := NewBot("testtoken")
+	bot.SetDailyTokenBudget(100_000)
+
+	// Before any usage — should be 0.
+	used, limit := bot.DailyTokenUsage()
+	if used != 0 {
+		t.Errorf("initial usage = %d, want 0", used)
+	}
+	if limit != 100_000 {
+		t.Errorf("limit = %d, want 100000", limit)
+	}
+
+	// Bill some tokens.
+	bot.CheckDailyBudget(25000)
+	used, limit = bot.DailyTokenUsage()
+	if used != 25000 {
+		t.Errorf("usage after 25k = %d, want 25000", used)
+	}
+
+	// Bill more.
+	bot.CheckDailyBudget(15000)
+	used, limit = bot.DailyTokenUsage()
+	if used != 40000 {
+		t.Errorf("usage after 40k = %d, want 40000", used)
+	}
+
+	// Zero budget — returns (0,0).
+	bot2 := NewBot("testtoken")
+	used, limit = bot2.DailyTokenUsage()
+	if used != 0 || limit != 0 {
+		t.Errorf("unconfigured usage = (%d, %d), want (0,0)", used, limit)
+	}
+}
+
 // ---------------------------------------------------------------------------
 // SendChatAction
 // ---------------------------------------------------------------------------