feat(nudge): name the sender; blink lobby cards; re-animate toasts

The "waiting for your move" popup was the nudge (chat.nudge), shown without a
sender name. Resolve the nudger's per-game seat name server-side and carry it on
a new NudgeEvent.sender_name field, so:

- the in-app toast reads "<opponent>: Waiting for your move 🤭" (chat.nudgeBy);
- the out-of-app Telegram push names the sender too (render nudgeBy);

falling back to the plain phrase when the name is absent (RU mirrored). The
your_turn toast already named the opponent and is unchanged.

Lobby: when a card transitions into "your turn" or "finished" while the lobby is
open, its status emoji blinks twice (two 1s fades); the opponent's-turn change
stays in place. Blink state is keyed by game id (SvelteSet + per-id nonce/timer)
so overlapping events animate in isolation; suppressed under reduce-motion.

Toast: a per-message seq re-keys Toast.svelte, so the freshest toast cancels the
previous one and replays its entrance, uniformly on every screen.

Tests: notify.Nudge round-trip + render named/fallback (Go), game.Service.SeatName
(integration), codec/i18n/gamePhase/shouldBlink (UI). Docs (FUNCTIONAL +_ru,
UI_DESIGN) + PLAN TODO-7 (deferred FLIP card-relocation animation) updated.

backend/internal/game/service.go

@@ -1144,6 +1144,23 @@ func (svc *Service) Participants(ctx context.Context, gameID uuid.UUID) ([]uuid.
 	return seats, g.ToMove, g.Status, nil
 }
 
+// SeatName returns the display name shown for the account seated in the game — the seat's
+// captured snapshot, falling back to the account's current name (see seatDisplayName) — or ""
+// when the account holds no seat. It lets the social package name a nudge's sender by the same
+// per-game identity the rest of the game uses, without exposing the seats.
+func (svc *Service) SeatName(ctx context.Context, gameID, accountID uuid.UUID) (string, error) {
+	g, err := svc.store.GetGame(ctx, gameID)
+	if err != nil {
+		return "", err
+	}
+	for _, s := range g.Seats {
+		if s.AccountID == accountID {
+			return svc.seatDisplayName(ctx, s), nil
+		}
+	}
+	return "", nil
+}
+
 // SharedGame reports whether accounts a and b are seated together in any game
 // (active or finished). It backs the social package's "befriend an opponent"
 // request gate without exposing the games tables; a self-pair is never shared.

backend/internal/inttest/social_test.go

@@ -382,6 +382,33 @@ func TestNudgeRulesAndRateLimit(t *testing.T) {
 	}
 }
 
+// TestSeatNameResolvesDisplayName checks game.Service.SeatName surfaces a seated account's
+// display name — the identity social.Nudge voices the nudge with — and returns "" for an account
+// that holds no seat (the render then falls back to the plain phrase).
+func TestSeatNameResolvesDisplayName(t *testing.T) {
+	ctx := context.Background()
+	gsvc := newGameService()
+	// ProvisionRobot is the one provisioning path that stamps a known display name (a plain
+	// provisioned account has none), so the seat resolves to a name we can assert.
+	named, err := account.NewStore(testDB).ProvisionRobot(ctx, "tg-"+uuid.NewString(), "Ann")
+	if err != nil {
+		t.Fatalf("provision named account: %v", err)
+	}
+	g, err := gsvc.Create(ctx, game.CreateParams{
+		Variant: engine.VariantEnglish, Seats: []uuid.UUID{provisionAccount(t), named.ID},
+		TurnTimeout: 24 * time.Hour, Seed: openingSeed(t),
+	})
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if got, err := gsvc.SeatName(ctx, g.ID, named.ID); err != nil || got != "Ann" {
+		t.Errorf("seated SeatName = (%q, %v), want (\"Ann\", nil)", got, err)
+	}
+	if got, err := gsvc.SeatName(ctx, g.ID, provisionAccount(t)); err != nil || got != "" {
+		t.Errorf("non-seated SeatName = (%q, %v), want (\"\", nil)", got, err)
+	}
+}
+
 // TestNudgeCooldownResetsOnAction checks the nudge cooldown clears once the player has
 // acted (moved or chatted) since their last nudge, even within the hour.
 func TestNudgeCooldownResetsOnAction(t *testing.T) {

backend/internal/notify/events.go

@@ -96,14 +96,18 @@ func ChatMessage(userID, gameID, senderID uuid.UUID, id, kind, body string, crea
 	return Intent{UserID: userID, Kind: KindChatMessage, Payload: b.FinishedBytes(), EventID: eventID()}
 }
 
-// Nudge tells userID that fromUserID nudged them in game gameID.
-func Nudge(userID, gameID, fromUserID uuid.UUID) Intent {
+// Nudge tells userID that fromUserID nudged them in game gameID. senderName is fromUserID's
+// seat display name, used to voice the toast and the out-of-app push ("<name>: …"); an empty
+// name leaves the render to fall back to the plain phrase.
+func Nudge(userID, gameID, fromUserID uuid.UUID, senderName string) Intent {
 	b := flatbuffers.NewBuilder(64)
 	gid := b.CreateString(gameID.String())
 	from := b.CreateString(fromUserID.String())
+	name := b.CreateString(senderName)
 	fb.NudgeEventStart(b)
 	fb.NudgeEventAddGameId(b, gid)
 	fb.NudgeEventAddFromUserId(b, from)
+	fb.NudgeEventAddSenderName(b, name)
 	b.Finish(fb.NudgeEventEnd(b))
 	return Intent{UserID: userID, Kind: KindNudge, Payload: b.FinishedBytes(), EventID: eventID()}
 }

backend/internal/notify/notify_test.go

@@ -83,6 +83,18 @@ func TestYourTurnPayloadRoundTrips(t *testing.T) {
 	}
 }
 
+func TestNudgePayloadRoundTrips(t *testing.T) {
+	uid, gid, from := uuid.New(), uuid.New(), uuid.New()
+	in := notify.Nudge(uid, gid, from, "Ann")
+	if in.UserID != uid || in.Kind != notify.KindNudge || in.EventID == "" {
+		t.Fatalf("intent metadata wrong: %+v", in)
+	}
+	ev := fb.GetRootAsNudgeEvent(in.Payload, 0)
+	if string(ev.GameId()) != gid.String() || string(ev.FromUserId()) != from.String() || string(ev.SenderName()) != "Ann" {
+		t.Fatalf("nudge fields wrong: game=%q from=%q name=%q", ev.GameId(), ev.FromUserId(), ev.SenderName())
+	}
+}
+
 func TestGameOverPayloadRoundTrips(t *testing.T) {
 	uid, gid := uuid.New(), uuid.New()
 	summary := notify.GameSummary{ID: gid.String(), Status: "finished", MoveCount: 18, Seats: []notify.SeatStanding{{Seat: 0, Score: 120, IsWinner: true}}}

backend/internal/social/chat.go

@@ -154,7 +154,10 @@ func (svc *Service) Nudge(ctx context.Context, gameID, senderID uuid.UUID) (Mess
 	}
 	svc.metrics.recordChat(ctx, kindNudge)
 	if toMove >= 0 && toMove < len(seats) {
-		nudge := notify.Nudge(seats[toMove], gameID, senderID)
+		// Name the sender by their per-game seat snapshot, so the toast and the out-of-app push
+		// read "<name>: …"; an unresolved name (best-effort) falls back to the plain phrase.
+		senderName, _ := svc.games.SeatName(ctx, gameID, senderID)
+		nudge := notify.Nudge(seats[toMove], gameID, senderID, senderName)
 		if lang, err := svc.games.GameLanguage(ctx, gameID); err == nil {
 			nudge.Language = lang // route by the game's bot, not the recipient's last-login one
 		}

backend/internal/social/social.go

@@ -25,6 +25,10 @@ import (
 // private state.
 type GameReader interface {
 	Participants(ctx context.Context, gameID uuid.UUID) (seats []uuid.UUID, toMove int, status string, err error)
+	// SeatName is the display name of the account seated in the game (its per-game snapshot,
+	// falling back to the account's current name), or "" when it holds no seat; it names a
+	// nudge's sender in the toast and the out-of-app push by the same identity the game uses.
+	SeatName(ctx context.Context, gameID, accountID uuid.UUID) (string, error)
 	// SharedGame reports whether two accounts are seated together in any game
 	// (active or finished); it gates the "befriend an opponent" request path.
 	SharedGame(ctx context.Context, a, b uuid.UUID) (bool, error)