fix(clock): only flag the player whose turn it is

After the first-move deduction fix, both players had identical stored
times (5000ms). When the clock expired, checkTimeout reported both
players as timed out because it didn't verify whose turn it was.
Whichever flag message arrived first determined the winner — on CI,
black's flag won the race, producing "Black wins" instead of
"White wins".

Add a FEN turn check to checkTimeout: only the player whose clock is
actively ticking (the one whose turn it is) can time out.

Author: shipurjan

lib/game-session.test.ts

@@ -1077,34 +1077,52 @@ describe("game-session", () => {
         whiteTimeMs: "5000",
         blackTimeMs: "5000",
         lastMoveAt: "0",
+        currentFen: "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
       });
 
       const result = await checkTimeout(TEST_GAME_ID, "white", Date.now());
       expect(result.timedOut).toBe(false);
     });
 
-    it("returns timed out when clock has expired", async () => {
+    it("returns timed out when active player's clock has expired", async () => {
       const lastMoveAt = Date.now() - 6000;
+      // FEN has "b" turn — black's clock is ticking
       mockRedis.hgetall.mockResolvedValueOnce({
         whiteTimeMs: "5000",
         blackTimeMs: "5000",
         lastMoveAt: String(lastMoveAt),
+        currentFen: "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1",
       });
 
-      const result = await checkTimeout(TEST_GAME_ID, "white", Date.now());
+      const result = await checkTimeout(TEST_GAME_ID, "black", Date.now());
       expect(result.timedOut).toBe(true);
       expect(result.remainingMs).toBe(0);
     });
 
+    it("returns not timed out when it is not the checked player's turn", async () => {
+      const lastMoveAt = Date.now() - 6000;
+      // FEN has "b" turn — black's clock is ticking, not white's
+      mockRedis.hgetall.mockResolvedValueOnce({
+        whiteTimeMs: "5000",
+        blackTimeMs: "5000",
+        lastMoveAt: String(lastMoveAt),
+        currentFen: "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1",
+      });
+
+      const result = await checkTimeout(TEST_GAME_ID, "white", Date.now());
+      expect(result.timedOut).toBe(false);
+    });
+
     it("returns not timed out when clock has time remaining", async () => {
       const lastMoveAt = Date.now() - 2000;
       mockRedis.hgetall.mockResolvedValueOnce({
         whiteTimeMs: "5000",
         blackTimeMs: "5000",
         lastMoveAt: String(lastMoveAt),
+        currentFen: "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1",
       });
 
-      const result = await checkTimeout(TEST_GAME_ID, "white", Date.now());
+      const result = await checkTimeout(TEST_GAME_ID, "black", Date.now());
       expect(result.timedOut).toBe(false);
       expect(result.remainingMs).toBeGreaterThan(0);
     });

lib/game-session.ts

@@ -600,6 +600,12 @@ export async function checkTimeout(
   // Clock hasn't started yet (no moves made)
   if (lastMoveAt === 0) return { timedOut: false, remainingMs: 0 };
 
+  // Only the player whose turn it is can time out
+  const fen = data.currentFen || "";
+  const turnChar = fen.split(" ")[1];
+  const turnColor = turnChar === "w" ? "white" : "black";
+  if (activeColor !== turnColor) return { timedOut: false, remainingMs: 0 };
+
   const timeField =
     activeColor === "white" ? "whiteTimeMs" : "blackTimeMs";
   const remaining = parseInt(data[timeField] || "0", 10);