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.

ui/src/lib/client.ts

@@ -98,6 +98,8 @@ export interface GatewayClient {
   // --- friends (Stage 8) ---
   friendsList(): Promise<AccountRef[]>;
   friendsIncoming(): Promise<AccountRef[]>;
+  /** Addressees the caller has already requested (pending or declined); cannot re-request. */
+  friendsOutgoing(): Promise<AccountRef[]>;
   friendRequest(accountId: string): Promise<void>;
   friendRespond(requesterId: string, accept: boolean): Promise<void>;
   friendCancel(accountId: string): Promise<void>;

ui/src/lib/codec.ts

@@ -249,6 +249,7 @@ function decodeGameView(g: fb.GameView): GameView {
     turnTimeoutSecs: g.turnTimeoutSecs(),
     moveCount: g.moveCount(),
     endReason: s(g.endReason()),
+    lastActivityUnix: Number(g.lastActivityUnix()),
     seats,
   };
 }
@@ -587,6 +588,16 @@ export function decodeIncomingList(buf: Uint8Array): AccountRef[] {
   return out;
 }
 
+export function decodeOutgoingList(buf: Uint8Array): AccountRef[] {
+  const l = fb.OutgoingRequestList.getRootAsOutgoingRequestList(new ByteBuffer(buf));
+  const out: AccountRef[] = [];
+  for (let i = 0; i < l.requestsLength(); i++) {
+    const r = l.requests(i);
+    if (r) out.push(decodeAccountRef(r));
+  }
+  return out;
+}
+
 export function decodeBlockList(buf: Uint8Array): AccountRef[] {
   const l = fb.BlockList.getRootAsBlockList(new ByteBuffer(buf));
   const out: AccountRef[] = [];
@@ -678,6 +689,7 @@ function emptyGame(): GameView {
     turnTimeoutSecs: 0,
     moveCount: 0,
     endReason: '',
+    lastActivityUnix: 0,
     seats: [],
   };
 }

ui/src/lib/i18n/en.ts

@@ -241,6 +241,7 @@ export const en = {
   'game.exportGcg': 'Export GCG',
   'game.gcgActiveOnly': 'Available once the game is finished.',
   'game.requestSent': 'Request sent',
+  'game.alreadyFriends': '✓ In friends',
 
   'time.minutes': '{n} min',
   'time.hours': '{n} h',

ui/src/lib/i18n/ru.ts

@@ -242,6 +242,7 @@ export const ru: Record<MessageKey, string> = {
   'game.exportGcg': 'Экспорт GCG',
   'game.gcgActiveOnly': 'Доступно после завершения игры.',
   'game.requestSent': 'Запрос отправлен',
+  'game.alreadyFriends': '✓ В друзьях',
 
   'time.minutes': '{n} мин',
   'time.hours': '{n} ч',

ui/src/lib/lobbysort.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { groupGames, isMyTurn } from './lobbysort';
+import type { GameView, Seat } from './model';
+
+const ME = 'me';
+const seat = (s: number, accountId: string): Seat => ({
+  seat: s,
+  accountId,
+  displayName: accountId,
+  score: 0,
+  hintsUsed: 0,
+  isWinner: false,
+});
+
+function game(id: string, status: GameView['status'], toMove: number, lastActivityUnix: number): GameView {
+  return {
+    id,
+    variant: 'english',
+    dictVersion: 'v1',
+    status,
+    players: 2,
+    toMove,
+    turnTimeoutSecs: 0,
+    moveCount: 0,
+    endReason: '',
+    lastActivityUnix,
+    seats: [seat(0, ME), seat(1, 'opp')],
+  };
+}
+
+describe('groupGames', () => {
+  it('partitions into your-turn, their-turn and finished', () => {
+    const g = groupGames(
+      [
+        game('a', 'active', 0, 100), // toMove 0 == my seat -> my turn
+        game('b', 'active', 1, 100), // their turn
+        game('c', 'finished', 0, 100),
+      ],
+      ME,
+    );
+    expect(g.yourTurn.map((x) => x.id)).toEqual(['a']);
+    expect(g.theirTurn.map((x) => x.id)).toEqual(['b']);
+    expect(g.finished.map((x) => x.id)).toEqual(['c']);
+  });
+
+  it('orders your-turn oldest-first, the other two newest-first', () => {
+    const g = groupGames(
+      [
+        game('y_new', 'active', 0, 200),
+        game('y_old', 'active', 0, 100),
+        game('t_new', 'active', 1, 200),
+        game('t_old', 'active', 1, 100),
+        game('f_new', 'finished', 0, 200),
+        game('f_old', 'finished', 0, 100),
+      ],
+      ME,
+    );
+    expect(g.yourTurn.map((x) => x.id)).toEqual(['y_old', 'y_new']);
+    expect(g.theirTurn.map((x) => x.id)).toEqual(['t_new', 't_old']);
+    expect(g.finished.map((x) => x.id)).toEqual(['f_new', 'f_old']);
+  });
+
+  it('isMyTurn is false for a finished game even at my seat', () => {
+    expect(isMyTurn(game('x', 'finished', 0, 0), ME)).toBe(false);
+    expect(isMyTurn(game('x', 'active', 0, 0), ME)).toBe(true);
+    expect(isMyTurn(game('x', 'active', 1, 0), ME)).toBe(false);
+  });
+});

ui/src/lib/lobbysort.ts

@@ -0,0 +1,39 @@
+// Pure grouping + ordering of the lobby's game list (Stage 17). The lobby shows three
+// sections — games awaiting the caller's move, games awaiting the opponent, and finished
+// games — each ordered by last activity: your-turn oldest-first (the longest-neglected on
+// top), the other two newest-first.
+
+import type { GameView } from './model';
+
+/** isMyTurn reports whether an active game's seat-to-move belongs to the caller. */
+export function isMyTurn(game: GameView, myId: string): boolean {
+  const me = game.seats.find((s) => s.accountId === myId);
+  return game.status === 'active' && !!me && game.toMove === me.seat;
+}
+
+/** LobbyGroups holds the three ordered lobby sections. */
+export interface LobbyGroups {
+  yourTurn: GameView[];
+  theirTurn: GameView[];
+  finished: GameView[];
+}
+
+/**
+ * groupGames partitions games for myId into the three lobby sections and orders each: the
+ * your-turn games by ascending last activity (the longest-waiting first), the opponent-turn
+ * and finished games by descending last activity (the most recent first).
+ */
+export function groupGames(games: GameView[], myId: string): LobbyGroups {
+  const yourTurn: GameView[] = [];
+  const theirTurn: GameView[] = [];
+  const finished: GameView[] = [];
+  for (const g of games) {
+    if (g.status !== 'active') finished.push(g);
+    else if (isMyTurn(g, myId)) yourTurn.push(g);
+    else theirTurn.push(g);
+  }
+  yourTurn.sort((a, b) => a.lastActivityUnix - b.lastActivityUnix);
+  theirTurn.sort((a, b) => b.lastActivityUnix - a.lastActivityUnix);
+  finished.sort((a, b) => b.lastActivityUnix - a.lastActivityUnix);
+  return { yourTurn, theirTurn, finished };
+}

ui/src/lib/mock/client.ts

@@ -90,6 +90,7 @@ export class MockGateway implements GatewayClient {
   private pendingMatch: string | null = null;
   private friends: AccountRef[] = MOCK_FRIENDS.map((f) => ({ ...f }));
   private incoming: AccountRef[] = MOCK_INCOMING.map((f) => ({ ...f }));
+  private outgoing: AccountRef[] = [];
   private blocks: AccountRef[] = [];
   private invitations: Invitation[] = mockInvitations();
   private readonly stats: Stats = { ...MOCK_STATS };
@@ -155,6 +156,7 @@ export class MockGateway implements GatewayClient {
         turnTimeoutSecs: 86400,
         moveCount: 0,
         endReason: '',
+        lastActivityUnix: Math.floor(Date.now() / 1000),
         seats: [
           { seat: 0, accountId: ME, displayName: 'You', score: 0, hintsUsed: 0, isWinner: false },
           { seat: 1, accountId: 'robot', displayName: 'Robo', score: 0, hintsUsed: 0, isWinner: false },
@@ -372,8 +374,15 @@ export class MockGateway implements GatewayClient {
   async friendsIncoming(): Promise<AccountRef[]> {
     return this.incoming.map((f) => ({ ...f }));
   }
-  async friendRequest(_accountId: string): Promise<void> {
-    // The real backend requires a shared game; the mock simply acknowledges.
+  async friendsOutgoing(): Promise<AccountRef[]> {
+    return this.outgoing.map((f) => ({ ...f }));
+  }
+  async friendRequest(accountId: string): Promise<void> {
+    // The real backend requires a shared game; the mock records the outgoing request so
+    // the game's "add to friends" item reads as sent across reloads.
+    if (!this.outgoing.some((o) => o.accountId === accountId)) {
+      this.outgoing.push({ accountId, displayName: this.nameFor(accountId) });
+    }
   }
   async friendRespond(requesterId: string, accept: boolean): Promise<void> {
     const i = this.incoming.findIndex((r) => r.accountId === requesterId);

ui/src/lib/mock/data.ts

@@ -43,10 +43,9 @@ export const PROFILE: Profile = {
 
 // Seed social/account data for the mock (pnpm start + Playwright). The mock profile
 // is a durable account so the Stage 8 surfaces (friends, stats, history) are reachable.
-export const MOCK_FRIENDS: AccountRef[] = [
-  { accountId: 'ann', displayName: 'Ann' },
-  { accountId: 'kaya', displayName: 'Kaya' },
-];
+// Ann is the active game's opponent but deliberately not a friend, so the in-game
+// "add to friends" flow is demonstrable; Kaya (a finished-game opponent) is the friend.
+export const MOCK_FRIENDS: AccountRef[] = [{ accountId: 'kaya', displayName: 'Kaya' }];
 
 export const MOCK_INCOMING: AccountRef[] = [{ accountId: 'rick', displayName: 'Rick' }];
 
@@ -144,6 +143,7 @@ function activeGame(): MockGame {
       turnTimeoutSecs: 86400,
       moveCount: G1_MOVES.length,
       endReason: '',
+      lastActivityUnix: Math.floor(Date.now() / 1000) - 7200,
       seats: [seat(0, ME, 'You', 19), seat(1, 'ann', 'Ann', 13)],
     },
     moves: G1_MOVES,
@@ -177,6 +177,7 @@ function finishedG2(): MockGame {
       turnTimeoutSecs: 86400,
       moveCount: 2,
       endReason: 'normal',
+      lastActivityUnix: Math.floor(Date.now() / 1000) - 86400,
       seats: [seat(0, ME, 'You', 320, true), seat(1, 'kaya', 'Kaya', 281)],
     },
     moves: [
@@ -211,6 +212,7 @@ function finishedG3(): MockGame {
       turnTimeoutSecs: 86400,
       moveCount: 1,
       endReason: 'resignation',
+      lastActivityUnix: Math.floor(Date.now() / 1000) - 172800,
       seats: [seat(0, ME, 'You', 150), seat(1, 'rick', 'Rick', 212, true)],
     },
     moves: [

ui/src/lib/model.ts

@@ -40,6 +40,8 @@ export interface GameView {
   turnTimeoutSecs: number;
   moveCount: number;
   endReason: string;
+  /** Lobby sort key: the current turn's start (active) or the finish time (finished), Unix seconds. */
+  lastActivityUnix: number;
   seats: Seat[];
 }
 

ui/src/lib/result.test.ts

@@ -22,6 +22,7 @@ function game(seats: Seat[], status = 'finished', toMove = 0): GameView {
     turnTimeoutSecs: 0,
     moveCount: 0,
     endReason: '',
+    lastActivityUnix: 0,
     seats,
   };
 }

ui/src/lib/transport.ts

@@ -137,6 +137,9 @@ export function createTransport(baseUrl: string): GatewayClient {
     async friendsIncoming() {
       return codec.decodeIncomingList(await exec('friends.incoming', codec.empty()));
     },
+    async friendsOutgoing() {
+      return codec.decodeOutgoingList(await exec('friends.outgoing', codec.empty()));
+    },
     async friendRequest(accountId) {
       await exec('friends.request', codec.encodeTarget(accountId));
     },