fix(feedback): show the operator reply only on the player's latest message

A reply was bound to 'the latest message that has a reply', so after the player
read a reply and sent a new (unanswered) message, the old reply kept showing as
'Ответ на ваше последнее сообщение'. Bind it to the single most-recent message
instead: sending any new message immediately drops the previous reply (the new
message has no reply yet), well before the one-week window. Client clears the
reply optimistically on submit; the mock mirrors it; inttest covers the case.

backend/internal/feedback/store.go

@@ -86,25 +86,25 @@ func (s *Store) HasUnreadReply(ctx context.Context, accountID uuid.UUID) (bool,
 // VisibleReply is the operator reply shown back to the player: the reply on their
 // most recent replied message still inside the visibility window.
 type VisibleReply struct {
-	MessageID   uuid.UUID
-	Body        string
-	RepliedAt   time.Time
-	ReplyReadAt sql.NullTime
+	Body      string
+	RepliedAt time.Time
 }
 
-// LatestVisibleReply returns the account's most recent message that carries a reply
-// still visible to the player — not yet delivered, or delivered after cutoff (one
-// week ago). Reports false when there is none.
+// LatestVisibleReply returns the reply on the account's **most recent** message, if
+// that message carries one still visible to the player — not yet delivered, or
+// delivered after cutoff (one week ago). Binding it to the single latest message
+// means that the moment the player sends a newer message the previous reply stops
+// showing (the new message has no reply yet). Reports false when there is none.
 func (s *Store) LatestVisibleReply(ctx context.Context, accountID uuid.UUID, cutoff time.Time) (VisibleReply, bool, error) {
 	var vr VisibleReply
 	var repliedAt sql.NullTime
 	err := s.db.QueryRowContext(ctx,
-		`SELECT message_id, COALESCE(reply_body, ''), replied_at, reply_read_at
-		 FROM backend.feedback_messages
-		 WHERE account_id = $1 AND reply_body IS NOT NULL
-		   AND (reply_read_at IS NULL OR reply_read_at > $2)
-		 ORDER BY created_at DESC LIMIT 1`,
-		accountID, cutoff).Scan(&vr.MessageID, &vr.Body, &repliedAt, &vr.ReplyReadAt)
+		`SELECT COALESCE(reply_body, ''), replied_at FROM (
+			SELECT reply_body, replied_at, reply_read_at FROM backend.feedback_messages
+			WHERE account_id = $1 ORDER BY created_at DESC LIMIT 1
+		) latest
+		WHERE reply_body IS NOT NULL AND (reply_read_at IS NULL OR reply_read_at > $2)`,
+		accountID, cutoff).Scan(&vr.Body, &repliedAt)
 	if errors.Is(err, sql.ErrNoRows) {
 		return VisibleReply{}, false, nil
 	}

backend/internal/inttest/feedback_test.go

@@ -110,6 +110,41 @@ func TestFeedbackSubmitGateAndReplyLifecycle(t *testing.T) {
 	}
 }
 
+func TestFeedbackReplyHiddenAfterNewMessage(t *testing.T) {
+	ctx := context.Background()
+	svc := newFeedbackService()
+	acc := provisionAccount(t)
+
+	// msg1, replied → the player can send again and currently sees the reply.
+	if err := svc.Submit(ctx, acc, "first", nil, "", "web", ""); err != nil {
+		t.Fatalf("submit msg1: %v", err)
+	}
+	if err := svc.Reply(ctx, latestFeedbackID(t, svc, acc), "the answer"); err != nil {
+		t.Fatalf("reply: %v", err)
+	}
+	if st, err := svc.State(ctx, acc); err != nil {
+		t.Fatal(err)
+	} else if st.Reply == nil || st.Reply.Body != "the answer" {
+		t.Fatalf("reply not shown before the new message: %+v", st.Reply)
+	}
+
+	// Sending a new message immediately drops the previous reply (it now belongs to an
+	// older message), even though it is well within the one-week window.
+	if err := svc.Submit(ctx, acc, "second", nil, "", "web", ""); err != nil {
+		t.Fatalf("submit msg2: %v", err)
+	}
+	st, err := svc.State(ctx, acc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if st.Reply != nil {
+		t.Fatalf("reply should be hidden after a new message, got %+v", st.Reply)
+	}
+	if st.CanSend || st.BlockedReason != "pending" {
+		t.Fatalf("state after new message = %+v, want pending", st)
+	}
+}
+
 func TestFeedbackBanRole(t *testing.T) {
 	ctx := context.Background()
 	svc := newFeedbackService()