feat(i18n): add shared-contract architecture + bilingual MVP flow smoke

docs/I18N_ARCHITECTURE.md

@@ -0,0 +1,48 @@
+# Shared i18n architecture (frontend + backend)
+
+## Scope
+Issue #175 requires one shared i18n contract for MVP host/player flows across frontend and backend.
+
+## Source of truth
+- Catalog: `shared/i18n/lobby.json`
+- Locales:
+  - supported: `en`, `da`
+  - default/fallback: `en`
+
+Both Angular (`frontend/angular/src/app/lobby-i18n.ts`) and Django (`lobby/i18n.py`) read from this catalog.
+
+## Key naming convention
+- Domain-first namespaces:
+  - `frontend.ui.common.*`
+  - `frontend.ui.host.*`
+  - `frontend.ui.player.*`
+  - `frontend.errors.*`
+  - `backend.errors.*`
+  - `backend.error_codes.*`
+- UI lookup keys in Angular are shortened aliases mapped under `frontend.ui`, e.g.:
+  - `host.start_round`
+  - `player.submit_guess`
+  - `common.session_code`
+- Backend API errors return stable code + localized message:
+  - `error_code` = machine-stable key from `backend.error_codes`
+  - `error` = localized message from `backend.errors`
+  - `locale` = resolved request locale
+
+## Fallback model (robust)
+1. Resolve requested locale (`Accept-Language` on backend, user/browser preference on frontend).
+2. If locale unsupported -> use default `en`.
+3. If key missing -> return key and log warning.
+4. If locale translation missing for key -> fallback to `en` translation.
+
+## Audio-routing policy
+- Catalog capability: `frontend.capabilities.client_has_no_audio_output = true`
+- Host/player clients expose this as a read-only capability flag.
+- Policy: phone clients must not play audio directly; only primary/host output is allowed.
+
+## Verification
+- Backend tests: `lobby/tests.py` i18n coverage for locale selection + fallback + error-code/message matrix.
+- Frontend smoke/e2e-level unit coverage:
+  - `frontend/angular/src/app/lobby-i18n.spec.ts`
+  - `frontend/angular/src/app/i18n-mvp-flow-smoke.spec.ts`
+  - `frontend/angular/src/app/features/host/host-shell.component.spec.ts`
+  - `frontend/angular/src/app/features/player/player-shell.component.spec.ts`

docs/ISSUE-175-I18N-SHARED-CONTRACT-ARTIFACT.md

@@ -0,0 +1,35 @@
+# ISSUE-175 Artifact — shared i18n contract + MVP host/player flow
+
+## Delivered
+- Shared i18n contract is centralized in `shared/i18n/lobby.json` (da/en, default `en`, robust fallback).
+- Frontend host/player MVP copy is read via shared keys (no hardcoded Danish strings in Angular MVP flow components).
+- Backend error messages resolve from shared keyspace with locale-aware API payload (`error_code`, `error`, `locale`).
+- Audio-routing policy is explicit and shared: `frontend.capabilities.client_has_no_audio_output=true`.
+- Architecture + key naming documented in `docs/I18N_ARCHITECTURE.md`.
+
+## Smoke / e2e evidence
+### Backend locale + fallback
+Command:
+```bash
+. .venv/bin/activate && python manage.py test \
+  lobby.tests.LobbyFlowTests.test_join_error_localizes_to_danish_with_accept_language_header \
+  lobby.tests.LobbyFlowTests.test_join_error_falls_back_to_english_for_unsupported_locale \
+  lobby.tests.I18nResolverTests
+```
+Result:
+- PASS (7 tests)
+- Confirms `da` localization and fallback to `en` for unsupported locale.
+
+### Frontend host/player + language switch + audio policy
+Command:
+```bash
+cd frontend/angular
+npm test -- --run \
+  src/app/lobby-i18n.spec.ts \
+  src/app/i18n-mvp-flow-smoke.spec.ts \
+  src/app/features/host/host-shell.component.spec.ts \
+  src/app/features/player/player-shell.component.spec.ts
+```
+Result:
+- PASS (22 tests)
+- Includes smoke for host/player copy in **both en and da** and verifies primary-only audio policy flag (`clientHasNoAudioOutput=true`).

docs/ISSUE-188-SPA-CUTOVER-HARDENING-ARTIFACT.md

@@ -0,0 +1,47 @@
+# Issue #188 Artifact — SPA cutover hardening (asset versioning + rollback)
+
+## Scope
+Acceptance for `[READY][SPA][P11] Cutover hardening`:
+1. Dokumenteret strategi for cache-busting/versionering af SPA assets i Django staticfiles/reverse proxy setup.
+2. Konfigurerbar rollback-procedure for `USE_SPA_UI` (trin-for-trin, target <10 min).
+3. Smoke-artefakt for både SPA on/off i samme release-vindue.
+4. Ingen gameplay-ændringer.
+
+## 1) Asset versioning/cache-busting strategi
+Implementeret i SPA shell render-path:
+
+- Konfiguration i `partyhub/settings.py`:
+  - `WPP_SPA_ASSET_BASE` (eksisterende)
+  - `WPP_SPA_ASSET_VERSION` (ny)
+- `lobby/ui_views.py` injicerer `spa_asset_version` til template-context.
+- `lobby/templates/lobby/spa_shell.html` appender `?v={{ spa_asset_version }}` på:
+  - `styles.css`
+  - `main.js`
+
+Effekt:
+- Ny release-version (fx SHA/tag) kan tvinge cache-miss i browser/proxy uden ændring af route.
+- Rollback kan pege på tidligere stabil version-token med samme mekanisme.
+
+## 2) Rollback playbook (`USE_SPA_UI`) — target <10 min
+Dokumenteret i `docs/spa-cutover-flag.md`:
+
+1. Sæt `USE_SPA_UI=false`.
+2. Sæt `WPP_SPA_ASSET_VERSION` til sidste stabile release-token.
+3. Deploy/reload app-processer.
+4. Verificér legacy routes (`/lobby/ui/host` + `/lobby/ui/player`).
+5. Kør hurtig smoke sanity.
+6. Log trigger/timestamp/resultat i smoke artifact.
+
+## 3) Smoke artifact for SPA OFF/ON i samme release-vindue
+Dokumenteret i:
+- `docs/UI_SMOKE.md` (sektion: "Samme release-vindue: SPA OFF + ON verifikation")
+- `docs/STAGING_GAMEPLAY_SMOKE_ARTIFACT.md` (template udvidet med release-window check + `WPP_SPA_ASSET_VERSION`)
+
+Krav:
+- OFF-pass (legacy) og ON-pass (SPA) køres i samme deploy/release-vindue.
+- Begge passes logges i samme artifact med UTC timestamps og version-token.
+
+## Non-goals bekræftet
+- Ingen gameplay-regler ændret.
+- Ingen API-kontrakter ændret.
+- Ingen UX-redesign; kun drift/cutover-hardening.

docs/ISSUE-200-SPA-HOST-PLAYER-PHASE-SYNC-ARTIFACT.md

@@ -0,0 +1,57 @@
+# Issue #200 Artifact — SPA host→player phase sync (no reload)
+
+## Scope
+Acceptance for `[READY][SPA][P14] Gameplay MVP-del 5`:
+1. Host handlinger (`start round` / `næste fase`) propagere korrekt til player-ruter i SPA.
+2. Happy-path artefakt for én fuld faseovergang uden page reload.
+3. Sync-fejl giver kontrolleret fallback/error state.
+
+Afgrænsning overholdt: ingen nye spilregler og ingen redesign af backend event-model.
+
+## Happy-path faseovergang (uden page reload)
+Reference-flow i Angular shell:
+
+1. **Host starter runde/fase**
+   - Host action kalder backend endpoint (`POST /lobby/sessions/:code/start` eller fase-endpoint)
+   - Host shell hydrerer session igen (`GET /lobby/sessions/:code`)
+   - Host route synkes via hash-rewrite i samme SPA shell:
+     - `#/host/<phase>/<CODE>`
+     - Implementeret i `HostShellComponent.syncRouteFromSession()`
+
+2. **Player modtager ny fase via state sync**
+   - Player shell kører periodisk session-refresh (3s), uden hard reload
+   - Når `session.status` ændrer sig, synkes hash-route i samme SPA shell:
+     - `#/player/<phase>/<CODE>`
+     - Implementeret i `PlayerShellComponent.syncRouteFromSession()`
+
+3. **Ingen page reload**
+   - Routing sker med `window.history.replaceState(...)`
+   - URL opdateres i eksisterende SPA instans (ingen template-hop, ingen full refresh)
+
+## Kontrolleret fallback ved sync-fejl
+Når player-sync fejler (netværk/fetch/session-refresh):
+
+- UI går i kontrolleret connection-state:
+  - `reconnecting` ved online netværksfejl
+  - `offline` når browser rapporterer offline
+- Fejl vises med retry/back-to-join handlinger
+- Reconnect forsøges igen via timer (`scheduleReconnect`) uden at crashe shell
+
+## Verifikation (tests)
+Kørt i `frontend/angular` med Vitest:
+
+- `src/app/features/host/host-shell.component.spec.ts`
+  - Verificerer host-faseflow og hash-route sync uden reload
+- `src/app/features/player/player-shell.component.spec.ts`
+  - Verificerer periodisk player state sync + hash-route sync
+  - Verificerer reconnect/offline fallback ved sync-fejl
+- `src/app/api-contract-smoke.spec.ts`
+- `src/app/session-route-context.spec.ts`
+
+Kommando:
+
+```bash
+npm test -- --reporter=dot
+```
+
+Resultat: **4/4 testfiler grønne, 22/22 tests bestået**.

docs/ISSUE-207-I18N-AUDIO-SMOKE-ARTIFACT.md

@@ -0,0 +1,35 @@
+# Issue #207 Artifact — da/en locale switch + audio routing (primary-only)
+
+## Scope
+Acceptance for `[READY][i18n][P19]`:
+1. Verify one MVP host+player flow in both `en` and `da` locale context.
+2. Verify controlled fallback to `en` when a locale key is missing.
+3. Verify audio-routing policy is primary-only (client/player has no audio output).
+
+No new feature behavior added — this is verification-only evidence.
+
+## Smoke/e2e evidence (Angular shell test run)
+Executed from `frontend/angular`:
+
+```bash
+npm test -- --reporter=dot src/app/lobby-i18n.spec.ts src/app/features/host/host-shell.component.spec.ts src/app/features/player/player-shell.component.spec.ts
+```
+
+Evidence covered by the run:
+- `lobby-i18n.spec.ts`
+  - subscriber locale switch updates (`en -> da -> en`)
+  - controlled fallback where `da` key is removed during test and `en` copy is returned
+  - `clientHasNoAudioOutput === true` (primary-only audio routing)
+- `host-shell.component.spec.ts`
+  - host actions and route sync in SPA (no reload)
+- `player-shell.component.spec.ts`
+  - player session refresh/sync path and retry behavior
+
+## Policy evidence
+- Shared catalog capability: `shared/i18n/lobby.json`
+  - `frontend.capabilities.client_has_no_audio_output = true`
+- Angular host/player shells bind this capability:
+  - `HostShellComponent.clientHasNoAudioOutput`
+  - `PlayerShellComponent.clientHasNoAudioOutput`
+
+Conclusion: locale switching works in `da`/`en`, fallback resolves to `en` when locale key is intentionally missing, and client audio remains disabled by policy (`primary-only`).

docs/STAGING_GAMEPLAY_SMOKE_ARTIFACT.md

@@ -23,11 +23,14 @@ Formål: levere et lille, ensartet evidensformat for release-nær gameplay-smoke
 - Active category/questions present: <yes/no>
 - Participants: host + <N> players
 - `USE_SPA_UI`: <on/off>
+- `WPP_SPA_ASSET_VERSION`: <release-token/sha>
 - UI route used:
   - OFF (legacy): `/lobby/ui/host` + `/lobby/ui/player`
   - ON (SPA shell): `/lobby/ui/host/<spa-path>` + `/lobby/ui/player`
 
 #### Checks (PASS/FAIL)
+0. Same release-window verification
+   - OFF + ON smoke kørt i samme release-vindue: <pass/fail>
 1. Cutover route sanity
    - Flag OFF serves legacy UI templates: <pass/fail>
    - Flag ON serves SPA shell on expected path(s): <pass/fail>
@@ -39,6 +42,19 @@ Formål: levere et lille, ensartet evidensformat for release-nær gameplay-smoke
    - next round transitions: <pass/fail>
    - final leaderboard visible: <pass/fail>
 
+#### Smoke-gate decision (før `USE_SPA_UI=true`)
+- Gate status: <GREEN/RED>
+- Gate criteria met:
+  - [ ] Cutover route sanity = PASS (OFF + ON)
+  - [ ] Full gameplay round = PASS
+  - [ ] Next-round/final leaderboard sanity = PASS
+  - [ ] Ingen nye blocker-regressioner i host/player flow
+
+#### Rollback checkpoint
+- Rollback required: <yes/no>
+- Trigger reason (if yes): <kort trigger>
+- Rollback done (`USE_SPA_UI=false`) verified: <yes/no>
+
 #### Evidence pointers
 - Command(s): `<exact command(s)>`
 - UI notes/screenshots/log refs: <short refs>

docs/UI_SMOKE.md

@@ -20,4 +20,29 @@
 9. Host: Beregn score og Vis scoreboard.
 10. Host: Næste runde eller Afslut spil.
 
+## Smoke-gate (staging cutover)
+`USE_SPA_UI` må kun aktiveres i staging når følgende er opfyldt:
+- Cutover route sanity er PASS for både OFF (legacy) og ON (SPA shell).
+- Én fuld gameplay-runde til scoreboard er PASS.
+- Next-round/final leaderboard sanity er PASS.
+- Ingen nye blocker-regressioner i host/player kerneflow.
+
+## Samme release-vindue: SPA OFF + ON verifikation
+Kør begge checks i samme release-vindue (samme deploy/artifact version):
+
+1. **OFF-pass (legacy)**
+   - `USE_SPA_UI=false`
+   - Verificér legacy routes + fuld runde.
+2. **ON-pass (SPA)**
+   - `USE_SPA_UI=true`
+   - Behold samme release artifact og kun toggl flag/version-token ved behov.
+   - Verificér SPA shell routes + fuld runde.
+3. Dokumentér begge pass i samme smoke-artifact med UTC timestamps og `WPP_SPA_ASSET_VERSION`.
+
+## Rollback check points
+Skift straks tilbage til `USE_SPA_UI=false` hvis en gate fejler:
+1. Verificér legacy routes (`/lobby/ui/host` + `/lobby/ui/player`) fungerer igen.
+2. Log rollback trigger + kort repro i smoke artifact.
+3. Opret/link blocker issue før nyt cutover-forsøg.
+
 Resultat: En fuld runde kan køres uden rå API-kald fra terminal.

docs/spa-cutover-flag.md

@@ -12,6 +12,53 @@ Sæt env var pr. miljø:
 Backward compatibility under cutover:
 - Hvis `USE_SPA_UI` ikke er sat, bruges `WPP_SPA_ENABLED` som fallback.
 
+## Static asset versioning/cache-busting (hardening)
+Formål: sikre at browser/proxy/CDN hurtigt henter ny SPA bundle i release-vinduet uden at kræve hard refresh.
+
+- `WPP_SPA_ASSET_BASE` peger fortsat på build-output (`/static/frontend/angular/browser`).
+- `WPP_SPA_ASSET_VERSION` injiceres i SPA shell URLs som query-param (`?v=<version>`).
+- Anbefalet værdi for `WPP_SPA_ASSET_VERSION`: release-tag eller kort commit SHA.
+- Ved rollback sættes `WPP_SPA_ASSET_VERSION` til den tidligere kendte stabile release-værdi.
+
+Eksempel (staging/prod env):
+
+```env
+USE_SPA_UI=true
+WPP_SPA_ASSET_BASE=/static/frontend/angular/browser
+WPP_SPA_ASSET_VERSION=rel-2026-03-01-bb82357
+```
+
+## Staging rollout-checkliste (`USE_SPA_UI`)
+1. **Baseline (flag OFF)**
+   - Bekræft at staging kører med `USE_SPA_UI=false`.
+   - Kør gameplay smoke på legacy routes (`/lobby/ui/host` + `/lobby/ui/player`).
+2. **Smoke-gate før aktivering (skal være grøn)**
+   - Cutover route sanity = PASS for både OFF og ON checks.
+   - Full gameplay round (join/start/round/scoreboard) = PASS.
+   - Next-round/final leaderboard sanity = PASS.
+   - Ingen nye blocker-regressioner i host/player kerneflow.
+3. **Kontrolleret aktivering i staging**
+   - Sæt `USE_SPA_UI=true` i staging miljøet.
+   - Kør smoke-flow igen med SPA-route-verifikation.
+4. **Post-cutover dokumentation**
+   - Log evidens med commit/head SHA, UTC timestamp og gate-status.
+
+## Rollback playbook (`USE_SPA_UI`) — mål: <10 min
+Rollback til legacy (`USE_SPA_UI=false`) udføres straks hvis et checkpoint fejler:
+- Forkert route/shell for valgt flag i cutover route sanity.
+- Gameplay smoke kan ikke gennemføres til scoreboard/final leaderboard.
+- Kritisk regression i host/player flow under smoke.
+
+Trin-for-trin:
+1. Sæt `USE_SPA_UI=false` i deploy-env.
+2. Sæt `WPP_SPA_ASSET_VERSION` til sidste stabile release-token.
+3. Deploy/reload app-processer.
+4. Verificér legacy routes: `/lobby/ui/host` + `/lobby/ui/player`.
+5. Kør hurtig smoke sanity (join/start/scoreboard path).
+6. Log UTC tid, trigger, release-token og resultat i smoke artifact.
+
+Target: rollback + sanity-verifikation inden for 10 minutter.
+
 ## Verifikation
 - Flag OFF: `UiScreenTests.test_legacy_templates_are_used_when_spa_flag_is_off`
 - Flag ON (host): `UiScreenTests.test_host_screen_can_render_angular_shell_when_feature_flag_enabled`

frontend/angular/src/app/features/host/host-shell.component.ts

@@ -1,11 +1,11 @@
 import { CommonModule } from '@angular/common';
-import { Component, OnInit } from '@angular/core';
+import { Component, OnDestroy, OnInit } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { createApiClient } from '../../../../../src/api/client';
 import type { FinishGameResponse, ScoreboardResponse } from '../../../../../src/api/types';
 import { createVerticalSliceController } from '../../../../../src/spa/vertical-slice';
-import { clientHasNoAudioOutput, resolvePreferredLocale, t } from '../../lobby-i18n';
+import { clientHasNoAudioOutput, resolvePreferredLocale, subscribeToLocaleChanges, t } from '../../lobby-i18n';
 
 interface SessionDetail {
   session: { code: string; status: string; current_round: number };
@@ -64,7 +64,7 @@ type LeaderboardResponse = FinishGameResponse;
     </div>
   `,
 })
-export class HostShellComponent implements OnInit {
+export class HostShellComponent implements OnInit, OnDestroy {
   locale = resolvePreferredLocale();
   readonly clientHasNoAudioOutput = clientHasNoAudioOutput;
 
@@ -84,8 +84,12 @@ export class HostShellComponent implements OnInit {
 
   private readonly api = createApiClient();
   private readonly controller = createVerticalSliceController(this.api);
+  private unsubscribeLocale: (() => void) | null = null;
 
   ngOnInit(): void {
+    this.unsubscribeLocale = subscribeToLocaleChanges((locale) => {
+      this.locale = locale;
+    });
     if (typeof window === 'undefined') {
       return;
     }
@@ -105,6 +109,11 @@ export class HostShellComponent implements OnInit {
     void this.refreshSession();
   }
 
+  ngOnDestroy(): void {
+    this.unsubscribeLocale?.();
+    this.unsubscribeLocale = null;
+  }
+
   copy(key: string): string {
     return t(key, this.locale);
   }

frontend/angular/src/app/features/player/player-shell.component.ts

@@ -5,7 +5,7 @@ import { FormsModule } from '@angular/forms';
 import { createApiClient } from '../../../../../src/api/client';
 import { createSessionContextStore } from '../../../../../src/spa/session-context-store';
 import { createVerticalSliceController } from '../../../../../src/spa/vertical-slice';
-import { clientHasNoAudioOutput, resolvePreferredLocale, t } from '../../lobby-i18n';
+import { clientHasNoAudioOutput, resolvePreferredLocale, subscribeToLocaleChanges, t } from '../../lobby-i18n';
 
 interface SessionDetail {
   session: { code: string; status: string; current_round: number };
@@ -112,6 +112,7 @@ export class PlayerShellComponent implements OnInit, OnDestroy {
   private readonly controller = createVerticalSliceController(createApiClient(), this.sessionContextStore);
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private stateSyncTimer: ReturnType<typeof setTimeout> | null = null;
+  private unsubscribeLocale: (() => void) | null = null;
 
   constructor() {
     if (typeof navigator !== 'undefined' && !navigator.onLine) {
@@ -125,6 +126,10 @@ export class PlayerShellComponent implements OnInit, OnDestroy {
   }
 
   ngOnInit(): void {
+    this.unsubscribeLocale = subscribeToLocaleChanges((locale) => {
+      this.locale = locale;
+    });
+
     const hashRoute = window.location.hash.replace(/^#\/?/, '');
     const match = hashRoute.match(/^player(?:\/[^/]+)?(?:\/([^/?#]+))?/i);
     const codeFromRoute = match?.[1] ?? '';
@@ -151,6 +156,8 @@ export class PlayerShellComponent implements OnInit, OnDestroy {
     }
     this.clearReconnectTimer();
     this.clearStateSyncTimer();
+    this.unsubscribeLocale?.();
+    this.unsubscribeLocale = null;
   }
 
   private readonly handleOnline = (): void => {

frontend/angular/src/app/gameplay-phase-machine.spec.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+
+import { deriveGameplayPhase, transitionGameplayPhase } from '../../../src/spa/gameplay-phase-machine';
+
+describe('gameplay phase machine sync guards', () => {
+  it('keeps explicit scoreboard status as scoreboard phase', () => {
+    const phase = deriveGameplayPhase({
+      session: {
+        code: 'ABCD12',
+        status: 'scoreboard',
+        host_id: 1,
+        current_round: 1,
+        players_count: 2,
+      },
+      round_question: null,
+      players: [],
+      phase_view_model: {
+        status: 'scoreboard',
+        round_number: 1,
+        players_count: 2,
+        constraints: {
+          min_players_to_start: 2,
+          max_players_mvp: 8,
+          min_players_reached: true,
+          max_players_allowed: true,
+        },
+        host: {
+          can_start_round: false,
+          can_show_question: false,
+          can_mix_answers: false,
+          can_calculate_scores: false,
+          can_reveal_scoreboard: false,
+          can_start_next_round: true,
+          can_finish_game: true,
+        },
+        player: {
+          can_join: false,
+          can_submit_lie: false,
+          can_submit_guess: false,
+          can_view_final_result: false,
+        },
+      },
+    });
+
+    expect(phase).toBe('scoreboard');
+  });
+
+  it('maps finished status to scoreboard phase fallback', () => {
+    const phase = deriveGameplayPhase({
+      session: {
+        code: 'ABCD12',
+        status: 'finished',
+        host_id: 1,
+        current_round: 1,
+        players_count: 2,
+      },
+      round_question: null,
+      players: [],
+      phase_view_model: {
+        status: 'finished',
+        round_number: 1,
+        players_count: 2,
+        constraints: {
+          min_players_to_start: 2,
+          max_players_mvp: 8,
+          min_players_reached: true,
+          max_players_allowed: true,
+        },
+        host: {
+          can_start_round: false,
+          can_show_question: false,
+          can_mix_answers: false,
+          can_calculate_scores: false,
+          can_reveal_scoreboard: false,
+          can_start_next_round: false,
+          can_finish_game: false,
+        },
+        player: {
+          can_join: false,
+          can_submit_lie: false,
+          can_submit_guess: false,
+          can_view_final_result: true,
+        },
+      },
+    });
+
+    expect(phase).toBe('scoreboard');
+  });
+
+  it('transitions reveal -> scoreboard on SCOREBOARD_READY', () => {
+    expect(transitionGameplayPhase('reveal', 'SCOREBOARD_READY')).toEqual({
+      phase: 'scoreboard',
+      changed: true,
+    });
+  });
+});

frontend/angular/src/app/i18n-mvp-flow-smoke.spec.ts

@@ -0,0 +1,61 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { HostShellComponent } from './features/host/host-shell.component';
+import { PlayerShellComponent } from './features/player/player-shell.component';
+import { setPreferredLocale } from './lobby-i18n';
+
+describe('i18n MVP flow smoke (host/player + audio policy)', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it('resolves host/player copy in en and da from shared catalog', () => {
+    vi.stubGlobal('window', {
+      location: { hash: '', search: '' },
+      history: { state: null, replaceState: vi.fn() },
+      localStorage: { getItem: vi.fn().mockReturnValue('en'), setItem: vi.fn(), removeItem: vi.fn() },
+      sessionStorage: { getItem: vi.fn().mockReturnValue(null), setItem: vi.fn(), removeItem: vi.fn() },
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    });
+    vi.stubGlobal('navigator', { language: 'en-US', onLine: true });
+
+    const host = new HostShellComponent();
+    const player = new PlayerShellComponent();
+    host.ngOnInit();
+    player.ngOnInit();
+
+    expect(host.copy('host.start_round')).toBe('Start round');
+    expect(player.copy('player.submit_guess')).toBe('Submit guess');
+
+    setPreferredLocale('da');
+
+    expect(host.copy('host.start_round')).toBe('Start runde');
+    expect(player.copy('player.submit_guess')).toBe('Send gæt');
+
+    player.ngOnDestroy();
+    host.ngOnDestroy();
+  });
+
+  it('keeps audio routing policy primary-only (client has no audio output)', () => {
+    vi.stubGlobal('window', {
+      location: { hash: '', search: '' },
+      history: { state: null, replaceState: vi.fn() },
+      localStorage: { getItem: vi.fn().mockReturnValue('en'), setItem: vi.fn(), removeItem: vi.fn() },
+      sessionStorage: { getItem: vi.fn().mockReturnValue(null), setItem: vi.fn(), removeItem: vi.fn() },
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    });
+    vi.stubGlobal('navigator', { language: 'en-US', onLine: true });
+
+    const host = new HostShellComponent();
+    const player = new PlayerShellComponent();
+
+    expect(host.clientHasNoAudioOutput).toBe(true);
+    expect(player.clientHasNoAudioOutput).toBe(true);
+
+    player.ngOnDestroy();
+    host.ngOnDestroy();
+  });
+});

frontend/angular/src/app/lobby-i18n.spec.ts

@@ -0,0 +1,91 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+type StorageLike = {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+};
+
+function storageMock(initial: Record<string, string> = {}): StorageLike {
+  const data = new Map<string, string>(Object.entries(initial));
+  return {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => {
+      data.set(key, value);
+    }),
+  };
+}
+
+describe('lobby i18n locale propagation', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+    vi.resetModules();
+  });
+
+  it('notifies subscribers immediately and on locale changes', async () => {
+    const localStorage = storageMock({ 'wpp.locale': 'en' });
+    vi.stubGlobal('window', {
+      location: { search: '' },
+      localStorage,
+    });
+    vi.stubGlobal('navigator', { language: 'en-US' });
+
+    const i18n = await import('./lobby-i18n');
+
+    const updates: string[] = [];
+    const unsubscribe = i18n.subscribeToLocaleChanges((locale) => updates.push(locale));
+
+    expect(updates).toEqual(['en']);
+
+    i18n.setPreferredLocale('da');
+    expect(updates).toEqual(['en', 'da']);
+
+    unsubscribe();
+    i18n.setPreferredLocale('en');
+    expect(updates).toEqual(['en', 'da']);
+  });
+
+  it('falls back to default en translation when da key is intentionally missing', async () => {
+    vi.stubGlobal('window', {
+      location: { search: '' },
+      localStorage: storageMock({ 'wpp.locale': 'da' }),
+    });
+    vi.stubGlobal('navigator', { language: 'da-DK' });
+
+    const i18n = await import('./lobby-i18n');
+    const catalogModule = await import('../../../../shared/i18n/lobby.json');
+    const catalog = catalogModule.default as {
+      frontend: {
+        ui: {
+          common: {
+            refresh: {
+              en?: string;
+              da?: string;
+            };
+          };
+        };
+      };
+    };
+
+    const originalDa = catalog.frontend.ui.common.refresh.da;
+    catalog.frontend.ui.common.refresh.da = undefined;
+
+    try {
+      expect(i18n.t('common.refresh', 'da')).toBe(catalog.frontend.ui.common.refresh.en);
+    } finally {
+      catalog.frontend.ui.common.refresh.da = originalDa;
+    }
+  });
+
+  it('exposes primary-only audio routing policy to clients', async () => {
+    vi.stubGlobal('window', {
+      location: { search: '' },
+      localStorage: storageMock({ 'wpp.locale': 'en' }),
+    });
+    vi.stubGlobal('navigator', { language: 'en-US' });
+
+    const i18n = await import('./lobby-i18n');
+
+    expect(i18n.clientHasNoAudioOutput).toBe(true);
+  });
+});

frontend/angular/src/app/lobby-i18n.ts

@@ -5,6 +5,9 @@ type SupportedLocale = (typeof lobbyCatalog.locales.supported)[number];
 const DEFAULT_LOCALE = lobbyCatalog.locales.default as SupportedLocale;
 const SUPPORTED_LOCALES = lobbyCatalog.locales.supported as readonly SupportedLocale[];
 
+let activeLocale: SupportedLocale | null = null;
+const localeSubscribers = new Set<(locale: SupportedLocale) => void>();
+
 export function normalizeLocale(rawLocale?: string | null): SupportedLocale {
   const locale = (rawLocale ?? '').trim().toLowerCase();
   if ((SUPPORTED_LOCALES as readonly string[]).includes(locale)) {
@@ -20,25 +23,45 @@ export function normalizeLocale(rawLocale?: string | null): SupportedLocale {
 }
 
 export function resolvePreferredLocale(): SupportedLocale {
+  if (activeLocale) {
+    return activeLocale;
+  }
+
   if (typeof window === 'undefined') {
-    return DEFAULT_LOCALE;
+    activeLocale = DEFAULT_LOCALE;
+    return activeLocale;
   }
 
   const queryLocale = new URLSearchParams(window.location?.search ?? '').get('lang');
   const storedLocale = window.localStorage?.getItem?.('wpp.locale');
   const browserLocale = typeof navigator !== 'undefined' ? navigator.language : '';
 
-  return normalizeLocale(queryLocale || storedLocale || browserLocale || DEFAULT_LOCALE);
+  activeLocale = normalizeLocale(queryLocale || storedLocale || browserLocale || DEFAULT_LOCALE);
+  return activeLocale;
 }
 
 export function setPreferredLocale(locale: string): SupportedLocale {
   const normalized = normalizeLocale(locale);
+  activeLocale = normalized;
   if (typeof window !== 'undefined') {
     window.localStorage?.setItem?.('wpp.locale', normalized);
   }
+
+  for (const subscriber of localeSubscribers) {
+    subscriber(normalized);
+  }
+
   return normalized;
 }
 
+export function subscribeToLocaleChanges(callback: (locale: SupportedLocale) => void): () => void {
+  localeSubscribers.add(callback);
+  callback(resolvePreferredLocale());
+  return () => {
+    localeSubscribers.delete(callback);
+  };
+}
+
 export function t(key: string, locale: string): string {
   const normalizedLocale = normalizeLocale(locale);
   const fallbackLocale = DEFAULT_LOCALE;

frontend/src/spa/gameplay-phase-machine.ts

@@ -46,7 +46,7 @@ export function deriveGameplayPhase(session: SessionDetailResponse | null): Game
     return null;
   }
 
-  if (status === 'lie' || status === 'guess' || status === 'reveal') {
+  if (status === 'lie' || status === 'guess' || status === 'reveal' || status === 'scoreboard') {
     return status;
   }
 

frontend/src/spa/lobby-i18n.ts

@@ -1,31 +1,48 @@
 import lobbyCatalog from '../../../shared/i18n/lobby.json';
 
-type FrontendErrorKey = keyof typeof lobbyCatalog.frontend.errors;
-
 const frontendErrors = lobbyCatalog.frontend.errors;
+const localeConfig = lobbyCatalog.locales;
 
-const apiErrorMap: Record<string, FrontendErrorKey> = {
-  session_code_required: 'session_code_required',
-  session_not_found: 'session_not_found',
-  nickname_invalid: 'nickname_invalid',
-  nickname_taken: 'nickname_taken'
-};
+type FrontendErrorKey = keyof typeof frontendErrors;
+type SupportedLocale = (typeof localeConfig.supported)[number];
 
-export function lobbyMessage(key: FrontendErrorKey): string {
-  return frontendErrors[key] ?? frontendErrors.unknown;
+function isFrontendErrorKey(value: string): value is FrontendErrorKey {
+  return value in frontendErrors;
 }
 
-export function lobbyMessageFromApiPayload(payload: unknown, fallbackKey: FrontendErrorKey): string {
+function normalizeLocale(rawLocale?: string): SupportedLocale {
+  const requested = (rawLocale ?? '').trim().toLowerCase();
+  if (localeConfig.supported.includes(requested as SupportedLocale)) {
+    return requested as SupportedLocale;
+  }
+  return localeConfig.default;
+}
+
+export function lobbyMessage(key: FrontendErrorKey, locale?: string): string {
+  const resolvedLocale = normalizeLocale(locale);
+  const translations = frontendErrors[key] as Record<string, string>;
+
+  if (translations[resolvedLocale]) {
+    return translations[resolvedLocale];
+  }
+  if (translations[localeConfig.default]) {
+    return translations[localeConfig.default];
+  }
+
+  return key;
+}
+
+export function lobbyMessageFromApiPayload(payload: unknown, fallbackKey: FrontendErrorKey, locale?: string): string {
   if (!payload || typeof payload !== 'object') {
-    return lobbyMessage(fallbackKey);
+    return lobbyMessage(fallbackKey, locale);
   }
 
   const record = payload as Record<string, unknown>;
   const code = typeof record.error_code === 'string' ? record.error_code : '';
-  const mappedKey = apiErrorMap[code];
-  if (!mappedKey) {
-    return lobbyMessage(fallbackKey);
+  const payloadLocale = typeof record.locale === 'string' ? record.locale : locale;
+  if (!isFrontendErrorKey(code)) {
+    return lobbyMessage(fallbackKey, payloadLocale);
   }
 
-  return lobbyMessage(mappedKey);
+  return lobbyMessage(code, payloadLocale);
 }

frontend/tests/lobby-i18n.contract.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+
+import lobbyCatalog from '../../shared/i18n/lobby.json';
+import { lobbyMessage, lobbyMessageFromApiPayload } from '../src/spa/lobby-i18n';
+
+describe('shared i18n keyspace contract', () => {
+  it('keeps en as default and da/en matrix for frontend error keys', () => {
+    expect(lobbyCatalog.locales.default).toBe('en');
+    expect(lobbyCatalog.locales.supported).toEqual(expect.arrayContaining(['en', 'da']));
+
+    for (const [key, translations] of Object.entries(lobbyCatalog.frontend.errors)) {
+      expect(translations.en, `${key} missing en`).toBeTruthy();
+      expect(translations.da, `${key} missing da`).toBeTruthy();
+    }
+  });
+
+  it('keeps backend error-code keyspace aligned with backend translations', () => {
+    for (const [code, key] of Object.entries(lobbyCatalog.backend.error_codes)) {
+      expect(code).toBe(key);
+      expect(lobbyCatalog.backend.errors[key as keyof typeof lobbyCatalog.backend.errors]).toBeDefined();
+    }
+
+    for (const [key, translations] of Object.entries(lobbyCatalog.backend.errors)) {
+      expect(translations.en, `${key} missing en`).toBeTruthy();
+      expect(translations.da, `${key} missing da`).toBeTruthy();
+    }
+  });
+});
+
+describe('lobbyMessage locale handling', () => {
+  it('uses english by default and falls back to default for unsupported locale', () => {
+    expect(lobbyMessage('session_code_required')).toBe('Session code is required.');
+    expect(lobbyMessage('session_code_required', 'fr')).toBe('Session code is required.');
+  });
+
+  it('resolves locale from api payload and maps known backend error codes directly', () => {
+    expect(
+      lobbyMessageFromApiPayload(
+        { error_code: 'session_not_found', locale: 'da' },
+        'join_failed',
+      ),
+    ).toBe('Sessionskoden er ugyldig, eller sessionen findes ikke længere.');
+  });
+
+  it('falls back when backend error code has no frontend translation key', () => {
+    expect(
+      lobbyMessageFromApiPayload(
+        { error_code: 'session_not_joinable', locale: 'da' },
+        'join_failed',
+      ),
+    ).toBe('Kunne ikke joine. Tjek kode eller kaldenavn og prøv igen.');
+  });
+});

lobby/templates/lobby/spa_shell.html

@@ -4,10 +4,10 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>WPP SPA Shell</title>
-  <link rel="stylesheet" href="{{ spa_asset_base }}/styles.css">
+  <link rel="stylesheet" href="{{ spa_asset_base }}/styles.css?v={{ spa_asset_version|urlencode }}">
 </head>
 <body data-wpp-shell-route="{{ shell_route }}" data-wpp-shell-kind="{{ shell_kind }}">
   <app-root data-wpp-shell-route="{{ shell_route }}" data-wpp-shell-kind="{{ shell_kind }}">Indlæser Angular app-shell…</app-root>
-  <script type="module" src="{{ spa_asset_base }}/main.js"></script>
+  <script type="module" src="{{ spa_asset_base }}/main.js?v={{ spa_asset_version|urlencode }}"></script>
 </body>
 </html>

lobby/tests.py

@@ -2,6 +2,7 @@ import json
 import tempfile
 from datetime import timedelta
 from pathlib import Path
+from unittest.mock import patch
 
 from django.contrib.auth import get_user_model
 from django.core.management import call_command
@@ -19,7 +20,7 @@ from fupogfakta.models import (
     RoundConfig,
     RoundQuestion,
 )
-from lobby.i18n import resolve_error_message
+from lobby.i18n import i18n_locale_config, lobby_i18n_catalog, resolve_error_message
 
 User = get_user_model()
 
@@ -1022,7 +1023,8 @@ class UiScreenTests(TestCase):
         self.assertContains(response, "<app-root")
         self.assertContains(response, "data-wpp-shell-route=\"/host\"")
         self.assertContains(response, "data-wpp-shell-kind=\"host\"")
-        self.assertContains(response, "/static/frontend/angular/browser/main.js")
+        self.assertContains(response, "/static/frontend/angular/browser/main.js?v=dev")
+        self.assertContains(response, "/static/frontend/angular/browser/styles.css?v=dev")
 
     @override_settings(USE_SPA_UI=True)
     def test_host_screen_deeplink_preserves_spa_path_when_feature_flag_enabled(self):
@@ -1056,7 +1058,17 @@ class UiScreenTests(TestCase):
         self.assertContains(response, "<app-root")
         self.assertContains(response, "data-wpp-shell-route=\"/player\"")
         self.assertContains(response, "data-wpp-shell-kind=\"player\"")
-        self.assertContains(response, "/static/frontend/angular/browser/main.js")
+        self.assertContains(response, "/static/frontend/angular/browser/main.js?v=dev")
+
+    @override_settings(USE_SPA_UI=True, WPP_SPA_ASSET_VERSION="release-2026-03-01")
+    def test_spa_shell_uses_configured_asset_version_for_cache_busting(self):
+        self.client.login(username="host_ui", password="secret123")
+
+        response = self.client.get(reverse("lobby:host_screen"))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "/static/frontend/angular/browser/styles.css?v=release-2026-03-01")
+        self.assertContains(response, "/static/frontend/angular/browser/main.js?v=release-2026-03-01")
 
 
 class SessionDetailRoundQuestionTests(TestCase):
@@ -1206,3 +1218,44 @@ class SmokeStagingCommandTests(TestCase):
 class I18nResolverTests(TestCase):
     def test_missing_backend_key_returns_key_deterministically(self):
         self.assertEqual(resolve_error_message(key="missing_key", locale="da"), "missing_key")
+
+    def test_missing_backend_key_is_logged_with_context(self):
+        with self.assertLogs("lobby.i18n", level="WARNING") as logs:
+            result = resolve_error_message(key="missing_key", locale="da")
+
+        self.assertEqual(result, "missing_key")
+        self.assertTrue(any("i18n key missing in shared catalog" in entry for entry in logs.output))
+
+    def test_missing_locale_translation_falls_back_to_default_locale(self):
+        with patch(
+            "lobby.i18n.lobby_i18n_error_messages",
+            return_value={"session_code_required": {"en": "Session code is required"}},
+        ):
+            self.assertEqual(
+                resolve_error_message(key="session_code_required", locale="da"),
+                "Session code is required",
+            )
+
+    def test_shared_catalog_uses_en_default_and_da_en_matrix(self):
+        default_locale, supported_locales = i18n_locale_config()
+        catalog = lobby_i18n_catalog()
+
+        self.assertEqual(default_locale, "en")
+        self.assertIn("en", supported_locales)
+        self.assertIn("da", supported_locales)
+
+        for key, translations in catalog["backend"]["errors"].items():
+            self.assertTrue(translations.get("en"), f"backend key {key} missing en")
+            self.assertTrue(translations.get("da"), f"backend key {key} missing da")
+
+        for key, translations in catalog["frontend"]["errors"].items():
+            self.assertTrue(translations.get("en"), f"frontend key {key} missing en")
+            self.assertTrue(translations.get("da"), f"frontend key {key} missing da")
+
+    def test_backend_error_codes_map_to_same_named_translation_keys(self):
+        catalog = lobby_i18n_catalog()
+        backend_errors = catalog["backend"]["errors"]
+
+        for code, key in catalog["backend"]["error_codes"].items():
+            self.assertEqual(code, key)
+            self.assertIn(key, backend_errors)

lobby/ui_views.py

@@ -16,6 +16,7 @@ def _render_spa_shell(request, shell_route: str, shell_kind: str):
             "shell_route": shell_route,
             "shell_kind": shell_kind,
             "spa_asset_base": settings.WPP_SPA_ASSET_BASE,
+            "spa_asset_version": getattr(settings, "WPP_SPA_ASSET_VERSION", "dev"),
             "lobby_i18n": lobby_i18n_catalog(),
         },
     )

partyhub/settings.py

@@ -111,6 +111,9 @@ if USE_SPA_UI_RAW is None:
     USE_SPA_UI_RAW = env('WPP_SPA_ENABLED', 'false')
 USE_SPA_UI = USE_SPA_UI_RAW.lower() == 'true'
 WPP_SPA_ASSET_BASE = env('WPP_SPA_ASSET_BASE', '/static/frontend/angular/browser').rstrip('/')
+# Cache-busting token for SPA shell static asset URLs (querystring versioning).
+# Set to release id / commit SHA in deploy env for deterministic invalidation.
+WPP_SPA_ASSET_VERSION = env('WPP_SPA_ASSET_VERSION', 'dev')
 
 CHANNEL_REDIS_HOST = env('CHANNEL_REDIS_HOST', '127.0.0.1')
 CHANNEL_REDIS_PORT = int(env('CHANNEL_REDIS_PORT', '6379'))