Round 6: German localization (en + de)

Backend (backend-i18n teammate):
- Game.language: Literal["en","de"] = "en"; default keeps old snapshots loadable.
- language_directive(lang) appended to every call_structured user message;
system prefix stays byte-identical so the prompt cache stays warm.
- use_game_language() context manager + ContextVar; loop.py + orchestrator
pin language across all entry points; ThreadPoolExecutor in
run_deliberations now propagates context (fixes a latent issue for
per-game model selection too).
- CLI: wargame new --language en|de; wargame state shows the language.
- API: NewGameRequest.language + StateResponse.language.
- _delta_summary, _metrics_table, _recent_events placeholders localized
via _t(en, de) helper.
- 13 new tests including a system-prompt-byte-identical-across-languages
invariant that protects the cache.

Frontend (frontend-i18n teammate):
- New frontend/src/i18n/ module — ~95-line shim with useI18n() hook,
setLanguage, getLanguage, {name} interpolation, English fallback,
localStorage persistence. No new deps (no i18next).
- 329 keys in en.ts (source of truth) + de.ts (full parity).
- Every visible string across NewGame, GameView, SetupCase, Debrief,
GamesList, Shell, LiveProgress extracted; LiveProgress step labels
mapped from English phase event labels per the contract.
- Inline EN | Deutsch picker on NewGame; subtle EN | DE toggle in
Shell top-right for the global preference.
- GameView and Debrief follow state.language on mount.

301 tests pass (288 baseline + 13 new). Frontend npm run build green
(414 KB JS gzip 123 KB).

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

frontend/README.md

@@ -79,6 +79,16 @@ npm run preview  # serve dist on :4173
 npm run lint     # tsc --noEmit
 ```
 
+## i18n smoke test (Round 6)
+
+Strings live in `src/i18n/en.ts` (source of truth) and `src/i18n/de.ts`. Switch
+languages via the `EN | DE` toggle in the top-right of the app shell, or via the
+inline pills on the New Case screen (which also pin the language for the new
+game). Manual smoke check: open `/new`, switch to **Deutsch** — the page copy
+flips to German; switch back — it returns to English. Missing keys fall back to
+the English string at runtime, so untranslated UI is the visible regression
+signal.
+
 ## SSE smoke test (Round 5b)
 
 `scripts/sse-smoke.mjs` connects to `/games/<id>/stream` and prints each

frontend/src/App.tsx

@@ -5,6 +5,7 @@ import { NewGame } from './screens/NewGame';
 import { SetupCase } from './screens/SetupCase';
 import { GameView } from './screens/GameView';
 import { Debrief } from './screens/Debrief';
+import { useI18n } from './i18n';
 
 type Route =
   | { name: 'list' }
@@ -32,6 +33,7 @@ export function navigate(to: string) {
 export function App() {
   const [route, setRoute] = useState<Route>(parseHash);
   const [gameMeta, setGameMeta] = useState<{ id: string; turn: number; max: number; recon_remaining: number } | null>(null);
+  const { t } = useI18n();
   useEffect(() => {
     const h = () => setRoute(parseHash());
     window.addEventListener('hashchange', h);
@@ -52,8 +54,8 @@ export function App() {
         {route.name === 'debrief' && <Debrief id={route.id} onMeta={setGameMeta} />}
       </main>
       <footer className="nh-footer">
-        <span>Norhard · War — Board Console</span>
-        <span className="mono">MVP frontend</span>
+        <span>{t('shell.footer.tagline')}</span>
+        <span className="mono">{t('shell.footer.build')}</span>
       </footer>
     </>
   );

frontend/src/api.ts

@@ -24,12 +24,15 @@ export const api = {
     scenario_id: string,
     model?: string,
     role_model_overrides?: Record<string, string>,
+    language?: 'en' | 'de',
   ) => {
     const body: Record<string, unknown> = { scenario_id };
     if (model) body.model = model;
     if (role_model_overrides && Object.keys(role_model_overrides).length > 0) {
       body.role_model_overrides = role_model_overrides;
     }
+    // ---- i18n (round 6) ----
+    if (language) body.language = language;
     return req<{ game_id: string; turn: number; briefing: Briefing }>(`/games`, {
       method: 'POST',
       body: JSON.stringify(body),
@@ -168,7 +171,7 @@ export interface ReconResponseEnvelope { game_id: string; recon_budget_remaining
 export interface AdvanceResponse { game_id: string; status: string; turn_resolved: number; next_turn?: number; briefing?: Briefing }
 export interface DebriefResponse { game_id: string; status: string; markdown: string }
 export interface MetricsTimelineResponse { game_id: string; points: { turn: number; metrics: { key: string; label: string; unit: string; value: number; delta: number }[] }[] }
-export interface StateResponse { id: string; scenario_id: string; status: string; world: any; recon_budget_remaining: number; current_phase: string; turns: any[] }
+export interface StateResponse { id: string; scenario_id: string; status: string; world: any; recon_budget_remaining: number; current_phase: string; turns: any[]; language?: 'en' | 'de' }
 export interface SetupMessage { role: 'user' | 'setup_agent'; content: string; at: string }
 export interface SetupSession {
   session_id: string;

frontend/src/components/LiveProgress.tsx

@@ -1,6 +1,7 @@
 import { useEffect, useRef, useState } from 'react';
 import { api, PhaseEvent, VerdictOutcome } from '../api';
 import { Spinner } from './Shell';
+import { useI18n, type StringKey } from '../i18n';
 
 // ---------------------------------------------------------------------------
 // LiveProgress — SSE-driven in-turn UX. Mounts an EventSource on the game's
@@ -13,20 +14,21 @@ type StepState = 'idle' | 'running' | 'done' | 'failed';
 
 interface Step {
   key: string;
-  label: string;
+  // i18n key for the step label.
+  labelKey: StringKey;
   // Backend `phase_started`/`phase_completed` `label` values that map to
   // this rail step. Match is case-insensitive substring.
   match: string[];
 }
 
 const STEPS: Step[] = [
-  { key: 'deliberation', label: 'Deliberation', match: ['deliberation'] },
-  { key: 'critic', label: 'Critic', match: ['critic'] },
-  { key: 'premortem', label: 'Pre-mortem', match: ['premortem', 'pre-mortem'] },
-  { key: 'adjudication', label: 'Adjudication', match: ['adjudication'] },
-  { key: 'evaluator', label: 'Evaluator', match: ['evaluator'] },
-  { key: 'world_update', label: 'World update', match: ['world_update', 'world update'] },
-  { key: 'next_briefing', label: 'Next briefing', match: ['briefing'] },
+  { key: 'deliberation', labelKey: 'liveProgress.steps.deliberation', match: ['deliberation'] },
+  { key: 'critic', labelKey: 'liveProgress.steps.critic', match: ['critic'] },
+  { key: 'premortem', labelKey: 'liveProgress.steps.premortem', match: ['premortem', 'pre-mortem'] },
+  { key: 'adjudication', labelKey: 'liveProgress.steps.adjudication', match: ['adjudication'] },
+  { key: 'evaluator', labelKey: 'liveProgress.steps.evaluator', match: ['evaluator'] },
+  { key: 'world_update', labelKey: 'liveProgress.steps.worldUpdate', match: ['world_update', 'world update'] },
+  { key: 'next_briefing', labelKey: 'liveProgress.steps.nextBriefing', match: ['briefing'] },
 ];
 
 interface DeliberationRow {
@@ -53,6 +55,7 @@ interface Props {
 export function LiveProgress({
   gameId, onPaused, onBriefingReady, onAdvanceComplete,
 }: Props) {
+  const { t } = useI18n();
   // Phase rail state — keyed by Step.key.
   const [stepStates, setStepStates] = useState<Record<string, StepState>>(
     () => Object.fromEntries(STEPS.map((s) => [s.key, 'idle'])),
@@ -185,7 +188,7 @@ export function LiveProgress({
         setPausedAt(null);
         return;
       case 'error':
-        setStreamErr(ev.label || 'Engine reported an error.');
+        setStreamErr(ev.label || t('liveProgress.engineErr.fallback'));
         return;
       default:
         return;
@@ -225,7 +228,7 @@ export function LiveProgress({
         if (cancelled) return;
         failedReconnectsRef.current += 1;
         if (failedReconnectsRef.current >= 2) {
-          setStreamErr('Live stream disconnected — refresh to reconnect.');
+          setStreamErr(t('liveProgress.streamErr.disconnected'));
           es.close();
           sseRef.current = null;
           // Schedule a single retry after ~2 s. Browser handles intermediate
@@ -263,22 +266,22 @@ export function LiveProgress({
     <section className="nh-live">
       <div className="nh-live__hd">
         <div>
-          <span className="eyebrow">Live · turn in flight</span>
+          <span className="eyebrow">{t('liveProgress.eyebrow')}</span>
           <h3 className="nh-serif-h" style={{ margin: '4px 0 0' }}>
             {pausedAt
-              ? `Paused — ${pausedAt}`
-              : 'Tracking deliberations and verdicts in real time.'}
+              ? t('liveProgress.titlePaused', { label: pausedAt })
+              : t('liveProgress.titleDefault')}
           </h3>
         </div>
-        <div className="nh-live__cost mono" aria-label="cumulative cost">
-          ${cost.toFixed(4)} <span className="fg-3">spent</span>
+        <div className="nh-live__cost mono" aria-label={t('liveProgress.cost.aria')}>
+          ${cost.toFixed(4)} <span className="fg-3">{t('liveProgress.cost.suffix')}</span>
         </div>
       </div>
 
       {pausedAt && (
         <div className="nh-live__paused">
-          <span className="eyebrow">Paused</span>
-          <span className="fg-2">Paused at end of {pausedAt}. Resume to continue.</span>
+          <span className="eyebrow">{t('liveProgress.paused.eyebrow')}</span>
+          <span className="fg-2">{t('liveProgress.paused.body', { label: pausedAt })}</span>
         </div>
       )}
 
@@ -286,13 +289,13 @@ export function LiveProgress({
         <div className="nh-live__err mono">{streamErr}</div>
       )}
 
-      <ol className="nh-live__rail" aria-label="phase progress">
+      <ol className="nh-live__rail" aria-label={t('liveProgress.rail.aria')}>
         {STEPS.map((s) => {
           const st = stepStates[s.key];
           return (
             <li key={s.key} className={`nh-live__pill ${st}`}>
               <span className="dot" aria-hidden />
-              <span className="t">{s.label}</span>
+              <span className="t">{t(s.labelKey)}</span>
               <span className="st mono">
                 {st === 'idle' && '—'}
                 {st === 'running' && <Spinner />}
@@ -306,12 +309,12 @@ export function LiveProgress({
 
       <div className="nh-live__grid">
         <div className="nh-live__panel">
-          <span className="eyebrow">Deliberations</span>
+          <span className="eyebrow">{t('liveProgress.deliberations')}</span>
           {deliberations.length === 0 ? (
             <p className="fg-3 body-sm" style={{ marginTop: 8 }}>
               {stepStates.deliberation === 'running'
-                ? <><Spinner /> Agents thinking…</>
-                : 'No agent deliberations yet.'}
+                ? <><Spinner /> {t('liveProgress.deliberations.thinking')}</>
+                : t('liveProgress.deliberations.empty')}
             </p>
           ) : (
             <ul className="nh-live__delibs">
@@ -319,10 +322,14 @@ export function LiveProgress({
                 <li key={d.id}>
                   <div className="who mono">{d.label}</div>
                   {d.expects && (
-                    <div className="ex"><span className="k mono">expects</span> {d.expects}</div>
+                    <div className="ex">
+                      <span className="k mono">{t('liveProgress.deliberations.expects')}</span> {d.expects}
+                    </div>
                   )}
                   {d.fears && (
-                    <div className="fe"><span className="k mono">fears</span> {d.fears}</div>
+                    <div className="fe">
+                      <span className="k mono">{t('liveProgress.deliberations.fears')}</span> {d.fears}
+                    </div>
                   )}
                 </li>
               ))}
@@ -331,10 +338,10 @@ export function LiveProgress({
         </div>
 
         <div className="nh-live__panel">
-          <span className="eyebrow">Verdicts</span>
+          <span className="eyebrow">{t('liveProgress.verdicts')}</span>
           {verdicts.length === 0 ? (
             <p className="fg-3 body-sm" style={{ marginTop: 8 }}>
-              No verdicts adjudicated yet this turn.
+              {t('liveProgress.verdicts.empty')}
             </p>
           ) : (
             <ul className="nh-live__verdicts">
@@ -342,9 +349,9 @@ export function LiveProgress({
                 <li key={v.id} className={`nh-live__verdict outcome-${outcomeToClass(v.outcome)}`}>
                   <div className="hd">
                     <span className="actor mono">{v.actor}</span>
-                    <span className="pl mono">P{v.plausibility}</span>
+                    <span className="pl mono">{t('liveProgress.verdict.plausibility', { n: v.plausibility })}</span>
                   </div>
-                  <div className="oc mono">{outcomeLabel(v.outcome)}</div>
+                  <div className="oc mono">{outcomeLabel(v.outcome, t)}</div>
                 </li>
               ))}
             </ul>
@@ -365,12 +372,15 @@ function outcomeToClass(o: VerdictOutcome): string {
   }
 }
 
-function outcomeLabel(o: VerdictOutcome): string {
+function outcomeLabel(
+  o: VerdictOutcome,
+  t: (k: StringKey, vars?: Record<string, string | number>) => string,
+): string {
   switch (o) {
-    case 'effect_major': return 'effect · major';
-    case 'effect_minor': return 'effect · minor';
-    case 'no_effect':    return 'no effect';
-    case 'backfires':    return 'backfires';
+    case 'effect_major': return t('liveProgress.verdict.outcome.major');
+    case 'effect_minor': return t('liveProgress.verdict.outcome.minor');
+    case 'no_effect':    return t('liveProgress.verdict.outcome.noEffect');
+    case 'backfires':    return t('liveProgress.verdict.outcome.backfires');
     default:             return o;
   }
 }

frontend/src/components/Shell.tsx

@@ -1,4 +1,5 @@
 import { ReactNode } from 'react';
+import { useI18n, type Language } from '../i18n';
 
 // Shell components ported from components/Shell.jsx — class names preserved
 // so the paper/ink/oxblood Board Console look is identical.
@@ -9,46 +10,124 @@ export function TopBar(props: {
   onNav: (r: string) => void;
 }) {
   const { game, route, onNav } = props;
+  const { t, lang, setLang } = useI18n();
   return (
     <header className="nh-topbar">
       <div className="nh-topbar__l">
         <button className="nh-brand" onClick={() => onNav('list')}>
-          Norhard<em>/</em>War<span className="nh-brand__tag">Board Console</span>
+          Norhard<em>/</em>War<span className="nh-brand__tag">{t('shell.brand.tag')}</span>
         </button>
         <nav className="nh-nav">
-          <button className={route === 'list' ? 'on' : ''} onClick={() => onNav('list')}>Cases</button>
-          <button className={route === 'new' ? 'on' : ''} onClick={() => onNav('new')}>New case</button>
+          <button className={route === 'list' ? 'on' : ''} onClick={() => onNav('list')}>
+            {t('shell.nav.cases')}
+          </button>
+          <button className={route === 'new' ? 'on' : ''} onClick={() => onNav('new')}>
+            {t('shell.nav.newCase')}
+          </button>
         </nav>
       </div>
-      {game && (
-        <div className="nh-status">
-          <span>Case <b className="mono">{game.id.slice(0, 4)}…{game.id.slice(-4)}</b></span>
-          <span className="nh-sep"></span>
-          <span>Turn <b>{game.turn} / {game.max}</b></span>
-          <span className="nh-sep"></span>
-          <span>Recon <b>{game.recon_remaining} / 3</b></span>
-        </div>
-      )}
+      <div className="nh-topbar__r" style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
+        {game && (
+          <div className="nh-status">
+            <span>{t('shell.status.case')} <b className="mono">{game.id.slice(0, 4)}…{game.id.slice(-4)}</b></span>
+            <span className="nh-sep"></span>
+            <span>{t('shell.status.turn')} <b>{game.turn} / {game.max}</b></span>
+            <span className="nh-sep"></span>
+            <span>{t('shell.status.recon')} <b>{game.recon_remaining} / 3</b></span>
+          </div>
+        )}
+        <LangToggle lang={lang} setLang={setLang} ariaLabel={t('shell.lang.toggle.aria')} />
+      </div>
     </header>
   );
 }
 
-const PHASES = [
-  { n: '01', t: 'Briefing' },
-  { n: '02', t: 'Recon' },
-  { n: '03', t: 'Action' },
-  { n: '04', t: 'Deliberation' },
-  { n: '05', t: 'Adjudication' },
+function LangToggle({
+  lang, setLang, ariaLabel,
+}: {
+  lang: Language;
+  setLang: (l: Language) => void;
+  ariaLabel: string;
+}) {
+  return (
+    <div
+      role="group"
+      aria-label={ariaLabel}
+      className="nh-lang"
+      style={{
+        display: 'inline-flex',
+        gap: 2,
+        fontFamily: 'var(--font-mono)',
+        fontSize: 11,
+        textTransform: 'uppercase',
+        letterSpacing: '0.06em',
+      }}
+    >
+      <button
+        type="button"
+        onClick={() => setLang('en')}
+        aria-pressed={lang === 'en'}
+        style={{
+          background: 'transparent',
+          border: 0,
+          padding: '4px 6px',
+          cursor: 'pointer',
+          color: lang === 'en' ? 'var(--ink)' : 'var(--slate)',
+          fontWeight: lang === 'en' ? 700 : 400,
+          textDecoration: lang === 'en' ? 'underline' : 'none',
+          textUnderlineOffset: 3,
+          fontFamily: 'inherit',
+          fontSize: 'inherit',
+          letterSpacing: 'inherit',
+          textTransform: 'inherit',
+        }}
+      >
+        EN
+      </button>
+      <span style={{ color: 'var(--slate)' }}>|</span>
+      <button
+        type="button"
+        onClick={() => setLang('de')}
+        aria-pressed={lang === 'de'}
+        style={{
+          background: 'transparent',
+          border: 0,
+          padding: '4px 6px',
+          cursor: 'pointer',
+          color: lang === 'de' ? 'var(--ink)' : 'var(--slate)',
+          fontWeight: lang === 'de' ? 700 : 400,
+          textDecoration: lang === 'de' ? 'underline' : 'none',
+          textUnderlineOffset: 3,
+          fontFamily: 'inherit',
+          fontSize: 'inherit',
+          letterSpacing: 'inherit',
+          textTransform: 'inherit',
+        }}
+      >
+        DE
+      </button>
+    </div>
+  );
+}
+
+const PHASES: { n: string; key: 'briefing' | 'recon' | 'action' | 'deliberation' | 'adjudication' }[] = [
+  { n: '01', key: 'briefing' },
+  { n: '02', key: 'recon' },
+  { n: '03', key: 'action' },
+  { n: '04', key: 'deliberation' },
+  { n: '05', key: 'adjudication' },
 ];
 
 export function PhaseRail({ current }: { current: 'briefing' | 'recon' | 'action' | 'deliberation' | 'adjudication' }) {
+  const { t } = useI18n();
   const order = ['briefing', 'recon', 'action', 'deliberation', 'adjudication'];
   const idx = order.indexOf(current);
   return (
     <div className="nh-rail">
       {PHASES.map((p, i) => (
         <div key={p.n} className={`nh-rail__p ${i < idx ? 'done' : ''} ${i === idx ? 'active' : ''}`}>
-          <span className="n mono">{p.n}</span><span className="t">{p.t}</span>
+          <span className="n mono">{p.n}</span>
+          <span className="t">{t(`phaseRail.${p.key}` as const)}</span>
         </div>
       ))}
     </div>
@@ -60,9 +139,10 @@ export function Dossier(props: {
   className?: string; fog?: boolean; inverse?: boolean;
 }) {
   const { tag, title, children, footnote, className = '', fog = false, inverse = false } = props;
+  const { t } = useI18n();
   return (
     <article className={`nh-dossier ${fog ? 'fog' : ''} ${inverse ? 'inverse' : ''} ${className}`}>
-      {fog && <span className="nh-dossier__fog">Fog of war</span>}
+      {fog && <span className="nh-dossier__fog">{t('shell.dossier.fog')}</span>}
       {tag && <span className="nh-dossier__tag">{tag}</span>}
       {title && <h3 className="nh-dossier__h">{title}</h3>}
       {children}

frontend/src/i18n/de.ts

@@ -0,0 +1,373 @@
+// German translations. Must cover every key in en.ts. Missing keys fall back
+// to English at runtime — the visible English string is the regression signal.
+
+import type { StringKey } from './en';
+
+export const de: Partial<Record<StringKey, string>> = {
+  // ---- Top bar / Shell ----
+  "shell.brand.tag": "Gefechtsstand",
+  "shell.dossier.fog": "Nebel des Krieges",
+  "shell.nav.cases": "Fälle",
+  "shell.nav.newCase": "Neuer Fall",
+  "shell.status.case": "Fall",
+  "shell.status.turn": "Runde",
+  "shell.status.recon": "Aufklärung",
+  "shell.lang.toggle.aria": "Sprache wechseln",
+  "shell.footer.tagline": "Norhard · War — Gefechtsstand",
+  "shell.footer.build": "MVP-Frontend",
+
+  // ---- Phase rail ----
+  "phaseRail.briefing": "Briefing",
+  "phaseRail.recon": "Aufklärung",
+  "phaseRail.action": "Aktion",
+  "phaseRail.deliberation": "Beratung",
+  "phaseRail.adjudication": "Urteil",
+
+  // ---- GamesList ----
+  "gamesList.eyebrow.lead": "Fälle",
+  "gamesList.eyebrow.note": "aktiv & abgeschlossen",
+  "gamesList.title": "Jeder durchgespielte Fall, mit Belegen.",
+  "gamesList.dek": "Öffnen Sie einen aktiven Fall, um die Beratung fortzusetzen, oder lesen Sie einen abgeschlossenen Debrief mit Urteilskette und Postmortem.",
+  "gamesList.docket": "Akten",
+  "gamesList.newCase": "+ Neuer Fall",
+  "gamesList.loading": "Fälle werden geladen…",
+  "gamesList.empty.lead": "Noch keine Fälle.",
+  "gamesList.empty.cta": "Neuen Fall öffnen",
+  "gamesList.empty.tail": "und Briefing für Runde 1 generieren.",
+  "gamesList.col.case": "Fall",
+  "gamesList.col.scenario": "Szenario",
+  "gamesList.col.turn": "Runde",
+  "gamesList.col.status": "Status",
+  "gamesList.col.model": "Modell",
+  "gamesList.col.updated": "Geändert",
+  "gamesList.scenario.summary": "{industry} · vs {rival}",
+  "gamesList.status.active": "aktiv",
+  "gamesList.status.complete": "abgeschlossen",
+
+  // ---- NewGame ----
+  "newGame.eyebrow.label": "Neuer Fall",
+  "newGame.eyebrow.note": "Szenario auswählen",
+  "newGame.title": "Wählen Sie ein Dossier. Wir generieren Runde 1 von Grund auf.",
+  "newGame.dek": "Jedes Szenario liefert ein Rivalen-Drehbuch, eine Vorstandsagenda, einen Beraterstab und ein Briefing mit Nebel des Krieges. Generierung dauert ca. dreißig Sekunden.",
+  "newGame.designOwn.eyebrow": "Oder selbst entwerfen",
+  "newGame.designOwn.title": "Neuen Fall mit dem Setup-Agenten aufbauen",
+  "newGame.designOwn.dek": "Schildern Sie Ihre Lage; der Agent stellt Rückfragen und erstellt ein neues Szenario — Welt-Kompendium, Beraterstab, verdeckte Agenden.",
+  "newGame.designOwn.cta": "Setup-Agent starten →",
+  "newGame.scenarios.loading": "Szenarien werden geladen…",
+  "newGame.scenario.role": "Rolle",
+  "newGame.scenario.agentCount": "{count} Berater am Vorstandstisch.",
+  "newGame.scenario.footnote": "Fünf Runden · Briefings im Nebel des Krieges · juriergte Ergebnisse",
+  "newGame.scenario.vs": "vs {rival}",
+  "newGame.ready.eyebrow": "Bereit",
+  "newGame.ready.openCompany": "{company} öffnen",
+  "newGame.ready.pick": "Szenario oben auswählen",
+  "newGame.ready.engineWith": "Engine ·",
+  "newGame.ready.engineTail": "· generiert Briefing · ~30s · Runde 1 von 5.",
+  "newGame.ready.modelOnly": "Modell generiert Briefing · ~30s · Runde 1 von 5.",
+  "newGame.ready.openCta": "Fall öffnen →",
+  "newGame.ready.busy": "Briefing wird generiert…",
+  "newGame.lang.eyebrow": "Sprache",
+  "newGame.lang.helper": "Briefing, Debrief und Stimmen der Berater folgen dieser Wahl.",
+  "newGame.lang.en": "English",
+  "newGame.lang.de": "Deutsch",
+
+  // ---- NewGame · per-role overrides ----
+  "newGame.roleOverrides.eyebrow": "Modell-Routing pro Rolle",
+  "newGame.roleOverrides.allDefault": "Alle Rollen nutzen den Spiel-Standard",
+  "newGame.roleOverrides.someRouted": "{count} Rolle auf anderes Modell umgeleitet",
+  "newGame.roleOverrides.someRouted.plural": "{count} Rollen auf andere Modelle umgeleitet",
+  "newGame.roleOverrides.hide": "Verbergen ↑",
+  "newGame.roleOverrides.configure": "Konfigurieren ↓",
+  "newGame.roleOverrides.intro.lead": "Jede Rolle kann an ein bestimmtes Modell gebunden werden — auf Standard belassen, um zu nutzen",
+  "newGame.roleOverrides.intro.tail": "Praktisch, um günstige Planung an kleine Modelle zu geben und das Flaggschiff für die Adjudikation zu reservieren.",
+  "newGame.roleOverrides.serverDefault": "(Server-Standard)",
+  "newGame.roleOverrides.useDefault": "(Spiel-Standard nutzen)",
+  "newGame.roleOverrides.reset": "Auf Standard zurücksetzen",
+  "newGame.roleOverrides.role.control": "Briefings, Adjudikation, Welt-Updates",
+  "newGame.roleOverrides.role.agent": "Beraterstimmen am Tisch",
+  "newGame.roleOverrides.role.rival": "Planer der Rivalen-CEO",
+  "newGame.roleOverrides.role.critic": "Kritiker-Agent",
+  "newGame.roleOverrides.role.premortem": "Pre-Mortem-Agent",
+  "newGame.roleOverrides.role.evaluator": "Unabhängiger Bewerter",
+
+  // ---- GameView · hero ----
+  "gameView.eyebrow.execBriefing": "Runde {turn} — Vorstands-Briefing",
+  "gameView.eyebrow.case": "Fall",
+  "gameView.status.paused": "Pausiert — bereit zum Fortsetzen",
+  "gameView.status.action": "Aktionsphase offen",
+  "gameView.status.recon": "Aufklärungsphase",
+  "gameView.status.actionSubmitted": "Aktion eingereicht — bereit zum Vorrücken",
+  "gameView.status.deliberating": "Berater beraten",
+  "gameView.status.adjudicating": "Wird juriert",
+  "gameView.byline.lead": "Eingereicht von Control · Nebel-Abschnitte unten · Aufklärungsbudget {budget} / 3",
+  "gameView.byline.engine": "Engine",
+  "gameView.errorTitle": "Fall konnte nicht geladen werden",
+  "gameView.errorTag": "Fehler",
+  "gameView.retry": "Erneut versuchen",
+  "gameView.loading": "Briefing wird geladen…",
+  "gameView.fog.label": "Nebel des Krieges · unbestätigt",
+
+  // ---- GameView · sections ----
+  "gameView.section.tag": "Abschnitt · {heading}",
+  "gameView.decisions.tag": "Entscheidungspunkte · Runde {turn}",
+  "gameView.decisions.title": "{count} Züge stehen zur Wahl. Wählen Sie einen, um zu komponieren.",
+  "gameView.decisions.compose": "Komponieren →",
+
+  // ---- GameView · recon panel ----
+  "gameView.recon.tag": "Aufklärungs-Queue",
+  "gameView.recon.title": "Budget {budget} von 3 in dieser Runde.",
+  "gameView.recon.empty": "Noch keine Anfragen verbraucht. Jede Anfrage offenbart das Thema dem Rivalen in zwei Runden.",
+  "gameView.recon.resolved": "Gelöst · {who}",
+  "gameView.recon.reveals": " · wird dem Rivalen offenbart",
+  "gameView.recon.askLabel": "Anderen Berater befragen",
+  "gameView.recon.placeholder": "Eine knappe Frage…",
+  "gameView.recon.cost": "Jede Anfrage kostet 1 / 3.",
+  "gameView.recon.spend": "Anfrage senden →",
+  "gameView.recon.asking": "Anfrage läuft…",
+  "gameView.recon.exhausted": "Aufklärungsbudget aufgebraucht. Aktion einreichen und vorrücken.",
+
+  // ---- GameView · agents panel ----
+  "gameView.agents.tag": "Beraterstab",
+  "gameView.agents.title": "Stimmen am Tisch",
+  "gameView.agents.kind.advisor": "Berater",
+  "gameView.agents.kind.rival": "Rivale",
+
+  // ---- GameView · composer ----
+  "gameView.composer.title": "Ihr Zug, Runde {turn}",
+  "gameView.composer.submitted": "Eingereicht",
+  "gameView.composer.tab.coach": "Mit Coach sprechen",
+  "gameView.composer.tab.manual": "Manuell",
+  "gameView.composer.afterSubmit": "Aktion für Runde {turn} eingereicht. Vorrücken, sobald Sie bereit sind — das Modell schreibt Urteile gegen Ihren Beraterstab und das Rivalen-Drehbuch. Dauert 2–5 Minuten.",
+  "gameView.composer.advanceWarning": "Vorrücken ist unwiderruflich. Stellen Sie sicher, dass Ihre Anker vollständig sind.",
+  "gameView.composer.resume": "Runde fortsetzen →",
+  "gameView.composer.resuming": "Wird fortgesetzt…",
+  "gameView.composer.advance": "Runde vorrücken →",
+  "gameView.composer.resolving": "Runde wird aufgelöst…",
+  "gameView.composer.pause": "Pause",
+  "gameView.composer.pausing": "Pausiert…",
+  "gameView.composer.pause.title": "Beim nächsten Phasen-Checkpoint anhalten",
+
+  // ---- GameView · manual form ----
+  "gameView.form.intent.label": "Absicht",
+  "gameView.form.intent.placeholder": "z. B. Helvetia bei 14 % effektiv binden, bevor Aergis ein LoI unterzeichnet.",
+  "gameView.form.why.label": "Warum jetzt",
+  "gameView.form.why.placeholder": "Die strategische Begründung. Was ändert sich, wenn Sie handeln statt eine Runde zu warten.",
+  "gameView.form.charCount": "{count} / {max}",
+  "gameView.form.anchors.legend": "Anker · jede Aktion muss drei zitieren",
+  "gameView.form.anchors.count": "{filled} / 3",
+  "gameView.form.anchors.add": "+ Vierten Anker hinzufügen (optional)",
+  "gameView.form.anchors.remove": "entfernen",
+  "gameView.form.anchors.priorAnalogue": "Frühere Analogie",
+  "gameView.form.anchors.statedCapability": "Erklärte Fähigkeit",
+  "gameView.form.anchors.resourceCommitted": "Verbindlich zugesagte Ressource",
+  "gameView.form.anchors.hint.priorAnalogue": "Ein früherer Fall — Ihrer oder eines anderen — bei dem dies funktioniert hat.",
+  "gameView.form.anchors.hint.statedCapability": "Eine Fähigkeit, die Sie bereits dokumentiert haben.",
+  "gameView.form.anchors.hint.resourceCommitted": "Konkretes Geld, Personal oder Zeit, das Sie hinterlegen.",
+  "gameView.form.anchors.placeholder.priorAnalogue": "z. B. Helvetia-Verlängerung 2022 — 16 % effektiv, 3-Jahres-Auto-Renewal",
+  "gameView.form.anchors.placeholder.statedCapability": "z. B. Horizont-X COP 3,4 nach UNI 11300 validiert (Juni 2024)",
+  "gameView.form.anchors.placeholder.resourceCommitted": "z. B. €500k/Quartal Pönalebudget, von Lange unterzeichnet",
+  "gameView.form.submit.violationsBlock": "Verstöße oben beheben, um die Einreichung freizuschalten.",
+  "gameView.form.submit.preflight": "Wird gegen harte Bedingungen geprüft…",
+  "gameView.form.submit.helper": "Einreichen sperrt Ihren Zug für Runde {turn}. Danach vorrücken.",
+  "gameView.form.submit.cta": "Aktion einreichen →",
+  "gameView.form.submit.checking": "Prüfung läuft…",
+  "gameView.form.submit.submitting": "Wird eingereicht…",
+
+  // ---- GameView · hard constraints ----
+  "gameView.constraints.eyebrow": "Harte Bedingungen",
+  "gameView.constraints.empty": "Keine Bedingungen für dieses Spiel deklariert",
+  "gameView.constraints.summary": "{hard} hart · bei Einreichung erzwungen",
+  "gameView.constraints.summaryWithSoft": "{hard} hart · {soft} weich · bei Einreichung erzwungen",
+  "gameView.constraints.show": "Anzeigen ↓",
+  "gameView.constraints.hide": "Verbergen ↑",
+  "gameView.constraints.emptyHint": "Keine harten Bedingungen aktiv. Fügen Sie unten eine hinzu, oder laden Sie beim Setup Quelldokumente hoch und lassen Sie den Setup-Agenten sie automatisch extrahieren.",
+  "gameView.constraints.add.cta": "+ Bedingung hinzufügen",
+  "gameView.constraints.footnote": "Harte Bedingungen blockieren bei Einreichung jede Aktion, die sie verletzt.",
+  "gameView.constraints.draft.description": "Beschreibung",
+  "gameView.constraints.draft.descriptionPlaceholder": "z. B. Der Helvetia-MSA verbietet Preiserhöhungen über 4 % p. a. ohne 90-Tage-Frist.",
+  "gameView.constraints.draft.rationale": "Begründung",
+  "gameView.constraints.draft.rationalePlaceholder": "z. B. Bruch löst eine Pönale-Klausel von €12 Mio. und ein öffentliches Schiedsverfahren aus.",
+  "gameView.constraints.draft.testQuestion": "Prüffrage",
+  "gameView.constraints.draft.testQuestionPlaceholder": "z. B. \"Erhöht diese Aktion die Preise im Helvetia-Vertrag um mehr als 4 % ohne 90-Tage-Frist?\"",
+  "gameView.constraints.draft.severity": "Schweregrad",
+  "gameView.constraints.draft.severity.hard": "Hart - blockiert jede verletzende Aktion",
+  "gameView.constraints.draft.severity.soft": "Weich - markieren, aber zulassen",
+  "gameView.constraints.draft.cancel": "Abbrechen",
+  "gameView.constraints.draft.add": "Bedingung hinzufügen →",
+  "gameView.constraints.draft.adding": "Wird hinzugefügt…",
+  "gameView.constraints.row.removeTitle": "Bedingung entfernen",
+  "gameView.constraints.row.remove": "entfernen",
+  "gameView.constraints.row.expand": "Klicken zum Ausklappen",
+  "gameView.constraints.row.collapse": "Klicken zum Einklappen",
+  "gameView.constraints.row.rationale": "Begründung",
+  "gameView.constraints.row.testQuestion": "Prüffrage",
+  "gameView.constraints.row.sourceRef": "Quellverweis",
+  "gameView.constraints.delete.confirm.scenario": "Diese Bedingung stammt aus der Szenariodatei.\n\nDas Entfernen umgeht eine ausdrücklich autorisierte Wissensbasis. Fortfahren?",
+  "gameView.constraints.delete.confirm.document": "Diese Bedingung stammt aus einem hochgeladenen Dokument.\n\nDas Entfernen umgeht eine ausdrücklich autorisierte Wissensbasis. Fortfahren?",
+  "gameView.violations.eyebrow": "Verstoß gegen harte Bedingung · Aktion blockiert",
+  "gameView.violations.dismiss": "schließen",
+  "gameView.violations.tail": "Aktion oben überarbeiten — der nächste Versuch wird neu geprüft.",
+  "gameView.violations.coachBlocked": "Aktion durch harte Bedingungen blockiert — siehe Panel über dem Composer.",
+
+  // ---- GameView · coach ----
+  "gameView.coach.intro": "Schildern Sie Ihren Zug in normaler Prosa. Der Coach entwirft eine strukturierte Aktion mit drei Ankern — der Matrix-Game-Schiedsrichter bewertet die Plausibilität daran, also zählt Spezifität. Bei einem unklaren Anker stellt der Coach eine fokussierte Rückfrage. Maximal zwei Runden.",
+  "gameView.coach.placeholder": "z. B. Aergis zuvorkommen und Helvetia bei 14 % effektiv binden, bevor sie das LoI unterzeichnen. Anker auf der Helvetia-Verlängerung 2022 — wir haben die Horizont-X UNI-11300-Validierung und ein €500k/Quartal-Pönalebudget, von Lange unterzeichnet.",
+  "gameView.coach.charHint": "{count} / 4000 · Strg/Cmd+Enter zum Senden",
+  "gameView.coach.start": "Coach starten →",
+  "gameView.coach.starting": "Entwurf läuft…",
+  "gameView.coach.replyPlaceholder": "Ihre Antwort… (Strg/Cmd+Enter zum Senden)",
+  "gameView.coach.replyHint": "{count} / 4000 · Runde {round} von 2",
+  "gameView.coach.send": "Senden →",
+  "gameView.coach.sending": "Wird gesendet…",
+  "gameView.coach.busy.label": "Coach",
+  "gameView.coach.busy.suffix": "entwirft…",
+  "gameView.coach.draft.eyebrowReady": "Aktionsentwurf · bereit zur Einreichung",
+  "gameView.coach.draft.eyebrowProgress": "Aktionsentwurf · in Arbeit ({rounds}/2 Runden)",
+  "gameView.coach.draft.footnote": "Einreichen sperrt diesen Zug für Runde {turn}.",
+  "gameView.coach.approve.eyebrow": "Zur Einreichung freigeben",
+  "gameView.coach.approve.title": "Entwurf als Aktion für Runde {turn} festschreiben",
+  "gameView.coach.approve.editManual": "Manuell bearbeiten →",
+  "gameView.coach.approve.restart": "Neu starten",
+  "gameView.coach.approve.submit": "Aktion einreichen →",
+  "gameView.coach.approve.submitting": "Wird eingereicht…",
+  "gameView.coach.restart.cta": "Gespräch neu starten",
+  "gameView.coach.draft.intent": "Absicht",
+  "gameView.coach.draft.why": "Warum jetzt",
+  "gameView.coach.draft.anchorsLabel": "Anker · {count} von 3",
+  "gameView.coach.label.user": "Sie",
+  "gameView.coach.label.coach": "Coach",
+
+  // ---- GameView · verdict history ----
+  "gameView.verdicts.title": "Frühere Runden · das Urteil des Schiedsrichters",
+  "gameView.verdicts.turn": "Runde {turn}",
+  "gameView.verdicts.resolved": "{count} Urteile aufgelöst",
+  "gameView.verdicts.actionOnly": "Aktion eingereicht",
+  "gameView.verdicts.fork": "Aus Runde {turn} verzweigen →",
+  "gameView.verdicts.forking": "Wird verzweigt…",
+  "gameView.verdicts.fork.title": "Neuen Fall ab Runde {turn} verzweigen und vorwärts spielen",
+  "gameView.verdicts.playerAction": "Spieleraktion",
+
+  // ---- GameView · orchestrator ----
+  "gameView.orch.eyebrow": "Szenario-Orchestrator · Vor-Spiel-Landschaft",
+  "gameView.orch.title.complete": "Sehen Sie, wie drei CEO-Profile diese Runde spielen würden.",
+  "gameView.orch.title.running": "Drei Profile werden parallel simuliert.",
+  "gameView.orch.title.idle": "Bevor Sie sich festlegen, sehen Sie, wie drei Profile diese Runde spielen.",
+  "gameView.orch.show": "Anzeigen ↓",
+  "gameView.orch.hide": "Verbergen ↑",
+  "gameView.orch.idleDek": "Drei Strategievektoren spielen eine Proxy-Version dieser Runde bei verschiedenen Spielstärken. Sie erhalten einen Vergleich der Ergebnisse, bevor Sie Ihren eigenen Zug festlegen. Dauert 3–5 Minuten.",
+  "gameView.orch.run": "Orchestrator starten →",
+  "gameView.orch.locked": "Orchestrator läuft nur vor der Aktion — aus Runde 1 verzweigen, um neu zu starten.",
+  "gameView.orch.progress": "{done} / {total} Zweige fertig",
+  "gameView.orch.progressDek": "Läuft im Hintergrund. Sie können das Briefing lesen — diese Seite aktualisiert sich live.",
+  "gameView.orch.vector.complete": "✓ fertig",
+  "gameView.orch.vector.running": "⋯ läuft",
+  "gameView.orch.generatingVectors": "Strategievektoren werden generiert…",
+  "gameView.orch.failed": "Orchestrierung fehlgeschlagen: {error}",
+  "gameView.orch.failed.unknown": "unbekannter Fehler",
+  "gameView.orch.retry": "Erneut versuchen →",
+  "gameView.orch.rerun": "Orchestrator neu starten →",
+  "gameView.orch.skipped.eyebrow": "Abgelehnt",
+  "gameView.orch.skipped.fallback": "Anker-Vorprüfung fehlgeschlagen.",
+  "gameView.orch.played": "Gespielt als",
+  "gameView.orch.adopt": "Diesen Auftakt übernehmen →",
+  "gameView.orch.fullSynthesis": "Vollständige Synthese · {chars} Zeichen",
+
+  // ---- LiveProgress ----
+  "liveProgress.eyebrow": "Live · Runde im Lauf",
+  "liveProgress.titleDefault": "Beratungen und Urteile in Echtzeit verfolgen.",
+  "liveProgress.titlePaused": "Pausiert — {label}",
+  "liveProgress.cost.aria": "kumulierte Kosten",
+  "liveProgress.cost.suffix": "verbraucht",
+  "liveProgress.paused.eyebrow": "Pausiert",
+  "liveProgress.paused.body": "Pausiert am Ende von {label}. Fortsetzen, um weiterzumachen.",
+  "liveProgress.streamErr.disconnected": "Live-Stream getrennt — Seite neu laden, um neu zu verbinden.",
+  "liveProgress.engineErr.fallback": "Engine meldete einen Fehler.",
+  "liveProgress.steps.deliberation": "Beratung",
+  "liveProgress.steps.critic": "Kritiker",
+  "liveProgress.steps.premortem": "Pre-Mortem",
+  "liveProgress.steps.adjudication": "Urteil",
+  "liveProgress.steps.evaluator": "Bewerter",
+  "liveProgress.steps.worldUpdate": "Welt-Update",
+  "liveProgress.steps.nextBriefing": "Nächstes Briefing",
+  "liveProgress.rail.aria": "Phasenfortschritt",
+  "liveProgress.deliberations": "Beratungen",
+  "liveProgress.deliberations.thinking": "Berater denken nach…",
+  "liveProgress.deliberations.empty": "Noch keine Beratungen.",
+  "liveProgress.deliberations.expects": "erwartet",
+  "liveProgress.deliberations.fears": "befürchtet",
+  "liveProgress.verdicts": "Urteile",
+  "liveProgress.verdicts.empty": "Noch keine Urteile in dieser Runde.",
+  "liveProgress.verdict.plausibility": "P{n}",
+  "liveProgress.verdict.outcome.major": "Wirkung · stark",
+  "liveProgress.verdict.outcome.minor": "Wirkung · gering",
+  "liveProgress.verdict.outcome.noEffect": "keine Wirkung",
+  "liveProgress.verdict.outcome.backfires": "geht nach hinten los",
+
+  // ---- GameView · advance log ----
+  "gameView.advance.seed": "[{time}] Orchestrator: Beratungen für Runde {turn} werden gesetzt…",
+  "gameView.advance.resolved": "[{time}] ✓ Runde {turn} aufgelöst",
+
+  // ---- SetupCase ----
+  "setup.eyebrow.lead": "Neuer Fall",
+  "setup.eyebrow.tail": "mit dem Setup-Agenten entwerfen",
+  "setup.intro.title": "Schildern Sie die Lage. Der Agent stellt Rückfragen und baut dann das Szenario auf.",
+  "setup.intro.dek": "Schreiben Sie ein bis zwei Absätze über das Unternehmen, den Rivalen oder die Bedrohung, die Risiken und alle Bedingungen, die Sie schon kennen. Der Setup-Agent füllt die Lücken: Beraterstab, Welt-Kompendium, Startmetriken, verdeckte Agenden. Dauert ein paar Q&A-Runden (30–60s pro Runde).",
+  "setup.caseId.label": "Fall-ID",
+  "setup.caseId.charCount": "{count} / 60",
+  "setup.caseId.placeholder": "z. B. nord_heatpump_takeover",
+  "setup.caseId.helper": "Kleinbuchstaben, Ziffern, Unterstriche. Muss mit einem Buchstaben beginnen. 3–60 Zeichen.",
+  "setup.caseId.invalid": "Ungültiges Format.",
+  "setup.brief.label": "Lagebrief",
+  "setup.brief.charCount": "{count} / 2000 (mind. 10)",
+  "setup.brief.placeholder": "z. B. Wir sind ein mittelgroßer deutscher Wärmepumpen-Hersteller, €680 Mio. Umsatz, 2800 Mitarbeitende. Ein chinesischer Anbieter (Aergis Climate) hat eine italienische Tochter erworben und unterbietet uns im EU-Gewerbesegment. Der Vorstand erwartet eine Antwort für Q2. Regulatorischer Druck durch den F-Gas-Ausstieg spielt uns auf dem Papier in die Hände, aber der Betriebsrat ist nervös wegen Restrukturierung.",
+  "setup.start.helper": "Der Agent nutzt dies als Ausgangskontext.",
+  "setup.start.cta": "Gespräch starten →",
+  "setup.start.busy": "Gespräch wird gestartet…",
+  "setup.chat.eyebrow.lead": "Setup-Agent",
+  "setup.chat.eyebrow.case": "Fall",
+  "setup.chat.status.gathering": "Kontext wird erhoben",
+  "setup.chat.status.ready": "Brief bereit — unten prüfen",
+  "setup.chat.title.gathering": "Beantworten Sie die Fragen des Agenten. Er stellt noch ein paar weitere und übergibt Ihnen dann einen synthetisierten Brief.",
+  "setup.chat.title.ready": "Der Agent hat einen vollständigen Brief. Prüfen und festschreiben, um das Szenario aufzubauen.",
+  "setup.chat.thinking": "denkt nach…",
+  "setup.chat.label.user": "Sie",
+  "setup.chat.label.agent": "Setup-Agent",
+  "setup.synthesis.eyebrow": "Synthetisierter Brief · genau das wird aufgebaut",
+  "setup.synthesis.footnote.lead": "Beim Festschreiben wird",
+  "setup.synthesis.footnote.tail": "geschrieben — world_bible, agents.yaml, initial_state.json — dann öffnet sich Runde 1.",
+  "setup.commit.eyebrow": "Zum Aufbau freigeben",
+  "setup.commit.title": "Brief festschreiben & Runde 1 starten",
+  "setup.commit.cta": "Festschreiben & starten →",
+  "setup.committing.lead": "Aufbau von",
+  "setup.committing.tail": "und Runde 1 wird generiert…",
+  "setup.committing.helper": "Dauert ~30–60s (Aufbau + Briefing). Nicht weg navigieren.",
+  "setup.reply.placeholder": "Ihre Antwort… (Strg/Cmd+Enter zum Senden)",
+  "setup.reply.charCount": "{count} / 4000",
+  "setup.reply.send": "Senden →",
+  "setup.reply.sending": "Wird gesendet…",
+  "setup.docs.eyebrow": "Quelldokumente",
+  "setup.docs.title": "Quellmaterial einlegen — der Setup-Agent extrahiert daraus beim Festschreiben harte Bedingungen.",
+  "setup.docs.count": "{used} / {max}",
+  "setup.docs.uploading": "Hochladen…",
+  "setup.docs.limitReached": "Limit erreicht — Dokument entfernen, um ein weiteres hochzuladen.",
+  "setup.docs.dropLead": "Dokumente hier ablegen",
+  "setup.docs.dropTail": "oder klicken zum Auswählen —",
+  "setup.docs.dropMeta": "max. 25 MB pro Datei.",
+  "setup.docs.remove": "entfernen",
+  "setup.docs.cap": "Maximal {max} Dokumente pro Sitzung — derzeit {count} hochgeladen.",
+  "setup.docs.unsupported": "\"{file}\": nur {exts} werden akzeptiert.",
+  "setup.docs.tooLarge": "\"{file}\": überschreitet das 25-MB-Limit ({size}).",
+  "setup.docs.uploadFail": "\"{file}\": {message}",
+  "setup.docs.removeFail": "\"{file}\" konnte nicht entfernt werden: {message}",
+
+  // ---- Debrief ----
+  "debrief.eyebrow.label": "Debrief",
+  "debrief.eyebrow.case": "Fall {short}…",
+  "debrief.eyebrow.tail": "Postmortem",
+  "debrief.title": "Das Urteil des Vorstands, aktenkundig.",
+  "debrief.dek": "Fünf Runden Beratung, das Rivalen-Drehbuch, der Verlauf der Welt und die Begründung des Schiedsrichters — in einem einzigen Bericht zusammengeführt. Nutzen Sie ihn, um Auftakte zu vergleichen, Anker zu prüfen und die Strategieklausur des nächsten Quartals vorzubereiten.",
+  "debrief.errorTitle": "Debrief konnte nicht geladen werden",
+  "debrief.errorTag": "Fehler",
+  "debrief.loading": "Debrief wird geladen…",
+  "debrief.dossier.tag": "Debrief · GET /games/{id}/debrief",
+};

frontend/src/i18n/en.ts

@@ -0,0 +1,373 @@
+// English strings — the source of truth. Every key here must also exist in de.ts.
+// Keys are dotted, scoped by screen / component, lowerCamelCase leaf names.
+
+export const en = {
+  // ---- Top bar / Shell ----
+  "shell.brand.tag": "Board Console",
+  "shell.dossier.fog": "Fog of war",
+  "shell.nav.cases": "Cases",
+  "shell.nav.newCase": "New case",
+  "shell.status.case": "Case",
+  "shell.status.turn": "Turn",
+  "shell.status.recon": "Recon",
+  "shell.lang.toggle.aria": "Switch language",
+  "shell.footer.tagline": "Norhard · War — Board Console",
+  "shell.footer.build": "MVP frontend",
+
+  // ---- Phase rail (engine phase numbers) ----
+  "phaseRail.briefing": "Briefing",
+  "phaseRail.recon": "Recon",
+  "phaseRail.action": "Action",
+  "phaseRail.deliberation": "Deliberation",
+  "phaseRail.adjudication": "Adjudication",
+
+  // ---- GamesList ----
+  "gamesList.eyebrow.lead": "Cases",
+  "gamesList.eyebrow.note": "active & closed engagements",
+  "gamesList.title": "Every case you've war-gamed, with the receipts.",
+  "gamesList.dek": "Open a live case to continue deliberation, or review a closed debrief for its verdict chain and post-mortem.",
+  "gamesList.docket": "Docket",
+  "gamesList.newCase": "+ New case",
+  "gamesList.loading": "Loading cases…",
+  "gamesList.empty.lead": "No cases yet.",
+  "gamesList.empty.cta": "Open a new case",
+  "gamesList.empty.tail": "to generate a Turn 1 briefing.",
+  "gamesList.col.case": "Case",
+  "gamesList.col.scenario": "Scenario",
+  "gamesList.col.turn": "Turn",
+  "gamesList.col.status": "Status",
+  "gamesList.col.model": "Model",
+  "gamesList.col.updated": "Updated",
+  "gamesList.scenario.summary": "{industry} · vs {rival}",
+  "gamesList.status.active": "active",
+  "gamesList.status.complete": "complete",
+
+  // ---- NewGame ----
+  "newGame.eyebrow.label": "New case",
+  "newGame.eyebrow.note": "choose the scenario",
+  "newGame.title": "Select a dossier. We'll generate Turn 1 from the ground up.",
+  "newGame.dek": "Each scenario seeds a rival playbook, board agenda, agent roster, and fog-of-war intelligence briefing. Generation takes about thirty seconds.",
+  "newGame.designOwn.eyebrow": "Or design your own",
+  "newGame.designOwn.title": "Build a new case with the setup agent",
+  "newGame.designOwn.dek": "Describe your situation; the agent asks clarifying questions and scaffolds a fresh scenario — world bible, agent roster, hidden agendas.",
+  "newGame.designOwn.cta": "Talk to the setup agent →",
+  "newGame.scenarios.loading": "Loading scenarios…",
+  "newGame.scenario.role": "Role",
+  "newGame.scenario.agentCount": "{count} advisory agents at your board.",
+  "newGame.scenario.footnote": "Five turns · fog-of-war briefings · adjudicated outcomes",
+  "newGame.scenario.vs": "vs {rival}",
+  "newGame.ready.eyebrow": "Ready",
+  "newGame.ready.openCompany": "Open {company}",
+  "newGame.ready.pick": "Pick a scenario above",
+  "newGame.ready.engineWith": "Engine ·",
+  "newGame.ready.engineTail": "· generates briefing · ~30s · Turn 1 of 5.",
+  "newGame.ready.modelOnly": "Model generates briefing · ~30s · Turn 1 of 5.",
+  "newGame.ready.openCta": "Open case →",
+  "newGame.ready.busy": "Generating briefing…",
+  "newGame.lang.eyebrow": "Language",
+  "newGame.lang.helper": "The briefing, debrief, and agent voices follow this choice.",
+  "newGame.lang.en": "English",
+  "newGame.lang.de": "Deutsch",
+
+  // ---- NewGame · per-role overrides ----
+  "newGame.roleOverrides.eyebrow": "Per-role model routing",
+  "newGame.roleOverrides.allDefault": "All roles use the game default",
+  "newGame.roleOverrides.someRouted": "{count} role routed to a different model",
+  "newGame.roleOverrides.someRouted.plural": "{count} roles routed to a different model",
+  "newGame.roleOverrides.hide": "Hide ↑",
+  "newGame.roleOverrides.configure": "Configure ↓",
+  "newGame.roleOverrides.intro.lead": "Each role can be pinned to a specific model — leave on the default to use",
+  "newGame.roleOverrides.intro.tail": "Useful for routing cheap planning to small models and reserving the flagship for adjudication.",
+  "newGame.roleOverrides.serverDefault": "(server default)",
+  "newGame.roleOverrides.useDefault": "(use game default)",
+  "newGame.roleOverrides.reset": "Reset to defaults",
+  "newGame.roleOverrides.role.control": "Briefings, adjudication, world updates",
+  "newGame.roleOverrides.role.agent": "Advisory voices in the room",
+  "newGame.roleOverrides.role.rival": "Rival CEO planner",
+  "newGame.roleOverrides.role.critic": "Critic agent",
+  "newGame.roleOverrides.role.premortem": "Pre-mortem agent",
+  "newGame.roleOverrides.role.evaluator": "Independent rubric scorer",
+
+  // ---- GameView · hero ----
+  "gameView.eyebrow.execBriefing": "Turn {turn} — Exec Briefing",
+  "gameView.eyebrow.case": "Case",
+  "gameView.status.paused": "Paused — ready to resume",
+  "gameView.status.action": "Action phase open",
+  "gameView.status.recon": "Recon phase",
+  "gameView.status.actionSubmitted": "Action submitted — ready to advance",
+  "gameView.status.deliberating": "Agents deliberating",
+  "gameView.status.adjudicating": "Adjudicating",
+  "gameView.byline.lead": "Filed by Control · fog-of-war sections below · recon budget {budget} / 3",
+  "gameView.byline.engine": "engine",
+  "gameView.errorTitle": "Case could not be loaded",
+  "gameView.errorTag": "Error",
+  "gameView.retry": "Retry",
+  "gameView.loading": "Loading briefing…",
+  "gameView.fog.label": "Fog of war · unconfirmed",
+
+  // ---- GameView · sections ----
+  "gameView.section.tag": "Section · {heading}",
+  "gameView.decisions.tag": "Decision points · Turn {turn}",
+  "gameView.decisions.title": "{count} moves are on the table. Pick one to compose.",
+  "gameView.decisions.compose": "Compose →",
+
+  // ---- GameView · recon panel ----
+  "gameView.recon.tag": "Recon queue",
+  "gameView.recon.title": "Budget {budget} of 3 this turn.",
+  "gameView.recon.empty": "No queries spent yet this turn. Each query reveals the topic to the rival two turns from now.",
+  "gameView.recon.resolved": "Resolved · {who}",
+  "gameView.recon.reveals": " · reveals to rival",
+  "gameView.recon.askLabel": "Ask another agent",
+  "gameView.recon.placeholder": "One concise question…",
+  "gameView.recon.cost": "Each query costs 1 / 3.",
+  "gameView.recon.spend": "Spend query →",
+  "gameView.recon.asking": "Asking…",
+  "gameView.recon.exhausted": "Recon budget exhausted. Submit action and advance.",
+
+  // ---- GameView · agents panel ----
+  "gameView.agents.tag": "Agent roster",
+  "gameView.agents.title": "Voices in the room",
+  "gameView.agents.kind.advisor": "advisor",
+  "gameView.agents.kind.rival": "rival",
+
+  // ---- GameView · composer ----
+  "gameView.composer.title": "Your move, Turn {turn}",
+  "gameView.composer.submitted": "Submitted",
+  "gameView.composer.tab.coach": "Talk to coach",
+  "gameView.composer.tab.manual": "Manual",
+  "gameView.composer.afterSubmit": "Action submitted for Turn {turn}. Advance when you're ready — the model writes verdicts against your agent roster and the rival playbook. This takes 2–5 minutes.",
+  "gameView.composer.advanceWarning": "Advancing is irreversible. Make sure your anchors are complete.",
+  "gameView.composer.resume": "Resume turn →",
+  "gameView.composer.resuming": "Resuming…",
+  "gameView.composer.advance": "Advance turn →",
+  "gameView.composer.resolving": "Resolving turn…",
+  "gameView.composer.pause": "Pause",
+  "gameView.composer.pausing": "Pausing…",
+  "gameView.composer.pause.title": "Stop at the next phase checkpoint",
+
+  // ---- GameView · manual form ----
+  "gameView.form.intent.label": "Intent",
+  "gameView.form.intent.placeholder": "e.g. Lock Helvetia at 14% effective before Aergis signs an LoI.",
+  "gameView.form.why.label": "Why now",
+  "gameView.form.why.placeholder": "The strategic reasoning. What changes if you act vs. wait one turn.",
+  "gameView.form.charCount": "{count} / {max}",
+  "gameView.form.anchors.legend": "Anchors · each action must cite three",
+  "gameView.form.anchors.count": "{filled} / 3",
+  "gameView.form.anchors.add": "+ Add a fourth anchor (optional)",
+  "gameView.form.anchors.remove": "remove",
+  "gameView.form.anchors.priorAnalogue": "Prior analogue",
+  "gameView.form.anchors.statedCapability": "Stated capability",
+  "gameView.form.anchors.resourceCommitted": "Resource committed",
+  "gameView.form.anchors.hint.priorAnalogue": "A past case — yours or someone else's — where this worked.",
+  "gameView.form.anchors.hint.statedCapability": "A capability you already have, on the record.",
+  "gameView.form.anchors.hint.resourceCommitted": "Specific money, headcount, or time you're putting behind this.",
+  "gameView.form.anchors.placeholder.priorAnalogue": "e.g. Helvetia renewal 2022 — 16% effective, 3-year auto-renew",
+  "gameView.form.anchors.placeholder.statedCapability": "e.g. Horizont-X COP 3.4 validated under UNI 11300 (Jun 2024)",
+  "gameView.form.anchors.placeholder.resourceCommitted": "e.g. €500k/quarter penalty cap, signed by Lange",
+  "gameView.form.submit.violationsBlock": "Resolve the constraint violations above to unlock submit.",
+  "gameView.form.submit.preflight": "Checking against hard constraints…",
+  "gameView.form.submit.helper": "Submitting locks your move for Turn {turn}. Advance after submission.",
+  "gameView.form.submit.cta": "Submit action →",
+  "gameView.form.submit.checking": "Checking…",
+  "gameView.form.submit.submitting": "Submitting…",
+
+  // ---- GameView · hard constraints ----
+  "gameView.constraints.eyebrow": "Hard constraints",
+  "gameView.constraints.empty": "No constraints declared on this game",
+  "gameView.constraints.summary": "{hard} hard · enforced at submit time",
+  "gameView.constraints.summaryWithSoft": "{hard} hard · {soft} soft · enforced at submit time",
+  "gameView.constraints.show": "Show ↓",
+  "gameView.constraints.hide": "Hide ↑",
+  "gameView.constraints.emptyHint": "No hard constraints are active. Add one below, or upload grounding documents at setup time and let the setup agent extract them automatically.",
+  "gameView.constraints.add.cta": "+ Add constraint",
+  "gameView.constraints.footnote": "Hard constraints block any action that breaches them at submission time.",
+  "gameView.constraints.draft.description": "Description",
+  "gameView.constraints.draft.descriptionPlaceholder": "e.g. The Helvetia MSA forbids price increases above 4% YoY without 90-day notice.",
+  "gameView.constraints.draft.rationale": "Rationale",
+  "gameView.constraints.draft.rationalePlaceholder": "e.g. Breach triggers a €12M penalty clause and a public arbitration filing.",
+  "gameView.constraints.draft.testQuestion": "Test question",
+  "gameView.constraints.draft.testQuestionPlaceholder": "e.g. \"Does this action raise prices on the Helvetia contract by more than 4% without 90-day notice?\"",
+  "gameView.constraints.draft.severity": "Severity",
+  "gameView.constraints.draft.severity.hard": "Hard - block any action that breaches",
+  "gameView.constraints.draft.severity.soft": "Soft - flag but allow",
+  "gameView.constraints.draft.cancel": "Cancel",
+  "gameView.constraints.draft.add": "Add constraint →",
+  "gameView.constraints.draft.adding": "Adding…",
+  "gameView.constraints.row.removeTitle": "Remove constraint",
+  "gameView.constraints.row.remove": "remove",
+  "gameView.constraints.row.expand": "Click to expand",
+  "gameView.constraints.row.collapse": "Click to collapse",
+  "gameView.constraints.row.rationale": "Rationale",
+  "gameView.constraints.row.testQuestion": "Test question",
+  "gameView.constraints.row.sourceRef": "Source ref",
+  "gameView.constraints.delete.confirm.scenario": "This constraint came from the scenario file.\n\nRemoving it bypasses an explicitly authored knowledge-base intent. Continue?",
+  "gameView.constraints.delete.confirm.document": "This constraint came from an uploaded document.\n\nRemoving it bypasses an explicitly authored knowledge-base intent. Continue?",
+  "gameView.violations.eyebrow": "Hard constraint violation · action blocked",
+  "gameView.violations.dismiss": "dismiss",
+  "gameView.violations.tail": "Revise the action above and the next submit attempt will be re-checked.",
+  "gameView.violations.coachBlocked": "Action blocked by hard constraints — see panel above the composer.",
+
+  // ---- GameView · coach ----
+  "gameView.coach.intro": "Describe your move in plain prose. The coach will draft a structured action with three anchors — the matrix-game umpire scores plausibility against those anchors, so specificity matters. If a critical anchor is ambiguous, the coach will ask one focused question. Capped at two rounds.",
+  "gameView.coach.placeholder": "e.g. Pre-empt Aergis by locking Helvetia at 14% effective before they sign the LoI. Anchor it on the 2022 Helvetia renewal — we have the Horizont-X UNI 11300 validation and a €500k/quarter penalty cap signed by Lange.",
+  "gameView.coach.charHint": "{count} / 4000 · Ctrl/Cmd+Enter to send",
+  "gameView.coach.start": "Talk to coach →",
+  "gameView.coach.starting": "Drafting…",
+  "gameView.coach.replyPlaceholder": "Your reply… (Ctrl/Cmd+Enter to send)",
+  "gameView.coach.replyHint": "{count} / 4000 · round {round} of 2",
+  "gameView.coach.send": "Send →",
+  "gameView.coach.sending": "Sending…",
+  "gameView.coach.busy.label": "Coach",
+  "gameView.coach.busy.suffix": "drafting…",
+  "gameView.coach.draft.eyebrowReady": "Draft action · ready to submit",
+  "gameView.coach.draft.eyebrowProgress": "Draft action · in progress ({rounds}/2 rounds)",
+  "gameView.coach.draft.footnote": "Submitting locks this move for Turn {turn}.",
+  "gameView.coach.approve.eyebrow": "Approve to submit",
+  "gameView.coach.approve.title": "Commit draft as your Turn {turn} action",
+  "gameView.coach.approve.editManual": "Edit in Manual →",
+  "gameView.coach.approve.restart": "Restart",
+  "gameView.coach.approve.submit": "Submit action →",
+  "gameView.coach.approve.submitting": "Submitting…",
+  "gameView.coach.restart.cta": "Restart conversation",
+  "gameView.coach.draft.intent": "Intent",
+  "gameView.coach.draft.why": "Why now",
+  "gameView.coach.draft.anchorsLabel": "Anchors · {count} of 3",
+  "gameView.coach.label.user": "You",
+  "gameView.coach.label.coach": "Coach",
+
+  // ---- GameView · verdict history ----
+  "gameView.verdicts.title": "Prior turns · the referee's ruling",
+  "gameView.verdicts.turn": "Turn {turn}",
+  "gameView.verdicts.resolved": "{count} verdicts resolved",
+  "gameView.verdicts.actionOnly": "action submitted",
+  "gameView.verdicts.fork": "Fork from Turn {turn} →",
+  "gameView.verdicts.forking": "Forking…",
+  "gameView.verdicts.fork.title": "Branch a new case from Turn {turn} and replay forward",
+  "gameView.verdicts.playerAction": "Player action",
+
+  // ---- GameView · orchestrator ----
+  "gameView.orch.eyebrow": "Scenario orchestrator · pre-play landscape",
+  "gameView.orch.title.complete": "See how three CEO profiles would play this turn.",
+  "gameView.orch.title.running": "Simulating three profiles in parallel.",
+  "gameView.orch.title.idle": "Before you commit, see how three profiles play this turn.",
+  "gameView.orch.show": "Show ↓",
+  "gameView.orch.hide": "Hide ↑",
+  "gameView.orch.idleDek": "Three strategy vectors will play a proxy version of this turn at different skill temperatures. You get a side-by-side outcome read before you commit your own move. Takes 3–5 minutes.",
+  "gameView.orch.run": "Run orchestrator →",
+  "gameView.orch.locked": "Orchestrator only runs pre-action — fork from Turn 1 to re-run.",
+  "gameView.orch.progress": "{done} / {total} branches complete",
+  "gameView.orch.progressDek": "Running in the background. You can read the briefing — this page will update live.",
+  "gameView.orch.vector.complete": "✓ complete",
+  "gameView.orch.vector.running": "⋯ running",
+  "gameView.orch.generatingVectors": "Generating strategy vectors…",
+  "gameView.orch.failed": "Orchestration failed: {error}",
+  "gameView.orch.failed.unknown": "unknown error",
+  "gameView.orch.retry": "Retry →",
+  "gameView.orch.rerun": "Re-run orchestrator →",
+  "gameView.orch.skipped.eyebrow": "Rejected",
+  "gameView.orch.skipped.fallback": "Anchor pre-check failed.",
+  "gameView.orch.played": "Played as",
+  "gameView.orch.adopt": "Use this opener →",
+  "gameView.orch.fullSynthesis": "Full synthesis · {chars} chars",
+
+  // ---- LiveProgress ----
+  "liveProgress.eyebrow": "Live · turn in flight",
+  "liveProgress.titleDefault": "Tracking deliberations and verdicts in real time.",
+  "liveProgress.titlePaused": "Paused — {label}",
+  "liveProgress.cost.aria": "cumulative cost",
+  "liveProgress.cost.suffix": "spent",
+  "liveProgress.paused.eyebrow": "Paused",
+  "liveProgress.paused.body": "Paused at end of {label}. Resume to continue.",
+  "liveProgress.streamErr.disconnected": "Live stream disconnected — refresh to reconnect.",
+  "liveProgress.engineErr.fallback": "Engine reported an error.",
+  "liveProgress.steps.deliberation": "Deliberation",
+  "liveProgress.steps.critic": "Critic",
+  "liveProgress.steps.premortem": "Pre-mortem",
+  "liveProgress.steps.adjudication": "Adjudication",
+  "liveProgress.steps.evaluator": "Evaluator",
+  "liveProgress.steps.worldUpdate": "World update",
+  "liveProgress.steps.nextBriefing": "Next briefing",
+  "liveProgress.rail.aria": "phase progress",
+  "liveProgress.deliberations": "Deliberations",
+  "liveProgress.deliberations.thinking": "Agents thinking…",
+  "liveProgress.deliberations.empty": "No agent deliberations yet.",
+  "liveProgress.deliberations.expects": "expects",
+  "liveProgress.deliberations.fears": "fears",
+  "liveProgress.verdicts": "Verdicts",
+  "liveProgress.verdicts.empty": "No verdicts adjudicated yet this turn.",
+  "liveProgress.verdict.plausibility": "P{n}",
+  "liveProgress.verdict.outcome.major": "effect · major",
+  "liveProgress.verdict.outcome.minor": "effect · minor",
+  "liveProgress.verdict.outcome.noEffect": "no effect",
+  "liveProgress.verdict.outcome.backfires": "backfires",
+
+  // ---- GameView · advance log ----
+  "gameView.advance.seed": "[{time}] Orchestrator: seeding agent deliberations for turn {turn}…",
+  "gameView.advance.resolved": "[{time}] ✓ Turn {turn} resolved",
+
+  // ---- SetupCase ----
+  "setup.eyebrow.lead": "New case",
+  "setup.eyebrow.tail": "design one with the setup agent",
+  "setup.intro.title": "Describe the situation. The agent will ask clarifying questions, then scaffold the scenario.",
+  "setup.intro.dek": "Write a paragraph or two about the company, the rival or threat, the stakes, and whatever constraints you already know. The setup agent will fill in the gaps: agent roster, world bible, starting metrics, hidden agendas. Takes a few rounds of Q&A (30–60s per round).",
+  "setup.caseId.label": "Case ID",
+  "setup.caseId.charCount": "{count} / 60",
+  "setup.caseId.placeholder": "e.g. nord_heatpump_takeover",
+  "setup.caseId.helper": "Lowercase letters, digits, underscores. Must start with a letter. 3–60 chars.",
+  "setup.caseId.invalid": "Invalid format.",
+  "setup.brief.label": "Situation brief",
+  "setup.brief.charCount": "{count} / 2000 (min 10)",
+  "setup.brief.placeholder": "e.g. We're a mid-sized German heat-pump maker, €680M revenue, 2800 employees. A Chinese entrant (Aergis Climate) just acquired an Italian subsidiary and is undercutting us on price at the EU commercial segment. Board wants a response for Q2. Regulatory pressure from F-gas phase-out plays in our favor on paper but the Betriebsrat is nervous about restructuring.",
+  "setup.start.helper": "The agent uses this as its starting context.",
+  "setup.start.cta": "Start conversation →",
+  "setup.start.busy": "Starting conversation…",
+  "setup.chat.eyebrow.lead": "Setup agent",
+  "setup.chat.eyebrow.case": "case",
+  "setup.chat.status.gathering": "Gathering context",
+  "setup.chat.status.ready": "Brief ready — review below",
+  "setup.chat.title.gathering": "Answer the agent’s questions. It’ll ask a few more then hand you a synthesized brief.",
+  "setup.chat.title.ready": "The agent has a complete brief. Review and commit to scaffold the scenario.",
+  "setup.chat.thinking": "thinking…",
+  "setup.chat.label.user": "You",
+  "setup.chat.label.agent": "Setup agent",
+  "setup.synthesis.eyebrow": "Synthesized brief · this is what will be scaffolded",
+  "setup.synthesis.footnote.lead": "Commit writes",
+  "setup.synthesis.footnote.tail": "— world_bible, agents.yaml, initial_state.json — then opens Turn 1.",
+  "setup.commit.eyebrow": "Approve to scaffold",
+  "setup.commit.title": "Commit brief & launch Turn 1",
+  "setup.commit.cta": "Commit & launch →",
+  "setup.committing.lead": "Scaffolding",
+  "setup.committing.tail": "and generating Turn 1…",
+  "setup.committing.helper": "This takes ~30–60s (scaffold + briefing). Don't navigate away.",
+  "setup.reply.placeholder": "Your answer… (Ctrl/Cmd+Enter to send)",
+  "setup.reply.charCount": "{count} / 4000",
+  "setup.reply.send": "Send →",
+  "setup.reply.sending": "Sending…",
+  "setup.docs.eyebrow": "Grounding documents",
+  "setup.docs.title": "Drop in source materials — the setup agent extracts hard constraints from these at commit time.",
+  "setup.docs.count": "{used} / {max}",
+  "setup.docs.uploading": "Uploading…",
+  "setup.docs.limitReached": "Limit reached — remove a document to upload another.",
+  "setup.docs.dropLead": "Drop documents here",
+  "setup.docs.dropTail": "or click to browse —",
+  "setup.docs.dropMeta": "max 25 MB each.",
+  "setup.docs.remove": "remove",
+  "setup.docs.cap": "Cap is {max} documents per session — currently {count} uploaded.",
+  "setup.docs.unsupported": "\"{file}\": only {exts} are accepted.",
+  "setup.docs.tooLarge": "\"{file}\": exceeds the 25 MB cap ({size}).",
+  "setup.docs.uploadFail": "\"{file}\": {message}",
+  "setup.docs.removeFail": "Could not remove \"{file}\": {message}",
+
+  // ---- Debrief ----
+  "debrief.eyebrow.label": "Debrief",
+  "debrief.eyebrow.case": "case {short}…",
+  "debrief.eyebrow.tail": "Post-mortem",
+  "debrief.title": "The board's verdict, on the record.",
+  "debrief.dek": "Five turns of deliberation, the rival playbook, the world-state arc, and the referee's reasoning — collated into a single report. Use it to compare openings, debug anchors, and line up next quarter's strategic review.",
+  "debrief.errorTitle": "Debrief could not be loaded",
+  "debrief.errorTag": "Error",
+  "debrief.loading": "Loading debrief…",
+  "debrief.dossier.tag": "Debrief · GET /games/{id}/debrief",
+} as const;
+
+export type StringKey = keyof typeof en;

frontend/src/i18n/index.ts

@@ -0,0 +1,92 @@
+import { useSyncExternalStore } from 'react';
+import { en, type StringKey } from './en';
+import { de } from './de';
+
+export type Language = 'en' | 'de';
+export type { StringKey } from './en';
+
+const STORAGE_KEY = 'wargame.lang';
+
+const tables: Record<Language, Partial<Record<StringKey, string>>> = {
+  en,
+  de,
+};
+
+function readInitial(): Language {
+  try {
+    const stored = window.localStorage.getItem(STORAGE_KEY);
+    if (stored === 'de' || stored === 'en') return stored;
+  } catch {
+    // Storage may be unavailable (SSR / privacy mode); fall through.
+  }
+  return 'en';
+}
+
+let current: Language = readInitial();
+const listeners = new Set<() => void>();
+
+function emit() {
+  for (const fn of listeners) fn();
+}
+
+function subscribe(fn: () => void): () => void {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+
+function getSnapshot(): Language {
+  return current;
+}
+
+export function getLanguage(): Language {
+  return current;
+}
+
+export function setLanguage(lang: Language): void {
+  if (lang !== 'en' && lang !== 'de') return;
+  if (current === lang) return;
+  current = lang;
+  try {
+    window.localStorage.setItem(STORAGE_KEY, lang);
+  } catch {
+    // Best-effort persist; the in-memory current still drives the UI.
+  }
+  emit();
+}
+
+function interpolate(template: string, vars?: Record<string, string | number>): string {
+  if (!vars) return template;
+  return template.replace(/\{(\w+)\}/g, (_, key) => {
+    const v = vars[key];
+    return v === undefined || v === null ? `{${key}}` : String(v);
+  });
+}
+
+function lookup(lang: Language, key: StringKey): string {
+  const localized = tables[lang][key];
+  if (localized !== undefined) return localized;
+  const fallback = en[key];
+  if (fallback !== undefined) return fallback as string;
+  return key;
+}
+
+export function translate(
+  lang: Language,
+  key: StringKey,
+  vars?: Record<string, string | number>,
+): string {
+  return interpolate(lookup(lang, key), vars);
+}
+
+export function useI18n(): {
+  lang: Language;
+  t: (key: StringKey, vars?: Record<string, string | number>) => string;
+  setLang: (l: Language) => void;
+} {
+  const lang = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return {
+    lang,
+    t: (key, vars) => translate(lang, key, vars),
+    setLang: setLanguage,
+  };
+}

frontend/src/screens/Debrief.tsx

@@ -3,6 +3,7 @@ import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import { api } from '../api';
 import { Dossier, Spinner } from '../components/Shell';
+import { setLanguage, useI18n, type Language } from '../i18n';
 
 interface Props {
   id: string;
@@ -10,11 +11,19 @@ interface Props {
 }
 
 export function Debrief({ id, onMeta }: Props) {
+  const { t } = useI18n();
   const [md, setMd] = useState<string | null>(null);
   const [err, setErr] = useState<string | null>(null);
 
   useEffect(() => {
     api.debrief(id).then((r) => setMd(r.markdown)).catch((e) => setErr(String(e)));
+    // The debrief belongs to a specific game — switch the UI to that game's
+    // language for the duration of this screen. The shell toggle still lets
+    // the user override.
+    api.getState(id).then((s) => {
+      const lang = s.language as Language | undefined;
+      if (lang === 'en' || lang === 'de') setLanguage(lang);
+    }).catch(() => { /* non-fatal */ });
   }, [id]);
 
   useEffect(() => {
@@ -27,28 +36,24 @@ export function Debrief({ id, onMeta }: Props) {
     <>
       <section className="nh-hero">
         <div className="nh-eyebrow">
-          <span>Debrief</span>
+          <span>{t('debrief.eyebrow.label')}</span>
           <span>·</span>
-          <span className="mono">case {id.slice(0, 8)}…</span>
+          <span className="mono">{t('debrief.eyebrow.case', { short: id.slice(0, 8) })}</span>
           <span>·</span>
-          <b>Post-mortem</b>
+          <b>{t('debrief.eyebrow.tail')}</b>
         </div>
-        <h1>The board's verdict, on the record.</h1>
-        <p className="nh-dek">
-          Five turns of deliberation, the rival playbook, the world-state arc, and the referee's reasoning —
-          collated into a single report. Use it to compare openings, debug anchors, and line up next quarter's
-          strategic review.
-        </p>
+        <h1>{t('debrief.title')}</h1>
+        <p className="nh-dek">{t('debrief.dek')}</p>
       </section>
 
       {err && (
-        <Dossier tag="Error" title="Debrief could not be loaded">
+        <Dossier tag={t('debrief.errorTag')} title={t('debrief.errorTitle')}>
           <p style={{ color: 'var(--oxblood)' }}>{err}</p>
         </Dossier>
       )}
-      {!md && !err && <p className="fg-3" style={{ padding: 20 }}><Spinner /> Loading debrief…</p>}
+      {!md && !err && <p className="fg-3" style={{ padding: 20 }}><Spinner /> {t('debrief.loading')}</p>}
       {md && (
-        <Dossier tag="Debrief · GET /games/{id}/debrief" title="">
+        <Dossier tag={t('debrief.dossier.tag', { id })} title="">
           <div className="debrief-md">
             <ReactMarkdown remarkPlugins={[remarkGfm]}>{md}</ReactMarkdown>
           </div>

frontend/src/screens/GameView.tsx

@@ -9,6 +9,7 @@ import {
 import { navigate } from '../App';
 import { Dossier, Panel, PhaseRail, Spinner } from '../components/Shell';
 import { LiveProgress } from '../components/LiveProgress';
+import { setLanguage, useI18n, type Language, type StringKey } from '../i18n';
 
 interface Props {
   id: string;
@@ -25,6 +26,7 @@ type Phase = 'briefing' | 'recon' | 'action' | 'deliberation' | 'adjudication';
  * composer + live advance terminal.
  */
 export function GameView({ id, onMeta }: Props) {
+  const { t } = useI18n();
   const [state, setState] = useState<any>(null);
   const [briefing, setBriefing] = useState<Briefing | null>(null);
   const [budget, setBudget] = useState<number>(3);
@@ -113,6 +115,19 @@ export function GameView({ id, onMeta }: Props) {
   }
   useEffect(() => { loadAll(); /* eslint-disable-next-line */ }, [id]);
 
+  // Sync the UI language with the game's recorded language *once per game*.
+  // After mount, the shell EN|DE toggle still works — we don't override it
+  // on every advance reload.
+  useEffect(() => {
+    let cancelled = false;
+    api.getState(id).then((s) => {
+      if (cancelled) return;
+      const gameLang = s.language as Language | undefined;
+      if (gameLang === 'en' || gameLang === 'de') setLanguage(gameLang);
+    }).catch(() => { /* non-fatal */ });
+    return () => { cancelled = true; };
+  }, [id]);
+
   // Hard constraints — load at mount so the panel + preflight stay in sync.
   async function loadConstraints() {
     try {
@@ -317,7 +332,7 @@ export function GameView({ id, onMeta }: Props) {
       const parsed = parseViolations(msg);
       if (status === 409 && parsed.length > 0) {
         setViolations(parsed);
-        setCoachErr('Action blocked by hard constraints — see panel above the composer.');
+        setCoachErr(t('gameView.violations.coachBlocked'));
       } else {
         setCoachErr(msg);
       }
@@ -355,9 +370,10 @@ export function GameView({ id, onMeta }: Props) {
     setConstraintsErr(null);
     const force = constraint.source !== 'manual';
     if (force) {
-      const ok = window.confirm(
-        `This constraint came from ${constraint.source === 'scenario' ? 'the scenario file' : 'an uploaded document'}.\n\nRemoving it bypasses an explicitly authored knowledge-base intent. Continue?`,
-      );
+      const message = constraint.source === 'scenario'
+        ? t('gameView.constraints.delete.confirm.scenario')
+        : t('gameView.constraints.delete.confirm.document');
+      const ok = window.confirm(message);
       if (!ok) return;
     }
     try {
@@ -372,10 +388,10 @@ export function GameView({ id, onMeta }: Props) {
     setAdvanceBusy(true);
     setShowLive(true);
     setPhase('deliberation');
-    setAdvanceLog([`[${nowHM()}] Orchestrator: seeding agent deliberations for turn ${turn}…`]);
+    setAdvanceLog([t('gameView.advance.seed', { time: nowHM(), turn })]);
     try {
       const r = await api.advance(id);
-      setAdvanceLog((L) => [...L, `[${nowHM()}] ✓ Turn ${r.turn_resolved} resolved`]);
+      setAdvanceLog((L) => [...L, t('gameView.advance.resolved', { time: nowHM(), turn: r.turn_resolved })]);
       if (r.status === 'paused') {
         // Engine hit a pause checkpoint; treat the same as a `paused` SSE
         // event. Refresh state so status flips and the Resume button shows.
@@ -465,14 +481,16 @@ export function GameView({ id, onMeta }: Props) {
 
   if (err) {
     return (
-      <Dossier tag="Error" title="Case could not be loaded">
+      <Dossier tag={t('gameView.errorTag')} title={t('gameView.errorTitle')}>
         <p style={{ color: 'var(--oxblood)' }}>{err}</p>
-        <button className="btn ghost sm" onClick={() => { setErr(null); loadAll(); }}>Retry</button>
+        <button className="btn ghost sm" onClick={() => { setErr(null); loadAll(); }}>
+          {t('gameView.retry')}
+        </button>
       </Dossier>
     );
   }
   if (!briefing) {
-    return <p className="fg-3" style={{ padding: 20 }}><Spinner /> Loading briefing…</p>;
+    return <p className="fg-3" style={{ padding: 20 }}><Spinner /> {t('gameView.loading')}</p>;
   }
 
   return (
@@ -480,18 +498,18 @@ export function GameView({ id, onMeta }: Props) {
       {/* HERO */}
       <section className="nh-hero">
         <div className="nh-eyebrow">
-          <span>Turn {turn} — Exec Briefing</span>
+          <span>{t('gameView.eyebrow.execBriefing', { turn })}</span>
           <span>·</span>
-          <span>Case <span className="mono">{id.slice(0, 8)}…</span></span>
+          <span>{t('gameView.eyebrow.case')} <span className="mono">{id.slice(0, 8)}…</span></span>
           <span>·</span>
           <b>
-            {state?.status === 'paused' ? 'Paused — ready to resume' : (
+            {state?.status === 'paused' ? t('gameView.status.paused') : (
               <>
-                {phase === 'briefing' && 'Action phase open'}
-                {phase === 'recon' && 'Recon phase'}
-                {phase === 'action' && 'Action submitted — ready to advance'}
-                {phase === 'deliberation' && 'Agents deliberating'}
-                {phase === 'adjudication' && 'Adjudicating'}
+                {phase === 'briefing' && t('gameView.status.action')}
+                {phase === 'recon' && t('gameView.status.recon')}
+                {phase === 'action' && t('gameView.status.actionSubmitted')}
+                {phase === 'deliberation' && t('gameView.status.deliberating')}
+                {phase === 'adjudication' && t('gameView.status.adjudicating')}
               </>
             )}
           </b>
@@ -499,8 +517,8 @@ export function GameView({ id, onMeta }: Props) {
         <h1>{briefing.headline}</h1>
         <p className="nh-dek">{briefing.exec_summary}</p>
         <div className="nh-byline mono">
-          Filed by Control · fog-of-war sections below · recon budget {budget} / 3
-          {model && <> · engine <b>{model}</b></>}
+          {t('gameView.byline.lead', { budget })}
+          {model && <> · {t('gameView.byline.engine')} <b>{model}</b></>}
         </div>
       </section>
 
@@ -523,12 +541,14 @@ export function GameView({ id, onMeta }: Props) {
       <div className="nh-grid">
         <div className="nh-narrative">
           {briefing.sections.map((s, i) => (
-            <Dossier key={i} tag={`Section · ${s.heading}`} fog={!!s.fog_of_war}>
+            <Dossier key={i} tag={t('gameView.section.tag', { heading: s.heading })} fog={!!s.fog_of_war}>
               <h3 className="nh-serif-h">{s.heading}</h3>
               <p style={{ whiteSpace: 'pre-wrap' }}>{s.body}</p>
               {s.fog_of_war && (
                 <div style={{ marginTop: 14, paddingTop: 12, borderTop: '1px dashed var(--vellum)' }}>
-                  <span className="eyebrow" style={{ display: 'block', marginBottom: 6 }}>Fog of war · unconfirmed</span>
+                  <span className="eyebrow" style={{ display: 'block', marginBottom: 6 }}>
+                    {t('gameView.fog.label')}
+                  </span>
                   <p className="body-sm" style={{ color: 'var(--slate)', fontStyle: 'italic' }}>{s.fog_of_war}</p>
                 </div>
               )}
@@ -536,8 +556,10 @@ export function GameView({ id, onMeta }: Props) {
           ))}
 
           {briefing.decision_points.length > 0 && (
-            <Dossier tag={`Decision points · Turn ${turn}`}>
-              <h3 className="nh-serif-h">{briefing.decision_points.length} moves are on the table. Pick one to compose.</h3>
+            <Dossier tag={t('gameView.decisions.tag', { turn })}>
+              <h3 className="nh-serif-h">
+                {t('gameView.decisions.title', { count: briefing.decision_points.length })}
+              </h3>
               <div className="nh-decisions">
                 {briefing.decision_points.map((d, i) => (
                   <div className="nh-decision" key={i}>
@@ -557,7 +579,7 @@ export function GameView({ id, onMeta }: Props) {
                         setTimeout(() => document.querySelector('.nh-composer')
                           ?.scrollIntoView({ block: 'start', behavior: 'smooth' }), 50);
                       }}
-                    >Compose →</button>
+                    >{t('gameView.decisions.compose')}</button>
                   </div>
                 ))}
               </div>
@@ -567,17 +589,17 @@ export function GameView({ id, onMeta }: Props) {
 
         {/* ASIDE */}
         <aside className="nh-aside">
-          <Panel tag="Recon queue" title={`Budget ${budget} of 3 this turn.`}>
+          <Panel tag={t('gameView.recon.tag')} title={t('gameView.recon.title', { budget })}>
             {reconLog.length === 0 && (
               <p className="body-sm fg-3" style={{ marginTop: 10 }}>
-                No queries spent yet this turn. Each query reveals the topic to the rival two turns from now.
+                {t('gameView.recon.empty')}
               </p>
             )}
             <ul className="nh-recon">
               {reconLog.map((r, i) => (
                 <li key={i}>
                   <span className={`who mono ${r.reveals ? '' : 'done'}`}>
-                    Resolved · {r.who}{r.reveals ? ' · reveals to rival' : ''}
+                    {t('gameView.recon.resolved', { who: r.who })}{r.reveals ? t('gameView.recon.reveals') : ''}
                   </span>
                   <span className="q">"{r.q}"</span>
                   <span className="a">{r.a}</span>
@@ -586,7 +608,7 @@ export function GameView({ id, onMeta }: Props) {
             </ul>
             {budget > 0 ? (
               <div className="nh-recon__in">
-                <label>Ask another agent</label>
+                <label>{t('gameView.recon.askLabel')}</label>
                 <div className="sel">
                   <select value={reconAgent} onChange={(e) => setReconAgent(e.target.value)}>
                     {((agents.length > 0
@@ -602,40 +624,48 @@ export function GameView({ id, onMeta }: Props) {
                   <input
                     value={reconQ}
                     onChange={(e) => setReconQ(e.target.value)}
-                    placeholder="One concise question…"
+                    placeholder={t('gameView.recon.placeholder')}
                   />
                 </div>
                 <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginTop: 8 }}>
-                  <span className="help mono">Each query costs 1 / 3.</span>
+                  <span className="help mono">{t('gameView.recon.cost')}</span>
                   <button
                     className="btn primary sm"
                     disabled={!reconQ.trim() || reconBusy}
                     onClick={askRecon}
-                  >{reconBusy ? <><Spinner /> Asking…</> : 'Spend query →'}</button>
+                  >{reconBusy ? <><Spinner /> {t('gameView.recon.asking')}</> : t('gameView.recon.spend')}</button>
                 </div>
               </div>
             ) : (
               <div className="nh-recon__in">
-                <span className="help mono">Recon budget exhausted. Submit action and advance.</span>
+                <span className="help mono">{t('gameView.recon.exhausted')}</span>
               </div>
             )}
           </Panel>
 
           {(agents.length > 0 || state?.agents) && (
-            <Panel tag="Agent roster" title="Voices in the room">
+            <Panel tag={t('gameView.agents.tag')} title={t('gameView.agents.title')}>
               <ul className="nh-agents">
-                {(agents.length > 0 ? agents : state.agents).map((a: any) => (
-                  <li key={a.id}>
-                    <span className="code mono">{a.code || a.id.slice(0, 4).toUpperCase()}</span>
-                    <div>
-                      <div className="nm">{a.label || a.name || a.id}</div>
-                      <div className="rl">{a.posture || a.role || a.kind}</div>
-                    </div>
-                    <div className="rt">
-                      <span className={`kind ${a.kind === 'rival' ? 'rival' : ''}`}>{a.kind || 'advisor'}</span>
-                    </div>
-                  </li>
-                ))}
+                {(agents.length > 0 ? agents : state.agents).map((a: any) => {
+                  const kindRaw = a.kind || 'advisor';
+                  const kindLabel = kindRaw === 'rival'
+                    ? t('gameView.agents.kind.rival')
+                    : kindRaw === 'advisor'
+                      ? t('gameView.agents.kind.advisor')
+                      : kindRaw;
+                  return (
+                    <li key={a.id}>
+                      <span className="code mono">{a.code || a.id.slice(0, 4).toUpperCase()}</span>
+                      <div>
+                        <div className="nm">{a.label || a.name || a.id}</div>
+                        <div className="rl">{a.posture || a.role || a.kind}</div>
+                      </div>
+                      <div className="rt">
+                        <span className={`kind ${a.kind === 'rival' ? 'rival' : ''}`}>{kindLabel}</span>
+                      </div>
+                    </li>
+                  );
+                })}
               </ul>
             </Panel>
           )}
@@ -657,9 +687,9 @@ export function GameView({ id, onMeta }: Props) {
       {/* ACTION COMPOSER */}
       <section className={`nh-composer ${actionSent ? 'submitted' : ''}`}>
         <div className="nh-composer__hd">
-          <h2>Your move, Turn {turn}</h2>
+          <h2>{t('gameView.composer.title', { turn })}</h2>
           {actionSent ? (
-            <span className="hint">Submitted</span>
+            <span className="hint">{t('gameView.composer.submitted')}</span>
           ) : (
             <div role="tablist" aria-label="Composer mode" style={{ display: 'flex', gap: 6 }}>
               <button
@@ -668,26 +698,23 @@ export function GameView({ id, onMeta }: Props) {
                 className={`btn sm ${composerMode === 'coach' ? 'primary' : 'ghost'}`}
                 onClick={() => setComposerMode('coach')}
                 disabled={submitBusy || coachBusy}
-              >Talk to coach</button>
+              >{t('gameView.composer.tab.coach')}</button>
               <button
                 role="tab"
                 aria-selected={composerMode === 'manual'}
                 className={`btn sm ${composerMode === 'manual' ? 'primary' : 'ghost'}`}
                 onClick={() => setComposerMode('manual')}
                 disabled={submitBusy || coachBusy}
-              >Manual</button>
+              >{t('gameView.composer.tab.manual')}</button>
             </div>
           )}
         </div>
 
         {actionSent ? (
           <>
-            <p className="fg-2">
-              Action submitted for Turn {turn}. Advance when you're ready — the model writes verdicts against
-              your agent roster and the rival playbook. This takes 2–5 minutes.
-            </p>
+            <p className="fg-2">{t('gameView.composer.afterSubmit', { turn })}</p>
             <div className="nh-submit">
-              <span className="hint mono fg-3">Advancing is irreversible. Make sure your anchors are complete.</span>
+              <span className="hint mono fg-3">{t('gameView.composer.advanceWarning')}</span>
               <div style={{ display: 'flex', gap: 8, alignItems: 'center' }}>
                 {state?.status === 'paused' ? (
                   <button
@@ -695,7 +722,9 @@ export function GameView({ id, onMeta }: Props) {
                     onClick={resumeAdvance}
                     disabled={resumeBusy}
                   >
-                    {resumeBusy ? <><Spinner /> Resuming…</> : 'Resume turn →'}
+                    {resumeBusy
+                      ? <><Spinner /> {t('gameView.composer.resuming')}</>
+                      : t('gameView.composer.resume')}
                   </button>
                 ) : (
                   <>
@@ -704,13 +733,17 @@ export function GameView({ id, onMeta }: Props) {
                         className="btn ghost sm"
                         onClick={pauseAdvance}
                         disabled={pauseBusy}
-                        title="Stop at the next phase checkpoint"
+                        title={t('gameView.composer.pause.title')}
                       >
-                        {pauseBusy ? <><Spinner /> Pausing…</> : 'Pause'}
+                        {pauseBusy
+                          ? <><Spinner /> {t('gameView.composer.pausing')}</>
+                          : t('gameView.composer.pause')}
                       </button>
                     )}
                     <button className="btn primary" onClick={advance} disabled={advanceBusy}>
-                      {advanceBusy ? <><Spinner /> Resolving turn…</> : 'Advance turn →'}
+                      {advanceBusy
+                        ? <><Spinner /> {t('gameView.composer.resolving')}</>
+                        : t('gameView.composer.advance')}
                     </button>
                   </>
                 )}
@@ -754,26 +787,34 @@ export function GameView({ id, onMeta }: Props) {
         ) : (
           <>
             <div className="nh-formrow">
-              <label>Intent <span className="ct mono">{intent.length} / 160</span></label>
+              <label>
+                {t('gameView.form.intent.label')}{' '}
+                <span className="ct mono">{t('gameView.form.charCount', { count: intent.length, max: 160 })}</span>
+              </label>
               <input
                 value={intent} maxLength={160}
                 onChange={(e) => setIntent(e.target.value)}
-                placeholder="e.g. Lock Helvetia at 14% effective before Aergis signs an LoI."
+                placeholder={t('gameView.form.intent.placeholder')}
               />
             </div>
             <div className="nh-formrow">
-              <label>Why now <span className="ct mono">{why.length} / 400</span></label>
+              <label>
+                {t('gameView.form.why.label')}{' '}
+                <span className="ct mono">{t('gameView.form.charCount', { count: why.length, max: 400 })}</span>
+              </label>
               <textarea
                 value={why} maxLength={400}
                 onChange={(e) => setWhy(e.target.value)}
-                placeholder="The strategic reasoning. What changes if you act vs. wait one turn."
+                placeholder={t('gameView.form.why.placeholder')}
               />
             </div>
 
             <div className="nh-anchors">
               <div className="legend">
-                <span>Anchors · each action must cite three</span>
-                <span className={`count ${anchorsFilled >= 3 ? 'ok' : ''}`}>{anchorsFilled} / 3</span>
+                <span>{t('gameView.form.anchors.legend')}</span>
+                <span className={`count ${anchorsFilled >= 3 ? 'ok' : ''}`}>
+                  {t('gameView.form.anchors.count', { filled: anchorsFilled })}
+                </span>
               </div>
               {anchors.map((a, i) => (
                 <div className="nh-anchor editable" key={i}>
@@ -790,11 +831,11 @@ export function GameView({ id, onMeta }: Props) {
                         setAnchors(v);
                       }}
                     >
-                      <option value="prior_analogue">Prior analogue</option>
-                      <option value="stated_capability">Stated capability</option>
-                      <option value="resource_committed">Resource committed</option>
+                      <option value="prior_analogue">{t('gameView.form.anchors.priorAnalogue')}</option>
+                      <option value="stated_capability">{t('gameView.form.anchors.statedCapability')}</option>
+                      <option value="resource_committed">{t('gameView.form.anchors.resourceCommitted')}</option>
                     </select>
-                    <div className="hint">{ANCHOR_HINTS[a.kind]}</div>
+                    <div className="hint">{t(ANCHOR_HINT_KEYS[a.kind])}</div>
                   </div>
                   <input
                     value={a.detail}
@@ -803,13 +844,13 @@ export function GameView({ id, onMeta }: Props) {
                       v[i] = { ...a, detail: e.target.value };
                       setAnchors(v);
                     }}
-                    placeholder={ANCHOR_PLACEHOLDERS[a.kind]}
+                    placeholder={t(ANCHOR_PLACEHOLDER_KEYS[a.kind])}
                   />
                   <button
                     className="rm"
                     onClick={() => setAnchors(anchors.filter((_, j) => j !== i))}
                     disabled={anchors.length <= 3}
-                  >remove</button>
+                  >{t('gameView.form.anchors.remove')}</button>
                 </div>
               ))}
               {anchors.length < 5 && (
@@ -817,7 +858,7 @@ export function GameView({ id, onMeta }: Props) {
                   <button
                     className="btn ghost sm"
                     onClick={() => setAnchors([...anchors, { kind: 'resource_committed', detail: '' }])}
-                  >+ Add a fourth anchor (optional)</button>
+                  >{t('gameView.form.anchors.add')}</button>
                 </div>
               )}
             </div>
@@ -832,10 +873,10 @@ export function GameView({ id, onMeta }: Props) {
             <div className="nh-submit">
               <span className="hint mono fg-3">
                 {violations.length > 0
-                  ? 'Resolve the constraint violations above to unlock submit.'
+                  ? t('gameView.form.submit.violationsBlock')
                   : preflightBusy
-                    ? 'Checking against hard constraints…'
-                    : `Submitting locks your move for Turn ${turn}. Advance after submission.`}
+                    ? t('gameView.form.submit.preflight')
+                    : t('gameView.form.submit.helper', { turn })}
               </span>
               <button
                 className="btn primary"
@@ -843,8 +884,8 @@ export function GameView({ id, onMeta }: Props) {
                 onClick={submitAction}
               >
                 {submitBusy
-                  ? <><Spinner /> {preflightBusy ? 'Checking…' : 'Submitting…'}</>
-                  : 'Submit action →'}
+                  ? <><Spinner /> {preflightBusy ? t('gameView.form.submit.checking') : t('gameView.form.submit.submitting')}</>
+                  : t('gameView.form.submit.cta')}
               </button>
             </div>
           </>
@@ -873,15 +914,15 @@ export function GameView({ id, onMeta }: Props) {
   );
 }
 
-const ANCHOR_HINTS: Record<AnchorKind, string> = {
-  prior_analogue: 'A past case — yours or someone else\'s — where this worked.',
-  stated_capability: 'A capability you already have, on the record.',
-  resource_committed: 'Specific money, headcount, or time you\'re putting behind this.',
+const ANCHOR_HINT_KEYS: Record<AnchorKind, StringKey> = {
+  prior_analogue: 'gameView.form.anchors.hint.priorAnalogue',
+  stated_capability: 'gameView.form.anchors.hint.statedCapability',
+  resource_committed: 'gameView.form.anchors.hint.resourceCommitted',
 };
-const ANCHOR_PLACEHOLDERS: Record<AnchorKind, string> = {
-  prior_analogue: 'e.g. Helvetia renewal 2022 — 16% effective, 3-year auto-renew',
-  stated_capability: 'e.g. Horizont-X COP 3.4 validated under UNI 11300 (Jun 2024)',
-  resource_committed: 'e.g. €500k/quarter penalty cap, signed by Lange',
+const ANCHOR_PLACEHOLDER_KEYS: Record<AnchorKind, StringKey> = {
+  prior_analogue: 'gameView.form.anchors.placeholder.priorAnalogue',
+  stated_capability: 'gameView.form.anchors.placeholder.statedCapability',
+  resource_committed: 'gameView.form.anchors.placeholder.resourceCommitted',
 };
 
 const DEFAULT_AGENTS = [
@@ -933,37 +974,42 @@ function VerdictHistory({
   forkBusy: number | null;
   onFork: (fromTurn: number) => void;
 }) {
+  const { t } = useI18n();
   const resolved = turns.filter(
-    (t) => (t?.verdicts?.length || 0) > 0 || !!t?.player_action,
+    (turn) => (turn?.verdicts?.length || 0) > 0 || !!turn?.player_action,
   );
   if (!resolved.length) return null;
   return (
     <section className="nh-verdicts">
-      <h2>Prior turns · the referee's ruling</h2>
-      {resolved.map((t, i) => {
-        const action = t.player_action;
-        const verdictCount = t?.verdicts?.length || 0;
+      <h2>{t('gameView.verdicts.title')}</h2>
+      {resolved.map((turn, i) => {
+        const action = turn.player_action;
+        const verdictCount = turn?.verdicts?.length || 0;
         return (
           <div className="nh-vturn" key={i}>
             <div className="nh-vturn__hd">
-              <span className="mono eyebrow">Turn {t.turn}</span>
+              <span className="mono eyebrow">{t('gameView.verdicts.turn', { turn: turn.turn })}</span>
               <span className="mono fg-3">
-                {verdictCount > 0 ? `${verdictCount} verdicts resolved` : 'action submitted'}
+                {verdictCount > 0
+                  ? t('gameView.verdicts.resolved', { count: verdictCount })
+                  : t('gameView.verdicts.actionOnly')}
               </span>
               <span className="spacer" style={{ flex: 1 }} />
               <button
                 className="btn ghost sm"
                 disabled={forkBusy !== null}
-                onClick={() => onFork(t.turn)}
-                title={`Branch a new case from Turn ${t.turn} and replay forward`}
+                onClick={() => onFork(turn.turn)}
+                title={t('gameView.verdicts.fork.title', { turn: turn.turn })}
               >
-                {forkBusy === t.turn ? <><Spinner /> Forking…</> : `Fork from Turn ${t.turn} →`}
+                {forkBusy === turn.turn
+                  ? <><Spinner /> {t('gameView.verdicts.forking')}</>
+                  : t('gameView.verdicts.fork', { turn: turn.turn })}
               </button>
             </div>
             {action && (
               <div className="nh-v">
                 <div className="nh-v__hd">
-                  <span className="actor mono">Player action</span>
+                  <span className="actor mono">{t('gameView.verdicts.playerAction')}</span>
                 </div>
                 <p style={{ whiteSpace: 'pre-wrap' }}>
                   <strong>{action.intent}</strong>
@@ -989,6 +1035,7 @@ function OrchestratorBar({
   onAdopt: (branch: ScenarioMap['branches'][number]) => void;
   canRun: boolean;
 }) {
+  const { t } = useI18n();
   const running = map?.status === 'running' || map?.status === 'pending';
   const failed = map?.status === 'failed';
   const complete = map?.status === 'complete';
@@ -1009,18 +1056,18 @@ function OrchestratorBar({
     <section className="nh-orch">
       <div className="nh-orch__hd">
         <div>
-          <span className="eyebrow">Scenario orchestrator · pre-play landscape</span>
+          <span className="eyebrow">{t('gameView.orch.eyebrow')}</span>
           <h2 className="nh-serif-h" style={{ margin: '4px 0 0' }}>
             {complete
-              ? 'See how three CEO profiles would play this turn.'
+              ? t('gameView.orch.title.complete')
               : running
-                ? 'Simulating three profiles in parallel.'
-                : 'Before you commit, see how three profiles play this turn.'}
+                ? t('gameView.orch.title.running')
+                : t('gameView.orch.title.idle')}
           </h2>
         </div>
         {(complete || failed) && (
           <button className="btn ghost sm" onClick={onToggle}>
-            {open ? 'Hide ↑' : 'Show ↓'}
+            {open ? t('gameView.orch.hide') : t('gameView.orch.show')}
           </button>
         )}
       </div>
@@ -1031,17 +1078,14 @@ function OrchestratorBar({
       {!map && !error && (
         <div className="nh-orch__idle">
           <p className="fg-2" style={{ margin: 0 }}>
-            Three strategy vectors will play a proxy version of this turn at different skill temperatures.
-            You get a side-by-side outcome read before you commit your own move. Takes 3–5 minutes.
+            {t('gameView.orch.idleDek')}
           </p>
           {canRun ? (
             <button className="btn primary" onClick={onRun}>
-              Run orchestrator →
+              {t('gameView.orch.run')}
             </button>
           ) : (
-            <span className="help mono fg-3">
-              Orchestrator only runs pre-action — fork from Turn 1 to re-run.
-            </span>
+            <span className="help mono fg-3">{t('gameView.orch.locked')}</span>
           )}
         </div>
       )}
@@ -1053,11 +1097,9 @@ function OrchestratorBar({
             <Spinner />
             <div>
               <div className="mono">
-                {map?.branches_complete ?? 0} / {total} branches complete
-              </div>
-              <div className="help mono fg-3">
-                Running in the background. You can read the briefing — this page will update live.
+                {t('gameView.orch.progress', { done: map?.branches_complete ?? 0, total })}
               </div>
+              <div className="help mono fg-3">{t('gameView.orch.progressDek')}</div>
             </div>
           </div>
           {vectors.length > 0 && (
@@ -1072,7 +1114,7 @@ function OrchestratorBar({
                     <div className="nh-orch__vhd">
                       <span className="code mono">{v.id.slice(0, 4).toUpperCase()}</span>
                       <span className="mono fg-3" style={{ fontSize: 10.5 }}>
-                        {done ? '✓ complete' : '⋯ running'}
+                        {done ? t('gameView.orch.vector.complete') : t('gameView.orch.vector.running')}
                       </span>
                     </div>
                     <div className="nh-orch__vlabel">{v.label}</div>
@@ -1083,7 +1125,7 @@ function OrchestratorBar({
           )}
           {vectors.length === 0 && (
             <div className="help fg-3 mono" style={{ marginTop: 8 }}>
-              Generating strategy vectors…
+              {t('gameView.orch.generatingVectors')}
             </div>
           )}
         </div>
@@ -1092,13 +1134,13 @@ function OrchestratorBar({
       {/* FAILED */}
       {failed && open && (
         <div className="nh-orch__failed">
-          <p style={{ color: 'var(--oxblood)' }}>Orchestration failed: {map?.error || 'unknown error'}</p>
+          <p style={{ color: 'var(--oxblood)' }}>
+            {t('gameView.orch.failed', { error: map?.error || t('gameView.orch.failed.unknown') })}
+          </p>
           {canRun ? (
-            <button className="btn ghost sm" onClick={onRun}>Retry →</button>
+            <button className="btn ghost sm" onClick={onRun}>{t('gameView.orch.retry')}</button>
           ) : (
-            <span className="help mono fg-3">
-              Orchestrator only runs pre-action — fork from Turn 1 to re-run.
-            </span>
+            <span className="help mono fg-3">{t('gameView.orch.locked')}</span>
           )}
         </div>
       )}
@@ -1124,8 +1166,8 @@ function OrchestratorBar({
                   <p className="nh-orch__cdesc">{v.description}</p>
                   {skipped ? (
                     <div className="nh-orch__cskip">
-                      <span className="eyebrow">Rejected</span>
-                      <div className="help">{b?.skip_reason || 'Anchor pre-check failed.'}</div>
+                      <span className="eyebrow">{t('gameView.orch.skipped.eyebrow')}</span>
+                      <div className="help">{b?.skip_reason || t('gameView.orch.skipped.fallback')}</div>
                     </div>
                   ) : (
                     <>
@@ -1144,7 +1186,7 @@ function OrchestratorBar({
                       )}
                       {action?.intent && (
                         <div className="nh-orch__cplay">
-                          <span className="eyebrow">Played as</span>
+                          <span className="eyebrow">{t('gameView.orch.played')}</span>
                           <div>{action.intent}</div>
                         </div>
                       )}
@@ -1154,7 +1196,7 @@ function OrchestratorBar({
                           onClick={() => b && onAdopt(b)}
                           style={{ marginTop: 'auto' }}
                         >
-                          Use this opener →
+                          {t('gameView.orch.adopt')}
                         </button>
                       )}
                     </>
@@ -1165,7 +1207,11 @@ function OrchestratorBar({
           </div>
           {map?.synthesis_markdown && (
             <details className="nh-orch__full">
-              <summary>Full synthesis · {map.synthesis_markdown.length.toLocaleString()} chars</summary>
+              <summary>
+                {t('gameView.orch.fullSynthesis', {
+                  chars: map.synthesis_markdown.length.toLocaleString(),
+                })}
+              </summary>
               <div className="setup-md" style={{ fontSize: 14, lineHeight: 1.6, marginTop: 10 }}>
                 <ReactMarkdown remarkPlugins={[remarkGfm]}>{map.synthesis_markdown}</ReactMarkdown>
               </div>
@@ -1173,11 +1219,9 @@ function OrchestratorBar({
           )}
           <div className="nh-orch__ft">
             {canRun ? (
-              <button className="btn ghost sm" onClick={onRun}>Re-run orchestrator →</button>
+              <button className="btn ghost sm" onClick={onRun}>{t('gameView.orch.rerun')}</button>
             ) : (
-              <span className="help mono fg-3">
-                Orchestrator only runs pre-action — fork from Turn 1 to re-run.
-              </span>
+              <span className="help mono fg-3">{t('gameView.orch.locked')}</span>
             )}
           </div>
         </>
@@ -1228,6 +1272,7 @@ function ActionCoachThread({
   onSwitchToManualWithDraft: () => void;
   turn: number;
 }) {
+  const { t } = useI18n();
   const hasSession = session !== null;
   const ready = session?.status === 'ready';
   const draft = session?.synthesized_draft ?? null;
@@ -1239,16 +1284,14 @@ function ActionCoachThread({
           // Intro — collect initial prose before kicking off the coach.
           <div className="nh-chat__input">
             <p className="fg-2" style={{ marginTop: 0, marginBottom: 12 }}>
-              Describe your move in plain prose. The coach will draft a structured action with three anchors —
-              the matrix-game umpire scores plausibility against those anchors, so specificity matters. If a
-              critical anchor is ambiguous, the coach will ask one focused question. Capped at two rounds.
+              {t('gameView.coach.intro')}
             </p>
             <form onSubmit={(e) => { e.preventDefault(); onStart(); }}>
               <textarea
                 value={input}
                 rows={5}
                 maxLength={4000}
-                placeholder="e.g. Pre-empt Aergis by locking Helvetia at 14% effective before they sign the LoI. Anchor it on the 2022 Helvetia renewal — we have the Horizont-X UNI 11300 validation and a EUR 500k/quarter penalty cap signed by Lange."
+                placeholder={t('gameView.coach.placeholder')}
                 onChange={(e) => setInput(e.target.value)}
                 onKeyDown={(e) => {
                   if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
@@ -1258,13 +1301,15 @@ function ActionCoachThread({
                 disabled={busy}
               />
               <div className="nh-chat__submit">
-                <span className="hint">{input.length} / 4000 · Ctrl/Cmd+Enter to send</span>
+                <span className="hint">{t('gameView.coach.charHint', { count: input.length })}</span>
                 <button
                   type="submit"
                   className="btn primary"
                   disabled={!input.trim() || busy}
                 >
-                  {busy ? <><Spinner /> Drafting…</> : 'Talk to coach →'}
+                  {busy
+                    ? <><Spinner /> {t('gameView.coach.starting')}</>
+                    : t('gameView.coach.start')}
                 </button>
               </div>
             </form>
@@ -1278,7 +1323,9 @@ function ActionCoachThread({
               ))}
               {busy && (
                 <div className="nh-msg control">
-                  <div className="nh-msg__meta"><span>Coach</span> drafting…</div>
+                  <div className="nh-msg__meta">
+                    <span>{t('gameView.coach.busy.label')}</span> {t('gameView.coach.busy.suffix')}
+                  </div>
                   <div className="nh-msg__body"><Spinner /></div>
                 </div>
               )}
@@ -1288,11 +1335,13 @@ function ActionCoachThread({
             {draft && (
               <div className="nh-spec">
                 <span className="eyebrow">
-                  Draft action {ready ? '· ready to submit' : `· in progress (${session?.rounds_used ?? 0}/2 rounds)`}
+                  {ready
+                    ? t('gameView.coach.draft.eyebrowReady')
+                    : t('gameView.coach.draft.eyebrowProgress', { rounds: session?.rounds_used ?? 0 })}
                 </span>
                 <CoachDraftCard draft={draft} />
                 <div className="nh-spec__fn" style={{ marginTop: 6 }}>
-                  Submitting locks this move for Turn {turn}.
+                  {t('gameView.coach.draft.footnote', { turn })}
                 </div>
               </div>
             )}
@@ -1300,18 +1349,20 @@ function ActionCoachThread({
             {ready ? (
               <div className="nh-chat__approve">
                 <div>
-                  <span className="eyebrow">Approve to submit</span>
-                  <div className="hd">Commit draft as your Turn {turn} action</div>
+                  <span className="eyebrow">{t('gameView.coach.approve.eyebrow')}</span>
+                  <div className="hd">{t('gameView.coach.approve.title', { turn })}</div>
                 </div>
                 <div style={{ display: 'flex', gap: 8, alignItems: 'center' }}>
                   <button className="btn ghost sm" onClick={onSwitchToManualWithDraft} disabled={busy}>
-                    Edit in Manual →
+                    {t('gameView.coach.approve.editManual')}
                   </button>
                   <button className="btn ghost sm" onClick={onReset} disabled={busy}>
-                    Restart
+                    {t('gameView.coach.approve.restart')}
                   </button>
                   <button className="btn primary" onClick={onCommit} disabled={busy}>
-                    {busy ? <><Spinner /> Submitting…</> : 'Submit action →'}
+                    {busy
+                      ? <><Spinner /> {t('gameView.coach.approve.submitting')}</>
+                      : t('gameView.coach.approve.submit')}
                   </button>
                 </div>
               </div>
@@ -1322,7 +1373,7 @@ function ActionCoachThread({
                     value={input}
                     rows={4}
                     maxLength={4000}
-                    placeholder="Your reply… (Ctrl/Cmd+Enter to send)"
+                    placeholder={t('gameView.coach.replyPlaceholder')}
                     onChange={(e) => setInput(e.target.value)}
                     onKeyDown={(e) => {
                       if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
@@ -1333,20 +1384,25 @@ function ActionCoachThread({
                   />
                   <div className="nh-chat__submit">
                     <span className="hint">
-                      {input.length} / 4000 · round {(session?.rounds_used ?? 0) + 1} of 2
+                      {t('gameView.coach.replyHint', {
+                        count: input.length,
+                        round: (session?.rounds_used ?? 0) + 1,
+                      })}
                     </span>
                     <button
                       type="submit"
                       className="btn primary"
                       disabled={!input.trim() || busy}
                     >
-                      {busy ? <><Spinner /> Sending…</> : 'Send →'}
+                      {busy
+                        ? <><Spinner /> {t('gameView.coach.sending')}</>
+                        : t('gameView.coach.send')}
                     </button>
                   </div>
                 </form>
                 <div style={{ marginTop: 8 }}>
                   <button className="btn ghost sm" onClick={onReset} disabled={busy}>
-                    Restart conversation
+                    {t('gameView.coach.restart.cta')}
                   </button>
                 </div>
               </div>
@@ -1360,8 +1416,9 @@ function ActionCoachThread({
 }
 
 function CoachMsg({ m }: { m: CoachMessage }) {
+  const { t } = useI18n();
   const who = m.role === 'user' ? 'user' : 'control';
-  const label = m.role === 'user' ? 'You' : 'Coach';
+  const label = m.role === 'user' ? t('gameView.coach.label.user') : t('gameView.coach.label.coach');
   return (
     <div className={`nh-msg ${who}`}>
       <div className="nh-msg__meta"><span>{label}</span> {fmtCoachAt(m.at)}</div>
@@ -1379,18 +1436,21 @@ function CoachMsg({ m }: { m: CoachMessage }) {
 }
 
 function CoachDraftCard({ draft }: { draft: NonNullable<ActionCoachSession['synthesized_draft']> }) {
+  const { t } = useI18n();
   return (
     <div style={{ display: 'grid', gap: 10, fontSize: 14, lineHeight: 1.55 }}>
       <div>
-        <div className="eyebrow" style={{ marginBottom: 2 }}>Intent</div>
+        <div className="eyebrow" style={{ marginBottom: 2 }}>{t('gameView.coach.draft.intent')}</div>
         <div style={{ fontWeight: 600 }}>{draft.intent}</div>
       </div>
       <div>
-        <div className="eyebrow" style={{ marginBottom: 2 }}>Why now</div>
+        <div className="eyebrow" style={{ marginBottom: 2 }}>{t('gameView.coach.draft.why')}</div>
         <div>{draft.justification}</div>
       </div>
       <div>
-        <div className="eyebrow" style={{ marginBottom: 4 }}>Anchors · {draft.anchors.length} of 3</div>
+        <div className="eyebrow" style={{ marginBottom: 4 }}>
+          {t('gameView.coach.draft.anchorsLabel', { count: draft.anchors.length })}
+        </div>
         <ul style={{ margin: 0, paddingLeft: 18 }}>
           {draft.anchors.map((a, i) => (
             <li key={i} style={{ marginBottom: 4 }}>
@@ -1423,6 +1483,7 @@ function ConstraintsPanel({
   onAdd: (input: { description: string; rationale: string; test_question: string; severity: ConstraintSeverity }) => Promise<void>;
   onDelete: (constraint: HardConstraint) => void | Promise<void>;
 }) {
+  const { t } = useI18n();
   const [adding, setAdding] = useState(false);
   const [draft, setDraft] = useState({
     description: '',
@@ -1468,14 +1529,18 @@ function ConstraintsPanel({
         aria-expanded={open}
       >
         <div>
-          <span className="eyebrow">Hard constraints</span>
+          <span className="eyebrow">{t('gameView.constraints.eyebrow')}</span>
           <div className="hd">
             {constraints.length === 0
-              ? 'No constraints declared on this game'
-              : `${hardCount} hard${softCount > 0 ? ` · ${softCount} soft` : ''} · enforced at submit time`}
+              ? t('gameView.constraints.empty')
+              : softCount > 0
+                ? t('gameView.constraints.summaryWithSoft', { hard: hardCount, soft: softCount })
+                : t('gameView.constraints.summary', { hard: hardCount })}
           </div>
         </div>
-        <span className="mono fg-3">{open ? 'Hide ↑' : 'Show ↓'}</span>
+        <span className="mono fg-3">
+          {open ? t('gameView.constraints.hide') : t('gameView.constraints.show')}
+        </span>
       </button>
 
       {open && (
@@ -1483,8 +1548,7 @@ function ConstraintsPanel({
           {err && <p className="nh-constraints__err">{err}</p>}
           {constraints.length === 0 ? (
             <p className="fg-3" style={{ margin: '0 0 12px' }}>
-              No hard constraints are active. Add one below, or upload grounding documents at setup time
-              and let the setup agent extract them automatically.
+              {t('gameView.constraints.emptyHint')}
             </p>
           ) : (
             <ul className="nh-constraint-list">
@@ -1497,44 +1561,53 @@ function ConstraintsPanel({
           {adding ? (
             <div className="nh-constraint-add">
               <div className="nh-formrow">
-                <label>Description <span className="ct mono">{draft.description.length} / 400</span></label>
+                <label>
+                  {t('gameView.constraints.draft.description')}{' '}
+                  <span className="ct mono">{t('gameView.form.charCount', { count: draft.description.length, max: 400 })}</span>
+                </label>
                 <textarea
                   value={draft.description}
                   maxLength={400}
                   rows={2}
                   onChange={(e) => setDraft({ ...draft, description: e.target.value })}
-                  placeholder="e.g. The Helvetia MSA forbids price increases above 4% YoY without 90-day notice."
+                  placeholder={t('gameView.constraints.draft.descriptionPlaceholder')}
                 />
               </div>
               <div className="nh-formrow">
-                <label>Rationale <span className="ct mono">{draft.rationale.length} / 400</span></label>
+                <label>
+                  {t('gameView.constraints.draft.rationale')}{' '}
+                  <span className="ct mono">{t('gameView.form.charCount', { count: draft.rationale.length, max: 400 })}</span>
+                </label>
                 <textarea
                   value={draft.rationale}
                   maxLength={400}
                   rows={2}
                   onChange={(e) => setDraft({ ...draft, rationale: e.target.value })}
-                  placeholder="e.g. Breach triggers a EUR 12M penalty clause and a public arbitration filing."
+                  placeholder={t('gameView.constraints.draft.rationalePlaceholder')}
                 />
               </div>
               <div className="nh-formrow">
-                <label>Test question <span className="ct mono">{draft.test_question.length} / 300</span></label>
+                <label>
+                  {t('gameView.constraints.draft.testQuestion')}{' '}
+                  <span className="ct mono">{t('gameView.form.charCount', { count: draft.test_question.length, max: 300 })}</span>
+                </label>
                 <textarea
                   value={draft.test_question}
                   maxLength={300}
                   rows={2}
                   onChange={(e) => setDraft({ ...draft, test_question: e.target.value })}
-                  placeholder='e.g. "Does this action raise prices on the Helvetia contract by more than 4% without 90-day notice?"'
+                  placeholder={t('gameView.constraints.draft.testQuestionPlaceholder')}
                 />
               </div>
               <div className="nh-formrow">
-                <label>Severity</label>
+                <label>{t('gameView.constraints.draft.severity')}</label>
                 <select
                   value={draft.severity}
                   onChange={(e) => setDraft({ ...draft, severity: e.target.value as ConstraintSeverity })}
                   style={{ font: 'inherit' }}
                 >
-                  <option value="hard">Hard - block any action that breaches</option>
-                  <option value="soft">Soft - flag but allow</option>
+                  <option value="hard">{t('gameView.constraints.draft.severity.hard')}</option>
+                  <option value="soft">{t('gameView.constraints.draft.severity.soft')}</option>
                 </select>
               </div>
               {localErr && <p className="nh-constraints__err">{localErr}</p>}
@@ -1544,24 +1617,26 @@ function ConstraintsPanel({
                   className="btn ghost sm"
                   onClick={() => { setAdding(false); setLocalErr(null); }}
                   disabled={busy}
-                >Cancel</button>
+                >{t('gameView.constraints.draft.cancel')}</button>
                 <button
                   type="button"
                   className="btn primary"
                   onClick={submit}
                   disabled={!draftValid || busy}
                 >
-                  {busy ? <><Spinner /> Adding…</> : 'Add constraint →'}
+                  {busy
+                    ? <><Spinner /> {t('gameView.constraints.draft.adding')}</>
+                    : t('gameView.constraints.draft.add')}
                 </button>
               </div>
             </div>
           ) : (
             <div className="nh-constraints__addbar">
               <span className="hint mono fg-3">
-                Hard constraints block any action that breaches them at submission time.
+                {t('gameView.constraints.footnote')}
               </span>
               <button type="button" className="btn ghost sm" onClick={() => setAdding(true)}>
-                + Add constraint
+                {t('gameView.constraints.add.cta')}
               </button>
             </div>
           )}
@@ -1577,6 +1652,7 @@ function ConstraintRow({
   c: HardConstraint;
   onDelete: () => void | Promise<void>;
 }) {
+  const { t } = useI18n();
   const [expanded, setExpanded] = useState(false);
   const long = c.description.length > 120;
   const display = expanded || !long ? c.description : `${c.description.slice(0, 117)}…`;
@@ -1589,7 +1665,9 @@ function ConstraintRow({
           type="button"
           className="nh-constraint__desc"
           onClick={() => long && setExpanded((v) => !v)}
-          title={long ? (expanded ? 'Click to collapse' : 'Click to expand') : c.description}
+          title={long
+            ? (expanded ? t('gameView.constraints.row.collapse') : t('gameView.constraints.row.expand'))
+            : c.description}
         >
           {display}
         </button>
@@ -1597,17 +1675,23 @@ function ConstraintRow({
           type="button"
           className="nh-constraint__rm"
           onClick={onDelete}
-          title="Remove constraint"
+          title={t('gameView.constraints.row.removeTitle')}
         >
-          remove
+          {t('gameView.constraints.row.remove')}
         </button>
       </div>
       {expanded && (
         <div className="nh-constraint__detail">
-          <div><span className="eyebrow">Rationale</span> {c.rationale}</div>
-          <div><span className="eyebrow">Test question</span> <span className="mono">{c.test_question}</span></div>
+          <div><span className="eyebrow">{t('gameView.constraints.row.rationale')}</span> {c.rationale}</div>
+          <div>
+            <span className="eyebrow">{t('gameView.constraints.row.testQuestion')}</span>{' '}
+            <span className="mono">{c.test_question}</span>
+          </div>
           {c.source_ref && (
-            <div><span className="eyebrow">Source ref</span> <span className="mono">{c.source_ref}</span></div>
+            <div>
+              <span className="eyebrow">{t('gameView.constraints.row.sourceRef')}</span>{' '}
+              <span className="mono">{c.source_ref}</span>
+            </div>
           )}
         </div>
       )}
@@ -1621,11 +1705,14 @@ function ViolationsBanner({
   violations: ConstraintViolation[];
   onDismiss: () => void;
 }) {
+  const { t } = useI18n();
   return (
     <div className="nh-violations" role="alert">
       <div className="nh-violations__hd">
-        <span className="eyebrow">Hard constraint violation · action blocked</span>
-        <button type="button" className="nh-violations__rm" onClick={onDismiss}>dismiss</button>
+        <span className="eyebrow">{t('gameView.violations.eyebrow')}</span>
+        <button type="button" className="nh-violations__rm" onClick={onDismiss}>
+          {t('gameView.violations.dismiss')}
+        </button>
       </div>
       <ul>
         {violations.map((v, i) => (
@@ -1636,7 +1723,7 @@ function ViolationsBanner({
         ))}
       </ul>
       <p className="hint mono fg-3" style={{ marginTop: 6 }}>
-        Revise the action above and the next submit attempt will be re-checked.
+        {t('gameView.violations.tail')}
       </p>
     </div>
   );

frontend/src/screens/GamesList.tsx

@@ -1,8 +1,10 @@
 import { useEffect, useState } from 'react';
 import { api, GameSummary, Scenario } from '../api';
 import { navigate } from '../App';
+import { useI18n } from '../i18n';
 
 export function GamesList() {
+  const { t } = useI18n();
   const [games, setGames] = useState<GameSummary[] | null>(null);
   const [scenarios, setScenarios] = useState<Record<string, Scenario>>({});
   const [err, setErr] = useState<string | null>(null);
@@ -19,25 +21,28 @@ export function GamesList() {
   return (
     <>
       <section className="nh-hero">
-        <div className="nh-eyebrow"><b>Cases</b> · active & closed engagements</div>
-        <h1>Every case you've war-gamed, with the receipts.</h1>
-        <p className="nh-dek">
-          Open a live case to continue deliberation, or review a closed debrief for its verdict chain and post-mortem.
-        </p>
+        <div className="nh-eyebrow"><b>{t('gamesList.eyebrow.lead')}</b> · {t('gamesList.eyebrow.note')}</div>
+        <h1>{t('gamesList.title')}</h1>
+        <p className="nh-dek">{t('gamesList.dek')}</p>
       </section>
 
       <div className="nh-tablehd">
-        <span>Docket</span>
+        <span>{t('gamesList.docket')}</span>
         <div className="nh-tablehd__r">
-          <button className="btn ghost sm" onClick={() => navigate('/new')}>+ New case</button>
+          <button className="btn ghost sm" onClick={() => navigate('/new')}>
+            {t('gamesList.newCase')}
+          </button>
         </div>
       </div>
 
       {err && <div className="nh-dossier"><p style={{ color: 'var(--oxblood)' }}>{err}</p></div>}
-      {!games && !err && <p className="fg-3" style={{ padding: 20 }}>Loading cases…</p>}
+      {!games && !err && <p className="fg-3" style={{ padding: 20 }}>{t('gamesList.loading')}</p>}
       {games && games.length === 0 && (
         <div className="nh-dossier">
-          <p>No cases yet. <a href="#/new">Open a new case</a> to generate a Turn 1 briefing.</p>
+          <p>
+            {t('gamesList.empty.lead')} <a href="#/new">{t('gamesList.empty.cta')}</a>{' '}
+            {t('gamesList.empty.tail')}
+          </p>
         </div>
       )}
 
@@ -45,18 +50,21 @@ export function GamesList() {
         <table className="nh-games">
           <thead>
             <tr>
-              <th>Case</th>
-              <th>Scenario</th>
-              <th>Turn</th>
-              <th>Status</th>
-              <th>Model</th>
-              <th className="rt">Updated</th>
+              <th>{t('gamesList.col.case')}</th>
+              <th>{t('gamesList.col.scenario')}</th>
+              <th>{t('gamesList.col.turn')}</th>
+              <th>{t('gamesList.col.status')}</th>
+              <th>{t('gamesList.col.model')}</th>
+              <th className="rt">{t('gamesList.col.updated')}</th>
             </tr>
           </thead>
           <tbody>
             {games.map((g) => {
               const sc = scenarios[g.scenario_id];
               const href = g.status === 'complete' ? `#/games/${g.id}/debrief` : `#/games/${g.id}`;
+              const statusLabel = g.status === 'complete'
+                ? t('gamesList.status.complete')
+                : t('gamesList.status.active');
               return (
                 <tr key={g.id} onClick={() => (window.location.hash = href)} style={{ cursor: 'pointer' }}>
                   <td>
@@ -64,11 +72,11 @@ export function GamesList() {
                     <div className="sub mono">{g.id.slice(0, 8)}…</div>
                   </td>
                   <td>
-                    {sc ? `${sc.industry} · vs ${sc.rival_name}` : g.scenario_id}
+                    {sc ? t('gamesList.scenario.summary', { industry: sc.industry, rival: sc.rival_name }) : g.scenario_id}
                   </td>
                   <td className="mono">{g.turn} / {g.max_turns}</td>
                   <td>
-                    <span className={`nh-chip ${g.status}`}>{g.status}</span>
+                    <span className={`nh-chip ${g.status}`}>{statusLabel}</span>
                   </td>
                   <td className="mono fg-3">{g.llm_model || '—'}</td>
                   <td className="rt mono fg-3">{new Date(g.updated_at).toLocaleDateString()}</td>

frontend/src/screens/NewGame.tsx

@@ -1,21 +1,23 @@
 import { useEffect, useState } from 'react';
 import { api, Scenario, ModelInfo } from '../api';
 import { navigate } from '../App';
+import { useI18n, type StringKey, type Language } from '../i18n';
 
 // Fallback role list when an older backend returns ModelsResponse without
 // `roles[]`. Mirrors `wargame.agents.roles.CANONICAL_ROLES`.
 const FALLBACK_ROLES = ['control', 'agent', 'rival', 'critic', 'premortem', 'evaluator'];
 
-const ROLE_BLURBS: Record<string, string> = {
-  control: 'Briefings, adjudication, world updates',
-  agent: 'Advisory voices in the room',
-  rival: 'Rival CEO planner',
-  critic: 'Critic agent',
-  premortem: 'Pre-mortem agent',
-  evaluator: 'Independent rubric scorer',
+const ROLE_BLURB_KEYS: Record<string, StringKey> = {
+  control: 'newGame.roleOverrides.role.control',
+  agent: 'newGame.roleOverrides.role.agent',
+  rival: 'newGame.roleOverrides.role.rival',
+  critic: 'newGame.roleOverrides.role.critic',
+  premortem: 'newGame.roleOverrides.role.premortem',
+  evaluator: 'newGame.roleOverrides.role.evaluator',
 };
 
 export function NewGame() {
+  const { t, lang, setLang } = useI18n();
   const [scenarios, setScenarios] = useState<Scenario[] | null>(null);
   const [picked, setPicked] = useState<string>('');
   const [models, setModels] = useState<ModelInfo[]>([]);
@@ -25,6 +27,7 @@ export function NewGame() {
   const [overridesOpen, setOverridesOpen] = useState(false);
   const [busy, setBusy] = useState(false);
   const [err, setErr] = useState<string | null>(null);
+  const [language, setGameLanguage] = useState<Language>(lang);
 
   useEffect(() => {
     api.listScenarios().then((r) => {
@@ -44,6 +47,10 @@ export function NewGame() {
     }).catch(() => { /* non-fatal — backend will use its default */ });
   }, []);
 
+  // Keep the local `language` state in sync with the global preference until
+  // the user explicitly clicks one of the pills (after which it pins).
+  useEffect(() => { setGameLanguage(lang); }, [lang]);
+
   function setRoleOverride(role: string, modelId: string) {
     setOverrides((prev) => {
       const next = { ...prev };
@@ -53,6 +60,11 @@ export function NewGame() {
     });
   }
 
+  function pickLanguage(next: Language) {
+    setGameLanguage(next);
+    setLang(next);
+  }
+
   async function create() {
     setBusy(true); setErr(null);
     try {
@@ -60,36 +72,36 @@ export function NewGame() {
         picked,
         model || undefined,
         Object.keys(overrides).length > 0 ? overrides : undefined,
+        language,
       );
       navigate(`/games/${r.game_id}`);
     } catch (e) { setErr(String(e)); setBusy(false); }
   }
 
+  const pickedScenario = scenarios?.find((s) => s.scenario_id === picked);
+  const readyTitle = pickedScenario
+    ? t('newGame.ready.openCompany', { company: pickedScenario.company_name })
+    : t('newGame.ready.pick');
+
   return (
     <>
       <section className="nh-hero">
-        <div className="nh-eyebrow"><b>New case</b> · choose the scenario</div>
-        <h1>Select a dossier. We'll generate Turn 1 from the ground up.</h1>
-        <p className="nh-dek">
-          Each scenario seeds a rival playbook, board agenda, agent roster, and fog-of-war intelligence briefing.
-          Generation takes about thirty seconds.
-        </p>
+        <div className="nh-eyebrow"><b>{t('newGame.eyebrow.label')}</b> · {t('newGame.eyebrow.note')}</div>
+        <h1>{t('newGame.title')}</h1>
+        <p className="nh-dek">{t('newGame.dek')}</p>
       </section>
 
       <div className="nh-create" style={{ marginBottom: 20 }}>
         <div>
-          <span className="eyebrow">Or design your own</span>
-          <div className="hd">Build a new case with the setup agent</div>
-          <p className="fg-3">
-            Describe your situation; the agent asks clarifying questions and scaffolds a fresh scenario —
-            world bible, agent roster, hidden agendas.
-          </p>
+          <span className="eyebrow">{t('newGame.designOwn.eyebrow')}</span>
+          <div className="hd">{t('newGame.designOwn.title')}</div>
+          <p className="fg-3">{t('newGame.designOwn.dek')}</p>
         </div>
-        <a className="btn secondary" href="#/new-case">Talk to the setup agent →</a>
+        <a className="btn secondary" href="#/new-case">{t('newGame.designOwn.cta')}</a>
       </div>
 
       {err && <div className="nh-dossier"><p style={{ color: 'var(--oxblood)' }}>{err}</p></div>}
-      {!scenarios && !err && <p className="fg-3">Loading scenarios…</p>}
+      {!scenarios && !err && <p className="fg-3">{t('newGame.scenarios.loading')}</p>}
 
       {scenarios && (
         <div className="nh-scenarios">
@@ -104,37 +116,51 @@ export function NewGame() {
               <div className="nh-sc__meta">
                 <span>{s.industry}</span>
                 <span className="sep" />
-                <span>vs {s.rival_name}</span>
+                <span>{t('newGame.scenario.vs', { rival: s.rival_name })}</span>
               </div>
-              <p>Role · {s.player_role} · {s.agent_count} advisory agents at your board.</p>
-              <div className="nh-sc__fn">Five turns · fog-of-war briefings · adjudicated outcomes</div>
+              <p>
+                {t('newGame.scenario.role')} · {s.player_role} ·{' '}
+                {t('newGame.scenario.agentCount', { count: s.agent_count })}
+              </p>
+              <div className="nh-sc__fn">{t('newGame.scenario.footnote')}</div>
             </button>
           ))}
         </div>
       )}
 
+      <LanguagePicker
+        language={language}
+        onPick={pickLanguage}
+        labels={{
+          eyebrow: t('newGame.lang.eyebrow'),
+          helper: t('newGame.lang.helper'),
+          en: t('newGame.lang.en'),
+          de: t('newGame.lang.de'),
+        }}
+      />
+
       <div className="nh-create">
         <div>
-          <span className="eyebrow">Ready</span>
-          <div className="hd">{picked ? `Open ${scenarios?.find((s) => s.scenario_id === picked)?.company_name ?? picked}` : 'Pick a scenario above'}</div>
+          <span className="eyebrow">{t('newGame.ready.eyebrow')}</span>
+          <div className="hd">{readyTitle}</div>
           <p className="fg-3">
             {models.length > 0 ? (
               <>
-                Engine ·{' '}
+                {t('newGame.ready.engineWith')}{' '}
                 <select value={model} onChange={(e) => setModel(e.target.value)} style={{ font: 'inherit' }}>
                   {models.map((m) => (
                     <option key={m.id} value={m.id}>{m.display_name} · {m.provider}</option>
                   ))}
                 </select>
-                {' '}· generates briefing · ~30s · Turn 1 of 5.
+                {' '}{t('newGame.ready.engineTail')}
               </>
             ) : (
-              <>Model generates briefing · ~30s · Turn 1 of 5.</>
+              <>{t('newGame.ready.modelOnly')}</>
             )}
           </p>
         </div>
         <button className="btn primary" onClick={create} disabled={!picked || busy}>
-          {busy ? 'Generating briefing…' : 'Open case →'}
+          {busy ? t('newGame.ready.busy') : t('newGame.ready.openCta')}
         </button>
       </div>
 
@@ -154,6 +180,40 @@ export function NewGame() {
   );
 }
 
+function LanguagePicker({
+  language, onPick, labels,
+}: {
+  language: Language;
+  onPick: (l: Language) => void;
+  labels: { eyebrow: string; helper: string; en: string; de: string };
+}) {
+  const Pill = ({ value, children }: { value: Language; children: React.ReactNode }) => (
+    <button
+      type="button"
+      onClick={() => onPick(value)}
+      aria-pressed={language === value}
+      className={`btn sm ${language === value ? 'primary' : 'ghost'}`}
+      style={{ minWidth: 96 }}
+    >
+      {children}
+    </button>
+  );
+  return (
+    <section className="nh-lang-picker" style={{ marginBottom: 20 }}>
+      <div className="nh-create" style={{ alignItems: 'center' }}>
+        <div>
+          <span className="eyebrow">{labels.eyebrow}</span>
+          <p className="fg-3" style={{ margin: 0 }}>{labels.helper}</p>
+        </div>
+        <div role="group" aria-label={labels.eyebrow} style={{ display: 'flex', gap: 6 }}>
+          <Pill value="en">{labels.en}</Pill>
+          <Pill value="de">{labels.de}</Pill>
+        </div>
+      </div>
+    </section>
+  );
+}
+
 function RoleOverrides({
   roles, models, overrides, open, onToggle, onSet, onReset, gameDefault,
 }: {
@@ -166,7 +226,13 @@ function RoleOverrides({
   onReset: () => void;
   gameDefault: string;
 }) {
+  const { t } = useI18n();
   const overrideCount = Object.keys(overrides).length;
+  const summary = overrideCount === 0
+    ? t('newGame.roleOverrides.allDefault')
+    : overrideCount === 1
+      ? t('newGame.roleOverrides.someRouted', { count: overrideCount })
+      : t('newGame.roleOverrides.someRouted.plural', { count: overrideCount });
   return (
     <section className="nh-role-overrides">
       <button
@@ -176,39 +242,36 @@ function RoleOverrides({
         aria-expanded={open}
       >
         <div>
-          <span className="eyebrow">Per-role model routing</span>
-          <div className="hd">
-            {overrideCount === 0
-              ? 'All roles use the game default'
-              : `${overrideCount} role${overrideCount === 1 ? '' : 's'} routed to a different model`}
-          </div>
+          <span className="eyebrow">{t('newGame.roleOverrides.eyebrow')}</span>
+          <div className="hd">{summary}</div>
         </div>
-        <span className="mono fg-3">{open ? 'Hide ↑' : 'Configure ↓'}</span>
+        <span className="mono fg-3">
+          {open ? t('newGame.roleOverrides.hide') : t('newGame.roleOverrides.configure')}
+        </span>
       </button>
       {open && (
         <div className="nh-role-overrides__body">
           <p className="fg-3" style={{ margin: '0 0 12px' }}>
-            Each role can be pinned to a specific model — leave on the default to use{' '}
-            <span className="mono">{gameDefault || '(server default)'}</span>. Useful for routing
-            cheap planning to small models and reserving the flagship for adjudication.
+            {t('newGame.roleOverrides.intro.lead')}{' '}
+            <span className="mono">{gameDefault || t('newGame.roleOverrides.serverDefault')}</span>.
+            {' '}{t('newGame.roleOverrides.intro.tail')}
           </p>
           <div className="nh-role-overrides__rows">
             {roles.map((role) => {
               const current = overrides[role] ?? '';
+              const blurbKey = ROLE_BLURB_KEYS[role];
               return (
                 <div className="nh-role-row" key={role}>
                   <div className="nh-role-row__name">
                     <span className="code mono">{role}</span>
-                    {ROLE_BLURBS[role] && (
-                      <span className="hint">{ROLE_BLURBS[role]}</span>
-                    )}
+                    {blurbKey && <span className="hint">{t(blurbKey)}</span>}
                   </div>
                   <select
                     value={current}
                     onChange={(e) => onSet(role, e.target.value)}
                     style={{ font: 'inherit' }}
                   >
-                    <option value="">(use game default)</option>
+                    <option value="">{t('newGame.roleOverrides.useDefault')}</option>
                     {models.map((m) => (
                       <option key={m.id} value={m.id}>
                         {m.display_name} · {m.provider}
@@ -226,7 +289,7 @@ function RoleOverrides({
               onClick={onReset}
               disabled={overrideCount === 0}
             >
-              Reset to defaults
+              {t('newGame.roleOverrides.reset')}
             </button>
           </div>
         </div>

frontend/src/screens/SetupCase.tsx

@@ -4,6 +4,7 @@ import remarkGfm from 'remark-gfm';
 import { api, SetupSession, SetupMessage, UploadedDocument } from '../api';
 import { navigate } from '../App';
 import { Spinner } from '../components/Shell';
+import { useI18n, type StringKey } from '../i18n';
 
 type Phase = 'intro' | 'chat' | 'committing';
 
@@ -28,6 +29,7 @@ function isAllowedExt(name: string): boolean {
 }
 
 export function SetupCase() {
+  const { t } = useI18n();
   const [phase, setPhase] = useState<Phase>('intro');
   const [scenarioId, setScenarioId] = useState(defaultScenarioId);
   const [brief, setBrief] = useState('');
@@ -92,24 +94,24 @@ export function SetupCase() {
     const list = Array.from(files);
     if (list.length === 0) return;
     if (docs.length + list.length > DOC_MAX_COUNT) {
-      setDocErr(`Cap is ${DOC_MAX_COUNT} documents per session — currently ${docs.length} uploaded.`);
+      setDocErr(t('setup.docs.cap', { max: DOC_MAX_COUNT, count: docs.length }));
       return;
     }
     setDocBusy(true);
     try {
       for (const file of list) {
         if (!isAllowedExt(file.name)) {
-          setDocErr(`"${file.name}": only ${DOC_ALLOWED_EXT.join(', ')} are accepted.`);
+          setDocErr(t('setup.docs.unsupported', { file: file.name, exts: DOC_ALLOWED_EXT.join(', ') }));
           continue;
         }
         if (file.size > DOC_MAX_BYTES) {
-          setDocErr(`"${file.name}": exceeds the 25 MB cap (${fmtBytes(file.size)}).`);
+          setDocErr(t('setup.docs.tooLarge', { file: file.name, size: fmtBytes(file.size) }));
           continue;
         }
         try {
           await api.uploadDocument(session.session_id, file);
         } catch (e: any) {
-          setDocErr(`"${file.name}": ${e?.message ?? String(e)}`);
+          setDocErr(t('setup.docs.uploadFail', { file: file.name, message: e?.message ?? String(e) }));
         }
       }
       await refreshDocs(session.session_id);
@@ -125,7 +127,7 @@ export function SetupCase() {
       await api.deleteDocument(session.session_id, filename);
       await refreshDocs(session.session_id);
     } catch (e: any) {
-      setDocErr(`Could not remove "${filename}": ${e?.message ?? String(e)}`);
+      setDocErr(t('setup.docs.removeFail', { file: filename, message: e?.message ?? String(e) }));
     }
   }
 
@@ -153,13 +155,9 @@ export function SetupCase() {
     return (
       <>
         <section className="nh-hero">
-          <div className="nh-eyebrow"><b>New case</b> · design one with the setup agent</div>
-          <h1>Describe the situation. The agent will ask clarifying questions, then scaffold the scenario.</h1>
-          <p className="nh-dek">
-            Write a paragraph or two about the company, the rival or threat, the stakes, and whatever constraints
-            you already know. The setup agent will fill in the gaps: agent roster, world bible, starting metrics,
-            hidden agendas. Takes a few rounds of Q&amp;A (30–60s per round).
-          </p>
+          <div className="nh-eyebrow"><b>{t('setup.eyebrow.lead')}</b> · {t('setup.eyebrow.tail')}</div>
+          <h1>{t('setup.intro.title')}</h1>
+          <p className="nh-dek">{t('setup.intro.dek')}</p>
         </section>
 
         {err && <div className="nh-dossier"><p style={{ color: 'var(--oxblood)' }}>{err}</p></div>}
@@ -170,44 +168,44 @@ export function SetupCase() {
               <form onSubmit={(e) => { e.preventDefault(); start(); }}>
                 <div className="nh-formrow">
                   <label>
-                    Case ID{' '}
-                    <span className="ct mono">{scenarioId.length} / 60</span>
+                    {t('setup.caseId.label')}{' '}
+                    <span className="ct mono">{t('setup.caseId.charCount', { count: scenarioId.length })}</span>
                   </label>
                   <input
                     value={scenarioId}
                     maxLength={60}
                     onChange={(e) => setScenarioId(e.target.value)}
-                    placeholder="e.g. nord_heatpump_takeover"
+                    placeholder={t('setup.caseId.placeholder')}
                     style={{ fontFamily: 'var(--font-mono)' }}
                   />
                   <div className="hint" style={{ marginTop: 4, color: 'var(--slate)' }}>
-                    Lowercase letters, digits, underscores. Must start with a letter. 3–60 chars.
+                    {t('setup.caseId.helper')}
                     {!scenarioIdValid && scenarioId.length > 0 && (
-                      <span style={{ color: 'var(--oxblood)' }}> Invalid format.</span>
+                      <span style={{ color: 'var(--oxblood)' }}> {t('setup.caseId.invalid')}</span>
                     )}
                   </div>
                 </div>
                 <div className="nh-formrow" style={{ marginTop: 14 }}>
                   <label>
-                    Situation brief{' '}
-                    <span className="ct mono">{brief.trim().length} / 2000 (min 10)</span>
+                    {t('setup.brief.label')}{' '}
+                    <span className="ct mono">{t('setup.brief.charCount', { count: brief.trim().length })}</span>
                   </label>
                   <textarea
                     value={brief}
                     maxLength={2000}
                     rows={8}
                     onChange={(e) => setBrief(e.target.value)}
-                    placeholder="e.g. We're a mid-sized German heat-pump maker, €680M revenue, 2800 employees. A Chinese entrant (Aergis Climate) just acquired an Italian subsidiary and is undercutting us on price at the EU commercial segment. Board wants a response for Q2. Regulatory pressure from F-gas phase-out plays in our favor on paper but the Betriebsrat is nervous about restructuring."
+                    placeholder={t('setup.brief.placeholder')}
                   />
                 </div>
                 <div className="nh-chat__submit">
-                  <span className="hint">The agent uses this as its starting context.</span>
+                  <span className="hint">{t('setup.start.helper')}</span>
                   <button
                     type="submit"
                     className="btn primary"
                     disabled={!scenarioIdValid || !briefValid || busy}
                   >
-                    {busy ? <><Spinner /> Starting conversation…</> : 'Start conversation →'}
+                    {busy ? <><Spinner /> {t('setup.start.busy')}</> : t('setup.start.cta')}
                   </button>
                 </div>
               </form>
@@ -226,14 +224,13 @@ export function SetupCase() {
     <>
       <section className="nh-hero">
         <div className="nh-eyebrow">
-          <b>Setup agent</b> · case <span className="mono">{session?.scenario_id}</span>
+          <b>{t('setup.chat.eyebrow.lead')}</b> · {t('setup.chat.eyebrow.case')}{' '}
+          <span className="mono">{session?.scenario_id}</span>
           <span>·</span>
-          <b>{ready ? 'Brief ready — review below' : 'Gathering context'}</b>
+          <b>{ready ? t('setup.chat.status.ready') : t('setup.chat.status.gathering')}</b>
         </div>
         <h1>
-          {ready
-            ? 'The agent has a complete brief. Review and commit to scaffold the scenario.'
-            : 'Answer the agent\u2019s questions. It\u2019ll ask a few more then hand you a synthesized brief.'}
+          {ready ? t('setup.chat.title.ready') : t('setup.chat.title.gathering')}
         </h1>
       </section>
 
@@ -255,7 +252,9 @@ export function SetupCase() {
             {msgs.map((m, i) => <Msg key={i} m={m} />)}
             {busy && (
               <div className="nh-msg control">
-                <div className="nh-msg__meta"><span>Setup agent</span> thinking…</div>
+                <div className="nh-msg__meta">
+                  <span>{t('setup.chat.label.agent')}</span> {t('setup.chat.thinking')}
+                </div>
                 <div className="nh-msg__body"><Spinner /></div>
               </div>
             )}
@@ -263,13 +262,14 @@ export function SetupCase() {
 
           {ready && session?.synthesized_brief && (
             <div className="nh-spec">
-              <span className="eyebrow">Synthesized brief · this is what will be scaffolded</span>
+              <span className="eyebrow">{t('setup.synthesis.eyebrow')}</span>
               <div className="setup-md" style={{ fontSize: 14, lineHeight: 1.55 }}>
                 <ReactMarkdown remarkPlugins={[remarkGfm]}>{session.synthesized_brief}</ReactMarkdown>
               </div>
               <div className="nh-spec__fn">
-                Commit writes <span className="mono">scenarios/{session.scenario_id}/</span> — world_bible,
-                agents.yaml, initial_state.json — then opens Turn 1.
+                {t('setup.synthesis.footnote.lead')}{' '}
+                <span className="mono">scenarios/{session.scenario_id}/</span>{' '}
+                {t('setup.synthesis.footnote.tail')}
               </div>
             </div>
           )}
@@ -279,20 +279,24 @@ export function SetupCase() {
               <div className="nh-chat__creating">
                 <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
                   <Spinner />
-                  <span>Scaffolding <span className="mono">{session?.scenario_id}</span> and generating Turn 1…</span>
+                  <span>
+                    {t('setup.committing.lead')}{' '}
+                    <span className="mono">{session?.scenario_id}</span>{' '}
+                    {t('setup.committing.tail')}
+                  </span>
                 </div>
                 <div className="hint mono fg-3" style={{ marginTop: 6 }}>
-                  This takes ~30–60s (scaffold + briefing). Don't navigate away.
+                  {t('setup.committing.helper')}
                 </div>
               </div>
             ) : (
               <div className="nh-chat__approve">
                 <div>
-                  <span className="eyebrow">Approve to scaffold</span>
-                  <div className="hd">Commit brief & launch Turn 1</div>
+                  <span className="eyebrow">{t('setup.commit.eyebrow')}</span>
+                  <div className="hd">{t('setup.commit.title')}</div>
                 </div>
                 <button className="btn primary" onClick={commitAndLaunch} disabled={busy}>
-                  Commit & launch →
+                  {t('setup.commit.cta')}
                 </button>
               </div>
             )
@@ -310,17 +314,17 @@ export function SetupCase() {
                       send();
                     }
                   }}
-                  placeholder="Your answer… (Ctrl/Cmd+Enter to send)"
+                  placeholder={t('setup.reply.placeholder')}
                   disabled={busy}
                 />
                 <div className="nh-chat__submit">
-                  <span className="hint">{answer.length} / 4000</span>
+                  <span className="hint">{t('setup.reply.charCount', { count: answer.length })}</span>
                   <button
                     type="submit"
                     className="btn primary"
                     disabled={!answer.trim() || busy}
                   >
-                    {busy ? <><Spinner /> Sending…</> : 'Send →'}
+                    {busy ? <><Spinner /> {t('setup.reply.sending')}</> : t('setup.reply.send')}
                   </button>
                 </div>
               </form>
@@ -333,11 +337,12 @@ export function SetupCase() {
 }
 
 function Msg({ m }: { m: SetupMessage }) {
+  const { t } = useI18n();
   const who = m.role === 'user' ? 'user' : 'control';
-  const label = m.role === 'user' ? 'You' : 'Setup agent';
+  const labelKey: StringKey = m.role === 'user' ? 'setup.chat.label.user' : 'setup.chat.label.agent';
   return (
     <div className={`nh-msg ${who}`}>
-      <div className="nh-msg__meta"><span>{label}</span> {fmtAt(m.at)}</div>
+      <div className="nh-msg__meta"><span>{t(labelKey)}</span> {fmtAt(m.at)}</div>
       <div className="nh-msg__body">
         {m.role === 'setup_agent' ? (
           <div className="setup-md">
@@ -367,6 +372,7 @@ function DocUploadPanel({
   onUpload: (files: FileList | File[]) => void | Promise<void>;
   onRemove: (filename: string) => void | Promise<void>;
 }) {
+  const { t } = useI18n();
   const [drag, setDrag] = useState(false);
   const fileInputRef = useRef<HTMLInputElement | null>(null);
   const remaining = DOC_MAX_COUNT - docs.length;
@@ -375,12 +381,10 @@ function DocUploadPanel({
     <section className="nh-doc-upload">
       <div className="nh-doc-upload__hd">
         <div>
-          <span className="eyebrow">Grounding documents</span>
-          <div className="hd">
-            Drop in source materials — the setup agent extracts hard constraints from these at commit time.
-          </div>
+          <span className="eyebrow">{t('setup.docs.eyebrow')}</span>
+          <div className="hd">{t('setup.docs.title')}</div>
         </div>
-        <span className="mono fg-3">{docs.length} / {DOC_MAX_COUNT}</span>
+        <span className="mono fg-3">{t('setup.docs.count', { used: docs.length, max: DOC_MAX_COUNT })}</span>
       </div>
 
       <div
@@ -425,13 +429,13 @@ function DocUploadPanel({
         />
         <div className="nh-doc-drop__cta">
           {busy ? (
-            <><Spinner /> Uploading…</>
+            <><Spinner /> {t('setup.docs.uploading')}</>
           ) : remaining <= 0 ? (
-            <span>Limit reached — remove a document to upload another.</span>
+            <span>{t('setup.docs.limitReached')}</span>
           ) : (
             <>
-              <strong>Drop documents here</strong> or click to browse —
-              <span className="mono"> {DOC_ALLOWED_EXT.join(' · ')}</span> · max 25 MB each.
+              <strong>{t('setup.docs.dropLead')}</strong> {t('setup.docs.dropTail')}
+              <span className="mono"> {DOC_ALLOWED_EXT.join(' · ')}</span> · {t('setup.docs.dropMeta')}
             </>
           )}
         </div>
@@ -451,7 +455,7 @@ function DocUploadPanel({
                 onClick={() => onRemove(d.filename)}
                 disabled={busy}
               >
-                remove
+                {t('setup.docs.remove')}
               </button>
             </li>
           ))}

wargame/agents/base.py

@@ -21,9 +21,11 @@ per-turn data into the user message.
 
 from __future__ import annotations
 
+import contextlib
 import json
 import logging
 import re
+from collections.abc import Iterator
 from contextvars import ContextVar
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, TypeVar
@@ -113,6 +115,65 @@ _current_turn_usage: ContextVar["TurnUsage | None"] = ContextVar(
 )
 
 
+# ---------------------------------------------------------------------------
+# Per-game output language (ContextVar set by engine entry points)
+#
+# The system prompt is cache-stable across turns (Anthropic prompt caching
+# requires byte-identical prefixes). The language directive is appended to
+# the USER message so the cache stays warm AND the directive is stable
+# within a language. Default is English so legacy snapshots without a
+# `language` field continue to behave exactly as before.
+# ---------------------------------------------------------------------------
+
+
+_current_language: ContextVar[str] = ContextVar(
+    "wargame_current_language", default="en"
+)
+
+
+def language_directive(lang: str) -> str:
+    """Return the user-message suffix that pins the LLM's output language.
+
+    The German directive explicitly preserves proper nouns and quoted
+    references so the world bible's named entities (Norhard Thermal AG,
+    Bettina Lange, Aergis Climate, …) don't get translated mid-sentence,
+    and so contract-style citations stay verbatim.
+    """
+    if lang == "de":
+        return (
+            "Antworte ausschliesslich auf klarem, praezisem Deutsch. "
+            "Behalte alle Eigennamen (Personen, Firmen, Behoerden, Produkte) "
+            "im Original und uebersetze sie nicht (z. B. Norhard Thermal AG, "
+            "Aergis Climate, Bettina Lange, Bundeskartellamt). Halte "
+            "numerische Werte, Kennzahlen, Vertragsklauseln und woertliche "
+            "Zitate im Originalwortlaut. Nur Fliesstext, Erklaerungen und "
+            "Rollen-/Tonalitaetsangaben werden ins Deutsche uebertragen."
+        )
+    return "Respond in clear, concise English."
+
+
+def current_language() -> str:
+    """Return the active output language for the current call context."""
+    return _current_language.get()
+
+
+@contextlib.contextmanager
+def use_game_language(lang: str) -> Iterator[None]:
+    """Pin the output language for every `call_structured` call in this scope.
+
+    Mirrors `wargame.config.use_game_model`: takes a ContextVar token and
+    restores the previous value on exit so nested scopes compose cleanly.
+    Unknown values fall back to English at directive-render time, so a
+    typoed value never crashes a turn — but `Game.language` is `Literal[
+    "en", "de"]` so the engine never gets there in practice.
+    """
+    token = _current_language.set(lang)
+    try:
+        yield
+    finally:
+        _current_language.reset(token)
+
+
 def begin_turn_usage() -> "TurnUsage":
     """Start a fresh per-turn TurnUsage and bind it in the current context."""
     from wargame.engine.state import TurnUsage
@@ -205,6 +266,11 @@ def call_structured(
     """
     model_id = model_for(role)
     spec = resolve_model(model_id)
+    # Append the language directive to the USER message (NOT the system
+    # prompt) so the system prefix stays byte-identical across turns and
+    # Anthropic prompt caching keeps hitting. The directive itself is
+    # stable within a language, so cache effectiveness is preserved.
+    user_with_directive = f"{user}\n\n{language_directive(current_language())}\n"
     # Lazy import to avoid loading optional SDKs at module-import time.
     from wargame.agents.providers import dispatch
 
@@ -212,7 +278,7 @@ def call_structured(
     return provider_fn(
         schema=schema,
         system=system,
-        user=user,
+        user=user_with_directive,
         model=model_id,
         role=role,
         temperature=temperature,

wargame/agents/control.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from wargame.agents.base import call_structured
+from wargame.agents.base import call_structured, current_language
 from wargame.agents.prompts_loader import render
 from wargame.engine.state import (
     ActionSubmission,
@@ -30,6 +30,23 @@ if TYPE_CHECKING:
     from wargame.agents.registry import ScenarioConfig
 
 
+# ---------------------------------------------------------------------------
+# Localizable strings — only the small set of UI fragments the engine emits
+# directly into the user message (the LLM doesn't author them, so the
+# language directive can't translate them). Scenario reference data
+# (world bible, agents.yaml) stays English by design.
+# ---------------------------------------------------------------------------
+
+
+def _t(en: str, de: str) -> str:
+    """Pick the EN or DE string based on the active language ContextVar.
+
+    Falls back to English when no language is bound — keeps the engine
+    safe to call from offline scripts that never set up a game.
+    """
+    return de if current_language() == "de" else en
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -37,8 +54,12 @@ if TYPE_CHECKING:
 
 def _metrics_table(world: WorldState) -> str:
     if not world.metrics:
-        return "_(no metrics)_"
-    lines = ["| Metric | Value | Δ last turn |", "|---|---|---|"]
+        return _t("_(no metrics)_", "_(keine Kennzahlen)_")
+    header = _t(
+        "| Metric | Value | Δ last turn |",
+        "| Kennzahl | Wert | Δ letzte Runde |",
+    )
+    lines = [header, "|---|---|---|"]
     for m in world.metrics:
         delta = f"{m.delta_last_turn:+.2f}".rstrip("0").rstrip(".") if m.delta_last_turn else "—"
         lines.append(f"| {m.label} | {m.value:g} {m.unit} | {delta} |")
@@ -47,7 +68,7 @@ def _metrics_table(world: WorldState) -> str:
 
 def _recent_events(world: WorldState, limit: int = 12) -> str:
     if not world.recent_events:
-        return "_(no recent events)_"
+        return _t("_(no recent events)_", "_(keine aktuellen Ereignisse)_")
     return "\n".join(f"- {e}" for e in world.recent_events[-limit:])
 
 
@@ -58,29 +79,37 @@ def _delta_summary(game: Game) -> str:
     it reports the last turn's verdicts and metric movements.
     """
     if len(game.turns) < 2:
-        return (
+        return _t(
             "This is turn 1. The disrupting event has just landed; the player "
             "has not yet acted. Focus the briefing on what the disruption means "
-            "for the CEO's next 10 days."
+            "for the CEO's next 10 days.",
+            "Dies ist Runde 1. Das auslösende Ereignis ist gerade eingetreten; "
+            "der Spieler hat noch nicht gehandelt. Konzentriere das Briefing "
+            "darauf, was die Disruption für die nächsten 10 Tage des CEO bedeutet.",
         )
     prev = game.turns[-2]
     lines: list[str] = []
     if prev.player_action:
-        lines.append(f"Player acted last turn: {prev.player_action.intent!r}")
+        prefix = _t("Player acted last turn", "Spieler-Aktion in letzter Runde")
+        lines.append(f"{prefix}: {prev.player_action.intent!r}")
     if prev.verdicts:
-        lines.append("Verdicts rendered:")
+        lines.append(_t("Verdicts rendered:", "Gefällte Urteile:"))
+        plaus_label = _t("plausibility", "Plausibilität")
         for v in prev.verdicts:
             lines.append(
                 f"  - {v.action_actor}: {v.outcome.value} "
-                f"(plausibility {v.plausibility}) — {v.effect_narrative}"
+                f"({plaus_label} {v.plausibility}) — {v.effect_narrative}"
             )
     if game.world.metrics:
         moved = [m for m in game.world.metrics if abs(m.delta_last_turn) > 1e-9]
         if moved:
-            lines.append("Metrics moved last turn:")
+            lines.append(_t("Metrics moved last turn:", "Bewegte Kennzahlen letzte Runde:"))
             for m in moved:
                 lines.append(f"  - {m.label}: {m.delta_last_turn:+g} {m.unit}")
-    return "\n".join(lines) or "_(no meaningful delta)_"
+    return "\n".join(lines) or _t(
+        "_(no meaningful delta)_",
+        "_(keine wesentliche Veränderung)_",
+    )
 
 
 # ---------------------------------------------------------------------------

wargame/api/routes.py

@@ -238,6 +238,7 @@ def create_game(body: NewGameRequest) -> NewGameResponse:
             body.scenario_id,
             model=spec.id,
             role_model_overrides=body.role_model_overrides,
+            language=body.language,
         )
     except ValueError as e:
         raise HTTPException(status_code=422, detail=str(e)) from None
@@ -282,6 +283,7 @@ def get_state(game_id: str) -> StateResponse:
         recon_budget_remaining=game.recon_budget_remaining,
         current_phase=phase,
         turns=game.turns,
+        language=game.language,
     )
 
 
@@ -404,6 +406,7 @@ def post_pause(game_id: str) -> StateResponse:
         recon_budget_remaining=game.recon_budget_remaining,
         current_phase=phase,
         turns=game.turns,
+        language=game.language,
     )
 
 

wargame/api/schemas.py

@@ -6,6 +6,8 @@ models — we only add HTTP-specific envelopes and request bodies here.
 
 from __future__ import annotations
 
+from typing import Literal
+
 from pydantic import BaseModel, Field
 
 from wargame.engine.state import (
@@ -51,6 +53,14 @@ class NewGameRequest(BaseModel):
             "Call `GET /models` for the list of canonical role tags."
         ),
     )
+    language: Literal["en", "de"] = Field(
+        default="en",
+        description=(
+            "Output language for every LLM-generated user-facing string in "
+            "this game. Scenario reference data stays English; only the "
+            "LLM's output language changes."
+        ),
+    )
 
 
 class ReconRequest(BaseModel):
@@ -112,6 +122,13 @@ class StateResponse(BaseModel):
     recon_budget_remaining: int
     current_phase: str
     turns: list[TurnRecord]
+    language: Literal["en", "de"] = Field(
+        default="en",
+        description=(
+            "Output language pinned to this game. Frontend can branch on "
+            "this to localize its own static UI chrome to match."
+        ),
+    )
 
 
 class BriefingResponse(BaseModel):

wargame/cli.py

@@ -207,6 +207,17 @@ def cmd_new(
             ),
         ),
     ] = None,
+    language: Annotated[
+        str,
+        typer.Option(
+            "--language",
+            help=(
+                "Output language for every LLM-generated user-facing string "
+                "in this game. Supported: en, de. Scenario reference data "
+                "(world bible, agent personas) stays English regardless."
+            ),
+        ),
+    ] = "en",
     orchestrate: Annotated[
         bool,
         typer.Option(
@@ -241,9 +252,14 @@ def cmd_new(
     except ValueError as e:
         raise typer.BadParameter(str(e)) from None
     overrides = _parse_model_for_flags(model_for)
+    if language not in ("en", "de"):
+        raise typer.BadParameter(
+            f"--language must be one of: en, de (got {language!r})."
+        )
     console.print(
         f"[bold]Starting new game:[/bold] scenario=[cyan]{scenario}[/cyan]  "
-        f"model=[cyan]{spec.id}[/cyan]"
+        f"model=[cyan]{spec.id}[/cyan]  "
+        f"language=[cyan]{language}[/cyan]"
         + (
             f"  overrides=[cyan]{', '.join(f'{r}={m}' for r, m in overrides.items())}[/cyan]"
             if overrides
@@ -251,7 +267,12 @@ def cmd_new(
         )
     )
     try:
-        game = loop.new_game(scenario, model=spec.id, role_model_overrides=overrides)
+        game = loop.new_game(
+            scenario,
+            model=spec.id,
+            role_model_overrides=overrides,
+            language=language,
+        )
     except ValueError as e:
         raise typer.BadParameter(str(e)) from None
     scen = load_scenario(scenario)
@@ -381,7 +402,8 @@ def cmd_state(
             f"[bold]{w.company_name}[/bold] vs [bold]{w.rival_name}[/bold]\n"
             f"Industry: {w.industry}\n"
             f"Turn: {w.turn}/{w.max_turns}   Status: {game.status}   "
-            f"Media tone: [magenta]{w.media_tone.value}[/magenta]\n\n"
+            f"Media tone: [magenta]{w.media_tone.value}[/magenta]   "
+            f"Language: [cyan]{game.language}[/cyan]\n\n"
             f"{w.public_narrative}",
             title="World state",
             border_style="cyan",

wargame/engine/loop.py

@@ -16,7 +16,7 @@ import logging
 import threading
 
 from wargame.agents import constraint_checker, rival_ceo
-from wargame.agents.base import begin_turn_usage, end_turn_usage
+from wargame.agents.base import begin_turn_usage, end_turn_usage, use_game_language
 from wargame.agents.registry import ScenarioConfig, load_scenario
 from wargame.agents.roles import CANONICAL_ROLES
 from wargame.config import resolve_model, use_game_model
@@ -123,6 +123,7 @@ def new_game(
     *,
     model: str | None = None,
     role_model_overrides: dict[str, str] | None = None,
+    language: str = "en",
 ) -> Game:
     scenario = load_scenario(scenario_id)
     # Validate model early so a bad id doesn't blow up mid-briefing.
@@ -133,6 +134,11 @@ def new_game(
     # rest of the engine never has to handle an invalid override.
     validated_overrides = _validate_overrides_at_boundary(role_model_overrides or {})
 
+    if language not in ("en", "de"):
+        raise ValueError(
+            f"Unknown language {language!r}. Supported: 'en', 'de'."
+        )
+
     world = _load_initial_world_state(scenario)
     world.turn = 1  # first playable turn
 
@@ -145,13 +151,14 @@ def new_game(
         scenario_id=scenario_id,
         llm_model=spec.id,
         role_model_overrides=validated_overrides,
+        language=language,
         world=world,
         private=_init_private_state(scenario),
         recon_budget_remaining=RECON_BUDGET_PER_TURN,
         hard_constraints=initial_constraints,
     )
 
-    with use_game_model(game.llm_model, game.role_model_overrides):
+    with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
         # Seed the first TurnRecord up front so begin/end_turn_usage can write
         # to it as the rival plan + briefing calls happen.
         first_turn = TurnRecord(turn=1, phase=Phase.BRIEFING)
@@ -186,7 +193,7 @@ def new_game(
 def query(game: Game, agent_id: str, question: str) -> ReconResponse:
     scenario = load_scenario(game.scenario_id)
     current = game.current_turn
-    with use_game_model(game.llm_model, game.role_model_overrides):
+    with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
         begin_turn_usage()
         try:
             response = phases.answer_recon(scenario, game, agent_id, question)
@@ -218,7 +225,7 @@ def act(game: Game, action: ActionSubmission) -> None:
     """
     if game.hard_constraints:
         scenario = load_scenario(game.scenario_id)
-        with use_game_model(game.llm_model, game.role_model_overrides):
+        with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
             result = constraint_checker.check(scenario, game, action)
         if not result.passes:
             raise HardConstraintViolation(violations=result.violations)
@@ -235,7 +242,7 @@ def check_action(game: Game, action: ActionSubmission) -> ConstraintCheckResult:
     if not game.hard_constraints:
         return ConstraintCheckResult(passes=True, violations=[])
     scenario = load_scenario(game.scenario_id)
-    with use_game_model(game.llm_model, game.role_model_overrides):
+    with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
         return constraint_checker.check(scenario, game, action)
 
 
@@ -306,7 +313,7 @@ def advance(game: Game, *, generate_next_briefing: bool = True) -> Game:
             f"advance() requires phase=ACTION (player must act first). Current: {current.phase}"
         )
 
-    with use_game_model(game.llm_model, game.role_model_overrides):
+    with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
         with events.bind_publisher(game.id, current.turn):
             # Accumulate this turn's closing LLM work onto the closing TurnRecord.
             # `current.usage` may already carry the briefing cost from new_game /
@@ -446,7 +453,7 @@ def coach_note(game: Game) -> CoachNote:
     if game.status != "complete":
         raise ValueError("Coach note is only available after the game completes.")
     scenario = load_scenario(game.scenario_id)
-    with use_game_model(game.llm_model, game.role_model_overrides):
+    with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
         note = control.write_coach_note(scenario, game)
     return note
 
@@ -466,7 +473,7 @@ def peek(
     turn: int | None = None,
 ) -> tuple[AgentDeliberation, PeekRecord]:
     """Reveal one past deliberation from `agent_id` (default: latest)."""
-    with use_game_model(game.llm_model, game.role_model_overrides):
+    with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
         deliberation, record = phases.peek_agent(game, agent_id, turn=turn)
     persistence.save(game)
     return deliberation, record
@@ -492,7 +499,7 @@ def challenge_verdict(
 ) -> VerdictChallenge:
     """Record a player challenge; optionally kick off re-adjudication async."""
     scenario = load_scenario(game.scenario_id)
-    with use_game_model(game.llm_model, game.role_model_overrides):
+    with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
         challenge = phases.record_challenge(
             scenario=scenario,
             game=game,
@@ -529,7 +536,7 @@ def _resolve_challenge_worker(game_id: str, turn: int, challenge_idx: int) -> No
             )
             return
         challenge = target_turn.challenges[challenge_idx]
-        with use_game_model(game.llm_model, game.role_model_overrides):
+        with use_game_model(game.llm_model, game.role_model_overrides), use_game_language(game.language):
             phases.resolve_challenge(scenario, game, challenge)
         persistence.save(game)
         log.info(

wargame/engine/phases.py

@@ -168,13 +168,23 @@ def run_deliberations(
 
     # Fan out the LLM calls — each deliberation is independent. HTTP waits
     # dominate, so threads are sufficient (no need for asyncio).
+    #
+    # ThreadPoolExecutor workers do NOT inherit the caller's ContextVar
+    # context, so without copying the context the per-game model and
+    # language ContextVars would default-out inside the worker and every
+    # deliberation call would silently route to `default_model()` and the
+    # English directive. `contextvars.copy_context()` snapshots the
+    # caller's bindings; `ctx.run(...)` re-enters them on the worker.
+    import contextvars as _contextvars
     workers = int(os.getenv("WARGAME_DELIBERATION_WORKERS", "8"))
     deliberations: list[AgentDeliberation] = [None] * len(specs)  # type: ignore[list-item]
     with ThreadPoolExecutor(max_workers=workers) as pool:
-        for idx, d in zip(
-            range(len(specs)),
-            pool.map(_deliberate_one, specs),
-        ):
+        ctxs = [_contextvars.copy_context() for _ in specs]
+        results = pool.map(
+            lambda pair: pair[0].run(_deliberate_one, pair[1]),
+            zip(ctxs, specs),
+        )
+        for idx, d in zip(range(len(specs)), results):
             deliberations[idx] = d
 
     # Serialize mutations on game state after parallel work completes.

wargame/engine/state.py

@@ -533,6 +533,17 @@ class Game(BaseModel):
             "Critic / Pre-mortem / Evaluator to a cheaper model than Control."
         ),
     )
+    language: Literal["en", "de"] = Field(
+        default="en",
+        description=(
+            "Output language for every LLM-generated user-facing string in this "
+            "game (briefings, deliberations, verdicts, world updates, debrief, "
+            "recon answers, critic / premortem / evaluator outputs, coach notes). "
+            "Scenario reference data (world_bible.md, agents.yaml) stays English "
+            "regardless — only the LLM's output language changes. Old snapshots "
+            "without this field load as 'en'."
+        ),
+    )
     world: WorldState
     private: dict[str, AgentPrivateState] = Field(
         default_factory=dict,

wargame/orchestrator/runner.py

@@ -25,6 +25,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from wargame.agents import role as role_agent
+from wargame.agents.base import use_game_language
 from wargame.agents.registry import load_scenario
 from wargame.config import use_game_model
 from wargame.engine import loop as engine_loop
@@ -110,7 +111,7 @@ def run_orchestration(
     # `engine_loop.act` / `engine_loop.advance`, which have their own inner
     # `use_game_model` wraps — those re-pin inside the daemon worker thread
     # at loop.py:_resolve_challenge_worker, which doesn't inherit contexts.
-    with use_game_model(source_game.llm_model, source_game.role_model_overrides):
+    with use_game_model(source_game.llm_model, source_game.role_model_overrides), use_game_language(source_game.language):
         try:
             log.info(
                 "Orchestration %s: generating %d strategy vectors…",

wargame/tests/test_api.py

@@ -227,6 +227,46 @@ def test_new_game_rejects_unknown_override_model(client: TestClient) -> None:
     assert "Unknown model" in r.json()["detail"]
 
 
+def test_new_game_default_language_is_english(client: TestClient) -> None:
+    """POST /games without `language` defaults to en; GET state surfaces it."""
+    r = client.post("/games", json={"scenario_id": "competitor_disruption"})
+    assert r.status_code == 201
+    gid = r.json()["game_id"]
+
+    r = client.get(f"/games/{gid}/state")
+    assert r.status_code == 200
+    assert r.json()["language"] == "en"
+
+
+def test_new_game_with_german_language(client: TestClient) -> None:
+    """POST /games with language='de' persists and surfaces via GET state."""
+    r = client.post(
+        "/games",
+        json={"scenario_id": "competitor_disruption", "language": "de"},
+    )
+    assert r.status_code == 201
+    gid = r.json()["game_id"]
+
+    r = client.get(f"/games/{gid}/state")
+    assert r.status_code == 200
+    assert r.json()["language"] == "de"
+
+    # Round-trip via persistence too — the field landed on the snapshot.
+    from wargame.engine import persistence
+
+    game = persistence.load(gid)
+    assert game.language == "de"
+
+
+def test_new_game_rejects_unknown_language(client: TestClient) -> None:
+    """An unsupported language value returns 422 at the request boundary."""
+    r = client.post(
+        "/games",
+        json={"scenario_id": "competitor_disruption", "language": "fr"},
+    )
+    assert r.status_code == 422
+
+
 # ---------------------------------------------------------------------------
 # Scenario listing + scaffolding
 # ---------------------------------------------------------------------------

wargame/tests/test_phases.py

@@ -304,3 +304,163 @@ class TestRedTeam:
         assert player_score is not None
         assert player_score.deviation_from_control is not None
         assert player_score.deviation_from_control > 0.0
+
+
+class TestLanguageDirective:
+    """Round-6 i18n: a configured language must reach every LLM call.
+
+    The conftest `fake_llm` fixture monkeypatches `call_structured` directly
+    at every call site, bypassing the directive-injection that `call_structured`
+    actually performs. To test the injection itself, we patch only the
+    provider dispatch *below* `call_structured` — that lets the real
+    `call_structured` run, append the directive, and pass the modified user
+    message down to a capturing fake.
+    """
+
+    @staticmethod
+    def _capturing_provider(
+        captured: list[dict],
+        canned_dispatch,
+    ):
+        """Build a provider fn that records the (model, user) it was called
+        with and returns canned data via the conftest's `_dispatch` map."""
+
+        def provider(
+            *,
+            schema,
+            system: str,
+            user: str,
+            model: str,
+            role: str,
+            temperature: float,
+            max_tokens: int,
+        ):
+            captured.append(
+                {
+                    "schema": schema.__name__,
+                    "system": system,
+                    "user": user,
+                    "model": model,
+                    "role": role,
+                }
+            )
+            return schema.model_validate(canned_dispatch(schema.__name__, user))
+
+        return provider
+
+    def _patch_real_call_structured(self, monkeypatch) -> list[dict]:
+        """Install a capturing provider in place of the real dispatch.
+
+        The real `call_structured` runs (so the directive gets appended to
+        the user message), then routes to our capturing provider instead of
+        Anthropic / Azure. Returns the list that captures user/system/model
+        for every LLM call made inside the wrapped code path.
+        """
+        from wargame.agents import providers
+        from wargame.tests.conftest import _dispatch
+
+        captured: list[dict] = []
+        provider = self._capturing_provider(captured, _dispatch)
+        # Override `dispatch(...)` so every provider lookup returns our fn.
+        monkeypatch.setattr(providers, "dispatch", lambda _kind: provider)
+        return captured
+
+    def test_directive_appended_to_user_message_when_de(
+        self, monkeypatch
+    ) -> None:
+        from wargame.engine import loop
+
+        captured = self._patch_real_call_structured(monkeypatch)
+        game = loop.new_game("competitor_disruption", language="de")
+        loop.act(game, _player_action())
+        loop.advance(game)
+
+        assert captured, "no LLM calls captured — provider patch did not engage."
+        # Every captured user message must end with the German directive.
+        for entry in captured:
+            user = entry["user"]
+            assert "Antworte" in user, (
+                f"Expected German directive in user message for "
+                f"{entry['schema']}, got tail: {user[-200:]!r}"
+            )
+            # Sanity-check the proper-noun preservation clause is present.
+            assert "Eigennamen" in user
+
+    def test_directive_appended_to_user_message_when_en(
+        self, monkeypatch
+    ) -> None:
+        from wargame.engine import loop
+
+        captured = self._patch_real_call_structured(monkeypatch)
+        # Default language is English.
+        game = loop.new_game("competitor_disruption")
+        loop.act(game, _player_action())
+        loop.advance(game)
+
+        assert captured
+        for entry in captured:
+            user = entry["user"]
+            assert "Respond in clear, concise English." in user, (
+                f"Expected English directive in user message for "
+                f"{entry['schema']}, got tail: {user[-200:]!r}"
+            )
+
+    def test_system_prompt_byte_identical_across_languages(
+        self, monkeypatch
+    ) -> None:
+        """Cache-stability invariant: the system prefix MUST NOT depend on
+        the configured language. Anthropic prompt caching keys on the
+        system prefix; if it diverged, every language switch would burn
+        the cache. The directive lives in user, never in system.
+        """
+        from wargame.engine import loop
+
+        # Capture an English run and a German run, then compare every
+        # (schema, system) pair across the two — they MUST be identical.
+        captured_en = self._patch_real_call_structured(monkeypatch)
+        game_en = loop.new_game("competitor_disruption")
+        loop.act(game_en, _player_action())
+        loop.advance(game_en)
+
+        captured_de = self._patch_real_call_structured(monkeypatch)
+        game_de = loop.new_game("competitor_disruption", language="de")
+        loop.act(game_de, _player_action())
+        loop.advance(game_de)
+
+        # Build (schema_name, system) lists for each run.
+        en_systems = {(e["schema"], e["system"]) for e in captured_en}
+        de_systems = {(e["schema"], e["system"]) for e in captured_de}
+        # Every system prompt that appeared in DE must also appear identically
+        # in EN; the system prefix doesn't shift on language.
+        common_schemas = {s for s, _ in en_systems} & {s for s, _ in de_systems}
+        for schema_name in common_schemas:
+            en_for_schema = {sys for s, sys in en_systems if s == schema_name}
+            de_for_schema = {sys for s, sys in de_systems if s == schema_name}
+            # The two sets must overlap — at least one byte-identical match.
+            assert en_for_schema & de_for_schema, (
+                f"Schema {schema_name}: EN system prompts differ from DE. "
+                "The language directive must NOT bleed into the system prefix."
+            )
+
+    def test_language_directive_helper_returns_expected_strings(self) -> None:
+        from wargame.agents.base import language_directive
+
+        en = language_directive("en")
+        de = language_directive("de")
+        assert "English" in en
+        assert "Antworte" in de
+        assert "Eigennamen" in de
+        # Unknown language defaults to English directive.
+        assert language_directive("fr") == en
+
+    def test_use_game_language_context_manager(self) -> None:
+        from wargame.agents.base import current_language, use_game_language
+
+        # Default outside any with-block.
+        assert current_language() == "en"
+        with use_game_language("de"):
+            assert current_language() == "de"
+            with use_game_language("en"):
+                assert current_language() == "en"
+            assert current_language() == "de"
+        assert current_language() == "en"

wargame/tests/test_state.py

@@ -467,3 +467,41 @@ class TestGameRoleModelOverrides:
 
         with pytest.raises(typer.BadParameter, match="role=model_id"):
             _parse_model_for_flags(["control"])
+
+
+class TestGameLanguage:
+    def _world(self) -> WorldState:
+        return WorldState(
+            company_name="N",
+            rival_name="A",
+            industry="heat pumps",
+            turn=1,
+        )
+
+    def test_default_is_english(self) -> None:
+        game = Game(scenario_id="x", world=self._world())
+        assert game.language == "en"
+
+    def test_explicit_de(self) -> None:
+        game = Game(scenario_id="x", world=self._world(), language="de")
+        assert game.language == "de"
+
+    def test_round_trip_through_dump_validate(self) -> None:
+        game = Game(scenario_id="x", world=self._world(), language="de")
+        dumped = game.model_dump()
+        assert dumped["language"] == "de"
+        rehydrated = Game.model_validate(dumped)
+        assert rehydrated.language == "de"
+
+    def test_legacy_snapshot_without_field_loads_as_english(self) -> None:
+        legacy = {
+            "id": "abc",
+            "scenario_id": "x",
+            "world": self._world().model_dump(),
+        }
+        rehydrated = Game.model_validate(legacy)
+        assert rehydrated.language == "en"
+
+    def test_invalid_language_rejected(self) -> None:
+        with pytest.raises(ValidationError):
+            Game(scenario_id="x", world=self._world(), language="fr")