fix(games): PR-P G-37 — shuffle AI client items + options per session

User reports: 'v tej novej hre boli všetky správne odpovede na
jednom mieste, a u niektorých typoch hier sa pozície správnych
odpovedí nemenia'.

Two compounding causes:

1. The Sonnet generator's correctIndex distribution is lopsided
   — for quiz / chart-read it picks index 0 disproportionately
   often, so several questions in a row showed the right answer
   in the same position.

2. AI specs are deterministic by content-hash. Replaying the
   same envelope (the spec lives in Redis until rotation) showed
   the same item sequence + same option arrangement every time,
   training pattern-matching instead of comprehension.

Fix per AI client: shuffle on mount via `useState` initializer
(runs ONCE per mount, NOT on every re-render — re-shuffling mid-
question would be jarring). Same Fisher-Yates from `lib/shuffle.ts`
the evergreen `pickRound` helper uses on /games/finance-quiz.

Per-client treatment:

- `ai-quiz-client.tsx` — shuffle items + each item's 4 options +
  recompute `correctIndex` to track the new option position.
  This is the most user-visible fix (multi-question, multi-option).
- `ai-truefalse-client.tsx` — items only (statement order); the
  T/F answer itself is binary so option-position bias doesn't
  apply.
- `ai-price-guess-client.tsx` — items only (each item has a free-
  form numeric answer, no options).
- `ai-fillblank-client.tsx` — items only (free-form string answer).
- `ai-calcsprint-client.tsx` — items only; calc cycles through
  problems repeatedly via `index % length`, so shuffling at mount
  also reshuffles each cycle relative to a vanilla replay.
- `ai-chartread-client.tsx` — single question, but 4 multiple-
  choice options. Shuffle options + recompute correctIndex.

`ai-order-client.tsx` already has its own internal shuffle (the
gameplay IS to put items in correct order). `ai-matchpairs-client`
and `ai-memory-client` randomise via card draw inherently. `ai-
budget-client.tsx` and `ai-whatif-client.tsx` have no positional
options to shuffle.

Validation:
- pnpm typecheck → 0 errors
- pnpm test → 719/719

Open follow-up: a Sonnet system-prompt nudge in
`lib/ai-pipeline/generate.ts` could ask the generator to
distribute correctIndex evenly across items at generation time
(belt-and-braces with the client shuffle). Sprint H polish.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: B2JK-Industry

components/games/ai-calcsprint-client.tsx

@@ -5,6 +5,7 @@ import type { z } from "zod";
 import type { CalcSpecSchema } from "@/lib/ai-pipeline/types";
 import { submitScore, type ScoreResponse } from "@/lib/client-api";
 import { RoundResult } from "@/components/games/round-result";
+import { shuffle } from "@/lib/shuffle";
 import type { Dict } from "@/lib/i18n";
 
 type Spec = z.infer<typeof CalcSpecSchema>;
@@ -25,6 +26,11 @@ export function AiCalcSprintClient({
   dict: Dict;
 }) {
   const t = dict.ai;
+  // G-37 — randomise problem order so a replay shows different
+  // problems first. Calc-sprint cycles through items repeatedly
+  // (`index % length`), so shuffling once at mount also reshuffles
+  // each lap relative to a vanilla replay.
+  const [shuffledItems] = useState(() => shuffle([...spec.items]));
   const [index, setIndex] = useState(0);
   const [input, setInput] = useState("");
   const [correctCount, setCorrectCount] = useState(0);
@@ -69,7 +75,7 @@ export function AiCalcSprintClient({
     return () => clearInterval(id);
   }, [done, submit, spec.xpPerCorrect]);
 
-  const current = spec.items[index % spec.items.length];
+  const current = shuffledItems[index % shuffledItems.length];
 
   function check() {
     const n = Number(input.replace(",", "."));

components/games/ai-chartread-client.tsx

@@ -5,6 +5,7 @@ import type { z } from "zod";
 import type { ChartReadSpecSchema } from "@/lib/ai-pipeline/types";
 import { submitScore, type ScoreResponse } from "@/lib/client-api";
 import { RoundResult } from "@/components/games/round-result";
+import { shuffle } from "@/lib/shuffle";
 import type { Dict } from "@/lib/i18n";
 
 type Spec = z.infer<typeof ChartReadSpecSchema>;
@@ -96,14 +97,26 @@ export function AiChartReadClient({
   dict: Dict;
 }) {
   const t = dict.ai;
+  // G-37 — shuffle the 4 options + recompute correctIndex so the
+  // answer position varies between sessions. Single question per
+  // chart-read spec → mount-time shuffle is enough; no per-item
+  // loop needed.
+  const [shuffled] = useState(() => {
+    const correctOption = spec.options[spec.correctIndex];
+    const shuffledOptions = shuffle([...spec.options]);
+    return {
+      options: shuffledOptions,
+      correctIndex: shuffledOptions.indexOf(correctOption),
+    };
+  });
   const [chosen, setChosen] = useState<number | null>(null);
   const [revealed, setRevealed] = useState(false);
   const [done, setDone] = useState(false);
   const [submitting, setSubmitting] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [result, setResult] = useState<ScoreResponse | null>(null);
 
-  const isCorrect = chosen === spec.correctIndex;
+  const isCorrect = chosen === shuffled.correctIndex;
 
   const submit = useCallback(
     async (xp: number) => {
@@ -137,8 +150,8 @@ export function AiChartReadClient({
       <div className="card p-5 flex flex-col gap-4">
         <p className="font-semibold">{spec.question}</p>
         <div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
-          {spec.options.map((opt, i) => {
-            const isAnswer = i === spec.correctIndex;
+          {shuffled.options.map((opt, i) => {
+            const isAnswer = i === shuffled.correctIndex;
             const isChosen = chosen === i;
             const tone = !revealed
               ? isChosen

components/games/ai-fillblank-client.tsx

@@ -5,6 +5,7 @@ import type { z } from "zod";
 import type { FillBlankSpecSchema } from "@/lib/ai-pipeline/types";
 import { submitScore, type ScoreResponse } from "@/lib/client-api";
 import { RoundResult } from "@/components/games/round-result";
+import { shuffle } from "@/lib/shuffle";
 import type { Dict } from "@/lib/i18n";
 
 type Spec = z.infer<typeof FillBlankSpecSchema>;
@@ -26,6 +27,10 @@ export function AiFillBlankClient({
   dict: Dict;
 }) {
   const t = dict.ai;
+  // G-37 — randomise item order on mount so a replay shows different
+  // sentences first. Each item's answer is a free-form string so
+  // there are no options to per-item-shuffle.
+  const [shuffledItems] = useState(() => shuffle([...spec.items]));
   const [index, setIndex] = useState(0);
   const [phase, setPhase] = useState<Phase>("playing");
   const [input, setInput] = useState("");
@@ -34,8 +39,8 @@ export function AiFillBlankClient({
   const [error, setError] = useState<string | null>(null);
   const [result, setResult] = useState<ScoreResponse | null>(null);
 
-  const total = spec.items.length;
-  const current = spec.items[index];
+  const total = shuffledItems.length;
+  const current = shuffledItems[index];
 
   const submit = useCallback(
     async (xp: number) => {

components/games/ai-price-guess-client.tsx

@@ -11,6 +11,7 @@ import type { z } from "zod";
 import type { PriceGuessSpecSchema } from "@/lib/ai-pipeline/types";
 import { submitScore, type ScoreResponse } from "@/lib/client-api";
 import { RoundResult } from "@/components/games/round-result";
+import { shuffle } from "@/lib/shuffle";
 import type { Dict } from "@/lib/i18n";
 
 type PriceGuessSpec = z.infer<typeof PriceGuessSpecSchema>;
@@ -33,7 +34,11 @@ export function AiPriceGuessClient({
   dict: Dict;
 }) {
   const t = dict.ai;
-  const items = spec.items;
+  // G-37 — randomise item order so a replay shows a different
+  // sequence. Each item's correct answer is a number (no options to
+  // shuffle), so per-item shuffle isn't needed; only the order.
+  const [shuffledItems] = useState(() => shuffle([...spec.items]));
+  const items = shuffledItems;
   const total = items.length;
   const xpPer = spec.xpPerCorrect;
   const xpCap = total * xpPer;

components/games/ai-quiz-client.tsx

@@ -5,6 +5,7 @@ import type { z } from "zod";
 import type { QuizSpecSchema } from "@/lib/ai-pipeline/types";
 import { submitScore, type ScoreResponse } from "@/lib/client-api";
 import { RoundResult } from "@/components/games/round-result";
+import { shuffle } from "@/lib/shuffle";
 import type { Dict } from "@/lib/i18n";
 
 type QuizSpec = z.infer<typeof QuizSpecSchema>;
@@ -20,6 +21,28 @@ export function AiQuizClient({
   dict: Dict;
 }) {
   const t = dict.ai;
+  // G-37 — shuffle option order per item + question order per session.
+  // The AI generator's correctIndex distribution can be lopsided
+  // (Claude tends to put the correct option at index 0 disproportion-
+  // ately often), and the spec is deterministic — replaying the same
+  // envelope shows the same answer pattern. Shuffling at mount via
+  // `useState` initializer makes every mount session distinct without
+  // re-shuffling on every re-render (which would scramble options
+  // mid-question and confuse the player). Same pattern as the
+  // evergreen `pickRound` in app/games/finance-quiz/page.tsx.
+  const [shuffledItems] = useState(() =>
+    shuffle(
+      spec.items.map((item) => {
+        const correctOption = item.options[item.correctIndex];
+        const shuffledOptions = shuffle([...item.options]);
+        return {
+          ...item,
+          options: shuffledOptions,
+          correctIndex: shuffledOptions.indexOf(correctOption),
+        };
+      }),
+    ),
+  );
   const [index, setIndex] = useState(0);
   const [phase, setPhase] = useState<Phase>("playing");
   const [chosen, setChosen] = useState<number | null>(null);
@@ -28,7 +51,7 @@ export function AiQuizClient({
   const [submitError, setSubmitError] = useState<string | null>(null);
   const [result, setResult] = useState<ScoreResponse | null>(null);
 
-  const items = spec.items;
+  const items = shuffledItems;
   const total = items.length;
   const current = items[index];
   const xpPer = spec.xpPerCorrect;

components/games/ai-truefalse-client.tsx

@@ -5,6 +5,7 @@ import type { z } from "zod";
 import type { TrueFalseSpecSchema } from "@/lib/ai-pipeline/types";
 import { submitScore, type ScoreResponse } from "@/lib/client-api";
 import { RoundResult } from "@/components/games/round-result";
+import { shuffle } from "@/lib/shuffle";
 import type { Dict } from "@/lib/i18n";
 
 type TrueFalseSpec = z.infer<typeof TrueFalseSpecSchema>;
@@ -20,6 +21,12 @@ export function AiTrueFalseClient({
   dict: Dict;
 }) {
   const t = dict.ai;
+  // G-37 — shuffle statement order per session. The True/False answer
+  // itself is binary so option-position bias doesn't apply, but
+  // replaying the same envelope shouldn't show statements in the
+  // same order (or in PL-source-document order, which Claude tends
+  // to follow).
+  const [shuffledItems] = useState(() => shuffle([...spec.items]));
   const [index, setIndex] = useState(0);
   const [phase, setPhase] = useState<Phase>("playing");
   const [chosen, setChosen] = useState<boolean | null>(null);
@@ -28,7 +35,7 @@ export function AiTrueFalseClient({
   const [submitError, setSubmitError] = useState<string | null>(null);
   const [result, setResult] = useState<ScoreResponse | null>(null);
 
-  const items = spec.items;
+  const items = shuffledItems;
   const total = items.length;
   const current = items[index];
   const xpPer = spec.xpPerCorrect;