fix: auto-split long messages to fit Telegram 4096-char limit

Messages exceeding Telegram's 4096-character limit now automatically
split into multiple messages. Split prefers newline boundaries (within
last 25% of chunk) for natural breaks, falls back to rune boundary.

This fixes the "Bad Request: message is too long" error that caused
outbox retry loops for long Claude responses.

- splitMessage() operates on runes (UTF-8 safe for Korean/emoji)
- SendMessage() sends chunks sequentially
- 4 new test cases: content preservation, newline preference, Korean

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: GrapeInTheTree

internal/bot/bot.go

@@ -50,15 +50,54 @@ func (b *Bot) SetWorker(w *worker.Worker) {
 	b.worker = w
 }
 
+// telegramMaxLength is the maximum message length allowed by Telegram API.
+const telegramMaxLength = 4096
+
 // SendMessage sends a plain text message to the configured chat.
+// Messages longer than 4096 characters are automatically split into multiple messages.
 func (b *Bot) SendMessage(text string) error {
 	text = strings.ToValidUTF8(text, "")
-	msg := tgbotapi.NewMessage(b.cfg.TelegramChatID, text)
-	_, err := b.api.Send(msg)
-	if err != nil {
-		b.logger.Error("SendMessage failed", "error", err)
+
+	chunks := splitMessage(text, telegramMaxLength)
+	for i, chunk := range chunks {
+		msg := tgbotapi.NewMessage(b.cfg.TelegramChatID, chunk)
+		if _, err := b.api.Send(msg); err != nil {
+			b.logger.Error("SendMessage failed", "error", err, "chunk", i+1, "total", len(chunks))
+			return err
+		}
+	}
+	return nil
+}
+
+// splitMessage splits text into chunks that fit within maxLen runes.
+// Prefers splitting at newlines, falls back to rune boundary.
+func splitMessage(text string, maxLen int) []string {
+	runes := []rune(text)
+	if len(runes) <= maxLen {
+		return []string{text}
+	}
+
+	var chunks []string
+	for len(runes) > 0 {
+		if len(runes) <= maxLen {
+			chunks = append(chunks, string(runes))
+			break
+		}
+
+		// Find the best split point: last newline within maxLen
+		chunk := runes[:maxLen]
+		splitAt := maxLen
+		for i := len(chunk) - 1; i >= maxLen*3/4; i-- {
+			if chunk[i] == '\n' {
+				splitAt = i + 1 // include the newline in current chunk
+				break
+			}
+		}
+
+		chunks = append(chunks, string(runes[:splitAt]))
+		runes = runes[splitAt:]
 	}
-	return err
+	return chunks
 }
 
 // SendTyping sends a "typing..." indicator to the chat.

internal/bot/bot_test.go

@@ -41,3 +41,90 @@ func TestSafeTruncateNoEllipsis(t *testing.T) {
 		t.Errorf("Expected no ellipsis, got %q", got)
 	}
 }
+
+func TestSplitMessage(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		maxLen    int
+		wantCount int
+	}{
+		{"short message", "hello", 4096, 1},
+		{"empty", "", 4096, 1},
+		{"exact limit", string(make([]rune, 4096)), 4096, 1},
+		{"just over limit", string(make([]rune, 4097)), 4096, 2},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			chunks := splitMessage(tt.input, tt.maxLen)
+			if len(chunks) != tt.wantCount {
+				t.Errorf("splitMessage() returned %d chunks, want %d", len(chunks), tt.wantCount)
+			}
+		})
+	}
+}
+
+func TestSplitMessagePreservesContent(t *testing.T) {
+	// Build a long message with newlines
+	var input string
+	for i := 0; i < 200; i++ {
+		input += "This is line number that is fairly long.\n"
+	}
+
+	chunks := splitMessage(input, 100)
+
+	// Reassemble and verify no content is lost
+	var reassembled string
+	for _, c := range chunks {
+		reassembled += c
+	}
+	if reassembled != input {
+		t.Errorf("Content lost during split: input len=%d, reassembled len=%d", len(input), len(reassembled))
+	}
+}
+
+func TestSplitMessagePrefersNewline(t *testing.T) {
+	// 80 chars + newline + 80 chars, with maxLen=100
+	line1 := string(make([]rune, 80))
+	line2 := string(make([]rune, 80))
+	input := line1 + "\n" + line2
+
+	chunks := splitMessage(input, 100)
+
+	if len(chunks) != 2 {
+		t.Fatalf("Expected 2 chunks, got %d", len(chunks))
+	}
+	// First chunk should end at newline (81 runes: 80 + '\n')
+	if []rune(chunks[0])[len([]rune(chunks[0]))-1] != '\n' {
+		t.Error("Expected first chunk to end with newline")
+	}
+}
+
+func TestSplitMessageKorean(t *testing.T) {
+	// Korean text should split on rune boundaries, not byte boundaries
+	var input string
+	for i := 0; i < 2000; i++ {
+		input += "안녕"
+	}
+	// 4000 Korean runes
+
+	chunks := splitMessage(input, 3000)
+
+	// Verify each chunk is valid and within limit
+	for i, c := range chunks {
+		runes := []rune(c)
+		if len(runes) > 3000 {
+			t.Errorf("Chunk %d has %d runes, exceeds limit 3000", i, len(runes))
+		}
+	}
+
+	// Verify no content lost
+	var reassembled string
+	for _, c := range chunks {
+		reassembled += c
+	}
+	if reassembled != input {
+		t.Error("Korean content lost during split")
+	}
+}