feat(i18n): PR-P G-35 follow-through — translate AI envelope on publish

User feedback: PR-P G-35 schema landed but the visible behaviour
didn't change yet — `titleLocalized` was still always undefined,
so the consumer kept hitting the PL canonical fallback. Adding
the real generator hook now.

`lib/ai-pipeline/generate.ts`:
  - new `translateEnvelopeFields(plPayload, targetLang)` helper.
    One Haiku call per non-pl lang; tight system prompt locks the
    same proper-noun list as the spec translator (BLIK, PKO, NBP,
    Tauron, IKE, IKZE, RRSO, WIBOR, WIRON, Katowice, Warszawa,
    Śląsk, Nikiszowiec, Varso Tower, ETF, S&P 500, WIG20). Returns
    PL fallback on parse failure (the consumer then falls back to
    `lang="pl"` rendering — no observable regression).

`lib/ai-pipeline/publish.ts` `runPipeline`:
  - PL envelope strings extracted into `plTitle`/`plTagline`/
    `plDescription` so the canonical fields and the localized maps
    use the same source string.
  - When `ANTHROPIC_API_KEY` is set, fan out 3 parallel
    `translateEnvelopeFields` calls (uk/cs/en). Each `.catch(() =>
    plPayload)` so a single-language outage doesn't kill the whole
    publish. Aggregated into `titleLocalized` / `taglineLocalized`
    / `descriptionLocalized` Records and stamped onto the envelope.
  - When the API key is absent (mock-fallback dev path) the
    localized maps stay undefined; the consumer keeps showing PL
    with `lang="pl"`.

Cost estimate: 3 extra Haiku calls per publish × 3 envelope
strings ≈ 60 input + 200 output tokens each = ~$0.001 per
rotation (negligible vs the existing spec translation).

Existing live envelopes (3 currently in Redis: fast/medium/slow)
were published before this commit so they have no localized maps.
They'll naturally rotate on schedule (1 h / 6 h / 12 h cycles)
and the next-generation replacements WILL be translated. An admin
backfill endpoint that re-translates currently-live envelopes is
documented as a Sprint H follow-up.

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

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

Author: B2JK-Industry

lib/ai-pipeline/generate.ts

@@ -1,5 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
+import { z } from "zod";
 import {
   QuizSpecSchema,
   ScrambleSpecSchema,
@@ -332,6 +333,59 @@ async function translateSpec(
   return mergeStructure(plSpec, response.parsed_output as GameSpec);
 }
 
+/* G-35 — translate envelope strings (title/tagline/description).
+ *
+ * Separate from translateSpec because the envelope fields are short,
+ * derived from the static seed catalog (not from the AI generator),
+ * and don't need the structural-invariant baby-sitting that spec
+ * translation requires. One Haiku call per non-pl lang; fallback to
+ * the PL canonical strings if the call fails so the page never
+ * blocks publish on a translation error. */
+const EnvelopeTranslationSchema = z.object({
+  title: z.string().min(1).max(60),
+  tagline: z.string().max(140),
+  description: z.string().max(600),
+});
+
+export async function translateEnvelopeFields(
+  pl: { title: string; tagline: string; description: string },
+  targetLang: Exclude<Lang, "pl">,
+): Promise<{ title: string; tagline: string; description: string }> {
+  const response = await client().messages.parse({
+    model: TRANSLATION_MODEL,
+    max_tokens: 600,
+    system: [
+      {
+        type: "text",
+        text: [
+          `Translate the JSON below from Polish to ${TARGET_LANG_LABEL[targetLang]}.`,
+          "Keep these proper nouns untranslated: BLIK, PKO, NBP, Tauron, IKE, IKZE, RRSO, WIBOR, WIRON, Katowice, Warszawa, Śląsk, Nikiszowiec, Varso Tower, ETF, S&P 500, WIG20.",
+          "Currency `zł` stays as `zł`.",
+          "Tone: neutral, educational, Gen Z friendly. Same length envelope (title ≤ 60, tagline ≤ 140, description ≤ 600).",
+          "Return EXACTLY the same JSON keys (title, tagline, description) with translated values.",
+        ].join("\n"),
+        cache_control: { type: "ephemeral" },
+      },
+    ],
+    messages: [
+      {
+        role: "user",
+        content: [
+          "SOURCE (Polish):",
+          "```json",
+          JSON.stringify(pl, null, 2),
+          "```",
+          "",
+          `Translate to ${TARGET_LANG_LABEL[targetLang]}.`,
+        ].join("\n"),
+      },
+    ],
+    output_config: { format: zodOutputFormat(EnvelopeTranslationSchema) },
+  });
+  if (!response.parsed_output) return pl;
+  return response.parsed_output;
+}
+
 function mergeStructure(pl: GameSpec, translated: GameSpec): GameSpec {
   if (pl.kind !== translated.kind) return pl; // last-ditch fallback
   if (pl.kind === "quiz" && translated.kind === "quiz") {

lib/ai-pipeline/publish.ts

@@ -11,7 +11,7 @@ import {
   type RotationSlot,
 } from "./types";
 import { pickResearchSeed, type ResearchSeed } from "./research";
-import { generateGameSpec } from "./generate";
+import { generateGameSpec, translateEnvelopeFields } from "./generate";
 import { moderateSpec, contentHash } from "./moderation";
 
 // Single union index of live AI game ids across all slots (unchanged key so
@@ -230,11 +230,59 @@ export async function runPipeline(
 
   // 5) Shape envelope + validate envelope too
   const id = `ai-${Math.floor(now / 1000).toString(36)}${slot === "fast" ? "" : slot[0]}`;
+  const plTitle = seed.theme.split(" — ")[0];
+  const plTagline = seed.notes.slice(0, 120);
+  const plDescription = `${seed.theme}. AI-generowane wyzwanie co godzinę. Top 3 graczy dostanie permanentny medal.`;
+
+  // G-35 — translate envelope strings (title/tagline/description) into
+  // the 3 non-pl locales alongside the spec translation. One Haiku
+  // call per lang (parallel); failure falls back to PL canonical so a
+  // translation outage never blocks publish. Skipped entirely when
+  // ANTHROPIC_API_KEY is missing (mock-fallback pipeline path).
+  let titleLocalized: AiGame["titleLocalized"] | undefined;
+  let taglineLocalized: AiGame["taglineLocalized"] | undefined;
+  let descriptionLocalized: AiGame["descriptionLocalized"] | undefined;
+  if (process.env.ANTHROPIC_API_KEY) {
+    try {
+      const plPayload = {
+        title: plTitle,
+        tagline: plTagline,
+        description: plDescription,
+      };
+      const [uk, cs, en] = await Promise.all([
+        translateEnvelopeFields(plPayload, "uk").catch(() => plPayload),
+        translateEnvelopeFields(plPayload, "cs").catch(() => plPayload),
+        translateEnvelopeFields(plPayload, "en").catch(() => plPayload),
+      ]);
+      titleLocalized = { pl: plTitle, uk: uk.title, cs: cs.title, en: en.title };
+      taglineLocalized = {
+        pl: plTagline,
+        uk: uk.tagline,
+        cs: cs.tagline,
+        en: en.tagline,
+      };
+      descriptionLocalized = {
+        pl: plDescription,
+        uk: uk.description,
+        cs: cs.description,
+        en: en.description,
+      };
+    } catch (e) {
+      console.warn(
+        "[publish] envelope translation failed, falling back to PL",
+        (e as Error).message,
+      );
+    }
+  }
+
   const game: AiGame = {
     id,
-    title: seed.theme.split(" — ")[0],
-    tagline: seed.notes.slice(0, 120),
-    description: `${seed.theme}. AI-generowane wyzwanie co godzinę. Top 3 graczy dostanie permanentny medal.`,
+    title: plTitle,
+    tagline: plTagline,
+    description: plDescription,
+    titleLocalized,
+    taglineLocalized,
+    descriptionLocalized,
     theme: seed.theme,
     source: seed.source,
     buildingName: seed.buildingName,