Stage 17 round 6 (#16/#17, PR C): lobby sort + server-derived in-game friend state

Lobby: group the my-games list into your-turn / opponent-turn / finished
(empty sections hidden), ordered by last activity (your-turn oldest-first,
the other two newest-first), as a compact line-separated list. gameDTO and
FB GameView gain last_activity_unix (turn start while active, finish time
once finished); a pure lib/lobbysort.ts holds the grouping/ordering.

Friends: the in-game 'add to friends' item is now server-derived via a new
GET /user/friends/outgoing (+ friends.outgoing op), returning addressees with
a pending OR declined request (both read as 'request sent'), so it is correct
across reloads; it shows a disabled '✓ in friends' once accepted. It
live-updates when the opponent answers: RespondFriendRequest now publishes
friend_added (accept) / friend_declined (new notify sub-kind, decline) to the
original requester, whose open game re-derives its friend state.

Tests: lobbysort unit test; gateway outgoing + last_activity transcode tests;
backend integration ListOutgoingRequests + respond-publishes-to-requester;
e2e updated for the new lobby section labels + a non-friend active opponent.
Docs: ARCHITECTURE notify catalog, FUNCTIONAL(+ru) lobby/friends, PLAN.

backend/internal/inttest/social_test.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -14,9 +15,36 @@ import (
 	"scrabble/backend/internal/account"
 	"scrabble/backend/internal/engine"
 	"scrabble/backend/internal/game"
+	"scrabble/backend/internal/notify"
 	"scrabble/backend/internal/social"
+	fb "scrabble/pkg/fbs/scrabblefb"
 )
 
+// capturePublisher records every published intent for assertions on live events.
+type capturePublisher struct {
+	mu      sync.Mutex
+	intents []notify.Intent
+}
+
+func (c *capturePublisher) Publish(in ...notify.Intent) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.intents = append(c.intents, in...)
+}
+
+// notified reports whether a Notification with the given sub-kind was published to user.
+func (c *capturePublisher) notified(user uuid.UUID, sub string) bool {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	for _, in := range c.intents {
+		if in.UserID == user && in.Kind == notify.KindNotification &&
+			string(fb.GetRootAsNotificationEvent(in.Payload, 0).Kind()) == sub {
+			return true
+		}
+	}
+	return false
+}
+
 // newSocialService builds a social service over the shared pool, reading game
 // state through a real game service.
 func newSocialService() *social.Service {
@@ -383,3 +411,93 @@ func TestNudgeCooldownResetsOnAction(t *testing.T) {
 		t.Fatalf("nudge after acting = %v, want allowed (cooldown reset)", err)
 	}
 }
+
+// TestListOutgoingRequests checks the requester-side list that backs the in-game "add to
+// friends" item (Stage 17): a pending request shows for the requester only; an accepted one
+// clears (it is a friendship now); a declined one stays (cannot be re-sent, so it reads as
+// still "sent"); a lazily expired pending one drops (it may be re-sent).
+func TestListOutgoingRequests(t *testing.T) {
+	ctx := context.Background()
+	svc := newSocialService()
+
+	// Pending: outgoing for the requester, not the addressee.
+	_, s1 := newGameWithSeats(t, 2)
+	a, b := s1[0], s1[1]
+	if err := svc.SendFriendRequest(ctx, a, b); err != nil {
+		t.Fatalf("send: %v", err)
+	}
+	if got, _ := svc.ListOutgoingRequests(ctx, a); len(got) != 1 || got[0] != b {
+		t.Fatalf("outgoing pending = %v, want [b]", got)
+	}
+	if got, _ := svc.ListOutgoingRequests(ctx, b); len(got) != 0 {
+		t.Fatalf("addressee outgoing = %v, want none", got)
+	}
+	// Accepted: a friendship, no longer an outgoing request.
+	if err := svc.RespondFriendRequest(ctx, b, a, true); err != nil {
+		t.Fatalf("accept: %v", err)
+	}
+	if got, _ := svc.ListOutgoingRequests(ctx, a); len(got) != 0 {
+		t.Fatalf("outgoing after accept = %v, want none", got)
+	}
+
+	// Declined: stays outgoing (reads as sent; cannot re-send).
+	_, s2 := newGameWithSeats(t, 2)
+	c, d := s2[0], s2[1]
+	if err := svc.SendFriendRequest(ctx, c, d); err != nil {
+		t.Fatalf("send2: %v", err)
+	}
+	if err := svc.RespondFriendRequest(ctx, d, c, false); err != nil {
+		t.Fatalf("decline: %v", err)
+	}
+	if got, _ := svc.ListOutgoingRequests(ctx, c); len(got) != 1 || got[0] != d {
+		t.Fatalf("outgoing after decline = %v, want [d]", got)
+	}
+
+	// Lazily expired pending: omitted (may be re-sent).
+	_, s3 := newGameWithSeats(t, 2)
+	e, f := s3[0], s3[1]
+	if err := svc.SendFriendRequest(ctx, e, f); err != nil {
+		t.Fatalf("send3: %v", err)
+	}
+	if _, err := testDB.ExecContext(ctx,
+		`UPDATE backend.friendships SET created_at = now() - interval '31 days' WHERE requester_id = $1 AND addressee_id = $2`, e, f); err != nil {
+		t.Fatalf("backdate: %v", err)
+	}
+	if got, _ := svc.ListOutgoingRequests(ctx, e); len(got) != 0 {
+		t.Fatalf("expired outgoing = %v, want none", got)
+	}
+}
+
+// TestRespondPublishesToRequester checks that answering a request notifies the original
+// requester over the live channel (Stage 17): accept -> friend_added, decline ->
+// friend_declined, so a game screen watching that opponent re-derives its friend state.
+func TestRespondPublishesToRequester(t *testing.T) {
+	ctx := context.Background()
+	svc := newSocialService()
+	pub := &capturePublisher{}
+	svc.SetNotifier(pub)
+
+	_, s1 := newGameWithSeats(t, 2)
+	a, b := s1[0], s1[1]
+	if err := svc.SendFriendRequest(ctx, a, b); err != nil {
+		t.Fatalf("send: %v", err)
+	}
+	if err := svc.RespondFriendRequest(ctx, b, a, true); err != nil {
+		t.Fatalf("accept: %v", err)
+	}
+	if !pub.notified(a, notify.NotifyFriendAdded) {
+		t.Errorf("accept did not notify requester with %q", notify.NotifyFriendAdded)
+	}
+
+	_, s2 := newGameWithSeats(t, 2)
+	c, d := s2[0], s2[1]
+	if err := svc.SendFriendRequest(ctx, c, d); err != nil {
+		t.Fatalf("send2: %v", err)
+	}
+	if err := svc.RespondFriendRequest(ctx, d, c, false); err != nil {
+		t.Fatalf("decline: %v", err)
+	}
+	if !pub.notified(c, notify.NotifyFriendDeclined) {
+		t.Errorf("decline did not notify requester with %q", notify.NotifyFriendDeclined)
+	}
+}

backend/internal/notify/events.go

@@ -85,8 +85,8 @@ func MatchFound(userID, gameID uuid.UUID) Intent {
 
 // Notification is a lightweight "re-poll" signal to userID that a friend request or
 // invitation changed. kind is a sub-discriminator (NotifyFriendRequest,
-// NotifyFriendAdded, NotifyInvitation, NotifyGameStarted) the client may use to
-// scope its refresh.
+// NotifyFriendAdded, NotifyFriendDeclined, NotifyInvitation, NotifyGameStarted) the
+// client may use to scope its refresh.
 func Notification(userID uuid.UUID, kind string) Intent {
 	b := flatbuffers.NewBuilder(32)
 	k := b.CreateString(kind)

backend/internal/notify/notify.go

@@ -34,8 +34,11 @@ const (
 const (
 	NotifyFriendRequest = "friend_request"
 	NotifyFriendAdded   = "friend_added"
-	NotifyInvitation    = "invitation"
-	NotifyGameStarted   = "game_started"
+	// NotifyFriendDeclined tells the original requester their request was declined, so a
+	// game screen watching that opponent re-derives its "add to friends" state.
+	NotifyFriendDeclined = "friend_declined"
+	NotifyInvitation     = "invitation"
+	NotifyGameStarted    = "game_started"
 )
 
 // Intent is one live event destined for a single user. Payload is the

backend/internal/server/dto.go

@@ -83,16 +83,19 @@ type seatDTO struct {
 
 // gameDTO is the shared game summary.
 type gameDTO struct {
-	ID              string    `json:"id"`
-	Variant         string    `json:"variant"`
-	DictVersion     string    `json:"dict_version"`
-	Status          string    `json:"status"`
-	Players         int       `json:"players"`
-	ToMove          int       `json:"to_move"`
-	TurnTimeoutSecs int       `json:"turn_timeout_secs"`
-	MoveCount       int       `json:"move_count"`
-	EndReason       string    `json:"end_reason"`
-	Seats           []seatDTO `json:"seats"`
+	ID              string `json:"id"`
+	Variant         string `json:"variant"`
+	DictVersion     string `json:"dict_version"`
+	Status          string `json:"status"`
+	Players         int    `json:"players"`
+	ToMove          int    `json:"to_move"`
+	TurnTimeoutSecs int    `json:"turn_timeout_secs"`
+	MoveCount       int    `json:"move_count"`
+	EndReason       string `json:"end_reason"`
+	// LastActivityUnix is the lobby sort key: the current turn's start for an active
+	// game, the finish time once finished (Stage 17).
+	LastActivityUnix int64     `json:"last_activity_unix"`
+	Seats            []seatDTO `json:"seats"`
 }
 
 // moveResultDTO is the outcome of a committed move.
@@ -189,17 +192,22 @@ func gameDTOFromGame(g game.Game) gameDTO {
 			IsWinner:  s.IsWinner,
 		})
 	}
+	last := g.TurnStartedAt
+	if g.FinishedAt != nil {
+		last = *g.FinishedAt
+	}
 	return gameDTO{
-		ID:              g.ID.String(),
-		Variant:         g.Variant.String(),
-		DictVersion:     g.DictVersion,
-		Status:          g.Status,
-		Players:         g.Players,
-		ToMove:          g.ToMove,
-		TurnTimeoutSecs: int(g.TurnTimeout.Seconds()),
-		MoveCount:       g.MoveCount,
-		EndReason:       g.EndReason,
-		Seats:           seats,
+		ID:               g.ID.String(),
+		Variant:          g.Variant.String(),
+		DictVersion:      g.DictVersion,
+		Status:           g.Status,
+		Players:          g.Players,
+		ToMove:           g.ToMove,
+		TurnTimeoutSecs:  int(g.TurnTimeout.Seconds()),
+		MoveCount:        g.MoveCount,
+		EndReason:        g.EndReason,
+		LastActivityUnix: last.Unix(),
+		Seats:            seats,
 	}
 }
 

backend/internal/server/handlers.go

@@ -87,6 +87,7 @@ func (s *Server) registerRoutes() {
 		u.POST("/games/:id/nudge", s.handleNudge)
 		u.GET("/friends", s.handleListFriends)
 		u.GET("/friends/incoming", s.handleIncomingRequests)
+		u.GET("/friends/outgoing", s.handleOutgoingRequests)
 		u.POST("/friends/request", s.handleFriendRequest)
 		u.POST("/friends/respond", s.handleFriendRespond)
 		u.POST("/friends/cancel", s.handleFriendCancel)

backend/internal/server/handlers_friends.go

@@ -31,6 +31,12 @@ type incomingListDTO struct {
 	Requests []accountRefDTO `json:"requests"`
 }
 
+// outgoingListDTO is the addressees the caller has already requested (a live pending
+// request or one the addressee declined) and therefore cannot re-request.
+type outgoingListDTO struct {
+	Requests []accountRefDTO `json:"requests"`
+}
+
 // friendCodeDTO is a freshly issued one-time friend code (returned once).
 type friendCodeDTO struct {
 	Code          string `json:"code"`
@@ -218,6 +224,22 @@ func (s *Server) handleIncomingRequests(c *gin.Context) {
 	c.JSON(http.StatusOK, incomingListDTO{Requests: s.accountRefs(c.Request.Context(), ids)})
 }
 
+// handleOutgoingRequests returns the addressees the caller has already requested
+// (pending or declined) and cannot re-request.
+func (s *Server) handleOutgoingRequests(c *gin.Context) {
+	uid, ok := userID(c)
+	if !ok {
+		abortBadRequest(c, "missing identity")
+		return
+	}
+	ids, err := s.social.ListOutgoingRequests(c.Request.Context(), uid)
+	if err != nil {
+		s.abortErr(c, err)
+		return
+	}
+	c.JSON(http.StatusOK, outgoingListDTO{Requests: s.accountRefs(c.Request.Context(), ids)})
+}
+
 // handleIssueFriendCode issues a one-time add-a-friend code for the caller.
 func (s *Server) handleIssueFriendCode(c *gin.Context) {
 	uid, ok := userID(c)

backend/internal/social/friends.go

@@ -124,6 +124,14 @@ func (svc *Service) RespondFriendRequest(ctx context.Context, addresseeID, reque
 	if !ok {
 		return ErrRequestNotFound
 	}
+	// Tell the original requester their request was answered, so a game screen watching
+	// this opponent re-derives its "add to friends" state (accepted -> friends, declined
+	// -> stays "request sent").
+	if accept {
+		svc.pub.Publish(notify.Notification(requesterID, notify.NotifyFriendAdded))
+	} else {
+		svc.pub.Publish(notify.Notification(requesterID, notify.NotifyFriendDeclined))
+	}
 	return nil
 }
 
@@ -156,6 +164,14 @@ func (svc *Service) ListIncomingRequests(ctx context.Context, accountID uuid.UUI
 	return svc.store.listIncomingRequests(ctx, accountID, svc.now().Add(-friendRequestTTL))
 }
 
+// ListOutgoingRequests returns the account IDs the caller has already requested and
+// cannot (re-)request: a live (not yet expired) pending request, or one the addressee
+// permanently declined. The game's "add to friends" item reads it to stay disabled
+// across reloads (a declined request reads identically to a still-pending one).
+func (svc *Service) ListOutgoingRequests(ctx context.Context, accountID uuid.UUID) ([]uuid.UUID, error) {
+	return svc.store.listOutgoingRequests(ctx, accountID, svc.now().Add(-friendRequestTTL))
+}
+
 // loadEdges returns every friendship row between a and b in either direction (at
 // most one per direction). It feeds SendFriendRequest's re-send classification.
 func (s *Store) loadEdges(ctx context.Context, a, b uuid.UUID) ([]model.Friendships, error) {
@@ -294,6 +310,29 @@ func (s *Store) listIncomingRequests(ctx context.Context, accountID uuid.UUID, c
 	return out, nil
 }
 
+// listOutgoingRequests returns the addressees of the caller's requests that block a
+// re-send: a live (created after cutoff) pending request, or a permanently declined
+// one. An ignored pending request that has lazily expired is omitted (it may be re-sent).
+func (s *Store) listOutgoingRequests(ctx context.Context, accountID uuid.UUID, cutoff time.Time) ([]uuid.UUID, error) {
+	stmt := postgres.SELECT(table.Friendships.AddresseeID).
+		FROM(table.Friendships).
+		WHERE(
+			table.Friendships.RequesterID.EQ(postgres.UUID(accountID)).
+				AND(table.Friendships.Status.EQ(postgres.String(friendDeclined)).
+					OR(table.Friendships.Status.EQ(postgres.String(friendPending)).
+						AND(table.Friendships.CreatedAt.GT(postgres.TimestampzT(cutoff))))),
+		)
+	var rows []model.Friendships
+	if err := stmt.QueryContext(ctx, s.db, &rows); err != nil {
+		return nil, fmt.Errorf("social: list outgoing requests: %w", err)
+	}
+	out := make([]uuid.UUID, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, r.AddresseeID)
+	}
+	return out, nil
+}
+
 // edgeEither matches a friendship row between a and b in either direction.
 func edgeEither(a, b uuid.UUID) postgres.BoolExpression {
 	return table.Friendships.RequesterID.EQ(postgres.UUID(a)).AND(table.Friendships.AddresseeID.EQ(postgres.UUID(b))).