fix(telegram): reopen a deleted support topic instead of losing it to General

Telegram silently routes a copyMessage aimed at a deleted forum topic
into the chat's General topic with NO error, so the bot's error-based
recreate never fired — the user's next message landed in General with no
card. Confirmed against the prod bot logs: a relay after a topic deletion
logged neither "relay to topic failed" nor "topic gone, reopening".

Probe topic liveness before reusing it: re-applying the info card's reply
markup is a no-op that errors only when the card (hence the topic) is
gone, so the bot detects the deletion and reopens the topic + card rather
than relying on the (absent) copy error. The post-copy recreate stays as
a race backstop.

platform/telegram/internal/bot/support.go

@@ -12,6 +12,8 @@ import (
 	tgbot "github.com/go-telegram/bot"
 	"github.com/go-telegram/bot/models"
 	"go.uber.org/zap"
+
+	"scrabble/platform/telegram/internal/support"
 )
 
 // Support relay: the bot forwards a user's direct messages into a per-user forum
@@ -130,26 +132,20 @@ func (t *Bot) handleSupportUserMessage(ctx context.Context, m *models.Message) {
 	unlock := t.supportLocks.lock(uid)
 	defer unlock()
 
-	rec, ok := t.support.Get(uid)
-	if ok && rec.Blocked {
+	rec, _ := t.support.Get(uid)
+	if rec.Blocked {
 		return
 	}
-	topicID := 0
-	if ok {
-		topicID = rec.TopicID
-	}
-	if topicID == 0 {
-		var err error
-		if topicID, err = t.openSupportTopic(ctx, m.From); err != nil {
-			t.log.Warn("support: open topic failed", zap.Int64("user_id", uid), zap.Error(err))
-			return
-		}
+	topicID, err := t.ensureTopic(ctx, m.From, rec)
+	if err != nil {
+		t.log.Warn("support: ensure topic failed", zap.Int64("user_id", uid), zap.Error(err))
+		return
 	}
 
 	newID, err := t.copyToTopic(ctx, m.Chat.ID, m.ID, topicID)
 	if err != nil && isTopicMissingErr(err) {
-		// The operators deleted the whole topic; reopen it and retry once.
-		t.log.Info("support: topic gone, reopening", zap.Int64("user_id", uid), zap.Int("topic_id", topicID))
+		// Backstop: the topic vanished between the liveness probe and the copy.
+		t.log.Info("support: topic gone on copy, reopening", zap.Int64("user_id", uid), zap.Int("topic_id", topicID))
 		if topicID, err = t.openSupportTopic(ctx, m.From); err == nil {
 			newID, err = t.copyToTopic(ctx, m.Chat.ID, m.ID, topicID)
 		}
@@ -258,6 +254,31 @@ func (t *Bot) clearSupportTopic(ctx context.Context, cq *models.CallbackQuery, u
 	t.answerSupportCallback(ctx, cq.ID, "Очищено")
 }
 
+// ensureTopic returns a live forum-topic id for the user, opening a fresh topic (and
+// info card) when none exists or the previous one was deleted. Telegram silently
+// routes a copy aimed at a deleted topic into the chat's General topic (no error), so
+// the bot cannot rely on copyMessage failing; instead it probes the info card —
+// re-applying the card's reply markup is a no-op that errors only when the card (hence
+// the topic) is gone — and reopens on that signal. The probe also keeps the card's
+// block button in sync with the stored state.
+func (t *Bot) ensureTopic(ctx context.Context, u *models.User, rec support.User) (int, error) {
+	if rec.TopicID == 0 || rec.HeaderMsgID == 0 {
+		return t.openSupportTopic(ctx, u)
+	}
+	_, err := t.api.EditMessageReplyMarkup(ctx, &tgbot.EditMessageReplyMarkupParams{
+		ChatID:      t.supportChatID,
+		MessageID:   rec.HeaderMsgID,
+		ReplyMarkup: supportCardMarkup(u.ID, rec.Blocked),
+	})
+	if isCardMissingErr(err) {
+		t.log.Info("support: topic gone, reopening", zap.Int64("user_id", u.ID), zap.Int("topic_id", rec.TopicID))
+		return t.openSupportTopic(ctx, u)
+	}
+	// Any other outcome (success, or a benign "message is not modified") means the
+	// topic is alive; reuse it.
+	return rec.TopicID, nil
+}
+
 // openSupportTopic creates a forum topic for the user and posts its info card with
 // the block/clear buttons, persisting both. It returns the new topic id. A failure to
 // persist is logged but not fatal: the in-memory mapping still lets the relay proceed.
@@ -436,6 +457,19 @@ func supportCard(u *models.User) (string, []models.MessageEntity) {
 	return b.String(), entities
 }
 
+// isCardMissingErr reports whether err means the info-card message no longer exists
+// (the operators deleted the topic), as opposed to a benign "message is not modified"
+// no-op when the card is still there.
+func isCardMissingErr(err error) bool {
+	if err == nil {
+		return false
+	}
+	s := strings.ToLower(err.Error())
+	return strings.Contains(s, "message to edit not found") ||
+		strings.Contains(s, "message can't be edited") ||
+		strings.Contains(s, "message_id_invalid")
+}
+
 // isTopicMissingErr reports whether err is Telegram's deleted/absent forum-topic
 // error, signalling the topic must be reopened.
 func isTopicMissingErr(err error) bool {