test: add coverage for daily token budget production wiring

Adds tests covering the exact patterns used in handleChatMessage:

internal/telegram/bot_test.go:
- TestBot_CheckDailyBudget_PreflightPattern — verifies the pre-flight
  check pattern (CheckDailyBudget(1) to detect exhaustion before agent run)
- TestBot_CheckDailyBudget_SequentialBillings — verifies the post-run
  billing pattern (multiple agent runs deducting actual tokens)

cmd/odek/telegram_test.go:
- TestBudgetMessage_ContainsAllElements — verifies the pre-flight
  budget exhausted message format sent to the chat
- TestBudgetWarning_ContainsAllElements — verifies the post-run
  budget warning message format sent to the chat

Author: jkyberneees

cmd/odek/telegram_test.go

@@ -257,3 +257,53 @@ func TestRestartStderrMessage_NoArgs(t *testing.T) {
 		t.Errorf("stderr restart message should show empty args as []: %q", msg)
 	}
 }
+
+// ── Daily Token Budget integration tests ──────────────────────────────
+
+func TestBudgetMessage_ContainsAllElements(t *testing.T) {
+	// Verify the budget exceeded message format sent to the Telegram chat.
+	// This is the message produced when CheckDailyBudget fails in the
+	// pre-flight check, before the agent runs.
+	msg := fmt.Sprintf(
+		"Daily token budget exhausted: daily token budget exceeded: 10000 used + 1 new = 10001 total, limit is 10000. "+
+			"The budget resets at midnight UTC. "+
+			"Set daily_token_budget to 0 in config for unlimited usage.",
+	)
+
+	if !strings.Contains(msg, "Daily token budget exhausted") {
+		t.Errorf("budget message missing 'Daily token budget exhausted': %q", msg)
+	}
+	if !strings.Contains(msg, "resets at midnight UTC") {
+		t.Errorf("budget message missing 'resets at midnight UTC': %q", msg)
+	}
+	if !strings.Contains(msg, "daily_token_budget to 0") {
+		t.Errorf("budget message missing 'daily_token_budget to 0': %q", msg)
+	}
+	if !strings.Contains(msg, "10000") {
+		t.Errorf("budget message should contain the limit: %q", msg)
+	}
+}
+
+func TestBudgetWarning_ContainsAllElements(t *testing.T) {
+	// Verify the post-run budget warning message format sent when the
+	// agent completed successfully but the budget was exceeded.
+	msg := fmt.Sprintf(
+		"⚠️ Token budget warning\n\n"+
+			"daily token budget exceeded: 45000 used + 6000 new = 51000 total, limit is 50000. "+
+			"Further agent runs may be blocked until the daily budget resets. "+
+			"Use /stats to check current usage.",
+	)
+
+	if !strings.Contains(msg, "Token budget warning") {
+		t.Errorf("warning message missing 'Token budget warning': %q", msg)
+	}
+	if !strings.Contains(msg, "daily budget resets") {
+		t.Errorf("warning message missing 'daily budget resets': %q", msg)
+	}
+	if !strings.Contains(msg, "/stats") {
+		t.Errorf("warning message should mention /stats: %q", msg)
+	}
+	if !strings.Contains(msg, "51000") {
+		t.Errorf("warning message should contain the total: %q", msg)
+	}
+}

internal/telegram/bot_test.go

@@ -1124,6 +1124,62 @@ func TestBot_CheckDailyBudget_Exceeded(t *testing.T) {
 	}
 }
 
+func TestBot_CheckDailyBudget_PreflightPattern(t *testing.T) {
+	// This test verifies the exact pattern used by handleChatMessage:
+	// call CheckDailyBudget(1) to detect if the budget is already exhausted
+	// before running the agent (avoids wasting an API call).
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	bot := NewBot("testtoken")
+	bot.SetDailyTokenBudget(10_000)
+
+	// Pre-flight check with 1 token — should succeed (no usage yet).
+	if err := bot.CheckDailyBudget(1); err != nil {
+		t.Fatalf("pre-flight CheckDailyBudget(1) should succeed: %v", err)
+	}
+
+	// Simulate an agent run that used 9,999 tokens.
+	if err := bot.CheckDailyBudget(9999); err != nil {
+		t.Fatalf("CheckDailyBudget(9999) under 10000 limit: %v", err)
+	}
+
+	// Next pre-flight check with 1 token — should fail (budget exhausted).
+	if err := bot.CheckDailyBudget(1); err == nil {
+		t.Fatal("pre-flight CheckDailyBudget(1) should fail when budget is exhausted")
+	}
+}
+
+func TestBot_CheckDailyBudget_SequentialBillings(t *testing.T) {
+	// Simulates the production pattern: multiple agent runs, each billing
+	// actual input+output tokens against the daily budget.
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	bot := NewBot("testtoken")
+	bot.SetDailyTokenBudget(50_000)
+
+	// Agent run 1: used 12,000 tokens
+	if err := bot.CheckDailyBudget(12000); err != nil {
+		t.Fatalf("run 1: CheckDailyBudget(12000): %v", err)
+	}
+
+	// Agent run 2: used 8,000 tokens (running total: 20,000)
+	if err := bot.CheckDailyBudget(8000); err != nil {
+		t.Fatalf("run 2: CheckDailyBudget(8000): %v", err)
+	}
+
+	// Agent run 3: used 30,000 tokens (running total: 50,000 — exactly at limit)
+	if err := bot.CheckDailyBudget(30000); err != nil {
+		t.Fatalf("run 3: CheckDailyBudget(30000) at exact limit: %v", err)
+	}
+
+	// Agent run 4: used 1 token (running total: 50,001 — exceeds limit)
+	if err := bot.CheckDailyBudget(1); err == nil {
+		t.Fatal("run 4: expected error for exceeded budget")
+	}
+}
+
 // ---------------------------------------------------------------------------
 // SendChatAction
 // ---------------------------------------------------------------------------