feat(hint): idle-gated wallet-free vs_ai hint on a monotonic clock (B4)

A vs_ai hint is now unlimited and wallet-free, but idle-gated as an anti-frustration
aid: it unlocks only after the player has been stuck ~30 min on a turn (timed from the
robot's last move; the human's first move, before the robot has played, is exempt).
While gated the hint button carries a small lock badge and a tap shows the remaining
minutes ('Available in N min.'); the lock lifts live at the mark.

The gate is enforced CLIENT-SIDE against a MONOTONIC clock (performance.now()), never a
wall-clock timestamp: a device clock the player controls (or an auto-sync) must not be
able to open or freeze it. The wait is therefore session-scoped -- a reload restarts it
(there is no tamper-proof way to carry idle time across a relaunch without a wall clock).
An online vs_ai game will gate the same way but from the server's clock (a follow-up).

- lib/hints.ts: HINT_GATE_MS + pure hintGateRemainingMs (monotonic) + hintLockMinutes;
  removed the wall-clock hintRemainingMs. Unit-tested red->green.
- Game.svelte: the monotonic gate (hintGateStart/monoNow, armed on the turn change), a
  vs_ai hint button (plain: no confirm, no count; lock badge + gated tap -> toast), a
  live 10s tick.
- localgame: removed the wall-clock hint gate and the now-dead robotLastMoveAtUnix field
  from source.ts/serialize.ts (the client is authoritative); hint() just serves the top
  move.
- i18n game.hintLockedIn.
- offline.spec.ts: assert the first move is un-gated and the lock arms after the robot moves.
- Docs FUNCTIONAL(+_ru) + ARCHITECTURE; bundle budget 114->115 (game-screen feature).

ui/src/lib/localgame/serialize.test.ts

@@ -46,7 +46,7 @@ function makeGame(seed: bigint): LocalGame {
   return new LocalGame({ variant: 'scrabble_en', version: 'sample', seed, players: 2, dawg, multipleWords: true });
 }
 
-const meta = { id: 'g1', seats, createdAtUnix: 1, updatedAtUnix: 2, robotLastMoveAtUnix: 3 };
+const meta = { id: 'g1', seats, createdAtUnix: 1, updatedAtUnix: 2 };
 
 describe('local game serialize + replay', () => {
   it('reconstructs a mid-game position by replay', () => {

ui/src/lib/localgame/serialize.ts

@@ -38,8 +38,6 @@ export interface LocalGameRecord {
   status: 'active' | 'finished';
   createdAtUnix: number;
   updatedAtUnix: number;
-  /** Unix seconds of the robot's most recent move — the local hint gate (>30 min) reads this. */
-  robotLastMoveAtUnix: number;
 }
 
 /** The record fields the caller owns (the engine supplies the rest). */
@@ -48,7 +46,6 @@ export interface RecordMeta {
   seats: Seat[];
   createdAtUnix: number;
   updatedAtUnix: number;
-  robotLastMoveAtUnix: number;
 }
 
 /**
@@ -70,7 +67,6 @@ export function serializeGame(game: LocalGame, meta: RecordMeta): LocalGameRecor
     status: game.isOver ? 'finished' : 'active',
     createdAtUnix: meta.createdAtUnix,
     updatedAtUnix: meta.updatedAtUnix,
-    robotLastMoveAtUnix: meta.robotLastMoveAtUnix,
   };
 }
 

ui/src/lib/localgame/source.test.ts

@@ -59,9 +59,15 @@ describe('LocalSource', () => {
     expect(events.some((e) => e.kind === 'opponent_moved')).toBe(true);
   });
 
-  it('gates the hint until 30 minutes since the robot last moved', async () => {
+  it('does not wall-clock-gate the hint (the idle gate is client-side and monotonic)', async () => {
     const src = await newSource('local:g3', 7n);
-    await expect(src.hint('local:g3')).rejects.toMatchObject({ code: 'hint_not_ready' });
+    // hint() serves the engine's top move (or no_hint when the tiny sample dictionary has none for
+    // this rack), but never the old timestamp gate 'hint_not_ready' — that moved to the client
+    // (lib/hints, measured with performance.now()) so a device clock change cannot defeat it.
+    await src.hint('local:g3').then(
+      (h) => expect(h.move).toBeDefined(),
+      (e) => expect((e as { code: string }).code).toBe('no_hint'),
+    );
   });
 
   it('records decoded moves in the history', async () => {

ui/src/lib/localgame/source.ts

@@ -34,9 +34,6 @@ import type { Move } from '../dict/validate';
 
 export { LOCAL_ID_PREFIX, isLocalGameId };
 
-/** HINT_GATE_MS is the idle time since the robot's last move before an offline hint unlocks. */
-export const HINT_GATE_MS = 30 * 60 * 1000;
-
 /**
  * GameLoopSource is the subset of GatewayClient the game screen calls to run a game. The real
  * gateway satisfies it structurally; the local source implements it for offline play.
@@ -123,7 +120,6 @@ export class LocalSource implements GameLoopSource {
       seats: opts.seats.map((s) => ({ kind: s.kind, name: s.name, accountId: s.accountId })),
       createdAtUnix: now,
       updatedAtUnix: now,
-      robotLastMoveAtUnix: now,
     });
     const entry: Live = { game, record };
     this.live.set(opts.id, entry);
@@ -191,10 +187,10 @@ export class LocalSource implements GameLoopSource {
   }
 
   async hint(gameId: string): Promise<HintResult> {
+    // The idle gate is enforced client-side with a monotonic clock (see Game.svelte / lib/hints):
+    // a wall-clock timestamp here could be defeated by changing the device clock. This just serves
+    // the engine's top-ranked move; the client only calls it once the gate is open.
     const entry = await this.load(gameId);
-    if (nowUnix() * 1000 - entry.record.robotLastMoveAtUnix * 1000 < HINT_GATE_MS) {
-      throw new GatewayError('hint_not_ready');
-    }
     const top = this.topMove(entry.game);
     if (!top) throw new GatewayError('no_hint');
     return { move: this.moveFromGen(entry.record.variant, entry.game.currentPlayer, top), hintsRemaining: 1, walletBalance: 0 };
@@ -280,7 +276,6 @@ export class LocalSource implements GameLoopSource {
       if (dec.kind === 'play') out.push(g.play(dec.move.dir, dec.move.tiles));
       else if (dec.kind === 'exchange' && g.bagLength >= RULESETS[entry.record.variant].rackSize) out.push(g.exchange(dec.exchange));
       else out.push(g.pass());
-      entry.record.robotLastMoveAtUnix = nowUnix();
     }
     return out;
   }
@@ -306,7 +301,6 @@ export class LocalSource implements GameLoopSource {
       seats: entry.record.seats,
       createdAtUnix: entry.record.createdAtUnix,
       updatedAtUnix: nowUnix(),
-      robotLastMoveAtUnix: entry.record.robotLastMoveAtUnix,
     });
     await saveLocalGame(entry.record);
   }