feat(chat): limit in-game chat to one message per turn

Enforce one chat message per turn on both ends. The backend rejects a
second message in the same turn (ErrChatAlreadySentThisTurn -> 409
chat_already_sent), keyed on the move-driven turn start (turn_started_at).
The UI derives "already wrote this turn" from the message list against
GameView.lastActivityUnix (no counter, survives reopening, resets on turn
change), hides the field behind a short caption once the limit is reached,
and now reloads the game state on turn/game-state events so the toggle and
the limit follow the live game. Enter is gated on !busy to avoid a
double-send in the in-flight window.

Backend: new game.TurnStartedAt; social GameReader gains it; PostMessage
enforces the limit reusing lastMessageAt. UI: new lib/chatlimit.ts pure
logic + unit tests; Chat/ChatScreen wiring; chat.sentThisTurn and
error.chat_already_sent i18n (en/ru); extended chat e2e. Docs: FUNCTIONAL
(+ru), ARCHITECTURE, UI_DESIGN.

ui/src/game/Chat.svelte

@@ -8,6 +8,7 @@
     myId,
     busy,
     myTurn = false,
+    canSend = false,
     waiting = false,
     nudgeOnCooldown = false,
     onsend,
@@ -16,11 +17,16 @@
     messages: ChatMessage[];
     myId: string;
     busy: boolean;
-    // Chat and nudge are mutually exclusive by turn: on the player's own turn the
-    // message field + send are shown (and nudging makes no sense — there is no one to
-    // hurry); on the opponent's turn only the nudge button shows. While the hourly nudge
-    // cooldown is active the nudge is disabled with an "awaiting reply" caption.
+    // The input area has three turn-driven states: on your own turn the message field +
+    // send show while you may still post (canSend); once the one allowed message is sent a
+    // short caption replaces them until the next turn; on the opponent's turn only the
+    // nudge button shows (nudging your own turn makes no sense — there is no one to hurry).
+    // While the hourly nudge cooldown is active the nudge is disabled with an "awaiting
+    // reply" caption.
     myTurn?: boolean;
+    // canSend is true while the player may still post this turn (own turn and the per-turn
+    // limit not yet reached); it gates the message field.
+    canSend?: boolean;
     // waiting is true while an auto-match game still has no opponent: both send and nudge
     // are disabled (there is no one to message or hurry yet).
     waiting?: boolean;
@@ -53,14 +59,18 @@
     {/each}
   </div>
   <div class="input">
-    {#if myTurn}
+    {#if canSend}
       <input
         maxlength="60"
         placeholder={t('chat.placeholder')}
         bind:value={text}
-        onkeydown={(e) => e.key === 'Enter' && send()}
+        onkeydown={(e) => e.key === 'Enter' && !busy && send()}
       />
       <button class="iconbtn" onclick={send} disabled={busy || waiting || !connection.online} aria-label={t('chat.send')}>⬆️</button>
+    {:else if myTurn}
+      <!-- Own turn, the one allowed message already sent: a caption holds the row until the
+           next turn (no nudge — there is no one to hurry on your own turn). -->
+      <span class="cooldown">{t('chat.sentThisTurn')}</span>
     {:else}
       <!-- A flex:1 caption keeps the nudge pinned right whether or not the cooldown text shows. -->
       <span class="cooldown">{nudgeOnCooldown ? t('chat.awaitingReply') : ''}</span>

ui/src/game/ChatScreen.svelte

@@ -3,6 +3,7 @@
   import Chat from './Chat.svelte';
   import { gateway } from '../lib/gateway';
   import { app, handleError, clearChatUnread } from '../lib/app.svelte';
+  import { canSendChat, sentThisTurn } from '../lib/chatlimit';
   import type { ChatMessage, StateView } from '../lib/model';
 
   // The Chat tab body, hosted by CommsHub (which supplies the nav bar + tab bar). The
@@ -20,6 +21,11 @@
   const isMyTurn = $derived(
     !!view && (view.game.status === 'active' || view.game.status === 'open') && view.game.toMove === view.seat,
   );
+  // At most one chat message per turn: "already wrote this turn" is derived from the
+  // message list against the move-driven turn start (lastActivityUnix), so it resets when
+  // the turn advances. canSend hides the field once the limit is reached (and always on
+  // the opponent's turn).
+  const canSend = $derived(canSendChat(isMyTurn, view ? sentThisTurn(messages, myId, view.game.lastActivityUnix) : 0));
   // While the auto-match game still has no opponent, chat and nudge are both disabled.
   const waiting = $derived(!!view && view.game.status === 'open');
   const nudgeCooldownSecs = 3600;
@@ -46,22 +52,35 @@
       /* best-effort */
     }
   }
-  onMount(async () => {
+  // loadState (re)reads the game state that drives the chat/nudge toggle and the per-turn
+  // limit. The initial load surfaces an error; live reloads are best-effort.
+  async function loadState(initial = false) {
     try {
       view = await gateway.gameState(id, false);
     } catch (e) {
-      handleError(e);
+      if (initial) handleError(e);
     }
+  }
+  onMount(async () => {
+    await loadState(true);
     await refresh();
   });
 
-  // Live: refresh (and keep the unread cleared) on a chat / nudge for this game.
+  // Live: refresh the message list on a chat / nudge for this game, and reload the state on
+  // a turn / game-state change so the chat/nudge toggle and the per-turn limit (keyed on the
+  // turn start) follow the live game.
   $effect(() => {
     const e = app.lastEvent;
     if (!e) return;
     if ((e.kind === 'chat_message' && e.message.gameId === id) || (e.kind === 'nudge' && e.gameId === id)) {
       void refresh();
     }
+    if (
+      (e.kind === 'your_turn' || e.kind === 'opponent_moved' || e.kind === 'game_over' || e.kind === 'opponent_joined') &&
+      e.gameId === id
+    ) {
+      void loadState();
+    }
   });
   // Re-evaluate the nudge cooldown on a timer so the control re-enables on time.
   $effect(() => {
@@ -91,4 +110,4 @@
   }
 </script>
 
-<Chat {messages} {myId} {busy} myTurn={isMyTurn} {waiting} {nudgeOnCooldown} onsend={sendChat} onnudge={nudge} />
+<Chat {messages} {myId} {busy} myTurn={isMyTurn} {canSend} {waiting} {nudgeOnCooldown} onsend={sendChat} onnudge={nudge} />