diff --git a/.env.example b/.env.example
index 7203756..bb2d926 100644
--- a/.env.example
+++ b/.env.example
@@ -8,13 +8,19 @@ POSTGRES_DB=mobilityops
 POSTGRES_USER=mobilityops
 POSTGRES_PASSWORD=mobilityops
 APP_SECRET=replace-in-production
-DEMO_TODAY=2026-08-01
 TZ=Europe/Brussels
 # Session cookie Secure flag. Keep false for LAN/plain-HTTP deployments (including the
 # current Unraid review environment); set true only once MobilityOps is served over HTTPS,
 # otherwise browsers will silently drop the cookie and no one can log in.
 SESSION_COOKIE_SECURE=false
 
+# Demo presentation (fictional org identity, badge/manifest, reset safety valve).
+# DEMO_ALLOW_RESET=false permanently disables POST /api/v1/demo/reset (403), independent
+# of role -- a safety valve for any environment where the dataset must not be rebuildable.
+DEMO_ORGANIZATION_NAME=Northstar Mobility
+DEMO_TIMEZONE=Europe/Brussels
+DEMO_ALLOW_RESET=true
+
 # n8n
 N8N_BASE_URL=http://n8n:5678
 N8N_WEBHOOK_URL=http://n8n:5678/webhook/mobilityops-return
diff --git a/PROJECT_STATE.md b/PROJECT_STATE.md
index 341b408..13f46c8 100644
--- a/PROJECT_STATE.md
+++ b/PROJECT_STATE.md
@@ -507,3 +507,314 @@ any change at `docs/functional-completion/server-baseline.md`.
   re-verified against the live server after every batch. See
   `artifacts/functional-completion/final-summary.md` for the definitive acceptance
   evidence.
+
+## Demo productization (in progress, same branch `feat/mobilityops-functional-completion`)
+
+Follows the functional-completion work above; turns the now feature-complete PoC into a
+guided, honestly-labelled demo (fictional org "Northstar Mobility", guided tour, 5 named
+scenarios, demo manifest, About page). Gap audit: `docs/demo-release/current-demo-gap-audit.md`.
+
+### Batch 1 — seed date anchoring (complete)
+
+- **Real bug fixed**: `seed/bookings.csv` etc. store absolute ISO timestamps authored
+  around a fixed anchor (`2026-08-01`). Nothing previously re-anchored them at seed/reset
+  time, so scenario bookings (e.g. `BK-DEMO-RETURN`) silently drifted into the past every
+  day the environment wasn't reset. `dashboard.py::_today()` compounded this by filtering
+  "today's movements" against the same frozen `demo_today` setting instead of real time.
+- Fix: `seed_loader.py` now computes `shift = today - SEED_AUTHORED_ANCHOR` once per
+  `load_seed()` call and applies it to every seeded booking/inspection/maintenance/outbox
+  datetime column, so scenarios stay "today"/"near-future" relative to the actual reset
+  moment. `SeedResult` now also carries `anchor_date`/`seeded_at`; `POST /api/v1/demo/reset`
+  returns them; a `demo_data_seeded` audit event records the anchor for traceability.
+  `dashboard.py::_today()` switched from the frozen `demo_today` setting to real wall-clock
+  UTC date. The now-dead `demo_today` setting/env var was removed from `config.py`,
+  `compose.yaml`, `.env`, `.env.example` (nothing else referenced it).
+- Added seed-validation tests (`backend/tests/test_seed.py`) proving S1 (`BK-DEMO-RETURN`/
+  `MO-024`), S2 (`CUS-0012`/`CUS-0178`/`DQ-DEMO-DUPLICATE`), S4 (`MO-016`/
+  `BK-DEMO-OVERLAP-A`/`-B`/`DQ-DEMO-OVERLAP`) and S5 (seeded failed outbox event
+  `00000000-0000-4000-8000-000000000020`, confirmed genuinely `failed` immediately after a
+  fresh reset, not silently auto-healed by the background dispatcher since it only claims
+  `pending` rows) are fully present after every reset, plus a dedicated anchoring test
+  asserting the shift and the audit marker.
+- Live-verified locally: reseeded and confirmed via `psql` that `BK-DEMO-RETURN` now ends
+  today and `BK-DEMO-NEXT`/overlap bookings sit in the near future (today = 2026-08-03).
+- Evidence: `pytest` **122 passed** (117 + 5 new/expanded seed tests), `ruff check .`
+  clean, `mypy app` clean (46 files, canonical `make` scope).
+- Deployed to Unraid (commit `8989ffb`): pushed to Gitea, `git archive` tarball extracted
+  over `/mnt/user/appdata/mobilityops` preserving `.env`/volumes, `api` rebuilt (`db`/`web`
+  untouched — no frontend changes this batch), migrations confirmed at `e7b08389f47f
+  (head)`, reseeded, live-verified via `psql` that `BK-DEMO-RETURN`/`BK-DEMO-NEXT`/overlap
+  bookings sit at the same real-time-relative positions as local. `curl` to
+  `http://192.168.10.150:1236/` returns 200.
+- Exact next action: `GET /api/v1/demo/manifest` + Dutch demo entry screen + permanent
+  demo badge (task #30), then the Demo Guide + scenario overview (task #31).
+
+### Batch 2 — demo manifest, Dutch demo entry, permanent demo badge, About page (complete)
+
+- `GET /api/v1/demo/manifest` (unauthenticated): single source of truth for demo org
+  identity, synthetic-data flag, reset allowance/timestamp/anchor date, guide
+  availability, and the 5 named scenarios with **live** readiness (queries the actual
+  `BK-DEMO-RETURN`/`DQ-DEMO-DUPLICATE`/`DQ-DEMO-OVERLAP`/seeded-failed-event/knowledge-
+  provider records — not hardcoded), plus plain-language integration summaries. Backed by
+  new `backend/app/services/demo_manifest.py`. Refactored the n8n status derivation out of
+  `integration_status.py` into a shared `services/integration_status.py` so the manifest
+  and the existing authenticated `/integrations/status` endpoint reuse one implementation.
+- New settings (`backend/app/core/config.py`, wired through `compose.yaml`/`.env.example`):
+  `DEMO_ORGANIZATION_NAME` (default "Northstar Mobility" — surfaces the project's already-
+  locked fictitious tenant, previously only used internally as the `ragcore_tenant` slug),
+  `DEMO_TIMEZONE`, `DEMO_ALLOW_RESET` (a safety valve — `false` makes `POST
+  /api/v1/demo/reset` return 403 regardless of role; the now-dead `demo_today` setting
+  removed in Batch 1 stays removed).
+- Rewrote `Login.tsx` in Dutch: names the fictional org, one-sentence explanation sourced
+  from the manifest, no password shown/copyable anywhere, "Start begeleide demo" primary
+  CTA (logs in as Operations Manager, navigates to `/dashboard?guide=start` for task #31 to
+  consume) plus "Verken als Operations Manager"/"Verken als Rental Employee" secondary
+  actions. Added a permanent demo badge (topbar pill + popover: synthetic notice,
+  "workflows are real" reassurance, last-reset timestamp, link to `/about`) replacing the
+  old full-width static `.demo-banner` bar — subtle by design per the brief, not a warning
+  bar. New `/about`
+  page (`AboutDemo.tsx`) covering the fictional problem, what's really implemented, what's
+  synthetic, honest per-integration labels (via the manifest), and a reset pointer —
+  reachable from the badge popover, not added to primary nav (preserves the existing Control
+  Rail nav per the "not a redesign" constraint). Frontend nav/design otherwise untouched.
+- Evidence: `pytest` **127 passed**, `ruff check .` clean, `mypy app` clean (48 files);
+  frontend `tsc -b` clean, `npm run build` clean; full Playwright suite **41 passed**
+  (37 existing + 4 new `demo-entry.spec.ts` covering entry copy/no-password, guided-demo
+  login redirect, badge popover content + About link, and Escape/outside-click close).
+  Updated stale English login-button aria-labels and login-copy assertions across the
+  existing specs to match the new Dutch copy.
+- Deployed to Unraid (commit `ac427f4`): pushed to Gitea, `git archive` tarball extracted
+  preserving `.env`/volumes, both `api` and `web` rebuilt (frontend changed this batch),
+  both healthy, migrations unchanged, reseeded. Live-verified: `GET
+  /api/v1/demo/manifest` returns `organization_name: "Northstar Mobility"`,
+  `allow_reset: true`, and all 5 scenarios `ready: true` right after reset. Ran
+  `demo-entry.spec.ts` (4 tests) and the five-minute demo script directly against
+  `http://192.168.10.150:1236` — **5/5 passed**. Reseeded again afterward to leave the
+  server demo-ready.
+- Exact next action: Demo Guide (collapsible panel, 8 steps) + scenario overview (5 cards
+  on the dashboard, consuming `/api/v1/demo/manifest`'s `scenarios` array) — task #31.
+
+### Batch 3 — Demo Guide + scenario overview (complete)
+
+- New `/scenarios` page (`Scenarios.tsx`): all 5 named scenarios as cards (title,
+  operational problem, duration, required role(s), "toont aan", ready/blocked status
+  from the manifest, "Start scenario" linking to the live `start_path`). Dashboard gets
+  one compact "Probeer een demonstratiescenario" panel (not 5 more cards — keeps the
+  existing dashboard uncluttered per the brief) showing readiness count and, for
+  Operations Managers, a guide resume/start control.
+- New Demo Guide: `DemoGuideContext` (sessionStorage-persisted `currentIndex`/`completed`
+  set — browser-only, never touches auth or business logic), 8 static steps
+  (`data/demoGuideSteps.ts`) each with what-you'll-see/why/start-action/expected-outcome,
+  resolving live routes from the manifest for the two scenario-backed steps (return,
+  duplicate-merge) so they can't drift from actual records. `DemoGuide.tsx` renders a
+  fixed side panel (desktop) that becomes a bottom sheet at ≤700px via CSS only (no
+  layout duplication); `DemoGuideTrigger` (topbar, Operations-Manager-only — the 8 steps
+  require OM throughout) shows a live `completed/8` pill. "Demo opnieuw voorbereiden"
+  calls the real reset endpoint, resets guide progress, and returns to `/login` (mirrors
+  the existing sidebar reset flow). Login's "Start begeleide demo" logs in as OM and
+  passes a one-shot `?guide=start` marker the dashboard consumes once then strips.
+- Fixed a real regression caught by the responsive-overflow tests: the new topbar guide
+  trigger pushed `.topbar-meta` past the viewport at ≤420px; fixed by hiding the guide
+  trigger (icon+pill) at that breakpoint — the Dashboard's own "Start demo-gids" control
+  remains reachable there. Also fixed a genuine mobile overflow in the new
+  `.demo-start-panel` (flex items without `min-width:0`/wrap on narrow screens).
+- Fixed one fragile new test (asserted on the transient `?guide=start` URL param, which
+  the app intentionally strips immediately — changed to assert the guide's actual open
+  state instead) and two Playwright strict-mode ambiguous-match errors; confirmed the
+  full 41+6=47-test suite passes twice in a row after these fixes (ruling out flakiness).
+- Evidence: frontend `tsc -b` clean, `npm run build` clean; full Playwright suite
+  **47 passed** (41 existing + 6 new `demo-guide.spec.ts`: scenario overview shows 5
+  ready cards after reset, starting a scenario navigates to its fixed record, guide
+  step navigation/jump/close, progress persists across page navigation, guide hidden
+  from Rental Employee, restart-from-guide resets data and returns to login). Backend
+  untouched this batch (no re-run needed; last backend gate was 127 passed/ruff/mypy
+  clean in Batch 2).
+- Deployed to Unraid (commits `9fff84d`, then `14c2ad3` for a test-only fix): pushed to
+  Gitea, tarball extracted, `web` rebuilt (frontend-only batch), healthy. Live-verified:
+  ran `demo-guide.spec.ts` (6), `demo-entry.spec.ts` (4) and the five-minute demo script
+  directly against `http://192.168.10.150:1236` — **11/11 passed**. Caught and fixed one
+  real environment-sensitive test bug in the process: two tests navigated straight to
+  `/scenarios` right after a login click without waiting for the `/dashboard` redirect,
+  which raced harmlessly on localhost but flaked against Unraid's higher latency — fixed
+  by asserting the redirect first, no app-code change needed. Reseeded afterward to leave
+  the server demo-ready.
+- Exact next action: layer plain-language Dutch explanation onto the return flow, the 5
+  data-quality panels, and fix the knowledge assistant's RAGcore-naming bug — task #33.
+
+### Batch 4 — return/data-quality/knowledge demo legibility (complete)
+
+- **Fixed a real honesty bug**: `Knowledge.tsx` named "RAGcore" in the body copy and the
+  retrieval-flow diagram even though the active provider is the demo TF-IDF one (the
+  small badge below was already honest, contradicting the prose one line above). Now
+  derives a `providerLabel` ("Demo knowledge base" vs "RAGcore") from the real health
+  check and uses it everywhere; added an explicit disclosure note when not RAGcore.
+  Added 4 suggested-question chips. **Discovered and fixed a second real bug in the
+  process**: the brief's suggested Dutch questions (and my own Demo Guide step 6 wording)
+  would have returned "insufficient evidence" against the demo provider, because the
+  indexed procedures are English-only — verified empirically (Dutch question →
+  `insufficient`, its English equivalent → `grounded`). Fixed by keeping suggested
+  questions in English (matching the indexed content) and rewording the Guide step to
+  explain the knowledge base is English, rather than mistranslating the demo's
+  centerpiece feature into silently returning wrong answers.
+- Return flow: `BookingDetail.tsx` now detects the one named return-anomaly scenario
+  booking (via the manifest, not a hardcoded ref) and fetches that vehicle's real
+  canonical odometer to pre-fill `ReturnForm`'s "End odometer" field with a suspicious
+  value below it, plus a callout explaining why — the brief explicitly requires the demo
+  not ask a visitor to invent a suspicious number themselves. Scoped narrowly to that one
+  scenario booking; ordinary returns are unaffected. `ReturnResultPanel` now links to
+  Automation and Audit trail (previously only the vehicle), and shows a "Ga verder met de
+  demo" button when the Demo Guide is open (advances the guide and navigates to the next
+  step). **Fixed a real regression caught by the existing return-review e2e test**: the
+  async pre-fill could silently overwrite odometer text a visitor had already started
+  typing, if the vehicle-detail fetch resolved after they began typing — fixed with an
+  `odometerEditedByUser` ref guard.
+- Data quality: added a shared `RuleExplainer` (what's wrong / why it matters, in plain
+  language) for all 5 rule types on `DataQualityIssueDetail.tsx`; added a generic
+  post-resolution confirmation (audit-trail link, vehicle link, "Ga verder met de demo")
+  for the 4 rule types that previously just silently flipped their status badge with no
+  explicit confirmation, and extended `VehicleStatusConflictPanel`'s existing confirmation
+  with the same links rather than duplicating it. Added a "Demo scenario's only" checkbox
+  filter on `DataQuality.tsx` (client-side `public_ref.startsWith("DQ-DEMO-")`, no new
+  business logic) so the curated issues are easy to find among the full queue.
+- Evidence: frontend `tsc -b` clean, `npm run build` clean; full Playwright suite
+  **51 passed** (47 existing + 4 new `demo-legibility.spec.ts`: return pre-fill + why-
+  suspicious explanation + result links, rule explainer visible, demo-scenario filter
+  narrows correctly, knowledge suggested question returns grounded evidence with the
+  correct provider label). Backend untouched this batch.
+- Deployed to Unraid (commit `ddc3a98`): pushed to Gitea, tarball extracted, `web`
+  rebuilt (frontend-only), healthy. Live-verified: ran `demo-legibility.spec.ts` (4) and
+  the five-minute demo script directly against `http://192.168.10.150:1236` —
+  **5/5 passed**. Reseeded afterward to leave the server demo-ready.
+- Exact next action: plain-language integration-status labels, richer audit narration,
+  the full "Over deze demo" page content (currently a first pass from Batch 2), and
+  wiring reset into the guide/About/OM menu narrative — task #34.
+
+### Batch 5 — integration-status UX, audit UX, About page, reset integrity (complete)
+
+- Plain-language integration status: extracted `frontend/src/data/integrationLabels.ts`
+  (`N8N_STATE_META`/`MCP_STATE_META`) mapping raw backend states to honest labels
+  ("Operational"/"Not connected"/"Prepared"/"Delivery failed"/"Retry available") while
+  keeping each mapped onto an existing `.status-*` CSS colour class (a few raw values like
+  `degraded`/`disabled`/`configured` had no matching CSS rule at all before this — a real,
+  pre-existing colour-coding gap). `StatusBadge` gained an optional `label` override prop
+  (backward compatible) so the badge's colour class and its displayed text can differ.
+  Wired into both `Automation.tsx` and `Dashboard.tsx`'s integration cards; also renamed
+  the "RAGcore" card heading to "Knowledge assistant" and made its text honestly name the
+  actual active provider (same bug class fixed in Knowledge.tsx in Batch 4).
+- Audit trail: added a "Follow-up" column with a "View related events" action per row that
+  filters the same list by `correlation_id` (reuses the backend's existing, already-tested
+  `correlation_id` query param — no new business logic), with a "Clear this filter"
+  affordance. This is how a visitor sees "what else happened as a result of this action"
+  (e.g. a return's linked vehicle-status-changed / workflow-queued events) without a
+  bigger grouped-timeline rebuild.
+- About page: added target-audience/scope, a short architecture summary, security
+  principles, and a testing-approach section (previously only covered the fictional
+  problem/real/synthetic/integrations/reset); added a "Start begeleide demo" CTA for
+  Operations Managers that opens the Demo Guide directly from this page.
+- Reset integrity: added `scenario_integrity_report()` (`backend/app/services/
+  demo_manifest.py`), reusing the exact same scenario-readiness derivation the manifest
+  and scenario overview already use (so it can't drift), and wired it into `POST
+  /api/v1/demo/reset` — both the response body and the `demo_reset` audit event's
+  metadata now carry `scenario_integrity: {all_ready, not_ready}`. This is the
+  server-side post-reset integrity check the brief asks for; visible today via the audit
+  event's raw-detail view, satisfying the requirement without adding a UI banner to a
+  flow that immediately logs the user out and redirects to `/login`.
+- **Fixed a second real regression this batch, caught by the existing return-review
+  e2e test**: restructured the odometer pre-fill so `BookingDetail.tsx` withholds
+  rendering `ReturnForm` until the scenario's canonical odometer has resolved (with a
+  brief "Scenario voorbereiden…" loading state), instead of mounting the form immediately
+  and patching its value in asynchronously. The previous approach raced visibly with
+  Playwright's `fill()` (and would have raced with a real visitor typing quickly),
+  producing a corrupted concatenated value in one observed failure. This also let the
+  now-unnecessary `odometerEditedByUser` ref guard be removed — simpler and more robust
+  than the effect-based patch it replaced.
+- Evidence: `pytest` **127 passed**, `ruff check .` clean, `mypy app` clean (48 files);
+  frontend `tsc -b` clean, `npm run build` clean; full Playwright suite **51 passed**,
+  confirmed stable across three consecutive full runs (given how many timing races this
+  batch and the previous one surfaced, stability was verified deliberately rather than
+  assumed from a single green run).
+- Deployed to Unraid (commit `5fa4fe0`): pushed to Gitea, tarball extracted, both `api`
+  and `web` rebuilt, healthy, migrations unchanged at `e7b08389f47f (head)`, reseeded.
+  Live-verified: ran `demo-legibility.spec.ts` (4), the five-minute demo script, and the
+  full `interactive-elements.spec.ts` suite (26) directly against
+  `http://192.168.10.150:1236` — **31/31 passed**. Reseeded afterward to leave the
+  server demo-ready.
+- Exact next action: full guided-demo Playwright test + remaining targeted demo tests per
+  section 19 (mobile guide, keyboard nav, all scenario flows, About page, accessibility/
+  reduced-motion/console/network checks) — task #35.
+
+### Batch 6 — full guided-demo test + targeted demo tests (complete)
+
+- **Found and fixed a real, fairly serious desktop layout bug** while writing the full
+  guided-demo test: the Demo Guide's fixed right-side panel (400px wide) overlapped the
+  main content area at normal desktop widths with no reflow, so its own step-list buttons
+  intercepted pointer events meant for the page underneath (concretely: the return form's
+  "Review return" button was unclickable while the guide was open, at exactly the
+  viewport size Playwright's default test browser uses — this would have hit real
+  visitors on ordinary laptop screens too). Fixed by adding a `guide-open` class to
+  `.app-workspace` that reserves `padding-right: min(400px, 92vw)` while the guide is open
+  (≥701px only; the ≤700px bottom-sheet layout is unaffected), so content reflows aside
+  instead of sitting underneath the panel.
+- Added `frontend/e2e/guided-demo-full.spec.ts`: one comprehensive test walking a fresh
+  Operations Manager session through all 8 Demo Guide steps in order, performing the
+  **real** action at each step (not just verifying copy) — processes the actual
+  odometer-anomaly return, resolves the resulting data-quality issue, merges the
+  duplicate customer, asks a suggested knowledge question, checks automation + audit,
+  reviews the About page — using the guide's own progression controls
+  ("Volgende"/"Ga naar deze stap"/"Ga verder met de demo") throughout, then resets the
+  demo data again at the end to restore the environment per the brief's requirement.
+- Added `frontend/e2e/demo-accessibility.spec.ts` (4 tests): the guide renders as a
+  correctly-anchored bottom sheet on a 390px mobile viewport with no horizontal overflow;
+  the guide never covers the return form's action buttons on desktop (regression test for
+  the bug above); the demo badge and guide trigger are keyboard-focusable and operable
+  (Enter to open, explicit close controls); key demo pages (dashboard, scenarios, about,
+  guide open) load with no unexpected console errors (the one expected benign 401 from
+  the app's own session-probe on first load is explicitly allow-listed, not silenced
+  blindly).
+- Evidence: full Playwright suite **56 passed** (51 existing + 1 guided-demo-full + 4
+  demo-accessibility), confirmed stable across two consecutive full runs. Backend
+  untouched this batch (last gate: 127 passed/ruff/mypy clean, Batch 5).
+- Deployed to Unraid (commit `07d5605`): pushed to Gitea, tarball extracted, `web`
+  rebuilt (frontend-only), healthy, reseeded. Live-verified: ran
+  `guided-demo-full.spec.ts` and `demo-accessibility.spec.ts` directly against
+  `http://192.168.10.150:1236` — **5/5 passed**, confirming the desktop-overlay layout
+  fix holds on the real deployment too. Reseeded afterward to leave the server
+  demo-ready.
+- Exact next action: clean-checkout demo drill, final documentation set (demo-concept/
+  demo-scenarios/demo-data/demo-guide/demo-runbook, README, .env.example), final Unraid
+  deploy + live evidence with screenshots, `artifacts/demo-release/final-summary.md` —
+  task #36 (final).
+
+### Batch 7 (final) — clean-checkout drill, docs, final Unraid evidence (complete)
+
+- **Clean-checkout drill**: fresh `git clone` into an isolated scratch directory,
+  isolated Compose project (`mobilityops-cleandrill`) + remapped ports via
+  `compose.override.yaml`, `up --build -d` from empty volumes. Migrations ran
+  automatically to `e7b08389f47f (head)`; seeded; full backend gate **127 passed**,
+  ruff/mypy clean; `npm ci` clean (same pre-existing advisories as before, unchanged);
+  `tsc -b`/`vite build` clean; full Playwright suite **56 passed** against the isolated
+  stack; reseeded and confirmed all 5 scenarios `ready: true` via the manifest; torn down
+  (`down -v` on the isolated project only — the working dev stack was untouched
+  throughout).
+- Added the full demo-release documentation set: `docs/demo-release/demo-concept.md`,
+  `demo-scenarios.md`, `demo-data.md`, `demo-guide.md`, `demo-runbook.md`; updated
+  `README.md` (current test counts, links to the new docs, a "Demo" section) and
+  `docs/17-runbook.md` (cross-reference to the demo-specific runbook).
+- Added `frontend/e2e/_capture-demo-screenshots.spec.ts` (tooling, excluded from the
+  regular suite) and captured 17 evidence screenshots live against
+  `http://192.168.10.150:1236` into `artifacts/demo-release/screenshots/`.
+- Final live acceptance: full Playwright suite re-run against the live server —
+  **56 passed**; `docker compose ps` on the server shows `api`/`db`/`web` all healthy;
+  `docker logs` for `api`/`web` show no errors; reseeded to leave the server
+  demo-ready after evidence capture.
+- Wrote `artifacts/demo-release/final-summary.md` with the full required evidence
+  (branches/commits, org/roles/guide/scenarios, seed/date-anchor/reset strategy, real vs.
+  synthetic vs. not-connected, all test results, clean-checkout result, deployment/
+  health/console/log results, responsive/accessibility results including the two real
+  layout bugs found and fixed this work (mobile topbar overflow in Batch 3, desktop
+  guide-panel overlap in Batch 6), known limitations, 5-/10-minute demo flows, redeploy/
+  rollback commands, and the screenshot list).
+- Demo-productization work on this branch is complete. Every task (#29–#36) is done;
+  every batch was tested locally, deployed to Unraid, and re-verified live before moving
+  to the next. See `artifacts/demo-release/final-summary.md` for the definitive
+  acceptance evidence.
diff --git a/README.md b/README.md
index c03e484..0a1b3cc 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,17 @@ design decision and visual evidence.
 
 All people, companies, vehicles, bookings and documents are synthetic. The workflows, validation, integrations, audit logging and access boundaries are intended to be real.
 
+## Demo
+
+The demo presents itself as **Northstar Mobility**, a fictitious Belgian camper/van
+rental company — the login screen, a permanent "Synthetische demo" indicator, an in-app
+guided tour (Demo Guide), a curated `/scenarios` overview, and an "Over deze demo" page
+all make the fictional context, synthetic-data status, and real-vs-simulated boundaries
+explicit without any verbal explanation. See `docs/demo-release/` for the full demo
+concept, the five named scenarios, the seed/date-anchoring strategy, the guided-tour
+design, and the operational runbook (5-minute and 10-minute demo flows, reset, redeploy,
+rollback).
+
 ## Scope
 
 The PoC implements:
@@ -77,6 +88,9 @@ and `artifacts/final-acceptance/summary.md` for the original M0–M7 acceptance
 - `artifacts/design-validation/` — baseline audit, Stitch direction references and implemented responsive captures.
 - `docs/functional-completion/` — the functional-completion audit and pre-work server baseline.
 - `artifacts/functional-completion/` — functional-completion acceptance evidence.
+- `docs/demo-release/` — demo concept, scenarios, seed/date-anchoring strategy, guided
+  tour, and runbook.
+- `artifacts/demo-release/` — demo-productization acceptance evidence.
 
 ## Quickstart
 
@@ -100,9 +114,9 @@ All defaults are configurable via `.env` (see `.env.example`).
 ## Quality gates
 
 ```bash
-make test    # backend: pytest (117 tests)
+make test    # backend: pytest (127 tests)
 make lint    # backend: ruff + mypy (strict, zero errors)
-make e2e     # frontend: Playwright end-to-end (37 tests, live stack required)
+make e2e     # frontend: Playwright end-to-end (56 tests, live stack required)
 ```
 
 Frontend build/typecheck: `cd frontend && npm run build` (`tsc -b && vite build`).
diff --git a/artifacts/demo-release/final-summary.md b/artifacts/demo-release/final-summary.md
new file mode 100644
index 0000000..cf311b5
--- /dev/null
+++ b/artifacts/demo-release/final-summary.md
@@ -0,0 +1,195 @@
+# Demo-productization final summary
+
+## Branches and commits
+
+- **Gitea repository**: `ssh://git@192.168.10.150:222/Jens/MobilityOps.git` (browsable at
+  `http://192.168.10.150:3000/Jens/MobilityOps`)
+- **Branch**: `feat/mobilityops-functional-completion` (no new branch created; no merge
+  to `main`; no rebase/reset/squash/force-push; full git history preserved, as required)
+- **Start commit** (functional-completion baseline, already accepted):
+  `e0c7ed60112510687627d20a957af91c8b9db7f8`
+- **Final commit**: `4a268c73515dc4f1d56c1aa2f231714654bffbb8` — verified via
+  `git rev-parse HEAD` on `feat/mobilityops-functional-completion` and confirmed to match
+  `/mnt/user/appdata/mobilityops/.deploy/source-revision` on the Unraid server exactly.
+  (This corrects a self-reference gap in the immediately preceding pair of commits, which
+  necessarily could not know their own hash at the time they were written; this is now
+  the single, unambiguous, verified reference. The repository's primary branch is
+  `master`, not `main` — no branch named `main` exists in this repository.)
+- **Live URL**: `http://192.168.10.150:1236`
+
+## Demo organisation and context
+
+**Northstar Mobility** — a fictitious Belgian camper/van rental company (~50 vehicles,
+one main location, rental team, an Operations Manager, a small workshop). This name was
+already a locked internal decision (`ragcore_tenant: northstar-mobility-demo`,
+`PROJECT_STATE.md`'s "Locked decisions") before this work — this pass surfaces it in the
+UI rather than inventing it. Full concept: `docs/demo-release/demo-concept.md`.
+
+## Roles
+
+- **Operations Manager** — full access: data-quality resolution, workflow retries, audit
+  trail, demo reset, the Demo Guide.
+- **Rental Employee** — scoped access: bookings, returns, fleet, knowledge assistant.
+
+Both are reachable from the login screen with no password.
+
+## Demo Guide
+
+An 8-step, sessionStorage-persisted guided tour (Operations-Manager-only, since every
+step requires that role). Full design: `docs/demo-release/demo-guide.md`. Steps: (1)
+understand operational state, (2) open the booking needing attention, (3) process the
+odometer-anomaly return, (4) handle the created data-quality issue, (5) merge the
+duplicate customer, (6) ask the knowledge assistant, (7) check automation + audit, (8)
+review real vs. synthetic vs. not-connected.
+
+## Scenarios (all 5, full detail in `docs/demo-release/demo-scenarios.md`)
+
+| # | Scenario | Fixed records | Role |
+|---|---|---|---|
+| 1 | Odometer regression on return | `BK-DEMO-RETURN` / `MO-024` | Either |
+| 2 | Possible duplicate customer | `CUS-0012` / `CUS-0178` / `DQ-DEMO-DUPLICATE` | OM |
+| 3 | Overlapping bookings | `MO-016` / `BK-DEMO-OVERLAP-A/B` / `DQ-DEMO-OVERLAP` | OM |
+| 4 | Failed automation, retried | outbox event `...020` / `BK-H-0020` | OM |
+| 5 | Grounded procedure question | (no fixed record; suggested questions) | Either |
+
+`GET /api/v1/demo/manifest`'s `scenarios` array derives `ready`/`blocked_reason` from the
+live underlying records, never hardcoded — confirmed via `backend/tests/
+test_demo_manifest.py` (`test_demo_manifest_scenarios_ready_after_fresh_reset`) and
+live-checked after every reset throughout this work.
+
+## Seed strategy and date-anchoring
+
+`seed/generate_seed.py --anchor 2026-08-01 --seed 20260801` produces deterministic CSVs
+with absolute timestamps authored against a fixed anchor. `backend/app/seed_loader.py`
+shifts every seeded datetime by `(real today − authored anchor)` on every seed/reset, so
+"today"/"near-future"/"currently overlapping" scenarios stay true to the actual reset
+moment instead of decaying. This fixed a real, confirmed bug (`BK-DEMO-RETURN` was found
+sitting 2 days in the past before this fix). Full detail: `docs/demo-release/demo-data.md`.
+
+## Reset strategy
+
+`POST /api/v1/demo/reset` (Operations Manager only, gated by `DEMO_ALLOW_RESET`) clears
+MobilityOps's own tables, reseeds with a fresh date anchor, re-runs the data-quality scan,
+and runs a server-side scenario-integrity check (`scenario_integrity_report()`) recorded
+in both the response and the `demo_reset` audit event. Reachable from the sidebar, the
+Demo Guide, and the About page. Never touches shared n8n/RAGcore/MCP data, other
+containers, or volumes.
+
+## Real vs. synthetic vs. not-connected
+
+See `docs/demo-release/demo-concept.md` for the full breakdown. In short: auth/roles,
+vehicle/booking management, return preview/commit, the 5 data-quality rules and their
+resolutions, the audit trail, n8n orchestration, Docker deployment, and the automated
+test suite are all really implemented. The organisation, all people, vehicles, bookings,
+procedures, and the 5 named scenarios are synthetic. RAGcore and the ITWorx MCP Hub are
+not live-connected (honestly labelled "Demomodus"/"Niet gekoppeld" everywhere, never a
+fabricated success).
+
+## Test results
+
+### Backend (clean checkout, isolated stack)
+- `pytest`: **127 passed**
+- `ruff check .`: clean
+- `mypy app`: clean (48 source files)
+
+### Frontend (clean checkout, isolated stack)
+- `npm ci`: clean (pre-existing esbuild-moderate/react-router-RSC-high advisories,
+  unchanged from before this work — not introduced by it)
+- `tsc -b`: clean
+- `npm run build`: clean
+- Full Playwright suite: **56 passed** (against the isolated clean-checkout stack)
+
+### Guided-demo test
+`frontend/e2e/guided-demo-full.spec.ts` — one comprehensive test walking a fresh
+Operations Manager session through all 8 Demo Guide steps performing the real action at
+each step (processes the actual odometer-anomaly return, resolves the resulting
+data-quality issue, merges the duplicate customer, asks a suggested knowledge question,
+checks automation + audit, reviews the About page), then resets the demo data again to
+restore the environment. **Passed**, confirmed stable across repeated runs both locally
+and against the live Unraid deployment.
+
+### Clean-checkout drill
+Fresh `git clone` of this branch/commit into an isolated scratch directory, `.env` from
+`.env.example`, isolated Compose project name (`mobilityops-cleandrill`) and remapped
+host ports (`compose.override.yaml` with `!override` merge tags — no shared state with
+any other stack), `docker compose up --build -d` from empty volumes → migrations ran
+automatically (`e7b08389f47f (head)`) → seeded → full backend gate (127 passed, ruff/
+mypy clean) → `npm ci`/`tsc -b`/`vite build` clean → full Playwright suite (56 passed)
+→ reseeded and confirmed all 5 scenarios `ready: true` via the manifest → torn down
+(`docker compose down -v` on the isolated project only; the working dev stack was never
+touched).
+
+### Server deployment
+Deployed incrementally after every batch (10 deploy cycles across this work); final
+state: both `api` and `web` rebuilt and healthy at the final commit, `db` untouched
+across all of them (no destructive migrations on this branch). Migrations at
+`e7b08389f47f (head)` throughout. `.deploy/source-revision` on the server matches the
+final commit exactly.
+
+### Container health
+`docker compose ps` on the server: `api`, `db`, `web` all `healthy`, no restart loops.
+
+### Browser console / network
+No unexpected console errors on login, dashboard, scenarios, About, or with the Demo
+Guide open (verified via `demo-accessibility.spec.ts`; the one benign 401 from the app's
+own session-probe on first load is expected and explicitly accounted for, not silenced
+blindly). No unresolved server errors in `docker logs` for `api`/`web` at the time of
+this evidence capture.
+
+### Responsive / accessibility
+- Demo Guide renders as a correctly-anchored bottom sheet at 390px with no horizontal
+  overflow (`demo-accessibility.spec.ts`).
+- **Real bug found and fixed**: the Demo Guide's fixed desktop side panel overlapped
+  main content with no reflow, making the return form's "Review return" button
+  unclickable while the guide was open at ordinary desktop widths — this surfaced while
+  writing the full guided-demo test. Fixed via a `guide-open` layout class that reserves
+  space for the panel; regression-tested.
+- Demo badge and Demo Guide triggers are keyboard-focusable and operable (Enter to open,
+  explicit close controls).
+- Existing responsive-overflow checks (390/768/1280/1440px) remain green throughout.
+
+## Known limitations
+
+- RAGcore and the ITWorx MCP Hub are not live-connected in this environment (by design
+  — see scope). The knowledge assistant uses a local, English-only demo knowledge base;
+  a Dutch question against it returns "insufficient evidence" (verified empirically), so
+  suggested questions and the Demo Guide's step 6 instructions deliberately stay in
+  English rather than silently breaking the demo's centerpiece grounded-answer feature.
+- Existing operational screens (Dashboard, Vehicles, Bookings, Data Quality workbench,
+  Audit, Automation internals) remain in English; only new demo-productization surfaces
+  (login, Demo Guide, scenario overview, About page, demo badge, plain-language
+  integration labels) are in Dutch — a deliberate, documented scope decision, not an
+  oversight (`docs/demo-release/current-demo-gap-audit.md`, gap #11).
+- Scenario S3 ("missing inspection before next booking", `MO-031`) is seeded and visible
+  in the attention queue but isn't one of the 5 scenarios surfaced on `/scenarios`,
+  matching the brief's request for exactly 5.
+
+## 5-minute and 10-minute demo flows
+
+See `docs/demo-release/demo-runbook.md` for the exact click-through scripts.
+
+## Redeploy commands and rollback procedure
+
+See `docs/demo-release/demo-runbook.md` — `git archive` → `scp` → extract → rebuild
+`api`/`web` → confirm migrations → reseed. Rollback: extract an earlier
+`.deploy/source-<short-sha>.tar.gz` and update `.deploy/source-revision` to match.
+
+## Evidence screenshots
+
+All captured live against `http://192.168.10.150:1236` (`artifacts/demo-release/screenshots/`):
+
+1. `01-demo-entry-desktop.png` / `02-demo-entry-mobile.png` — demo entry, both sizes
+2. `03-dashboard-with-scenarios.png` — dashboard with the scenario teaser panel
+3. `04-demo-guide.png` — the Demo Guide panel open
+4. `05-return-preview.png` / `06-return-result.png` — the return flow
+5. `07-data-quality-resolution.png` — a data-quality issue with its plain-language explainer
+6. `08-duplicate-customer-merge.png` — the duplicate-customer comparison/merge UI
+7. `09-knowledge-assistant.png` — a grounded answer with cited sources
+8. `10-integration-status.png` — plain-language integration status on Automation
+9. `11-automation-retry-before.png` / `11-automation-retry-after.png` — a workflow retry
+10. `12-audit-trail.png` / `13-audit-related-events.png` — audit trail + correlation drill-down
+11. `14-about-demo.png` — the About page
+12. `15-demo-badge-popover.png` — the permanent synthetic-demo badge popover
+13. `16-reset-confirm.png` — the reset confirmation flow
+
+No secrets appear in any screenshot or in this document.
diff --git a/artifacts/demo-release/screenshots/01-demo-entry-desktop.png b/artifacts/demo-release/screenshots/01-demo-entry-desktop.png
new file mode 100644
index 0000000..b5f6a9b
Binary files /dev/null and b/artifacts/demo-release/screenshots/01-demo-entry-desktop.png differ
diff --git a/artifacts/demo-release/screenshots/02-demo-entry-mobile.png b/artifacts/demo-release/screenshots/02-demo-entry-mobile.png
new file mode 100644
index 0000000..9fa5b7d
Binary files /dev/null and b/artifacts/demo-release/screenshots/02-demo-entry-mobile.png differ
diff --git a/artifacts/demo-release/screenshots/03-dashboard-with-scenarios.png b/artifacts/demo-release/screenshots/03-dashboard-with-scenarios.png
new file mode 100644
index 0000000..96eaea9
Binary files /dev/null and b/artifacts/demo-release/screenshots/03-dashboard-with-scenarios.png differ
diff --git a/artifacts/demo-release/screenshots/04-demo-guide.png b/artifacts/demo-release/screenshots/04-demo-guide.png
new file mode 100644
index 0000000..1935145
Binary files /dev/null and b/artifacts/demo-release/screenshots/04-demo-guide.png differ
diff --git a/artifacts/demo-release/screenshots/05-return-preview.png b/artifacts/demo-release/screenshots/05-return-preview.png
new file mode 100644
index 0000000..09995d2
Binary files /dev/null and b/artifacts/demo-release/screenshots/05-return-preview.png differ
diff --git a/artifacts/demo-release/screenshots/06-return-result.png b/artifacts/demo-release/screenshots/06-return-result.png
new file mode 100644
index 0000000..768c491
Binary files /dev/null and b/artifacts/demo-release/screenshots/06-return-result.png differ
diff --git a/artifacts/demo-release/screenshots/07-data-quality-resolution.png b/artifacts/demo-release/screenshots/07-data-quality-resolution.png
new file mode 100644
index 0000000..3fd60bc
Binary files /dev/null and b/artifacts/demo-release/screenshots/07-data-quality-resolution.png differ
diff --git a/artifacts/demo-release/screenshots/08-duplicate-customer-merge.png b/artifacts/demo-release/screenshots/08-duplicate-customer-merge.png
new file mode 100644
index 0000000..8d2f21b
Binary files /dev/null and b/artifacts/demo-release/screenshots/08-duplicate-customer-merge.png differ
diff --git a/artifacts/demo-release/screenshots/09-knowledge-assistant.png b/artifacts/demo-release/screenshots/09-knowledge-assistant.png
new file mode 100644
index 0000000..36f6bd1
Binary files /dev/null and b/artifacts/demo-release/screenshots/09-knowledge-assistant.png differ
diff --git a/artifacts/demo-release/screenshots/10-integration-status.png b/artifacts/demo-release/screenshots/10-integration-status.png
new file mode 100644
index 0000000..5891547
Binary files /dev/null and b/artifacts/demo-release/screenshots/10-integration-status.png differ
diff --git a/artifacts/demo-release/screenshots/11-automation-retry-after.png b/artifacts/demo-release/screenshots/11-automation-retry-after.png
new file mode 100644
index 0000000..270f681
Binary files /dev/null and b/artifacts/demo-release/screenshots/11-automation-retry-after.png differ
diff --git a/artifacts/demo-release/screenshots/11-automation-retry-before.png b/artifacts/demo-release/screenshots/11-automation-retry-before.png
new file mode 100644
index 0000000..5630a68
Binary files /dev/null and b/artifacts/demo-release/screenshots/11-automation-retry-before.png differ
diff --git a/artifacts/demo-release/screenshots/12-audit-trail.png b/artifacts/demo-release/screenshots/12-audit-trail.png
new file mode 100644
index 0000000..a18b6a1
Binary files /dev/null and b/artifacts/demo-release/screenshots/12-audit-trail.png differ
diff --git a/artifacts/demo-release/screenshots/13-audit-related-events.png b/artifacts/demo-release/screenshots/13-audit-related-events.png
new file mode 100644
index 0000000..e7b0d6f
Binary files /dev/null and b/artifacts/demo-release/screenshots/13-audit-related-events.png differ
diff --git a/artifacts/demo-release/screenshots/14-about-demo.png b/artifacts/demo-release/screenshots/14-about-demo.png
new file mode 100644
index 0000000..5c0b96c
Binary files /dev/null and b/artifacts/demo-release/screenshots/14-about-demo.png differ
diff --git a/artifacts/demo-release/screenshots/15-demo-badge-popover.png b/artifacts/demo-release/screenshots/15-demo-badge-popover.png
new file mode 100644
index 0000000..7d6a360
Binary files /dev/null and b/artifacts/demo-release/screenshots/15-demo-badge-popover.png differ
diff --git a/artifacts/demo-release/screenshots/16-reset-confirm.png b/artifacts/demo-release/screenshots/16-reset-confirm.png
new file mode 100644
index 0000000..f1eec84
Binary files /dev/null and b/artifacts/demo-release/screenshots/16-reset-confirm.png differ
diff --git a/backend/app/api/routers/dashboard.py b/backend/app/api/routers/dashboard.py
index 7042107..3385bec 100644
--- a/backend/app/api/routers/dashboard.py
+++ b/backend/app/api/routers/dashboard.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import date, datetime
+from datetime import UTC, date, datetime
 from typing import Literal
 
 from fastapi import APIRouter, Depends
@@ -30,7 +30,9 @@ _SEVERITY_ORDER = {"high": 0, "medium": 1, "low": 2}
 
 
 def _today() -> date:
-    return datetime.fromisoformat(settings.demo_today).date()
+    # Seeded dates are shifted to the real reset moment by `seed_loader.py`'s anchor
+    # shift, so "today" must be real wall-clock time, not the frozen `demo_today` setting.
+    return datetime.now(UTC).date()
 
 
 @router.get("", response_model=DashboardOut)
@@ -59,12 +61,11 @@ def get_dashboard(
             entity = customers_by_id.get(issue.entity_id)
             link_type = "customer"
         link_ref = entity.public_ref if entity else ""
-        title = f"{issue.rule_type.replace('_', ' ').title()} — {link_ref}"
         attention_items.append(
             AttentionItem(
                 kind="quality_issue",
                 severity=issue.severity,
-                title=title,
+                rule_type=issue.rule_type,
                 detail=issue.evidence_json.get("summary", ""),
                 link_type=link_type,
                 link_ref=link_ref,
diff --git a/backend/app/api/routers/demo.py b/backend/app/api/routers/demo.py
index 85c3b6f..fd06a68 100644
--- a/backend/app/api/routers/demo.py
+++ b/backend/app/api/routers/demo.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 import time
 import uuid
 
-from fastapi import APIRouter, Depends, Request, Response
+from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
@@ -11,14 +11,23 @@ from app.api.deps import get_current_user, get_db, require_operations_manager
 from app.core.config import get_settings
 from app.core.security import SessionPayload, create_session_token, read_session_token
 from app.models.user import User
-from app.schemas import CurrentUser, DemoLoginRequest
+from app.schemas import CurrentUser, DemoLoginRequest, DemoManifestOut
 from app.seed_loader import reset_and_seed
 from app.services.audit import record_audit_event
+from app.services.demo_manifest import build_demo_manifest, scenario_integrity_report
 
 router = APIRouter(prefix="/api/v1/demo", tags=["demo"])
 settings = get_settings()
 
 
+@router.get("/manifest", response_model=DemoManifestOut)
+def demo_manifest(db: Session = Depends(get_db)) -> DemoManifestOut:
+    # Deliberately unauthenticated: the demo-entry screen and the permanent demo badge
+    # both need this before any session exists. Nothing here is sensitive — it's the same
+    # honest "what is this demo" summary a logged-in user would see.
+    return build_demo_manifest(db)
+
+
 @router.post("/login", response_model=CurrentUser)
 def demo_login(
     body: DemoLoginRequest, response: Response, db: Session = Depends(get_db)
@@ -92,15 +101,31 @@ def demo_reset(
     db: Session = Depends(get_db),
     user: CurrentUser = Depends(require_operations_manager),
 ) -> dict:
+    if not settings.demo_allow_reset:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Demo reset is disabled on this deployment.",
+        )
     result = reset_and_seed(db)
+    integrity = scenario_integrity_report(db)
     record_audit_event(
         db,
         actor_type="user",
         actor_label=user.display_name,
         action="demo_reset",
         entity_type="system",
-        metadata={"counts": result.counts},
+        metadata={
+            "counts": result.counts,
+            "anchor_date": result.anchor_date.isoformat(),
+            "scenario_integrity": integrity,
+        },
     )
     db.commit()
     response.delete_cookie(settings.session_cookie_name)
-    return {"status": "reset", "counts": result.counts}
+    return {
+        "status": "reset",
+        "counts": result.counts,
+        "anchor_date": result.anchor_date.isoformat(),
+        "seeded_at": result.seeded_at.isoformat(),
+        "scenario_integrity": integrity,
+    }
diff --git a/backend/app/api/routers/integration_status.py b/backend/app/api/routers/integration_status.py
index b337709..c1f08f8 100644
--- a/backend/app/api/routers/integration_status.py
+++ b/backend/app/api/routers/integration_status.py
@@ -1,75 +1,28 @@
 from __future__ import annotations
 
-from typing import Literal
-
 from fastapi import APIRouter, Depends
-from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
 from app.api.deps import get_db, require_operations_manager
 from app.core.config import get_settings
-from app.models.outbox import OutboxEvent
 from app.schemas import (
     CurrentUser,
     IntegrationStatusOut,
     McpHubIntegrationStatus,
-    N8nIntegrationStatus,
 )
+from app.services.integration_status import derive_n8n_status
 
 router = APIRouter(prefix="/api/v1/integrations", tags=["integrations"])
 settings = get_settings()
 
 
-def _n8n_status(db: Session) -> N8nIntegrationStatus:
-    counts: dict[str, int] = dict(
-        db.execute(
-            select(OutboxEvent.delivery_status, func.count()).group_by(OutboxEvent.delivery_status)
-        ).all()  # type: ignore[arg-type]
-    )
-    pending = counts.get("pending", 0)
-    delivering = counts.get("delivering", 0)
-    failed = counts.get("failed", 0)
-    succeeded = counts.get("succeeded", 0)
-
-    latest_success_at = db.scalar(
-        select(func.max(OutboxEvent.updated_at)).where(OutboxEvent.delivery_status == "succeeded")
-    )
-    latest_failure_at = db.scalar(
-        select(func.max(OutboxEvent.updated_at)).where(OutboxEvent.delivery_status == "failed")
-    )
-
-    state: Literal["disabled", "unavailable", "degraded", "operational", "no_evidence"]
-    if not settings.n8n_dispatch_enabled:
-        state = "disabled"
-    elif failed > 0 and succeeded == 0:
-        state = "unavailable"
-    elif failed > 0:
-        state = "degraded"
-    elif succeeded > 0 or pending > 0 or delivering > 0:
-        state = "operational"
-    else:
-        state = "no_evidence"
-
-    return N8nIntegrationStatus(
-        configured=bool(settings.n8n_webhook_url),
-        dispatch_enabled=settings.n8n_dispatch_enabled,
-        state=state,
-        pending=pending,
-        delivering=delivering,
-        failed=failed,
-        succeeded=succeeded,
-        latest_success_at=latest_success_at,
-        latest_failure_at=latest_failure_at,
-    )
-
-
 @router.get("/status", response_model=IntegrationStatusOut)
 def integration_status(
     db: Session = Depends(get_db),
     _user: CurrentUser = Depends(require_operations_manager),
 ) -> IntegrationStatusOut:
     return IntegrationStatusOut(
-        n8n=_n8n_status(db),
+        n8n=derive_n8n_status(db),
         mcp_hub=McpHubIntegrationStatus(
             registration_enabled=settings.mcp_hub_registration_enabled,
             state="configured" if settings.mcp_hub_registration_enabled else "not_configured",
diff --git a/backend/app/api/routers/knowledge.py b/backend/app/api/routers/knowledge.py
index ae15346..340d4f2 100644
--- a/backend/app/api/routers/knowledge.py
+++ b/backend/app/api/routers/knowledge.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import uuid
+from typing import Literal
 
 from fastapi import APIRouter, Depends
 from pydantic import BaseModel, Field
@@ -13,9 +14,12 @@ from app.services.knowledge import GroundedAnswer, KnowledgeHealth, get_knowledg
 
 router = APIRouter(prefix="/api/v1/knowledge", tags=["knowledge"])
 
+SupportedLanguage = Literal["nl-BE", "en-GB", "fr-BE"]
+
 
 class AskQuestionRequest(BaseModel):
     question: str = Field(min_length=3, max_length=1000)
+    language: SupportedLanguage = "en-GB"
 
 
 @router.post("/questions", response_model=GroundedAnswer)
@@ -26,7 +30,7 @@ def ask_question(
 ) -> GroundedAnswer:
     correlation_id = str(uuid.uuid4())
     provider = get_knowledge_provider()
-    answer = provider.ask(body.question, correlation_id)
+    answer = provider.ask(body.question, correlation_id, body.language)
 
     record_audit_event(
         db,
@@ -40,6 +44,7 @@ def ask_question(
             "provider": answer.provider,
             "source_ids": [s.document_id for s in answer.sources],
             "question_length": len(body.question),
+            "language": body.language,
         },
     )
     db.commit()
@@ -47,5 +52,8 @@ def ask_question(
 
 
 @router.get("/status", response_model=KnowledgeHealth)
-def knowledge_status(_user: CurrentUser = Depends(get_current_user)) -> KnowledgeHealth:
-    return get_knowledge_provider().health()
+def knowledge_status(
+    language: SupportedLanguage = "en-GB",
+    _user: CurrentUser = Depends(get_current_user),
+) -> KnowledgeHealth:
+    return get_knowledge_provider().health(language)
diff --git a/backend/app/core/config.py b/backend/app/core/config.py
index 14470d6..62cb07a 100644
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -32,7 +32,9 @@ class Settings(BaseSettings):
     mcp_hub_service_token: str = "replace-me-mcp-hub-token"
     mcp_hub_registration_enabled: bool = False
     cors_allow_origins: str = "http://localhost:1228"
-    demo_today: str = "2026-08-01"
+    demo_organization_name: str = "Northstar Mobility"
+    demo_timezone: str = "Europe/Brussels"
+    demo_allow_reset: bool = True
 
 
 @lru_cache
diff --git a/backend/app/schemas.py b/backend/app/schemas.py
index ad3836b..00c8bfc 100644
--- a/backend/app/schemas.py
+++ b/backend/app/schemas.py
@@ -197,6 +197,37 @@ class IntegrationStatusOut(BaseModel):
     mcp_hub: McpHubIntegrationStatus
 
 
+class DemoScenarioOut(BaseModel):
+    id: str
+    estimated_minutes: int
+    required_roles: list[Role]
+    start_path: str
+    ready: bool
+    blocked_reason_code: str | None = None
+    blocked_reason_params: dict[str, str] = {}
+
+
+class DemoIntegrationSummaryOut(BaseModel):
+    key: Literal["n8n", "ragcore", "mcp_hub"]
+    status_code: str
+    detail_code: str
+    detail_params: dict[str, str | int] = {}
+
+
+class DemoManifestOut(BaseModel):
+    demo_mode: bool
+    organization_name: str
+    timezone: str
+    synthetic_data: bool
+    allow_reset: bool
+    last_reset_at: datetime | None
+    anchor_date: str | None
+    guide_available: bool
+    required_roles: list[Role]
+    scenarios: list[DemoScenarioOut]
+    integrations: list[DemoIntegrationSummaryOut]
+
+
 class VehicleDetailOut(VehicleOut):
     bookings: list[BookingSummaryOut] = Field(default_factory=list)
     inspections: list[InspectionOut] = Field(default_factory=list)
@@ -217,7 +248,7 @@ class DashboardMetrics(BaseModel):
 class AttentionItem(BaseModel):
     kind: Literal["quality_issue", "vehicle"]
     severity: str
-    title: str
+    rule_type: str
     detail: str
     link_type: Literal["vehicle", "booking", "customer"]
     link_ref: str
diff --git a/backend/app/seed_loader.py b/backend/app/seed_loader.py
index 041cc05..938d219 100644
--- a/backend/app/seed_loader.py
+++ b/backend/app/seed_loader.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 import csv
 import uuid
 from dataclasses import dataclass
-from datetime import UTC, datetime
+from datetime import UTC, date, datetime, timedelta
 from pathlib import Path
 
 from sqlalchemy import delete, insert, update
@@ -20,6 +20,7 @@ from app.models.maintenance import MaintenanceRecord
 from app.models.outbox import OutboxEvent
 from app.models.user import User
 from app.models.vehicle import Vehicle
+from app.services.audit import record_audit_event
 
 settings = get_settings()
 
@@ -36,6 +37,17 @@ DEMO_USERS = [
     },
 ]
 
+# seed/generate_seed.py authored the committed CSVs relative to this fixed date
+# (`--anchor 2026-08-01`, matching Settings.demo_today). Every reset shifts every
+# seeded date by (today - SEED_AUTHORED_ANCHOR) so "today" / "near-future" / "overlaps
+# right now" scenarios stay true to the actual reset moment instead of decaying as real
+# time passes between resets -- a fixed anchor with no shift goes stale within days.
+SEED_AUTHORED_ANCHOR = date(2026, 8, 1)
+
+
+def _seed_anchor_shift(today: date) -> timedelta:
+    return today - SEED_AUTHORED_ANCHOR
+
 
 def _parse_dt(value: str) -> datetime:
     return datetime.fromisoformat(value.replace("Z", "+00:00"))
@@ -53,6 +65,8 @@ def _parse_optional_int(value: str) -> int | None:
 @dataclass
 class SeedResult:
     counts: dict[str, int]
+    anchor_date: date
+    seeded_at: datetime
 
 
 def _seed_dir() -> Path:
@@ -83,6 +97,8 @@ def clear_all(db: Session) -> None:
 
 def load_seed(db: Session) -> SeedResult:
     counts: dict[str, int] = {}
+    today = datetime.now(UTC).date()
+    shift = _seed_anchor_shift(today)
 
     user_rows = [
         {"id": uuid.uuid4(), **user, "active": True} for user in DEMO_USERS
@@ -154,8 +170,8 @@ def load_seed(db: Session) -> SeedResult:
                 "public_ref": row["public_ref"],
                 "customer_id": customer_id_by_ref[row["customer_ref"]],
                 "vehicle_id": vehicle_id_by_ref[row["vehicle_ref"]],
-                "starts_at": _parse_dt(row["starts_at"]),
-                "ends_at": _parse_dt(row["ends_at"]),
+                "starts_at": _parse_dt(row["starts_at"]) + shift,
+                "ends_at": _parse_dt(row["ends_at"]) + shift,
                 "status": row["status"],
                 "start_odometer_km": _parse_optional_int(row["start_odometer_km"]),
                 "end_odometer_km": _parse_optional_int(row["end_odometer_km"]),
@@ -179,7 +195,7 @@ def load_seed(db: Session) -> SeedResult:
                 "damage_reported": _parse_bool(row["damage_reported"]),
                 "technical_warning": _parse_bool(row["technical_warning"]),
                 "odometer_km": int(row["odometer_km"]),
-                "completed_at": _parse_dt(row["completed_at"]),
+                "completed_at": _parse_dt(row["completed_at"]) + shift,
                 "completed_by": None,
             }
         )
@@ -193,7 +209,7 @@ def load_seed(db: Session) -> SeedResult:
                 "id": uuid.uuid4(),
                 "public_ref": row["public_ref"],
                 "vehicle_id": vehicle_id_by_ref[row["vehicle_ref"]],
-                "occurred_at": _parse_dt(row["occurred_at"]),
+                "occurred_at": _parse_dt(row["occurred_at"]) + shift,
                 "odometer_km": int(row["odometer_km"]),
                 "category": row["category"],
                 "summary": row["summary"],
@@ -266,7 +282,7 @@ def load_seed(db: Session) -> SeedResult:
                     },
                     "aggregate_ref": row["aggregate_ref"],
                 },
-                "occurred_at": _parse_dt(row["occurred_at"]),
+                "occurred_at": _parse_dt(row["occurred_at"]) + shift,
                 "delivery_status": row["status"],
                 "attempts": int(row["attempts"]),
                 "next_attempt_at": None,
@@ -277,7 +293,21 @@ def load_seed(db: Session) -> SeedResult:
     db.execute(insert(OutboxEvent), outbox_rows)
     counts["workflow_runs"] = len(outbox_rows)
 
-    return SeedResult(counts=counts)
+    seeded_at = datetime.now(UTC)
+    record_audit_event(
+        db,
+        actor_type="system",
+        actor_label="seed loader",
+        action="demo_data_seeded",
+        entity_type="system",
+        metadata={
+            "anchor_date": today.isoformat(),
+            "seed_authored_anchor": SEED_AUTHORED_ANCHOR.isoformat(),
+            "counts": counts,
+        },
+    )
+
+    return SeedResult(counts=counts, anchor_date=today, seeded_at=seeded_at)
 
 
 def reset_and_seed(db: Session) -> SeedResult:
diff --git a/backend/app/services/demo_manifest.py b/backend/app/services/demo_manifest.py
new file mode 100644
index 0000000..52ac618
--- /dev/null
+++ b/backend/app/services/demo_manifest.py
@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.core.config import get_settings
+from app.models.audit import AuditEvent
+from app.models.booking import Booking
+from app.models.data_quality import DataQualityIssue
+from app.models.outbox import OutboxEvent
+from app.schemas import DemoIntegrationSummaryOut, DemoManifestOut, DemoScenarioOut
+from app.services.integration_status import derive_n8n_status
+from app.services.knowledge import get_knowledge_provider
+
+settings = get_settings()
+
+_FAILED_DEMO_EVENT_ID = "00000000-0000-4000-8000-000000000020"
+
+
+def _last_reset(db: Session) -> tuple[datetime | None, str | None]:
+    marker = db.scalar(
+        select(AuditEvent)
+        .where(AuditEvent.action == "demo_data_seeded")
+        .order_by(AuditEvent.occurred_at.desc())
+    )
+    if marker is None:
+        return None, None
+    metadata = marker.metadata_json or {}
+    return marker.occurred_at, metadata.get("anchor_date")
+
+
+def _scenarios(db: Session) -> list[DemoScenarioOut]:
+    booking = db.scalar(select(Booking).where(Booking.public_ref == "BK-DEMO-RETURN"))
+    duplicate_issue = db.scalar(
+        select(DataQualityIssue).where(DataQualityIssue.public_ref == "DQ-DEMO-DUPLICATE")
+    )
+    overlap_issue = db.scalar(
+        select(DataQualityIssue).where(DataQualityIssue.public_ref == "DQ-DEMO-OVERLAP")
+    )
+    failed_run = db.scalar(
+        select(OutboxEvent).where(OutboxEvent.event_id == _FAILED_DEMO_EVENT_ID)
+    )
+    knowledge_health = get_knowledge_provider().health()
+
+    # Human copy (title, problem statement, "demonstrates" summary) lives entirely in the
+    # frontend's demo.json (scenarios.items.<id>.*) so it's available in all three UI
+    # languages. This service only emits stable identifiers and message codes -- never
+    # display prose -- per the message_code + params architecture used across the app.
+    return_ready = bool(
+        booking and booking.status == "active" and booking.end_odometer_km is None
+    )
+    duplicate_ready = bool(duplicate_issue and duplicate_issue.status == "open")
+    overlap_ready = bool(overlap_issue and overlap_issue.status == "open")
+    automation_ready = bool(failed_run and failed_run.delivery_status == "failed")
+
+    return [
+        DemoScenarioOut(
+            id="return-anomaly",
+            estimated_minutes=3,
+            required_roles=["rental_employee", "operations_manager"],
+            start_path=f"/bookings/{booking.public_ref}" if booking else "/bookings",
+            ready=return_ready,
+            blocked_reason_code=(
+                None
+                if return_ready
+                else "bookingNotFound" if booking is None else "bookingAlreadyProcessed"
+            ),
+        ),
+        DemoScenarioOut(
+            id="duplicate-customer",
+            estimated_minutes=3,
+            required_roles=["operations_manager"],
+            start_path=(
+                f"/data-quality/{duplicate_issue.public_ref}"
+                if duplicate_issue
+                else "/data-quality"
+            ),
+            ready=duplicate_ready,
+            blocked_reason_code=(
+                None
+                if duplicate_ready
+                else "duplicateIssueNotFound" if duplicate_issue is None else "issueAlreadyResolved"
+            ),
+        ),
+        DemoScenarioOut(
+            id="booking-overlap",
+            estimated_minutes=2,
+            required_roles=["operations_manager"],
+            start_path=(
+                f"/data-quality/{overlap_issue.public_ref}" if overlap_issue else "/data-quality"
+            ),
+            ready=overlap_ready,
+            blocked_reason_code=(
+                None
+                if overlap_ready
+                else "overlapIssueNotFound" if overlap_issue is None else "issueAlreadyResolved"
+            ),
+        ),
+        DemoScenarioOut(
+            id="automation-retry",
+            estimated_minutes=2,
+            required_roles=["operations_manager"],
+            start_path="/automation",
+            ready=automation_ready,
+            blocked_reason_code=(
+                None
+                if automation_ready
+                else "failedEventNotFound" if failed_run is None else "eventAlreadyRecovered"
+            ),
+        ),
+        DemoScenarioOut(
+            id="knowledge-question",
+            estimated_minutes=2,
+            required_roles=["rental_employee", "operations_manager"],
+            start_path="/knowledge",
+            ready=knowledge_health.available,
+            blocked_reason_code=None if knowledge_health.available else "knowledgeUnavailable",
+        ),
+    ]
+
+
+def _integrations(db: Session) -> list[DemoIntegrationSummaryOut]:
+    n8n = derive_n8n_status(db)
+    knowledge_health = get_knowledge_provider().health()
+
+    return [
+        DemoIntegrationSummaryOut(
+            key="n8n",
+            status_code=n8n.state,
+            detail_code="n8nDetail",
+            detail_params={
+                "succeeded": n8n.succeeded,
+                "failed": n8n.failed,
+                "pending": n8n.pending,
+            },
+        ),
+        DemoIntegrationSummaryOut(
+            key="ragcore",
+            status_code="operational" if knowledge_health.provider == "ragcore" else "demoMode",
+            detail_code="ragcoreDetail",
+            detail_params={
+                "count": knowledge_health.document_count,
+                "collection": knowledge_health.collection,
+            },
+        ),
+        DemoIntegrationSummaryOut(
+            key="mcp_hub",
+            status_code="operational" if settings.mcp_hub_registration_enabled else "notConnected",
+            detail_code=(
+                "mcpDetailEnabled"
+                if settings.mcp_hub_registration_enabled
+                else "mcpDetailNotConnected"
+            ),
+            detail_params={},
+        ),
+    ]
+
+
+def scenario_integrity_report(db: Session) -> dict:
+    """Server-side scenario-integrity check run after every reset (section 15): confirms
+    each of the 5 named scenarios is actually present and ready, rather than trusting the
+    seed loader silently. Reuses the same readiness derivation the manifest/scenario
+    overview already use, so this can never drift from what a visitor actually sees."""
+    scenarios = _scenarios(db)
+    not_ready = [
+        {"id": s.id, "reason_code": s.blocked_reason_code}
+        for s in scenarios
+        if not s.ready
+    ]
+    return {"all_ready": len(not_ready) == 0, "not_ready": not_ready}
+
+
+def build_demo_manifest(db: Session) -> DemoManifestOut:
+    last_reset_at, anchor_date = _last_reset(db)
+    return DemoManifestOut(
+        demo_mode=settings.mobilityops_demo_mode,
+        organization_name=settings.demo_organization_name,
+        timezone=settings.demo_timezone,
+        synthetic_data=True,
+        allow_reset=settings.demo_allow_reset,
+        last_reset_at=last_reset_at,
+        anchor_date=anchor_date,
+        guide_available=True,
+        required_roles=["operations_manager", "rental_employee"],
+        scenarios=_scenarios(db),
+        integrations=_integrations(db),
+    )
diff --git a/backend/app/services/integration_status.py b/backend/app/services/integration_status.py
new file mode 100644
index 0000000..d647272
--- /dev/null
+++ b/backend/app/services/integration_status.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from app.core.config import get_settings
+from app.models.outbox import OutboxEvent
+from app.schemas import N8nIntegrationStatus
+
+settings = get_settings()
+
+
+def derive_n8n_status(db: Session) -> N8nIntegrationStatus:
+    counts: dict[str, int] = dict(
+        db.execute(
+            select(OutboxEvent.delivery_status, func.count()).group_by(OutboxEvent.delivery_status)
+        ).all()  # type: ignore[arg-type]
+    )
+    pending = counts.get("pending", 0)
+    delivering = counts.get("delivering", 0)
+    failed = counts.get("failed", 0)
+    succeeded = counts.get("succeeded", 0)
+
+    latest_success_at = db.scalar(
+        select(func.max(OutboxEvent.updated_at)).where(OutboxEvent.delivery_status == "succeeded")
+    )
+    latest_failure_at = db.scalar(
+        select(func.max(OutboxEvent.updated_at)).where(OutboxEvent.delivery_status == "failed")
+    )
+
+    state: Literal["disabled", "unavailable", "degraded", "operational", "no_evidence"]
+    if not settings.n8n_dispatch_enabled:
+        state = "disabled"
+    elif failed > 0 and succeeded == 0:
+        state = "unavailable"
+    elif failed > 0:
+        state = "degraded"
+    elif succeeded > 0 or pending > 0 or delivering > 0:
+        state = "operational"
+    else:
+        state = "no_evidence"
+
+    return N8nIntegrationStatus(
+        configured=bool(settings.n8n_webhook_url),
+        dispatch_enabled=settings.n8n_dispatch_enabled,
+        state=state,
+        pending=pending,
+        delivering=delivering,
+        failed=failed,
+        succeeded=succeeded,
+        latest_success_at=latest_success_at,
+        latest_failure_at=latest_failure_at,
+    )
diff --git a/backend/app/services/knowledge/__init__.py b/backend/app/services/knowledge/__init__.py
index 48e5bcb..32c4896 100644
--- a/backend/app/services/knowledge/__init__.py
+++ b/backend/app/services/knowledge/__init__.py
@@ -39,9 +39,11 @@ class KnowledgeHealth(BaseModel):
 class KnowledgeProvider(Protocol):
     name: str
 
-    def health(self) -> KnowledgeHealth: ...
+    def health(self, language: str = "en-GB") -> KnowledgeHealth: ...
 
-    def ask(self, question: str, correlation_id: str) -> GroundedAnswer: ...
+    def ask(
+        self, question: str, correlation_id: str, language: str = "en-GB"
+    ) -> GroundedAnswer: ...
 
 
 @lru_cache
diff --git a/backend/app/services/knowledge/demo.py b/backend/app/services/knowledge/demo.py
index 7ab7a88..58e9433 100644
--- a/backend/app/services/knowledge/demo.py
+++ b/backend/app/services/knowledge/demo.py
@@ -8,12 +8,31 @@ from pathlib import Path
 from app.core.config import get_settings
 from app.services.knowledge import GroundedAnswer, KnowledgeHealth, SourceCard
 
-STOPWORDS = {
-    "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
-    "to", "of", "in", "on", "at", "for", "and", "or", "but", "if", "then",
-    "do", "does", "did", "must", "may", "can", "could", "should", "would",
-    "i", "you", "it", "we", "they", "my", "your", "what", "when", "how",
-    "with", "without", "this", "that", "these", "those", "not", "no",
+SUPPORTED_LANGUAGES = ("nl-BE", "en-GB", "fr-BE")
+DEFAULT_LANGUAGE = "en-GB"
+
+STOPWORDS_BY_LANGUAGE: dict[str, set[str]] = {
+    "en-GB": {
+        "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
+        "to", "of", "in", "on", "at", "for", "and", "or", "but", "if", "then",
+        "do", "does", "did", "must", "may", "can", "could", "should", "would",
+        "i", "you", "it", "we", "they", "my", "your", "what", "when", "how",
+        "with", "without", "this", "that", "these", "those", "not", "no",
+    },
+    "nl-BE": {
+        "een", "de", "het", "is", "zijn", "was", "waren", "worden", "wordt",
+        "van", "in", "op", "voor", "en", "of", "maar", "als", "dan",
+        "moet", "mag", "kan", "kunnen", "zou", "zouden",
+        "ik", "jij", "u", "we", "wij", "zij", "mijn", "jouw", "wat", "wanneer", "hoe",
+        "met", "zonder", "dit", "dat", "deze", "die", "niet", "geen",
+    },
+    "fr-BE": {
+        "un", "une", "le", "la", "les", "des", "est", "sont", "était", "être",
+        "de", "du", "en", "sur", "pour", "et", "ou", "mais", "si", "alors",
+        "doit", "peut", "peuvent", "pourrait", "devrait",
+        "je", "tu", "vous", "il", "elle", "nous", "ils", "mon", "votre", "quoi", "quand", "comment",
+        "avec", "sans", "ce", "cette", "ces", "cela", "pas", "non",
+    },
 }
 
 _WORD_RE = re.compile(r"[a-z0-9]+")
@@ -28,9 +47,10 @@ def _stem(word: str) -> str:
     return word
 
 
-def _tokenize(text: str) -> set[str]:
+def _tokenize(text: str, language: str) -> set[str]:
+    stopwords = STOPWORDS_BY_LANGUAGE.get(language, STOPWORDS_BY_LANGUAGE[DEFAULT_LANGUAGE])
     words = _WORD_RE.findall(text.lower())
-    return {_stem(w) for w in words if w not in STOPWORDS and len(w) > 2}
+    return {_stem(w) for w in words if w not in stopwords and len(w) > 2}
 
 
 @dataclass
@@ -86,7 +106,7 @@ def _split_sections(body: str) -> list[tuple[str, str]]:
     return sections
 
 
-def _load_sections(procedures_dir: Path) -> list[ScoredSection]:
+def _load_sections(procedures_dir: Path, language: str) -> list[ScoredSection]:
     sections: list[ScoredSection] = []
     for path in sorted(procedures_dir.glob("*.md")):
         raw = path.read_text(encoding="utf-8")
@@ -96,7 +116,7 @@ def _load_sections(procedures_dir: Path) -> list[ScoredSection]:
             document_id=meta.get("document_id", path.stem),
             title=title,
             version=meta.get("version", "1.0"),
-            title_tokens=_tokenize(title),
+            title_tokens=_tokenize(title, language),
         )
         for heading, text in _split_sections(body):
             sections.append(
@@ -104,19 +124,49 @@ def _load_sections(procedures_dir: Path) -> list[ScoredSection]:
                     document=doc,
                     heading=heading,
                     text=text,
-                    heading_tokens=_tokenize(heading),
-                    body_tokens=_tokenize(text),
+                    heading_tokens=_tokenize(heading, language),
+                    body_tokens=_tokenize(text, language),
                 )
             )
     return sections
 
 
+_NO_MATCH_TEXT = {
+    "en-GB": "No matching procedure was found for this question.",
+    "nl-BE": "Er werd geen passende procedure gevonden voor deze vraag.",
+    "fr-BE": "Aucune procédure correspondante n'a été trouvée pour cette question.",
+}
+_LOW_CONFIDENCE_TEXT = {
+    "en-GB": (
+        "The available procedures do not clearly answer this question. "
+        "The closest matches are included below for review."
+    ),
+    "nl-BE": (
+        "De beschikbare procedures beantwoorden deze vraag niet duidelijk. "
+        "De dichtstbijzijnde overeenkomsten staan hieronder ter beoordeling."
+    ),
+    "fr-BE": (
+        "Les procédures disponibles ne répondent pas clairement à cette question. "
+        "Les correspondances les plus proches sont indiquées ci-dessous pour examen."
+    ),
+}
+_LEAD_ANSWER_TEMPLATE = {
+    "en-GB": 'Per "{title}" (v{version}), section "{heading}": {excerpt}',
+    "nl-BE": 'Volgens "{title}" (v{version}), sectie "{heading}": {excerpt}',
+    "fr-BE": 'Selon « {title} » (v{version}), section « {heading} » : {excerpt}',
+}
+
+
 class DemoKnowledgeProvider:
     """Deterministic extractive retrieval over the local procedure Markdown files.
 
     Not a generative model: it scores sections with TF-IDF-weighted keyword overlap
     (downweighting terms common across the whole corpus, like "vehicle", in favor of
     distinctive ones, like "damage") and returns real excerpts, never invented text.
+
+    Each supported UI language has its own translated procedure corpus under
+    knowledge/procedures/<language>/ -- retrieval searches only within the requested
+    language's corpus so citations always link to a same-language document.
     """
 
     name = "demo"
@@ -124,10 +174,18 @@ class DemoKnowledgeProvider:
     def __init__(self) -> None:
         settings = get_settings()
         self._settings = settings
-        self._procedures_dir = Path(settings.knowledge_dir)
-        self._sections = _load_sections(self._procedures_dir)
-        self._document_count = len({s.document.document_id for s in self._sections})
-        self._idf = self._build_idf(self._sections)
+        base_dir = Path(settings.knowledge_dir)
+        self._sections_by_language: dict[str, list[ScoredSection]] = {}
+        self._idf_by_language: dict[str, dict[str, float]] = {}
+        self._document_count_by_language: dict[str, int] = {}
+        for language in SUPPORTED_LANGUAGES:
+            lang_dir = base_dir / language
+            sections = _load_sections(lang_dir, language) if lang_dir.is_dir() else []
+            self._sections_by_language[language] = sections
+            self._idf_by_language[language] = self._build_idf(sections)
+            self._document_count_by_language[language] = len(
+                {s.document.document_id for s in sections}
+            )
 
     @staticmethod
     def _build_idf(sections: list[ScoredSection]) -> dict[str, float]:
@@ -140,7 +198,13 @@ class DemoKnowledgeProvider:
                 doc_freq[token] = doc_freq.get(token, 0) + 1
         return {token: math.log((n + 1) / (df + 1)) + 1 for token, df in doc_freq.items()}
 
-    def health(self) -> KnowledgeHealth:
+    def _normalize_language(self, language: str | None) -> str:
+        if language in SUPPORTED_LANGUAGES:
+            return language
+        return DEFAULT_LANGUAGE
+
+    def health(self, language: str = DEFAULT_LANGUAGE) -> KnowledgeHealth:
+        language = self._normalize_language(language)
         return KnowledgeHealth(
             provider=self.name,
             available=True,
@@ -148,36 +212,40 @@ class DemoKnowledgeProvider:
             tenant=self._settings.ragcore_tenant,
             workspace=self._settings.ragcore_workspace,
             collection=self._settings.ragcore_collection,
-            document_count=self._document_count,
+            document_count=self._document_count_by_language[language],
         )
 
-    def _score(self, query_tokens: set[str], section: ScoredSection) -> float:
+    def _score(
+        self, query_tokens: set[str], section: ScoredSection, idf: dict[str, float]
+    ) -> float:
         score = 0.0
         for token in query_tokens:
-            idf = self._idf.get(token, 0.0)
-            if idf == 0.0:
+            token_idf = idf.get(token, 0.0)
+            if token_idf == 0.0:
                 continue
             if token in section.heading_tokens:
-                score += 3 * idf
+                score += 3 * token_idf
             elif token in section.document.title_tokens:
-                score += 2 * idf
+                score += 2 * token_idf
             elif token in section.body_tokens:
-                score += idf
+                score += token_idf
         return score
 
-    def ask(self, question: str, correlation_id: str) -> GroundedAnswer:
-        query_tokens = _tokenize(question)
-        scored = [
-            (self._score(query_tokens, section), section)
-            for section in self._sections
-        ]
+    def ask(
+        self, question: str, correlation_id: str, language: str = DEFAULT_LANGUAGE
+    ) -> GroundedAnswer:
+        language = self._normalize_language(language)
+        sections = self._sections_by_language[language]
+        idf = self._idf_by_language[language]
+        query_tokens = _tokenize(question, language)
+        scored = [(self._score(query_tokens, section, idf), section) for section in sections]
         scored = [(score, section) for score, section in scored if score > 0]
         scored.sort(key=lambda item: item[0], reverse=True)
         top = scored[:3]
 
         if not top:
             return GroundedAnswer(
-                answer="No matching procedure was found for this question.",
+                answer=_NO_MATCH_TEXT[language],
                 evidence_state="insufficient",
                 sources=[],
                 provider=self.name,
@@ -197,10 +265,7 @@ class DemoKnowledgeProvider:
 
         if top[0][0] < 3:
             return GroundedAnswer(
-                answer=(
-                    "The available procedures do not clearly answer this question. "
-                    "The closest matches are included below for review."
-                ),
+                answer=_LOW_CONFIDENCE_TEXT[language],
                 evidence_state="insufficient",
                 sources=sources,
                 provider=self.name,
@@ -208,9 +273,11 @@ class DemoKnowledgeProvider:
             )
 
         lead_section = top[0][1]
-        answer = (
-            f'Per "{lead_section.document.title}" (v{lead_section.document.version}), '
-            f'section "{lead_section.heading}": {lead_section.text.splitlines()[0][:300]}'
+        answer = _LEAD_ANSWER_TEMPLATE[language].format(
+            title=lead_section.document.title,
+            version=lead_section.document.version,
+            heading=lead_section.heading,
+            excerpt=lead_section.text.splitlines()[0][:300],
         )
         return GroundedAnswer(
             answer=answer,
diff --git a/backend/app/services/knowledge/ragcore.py b/backend/app/services/knowledge/ragcore.py
index 88abd0e..b2c55b7 100644
--- a/backend/app/services/knowledge/ragcore.py
+++ b/backend/app/services/knowledge/ragcore.py
@@ -32,7 +32,7 @@ class RAGcoreKnowledgeProvider:
             timeout=self._settings.ragcore_http_timeout_seconds,
         )
 
-    def health(self) -> KnowledgeHealth:
+    def health(self, language: str = "en-GB") -> KnowledgeHealth:
         try:
             with self._client() as client:
                 response = client.get("/health")
@@ -52,7 +52,7 @@ class RAGcoreKnowledgeProvider:
             document_count=0,
         )
 
-    def ask(self, question: str, correlation_id: str) -> GroundedAnswer:
+    def ask(self, question: str, correlation_id: str, language: str = "en-GB") -> GroundedAnswer:
         try:
             with self._client() as client:
                 response = client.post(
@@ -63,6 +63,7 @@ class RAGcoreKnowledgeProvider:
                         "collection": self._settings.ragcore_collection,
                         "question": question,
                         "correlation_id": correlation_id,
+                        "language": language,
                     },
                 )
                 response.raise_for_status()
diff --git a/backend/tests/test_auth.py b/backend/tests/test_auth.py
index 8bbeeb8..4cdd169 100644
--- a/backend/tests/test_auth.py
+++ b/backend/tests/test_auth.py
@@ -17,7 +17,25 @@ def test_rental_employee_cannot_reset_demo(employee_client):
 def test_operations_manager_can_reset_demo(ops_client):
     response = ops_client.post("/api/v1/demo/reset")
     assert response.status_code == 200
-    assert response.json()["counts"]["vehicles"] == 50
+    body = response.json()
+    assert body["counts"]["vehicles"] == 50
+    assert body["anchor_date"]
+    assert body["seeded_at"]
+    assert body["scenario_integrity"]["all_ready"] is True
+    assert body["scenario_integrity"]["not_ready"] == []
+
+
+def test_reset_is_rejected_when_demo_allow_reset_is_disabled(ops_client, monkeypatch):
+    import app.api.routers.demo as demo_router
+
+    monkeypatch.setattr(demo_router.settings, "demo_allow_reset", False)
+    response = ops_client.post("/api/v1/demo/reset")
+    assert response.status_code == 403
+
+    # Restore real demo data: this test intentionally disabled reset, so a following test
+    # module must not inherit a database left mid-mutation by an earlier test.
+    monkeypatch.setattr(demo_router.settings, "demo_allow_reset", True)
+    assert ops_client.post("/api/v1/demo/reset").status_code == 200
 
 
 def test_session_endpoint_requires_authentication(client):
diff --git a/backend/tests/test_demo_manifest.py b/backend/tests/test_demo_manifest.py
new file mode 100644
index 0000000..5f822d8
--- /dev/null
+++ b/backend/tests/test_demo_manifest.py
@@ -0,0 +1,54 @@
+from app.core.db import SessionLocal
+from app.seed_loader import reset_and_seed
+
+
+def test_demo_manifest_is_public(client):
+    # No login call at all -- the demo-entry screen and badge need this before any
+    # session exists.
+    response = client.get("/api/v1/demo/manifest")
+    assert response.status_code == 200
+
+
+def test_demo_manifest_shape(client):
+    body = client.get("/api/v1/demo/manifest").json()
+    assert body["organization_name"] == "Northstar Mobility"
+    assert body["demo_mode"] is True
+    assert body["synthetic_data"] is True
+    assert body["allow_reset"] is True
+    assert body["timezone"] == "Europe/Brussels"
+    assert body["guide_available"] is True
+    assert set(body["required_roles"]) == {"operations_manager", "rental_employee"}
+    assert body["last_reset_at"] is not None
+    assert body["anchor_date"] is not None
+
+    scenario_ids = {s["id"] for s in body["scenarios"]}
+    assert scenario_ids == {
+        "return-anomaly",
+        "duplicate-customer",
+        "booking-overlap",
+        "automation-retry",
+        "knowledge-question",
+    }
+    integration_keys = {i["key"] for i in body["integrations"]}
+    assert integration_keys == {"n8n", "ragcore", "mcp_hub"}
+
+
+def test_demo_manifest_scenarios_ready_after_fresh_reset(client):
+    db = SessionLocal()
+    try:
+        reset_and_seed(db)
+    finally:
+        db.close()
+
+    body = client.get("/api/v1/demo/manifest").json()
+    scenarios = {s["id"]: s for s in body["scenarios"]}
+    for scenario_id, scenario in scenarios.items():
+        assert scenario["ready"] is True, f"{scenario_id} should be ready right after a reset"
+        assert scenario["blocked_reason_code"] is None
+        assert scenario["start_path"]
+
+
+def test_demo_manifest_ragcore_labelled_as_demo_mode_not_live(client):
+    body = client.get("/api/v1/demo/manifest").json()
+    ragcore = next(i for i in body["integrations"] if i["key"] == "ragcore")
+    assert ragcore["status_code"] == "demoMode"
diff --git a/backend/tests/test_knowledge.py b/backend/tests/test_knowledge.py
index 19691ff..ef8ebe3 100644
--- a/backend/tests/test_knowledge.py
+++ b/backend/tests/test_knowledge.py
@@ -32,7 +32,52 @@ def test_demo_provider_health_reports_document_count():
     health = provider.health()
     assert health.provider == "demo"
     assert health.available is True
-    assert health.document_count == 10
+    assert health.document_count == 11
+
+
+def test_demo_provider_health_reports_document_count_per_language():
+    provider = DemoKnowledgeProvider()
+    for language in ("nl-BE", "en-GB", "fr-BE"):
+        assert provider.health(language).document_count == 11
+
+
+def test_demo_provider_grounds_damage_question_in_dutch():
+    provider = DemoKnowledgeProvider()
+    answer = provider.ask(
+        "Wat moet ik doen als een voertuig terugkomt met schade?",
+        "test-correlation-nl",
+        "nl-BE",
+    )
+    assert answer.evidence_state == "grounded"
+    document_ids = {s.document_id for s in answer.sources}
+    assert "damage-procedure" in document_ids
+
+
+def test_demo_provider_grounds_damage_question_in_french():
+    provider = DemoKnowledgeProvider()
+    answer = provider.ask(
+        "Que dois-je faire quand un véhicule revient avec des dommages ?",
+        "test-correlation-fr",
+        "fr-BE",
+    )
+    assert answer.evidence_state == "grounded"
+    document_ids = {s.document_id for s in answer.sources}
+    assert "damage-procedure" in document_ids
+
+
+def test_demo_provider_insufficient_evidence_message_is_localized():
+    provider = DemoKnowledgeProvider()
+    nl_answer = provider.ask(
+        "Wat is de hoofdstad van Frankrijk?", "test-correlation-nl-2", "nl-BE"
+    )
+    fr_answer = provider.ask(
+        "Quelle est la capitale de la France ?", "test-correlation-fr-2", "fr-BE"
+    )
+    assert nl_answer.evidence_state == "insufficient"
+    assert fr_answer.evidence_state == "insufficient"
+    assert nl_answer.answer != fr_answer.answer
+    assert "France" not in nl_answer.answer
+    assert "France" not in fr_answer.answer
 
 
 def test_ask_question_endpoint_grounded(ops_client):
diff --git a/backend/tests/test_seed.py b/backend/tests/test_seed.py
index 84ea3bd..076cd1a 100644
--- a/backend/tests/test_seed.py
+++ b/backend/tests/test_seed.py
@@ -1,13 +1,16 @@
+from datetime import UTC, datetime
+
 from sqlalchemy import func, select
 
 from app.core.db import SessionLocal
+from app.models.audit import AuditEvent
 from app.models.booking import Booking
 from app.models.customer import Customer
 from app.models.data_quality import DataQualityIssue
 from app.models.outbox import OutboxEvent
 from app.models.user import User
 from app.models.vehicle import Vehicle
-from app.seed_loader import reset_and_seed
+from app.seed_loader import SEED_AUTHORED_ANCHOR, reset_and_seed
 
 
 def test_seed_counts_match_deterministic_dataset():
@@ -52,3 +55,117 @@ def test_seed_demo_scenarios_present():
         assert failed_run is not None
     finally:
         db.close()
+
+
+def _by_ref(db, model, ref):
+    return db.scalar(select(model).where(model.public_ref == ref))
+
+
+def test_seed_scenario_s1_odometer_regression_return():
+    """S1: BK-DEMO-RETURN on MO-024 is an active booking ready for a return with a
+    below-canonical odometer reading, using the vehicle's own current odometer."""
+    db = SessionLocal()
+    try:
+        reset_and_seed(db)
+        booking = _by_ref(db, Booking, "BK-DEMO-RETURN")
+        vehicle = _by_ref(db, Vehicle, "MO-024")
+        assert booking is not None and vehicle is not None
+        assert booking.vehicle_id == vehicle.id
+        assert booking.status == "active"
+        assert booking.end_odometer_km is None
+        # A demo return reading must sit below the vehicle's canonical odometer to
+        # reproduce the odometer-regression anomaly deterministically.
+        assert vehicle.odometer_km > 0
+    finally:
+        db.close()
+
+
+def test_seed_scenario_s2_duplicate_customer_pair():
+    """S2: CUS-0012/CUS-0178 form a possible-duplicate pair with a matching open issue."""
+    db = SessionLocal()
+    try:
+        reset_and_seed(db)
+        primary = _by_ref(db, Customer, "CUS-0012")
+        duplicate = _by_ref(db, Customer, "CUS-0178")
+        assert primary is not None and duplicate is not None
+        assert primary.email == duplicate.email
+        assert duplicate.merged_into_customer_id is None
+
+        issue = _by_ref(db, DataQualityIssue, "DQ-DEMO-DUPLICATE")
+        assert issue is not None
+        assert issue.rule_type == "possible_duplicate_customer"
+        assert issue.status == "open"
+        related = issue.evidence_json.get("related_refs", [])
+        assert "CUS-0012" in related or "CUS-0178" in related
+    finally:
+        db.close()
+
+
+def test_seed_scenario_s4_booking_overlap():
+    """S4: MO-016 carries two overlapping reservations plus a matching open issue."""
+    db = SessionLocal()
+    try:
+        reset_and_seed(db)
+        vehicle = _by_ref(db, Vehicle, "MO-016")
+        booking_a = _by_ref(db, Booking, "BK-DEMO-OVERLAP-A")
+        booking_b = _by_ref(db, Booking, "BK-DEMO-OVERLAP-B")
+        assert vehicle is not None and booking_a is not None and booking_b is not None
+        assert booking_a.vehicle_id == vehicle.id
+        assert booking_b.vehicle_id == vehicle.id
+        assert booking_a.starts_at < booking_b.ends_at
+        assert booking_b.starts_at < booking_a.ends_at
+
+        issue = _by_ref(db, DataQualityIssue, "DQ-DEMO-OVERLAP")
+        assert issue is not None
+        assert issue.rule_type == "booking_overlap"
+        assert issue.status == "open"
+    finally:
+        db.close()
+
+
+def test_seed_scenario_s5_failed_workflow_run():
+    """S5: one seeded outbox event is durably 'failed' (terminal, retryable), not merely
+    pending, so the background dispatcher never silently auto-heals it away."""
+    db = SessionLocal()
+    try:
+        reset_and_seed(db)
+        failed = db.scalar(
+            select(OutboxEvent).where(
+                OutboxEvent.event_id == "00000000-0000-4000-8000-000000000020"
+            )
+        )
+        assert failed is not None
+        assert failed.delivery_status == "failed"
+        assert failed.attempts >= 1
+        assert failed.last_error
+    finally:
+        db.close()
+
+
+def test_seed_dates_are_anchored_to_reset_moment():
+    """Every reset shifts seeded dates by (real today - authored anchor), so scenario
+    bookings stay 'today'/'near-future' relative to whenever the reset actually ran,
+    instead of decaying back to the fixed 2026-08-01 authoring date."""
+    db = SessionLocal()
+    try:
+        result = reset_and_seed(db)
+        today = datetime.now(UTC).date()
+        assert result.anchor_date == today
+
+        shift = today - SEED_AUTHORED_ANCHOR
+        booking = _by_ref(db, Booking, "BK-DEMO-RETURN")
+        assert booking is not None
+        # Authored ends_at was 2026-08-01T09:00Z; after shifting it must land on the
+        # real reset date, not the frozen authoring date (unless shift is exactly zero).
+        assert booking.ends_at.date() == today or shift.days == 0
+
+        marker = db.scalar(
+            select(AuditEvent)
+            .where(AuditEvent.action == "demo_data_seeded")
+            .order_by(AuditEvent.occurred_at.desc())
+        )
+        assert marker is not None
+        assert marker.metadata_json["anchor_date"] == today.isoformat()
+        assert marker.metadata_json["seed_authored_anchor"] == SEED_AUTHORED_ANCHOR.isoformat()
+    finally:
+        db.close()
diff --git a/compose.yaml b/compose.yaml
index 3306969..5e0eadc 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -24,7 +24,6 @@ services:
       DATABASE_URL: ${DATABASE_URL:-postgresql+psycopg://mobilityops:mobilityops@db:5432/mobilityops}
       TZ: ${TZ:-Europe/Brussels}
       APP_SECRET: ${APP_SECRET:-replace-in-production}
-      DEMO_TODAY: ${DEMO_TODAY:-2026-08-01}
       CORS_ALLOW_ORIGINS: ${MOBILITYOPS_PUBLIC_URL:-http://localhost:1228}
       KNOWLEDGE_PROVIDER: ${KNOWLEDGE_PROVIDER:-demo}
       RAGCORE_BASE_URL: ${RAGCORE_BASE_URL:-http://ragcore-api:8000}
@@ -35,6 +34,9 @@ services:
       N8N_WEBHOOK_URL: ${N8N_WEBHOOK_URL:-http://n8n:5678/webhook/mobilityops-return}
       N8N_CALLBACK_TOKEN: ${MOBILITYOPS_CALLBACK_TOKEN:-replace-me-n8n-callback-token}
       MCP_HUB_SERVICE_TOKEN: ${MCP_HUB_SERVICE_TOKEN:-replace-me-mcp-hub-token}
+      DEMO_ORGANIZATION_NAME: ${DEMO_ORGANIZATION_NAME:-Northstar Mobility}
+      DEMO_TIMEZONE: ${DEMO_TIMEZONE:-Europe/Brussels}
+      DEMO_ALLOW_RESET: ${DEMO_ALLOW_RESET:-true}
     ports:
       - "8128:8000"
     depends_on:
diff --git a/docs/05-api-contract.md b/docs/05-api-contract.md
index 7f2d194..7cc5216 100644
--- a/docs/05-api-contract.md
+++ b/docs/05-api-contract.md
@@ -11,10 +11,17 @@ The demo may use signed server-issued sessions or short-lived JWTs. Demo-role bu
 ### System and demo
 
 - `GET /health`
+- `GET /api/v1/demo/manifest` — unauthenticated; demo org name/description, synthetic-data
+  flag, reset allowance and timestamp, guide availability, the 5 named scenarios (with
+  live readiness derived from actual records, not hardcoded), and plain-language
+  integration summaries. Single source of truth for the demo-entry screen, the permanent
+  demo badge, the scenario overview and the About page — avoids duplicating this logic
+  per surface.
 - `POST /api/v1/demo/login`
 - `GET /api/v1/demo/session` — confirms the current session; `Cache-Control: no-store`
 - `POST /api/v1/demo/logout` — safe to call without a session
-- `POST /api/v1/demo/reset` — Operations Manager only; invalidates the caller's own session
+- `POST /api/v1/demo/reset` — Operations Manager only; invalidates the caller's own
+  session; returns 403 if `DEMO_ALLOW_RESET=false`
 
 ### Dashboard
 
diff --git a/docs/13-seed-and-demo-scenarios.md b/docs/13-seed-and-demo-scenarios.md
index 0b53005..862ef8c 100644
--- a/docs/13-seed-and-demo-scenarios.md
+++ b/docs/13-seed-and-demo-scenarios.md
@@ -42,6 +42,19 @@ One seeded outbox/workflow record is failed with a safe simulated connection err
 
 Question: “What must I do when a vehicle returns with damage?” Expected: answer cites damage handling and return inspection procedures.
 
+## Date anchoring
+
+The committed CSVs store absolute ISO timestamps authored around a fixed anchor date
+(`SEED_AUTHORED_ANCHOR = 2026-08-01` in `backend/app/seed_loader.py`, matching the
+`--anchor` used to generate them). Every seed/reset shifts every seeded booking,
+inspection, maintenance and outbox timestamp by `today − SEED_AUTHORED_ANCHOR`, so
+"today"/"near-future"/"currently overlapping" scenarios stay true to the real moment the
+environment was (re)seeded instead of decaying as real time passes between resets. Public
+refs and entity relationships are untouched by the shift — only datetime columns move.
+`load_seed()` returns the resolved `anchor_date`/`seeded_at`, and records a
+`demo_data_seeded` audit event carrying both the resolved anchor and the original
+authoring anchor, so the shift applied on any given reset stays traceable.
+
 ## Demo reset
 
 Reset must:
@@ -49,6 +62,7 @@ Reset must:
 - require Operations Manager;
 - rebuild the deterministic dataset;
 - re-establish scenario references;
+- re-anchor scenario dates to the real reset moment (see above);
 - clear non-seed audit/workflow state;
 - complete safely and visibly;
 - be covered by a test.
diff --git a/docs/17-runbook.md b/docs/17-runbook.md
index 8a56b8c..8314167 100644
--- a/docs/17-runbook.md
+++ b/docs/17-runbook.md
@@ -1,5 +1,9 @@
 # PoC runbook
 
+For the demo-specific 5-minute/10-minute walkthroughs, reset behaviour, Unraid
+redeploy/rollback steps and troubleshooting, see `docs/demo-release/demo-runbook.md`.
+This document covers general environment bootstrap and n8n setup.
+
 ## Bootstrap (clean checkout)
 
 ```bash
diff --git a/docs/demo-release/current-demo-gap-audit.md b/docs/demo-release/current-demo-gap-audit.md
new file mode 100644
index 0000000..a95e180
--- /dev/null
+++ b/docs/demo-release/current-demo-gap-audit.md
@@ -0,0 +1,157 @@
+# Current demo-readiness gap audit
+
+Performed 2026-08-03 against `feat/mobilityops-functional-completion` @
+`e0c7ed60112510687627d20a957af91c8b9db7f8` (verified: correct branch, working tree
+clean, matches the deployed Unraid revision). Method: read `CLAUDE.md`/`AGENTS.md`
+(identical, no demo-specific guidance yet), `README.md`, `PROJECT_STATE.md`, the docs
+list in the brief, `artifacts/final-acceptance/summary.md`,
+`artifacts/functional-completion/final-summary.md`, `seed/generate_seed.py`,
+`seed/*.csv`, `backend/app/seed_loader.py`, `backend/app/core/config.py`,
+`backend/app/api/routers/dashboard.py`; live-browsed the deployed app at
+`http://192.168.10.150:1236` (login, dashboard, a data-quality issue, a booking detail,
+knowledge, automation).
+
+## What already works well (do not rebuild)
+
+- The premium Control Rail UI, role-based nav, server-backed sessions, return preview/
+  commit, all five data-quality resolution flows, audit before/after, role-aware search,
+  truthful integration status, demo reset, stale-lease recovery and the two n8n
+  workflows are all implemented, tested and live-verified per
+  `artifacts/functional-completion/final-summary.md` — this pass does not touch that
+  business logic.
+- `docs/13-seed-and-demo-scenarios.md` already names exactly the scenarios this brief
+  wants surfaced: **S1** odometer-regression return (`BK-DEMO-RETURN`/`MO-024`), **S2**
+  duplicate customer (`CUS-0012`/`CUS-0178`, issue `DQ-DEMO-DUPLICATE`), **S4** booking
+  overlap (`MO-016`, issue `DQ-DEMO-OVERLAP`, bookings `BK-DEMO-OVERLAP-A/B`), **S5**
+  failed workflow (seeded failed outbox event, retryable from Automation), **S6**
+  grounded knowledge question. These map directly to the brief's 5 requested scenarios
+  — no new scenarios need to be invented, only surfaced with guidance. (S3, "missing
+  inspection before next booking" on `MO-031`, exists too but isn't one of the 5
+  requested; leave it as-is, it still shows up in the attention queue.)
+- `seed/generate_seed.py` already produces believable Flemish/Dutch data: first/last
+  name pools (Sofie, Lotte, Bram, Peeters, Janssens, Vermeulen, ...), real Kempen-region
+  towns (Geel, Turnhout, Herentals, Mol, Westerlo, Tessenderlo-Ham), `.test` email
+  addresses, and believable RV/camper makes (Adria, Dethleffs, Hymer, Bürstner, ...).
+  Confirmed live: `DQ-DEMO-DUPLICATE` shows customer "Bram Peeters" (Geel) with email
+  `bram.peeters.12@example.test`. **The underlying data quality is already
+  demo-grade — the gap is structural/experiential, not data flavour.**
+
+## Confirmed gaps
+
+### 1. No fictional organisation identity anywhere
+Login/demo-entry screen says "MobilityOps · Control Centre" and generic marketing copy
+("Every hand-off. One clear view.") but never names a demonstration organisation. A
+stranger cannot tell *whose* fleet this is. **Confirmed via full-repo search:**
+"Northstar Mobility" is never rendered in the UI, but it is **already the project's
+locked fictitious tenant name** — `PROJECT_STATE.md`'s "Locked decisions" section
+states verbatim *"Fictitious tenant: Northstar Mobility Demo"*, and
+`ragcore_tenant` defaults to `"northstar-mobility-demo"` in `backend/app/core/config.py`,
+`compose.yaml`, `.env.example`, `knowledge/manifest.json` and `contracts/mcp-tools.json`.
+So using "Northstar Mobility" as the visible demo brand (as this brief suggests) is not
+a new invention — it surfaces a decision the project already made and only ever used
+internally as a RAGcore-tenant slug. No renaming/config changes needed, just make it
+visible.
+
+### 2. No guided path — a visitor has no idea where to start
+The dashboard shows real attention-queue items (duplicate customer, booking overlap,
+vehicle status conflict, missing field) and today's movements (`BK-DEMO-RETURN`
+11:00), but nothing tells a first-time visitor *which* of these is worth clicking, in
+what order, or why. There is no "start guided demo" affordance, no scenario overview,
+no step-by-step walkthrough. Everything technically works; nothing narrates.
+
+### 3. Live date anchoring is broken — confirmed, reproducible
+`seed/bookings.csv` stores **absolute fixed ISO timestamps** authored around anchor
+date 2026-08-01 (`generate_seed.py --anchor 2026-08-01`). `backend/app/core/config.py`'s
+`demo_today` setting (`"2026-08-01"`) is used *only* by
+`dashboard.py::_today()` to filter "today's movements" against that frozen date — nothing
+re-anchors the underlying booking/inspection/maintenance/outbox dates themselves.
+**Live-confirmed right now** (today is 2026-08-03): `BK-DEMO-RETURN` shows status
+`active` with `ends_at = 01/08/2026 09:00` — already two days in the past, for a
+booking that's supposed to look "in progress, due for return soon." `BK-DEMO-NEXT`
+(meant to read as "near-future") starts 2026-08-02, also already past. Every day this
+environment isn't reset, this gets worse, and after any `seed --reset` it snaps right
+back to the same frozen 2026-08-01-relative positions regardless of the real reset
+moment. This is exactly the failure mode brief section 7 describes and must be fixed at
+the source (`seed_loader.py`), not papered over in the UI.
+
+### 4. Knowledge assistant names "RAGcore" directly, not honestly "demo mode"
+`/knowledge` page copy: "Answers are shown only when **RAGcore** returns sufficient
+cited evidence" and a "RAGcore" label on the sources block — while the actual active
+provider is `KNOWLEDGE_PROVIDER=demo` (confirmed: badge below correctly shows
+`demo · Available · 10 procedures indexed`, which contradicts the body copy one line
+below it). This is the exact misleading-integration-status problem brief section 11
+warns against — the small badge is honest, the prose isn't. No suggested questions are
+offered.
+
+### 5. Integration status labels are technical, not demo-plain-language
+Automation page shows raw states like `not_configured`/`degraded`/`operational` (English,
+developer register) rather than the plain-language labels section 12 asks for
+(Operationeel / Demomodus / Niet gekoppeld / Voorbereid / Verwerking mislukt / Opnieuw
+proberen mogelijk).
+
+### 6. Data-quality resolution panels are functionally complete but not narrated
+Confirmed live on `DQ-DEMO-DUPLICATE`: the compare/merge UI works well, but nothing
+explains *why this matters operationally* (duplicate billing/contact risk) or what
+happens next in plain terms before the user acts. Same pattern across the other 4
+rule-type panels (already reviewed in this session's earlier batch). No "demo scenario"
+filter exists to surface the curated issues first.
+
+### 7. No "About this demo" page
+No page anywhere explains what's real, what's synthetic, what's live vs. demo-mode vs.
+not-connected, or the architecture/testing approach in plain terms. A visitor exploring
+alone has no way to self-answer "is this real?"
+
+### 8. No permanent, explained "synthetic demo" indicator
+The existing `demo-banner` ("Synthetic demo data · no real customer or vehicle
+information") is a full-width static bar repeated on every page — present, but static
+text only, no link to more explanation, no reset-timestamp/anchor info, and (per section
+4) shouldn't be a dominant warning bar; it should be a subtle, explained badge.
+
+### 9. Demo reset exists but is not discoverable as a demo feature
+`POST /api/v1/demo/reset` and its sidebar UI trigger (this session's earlier batch)
+work correctly and are Operations-Manager-gated, but reset isn't connected to any demo
+narrative (no "prepare demo again" framing, not reachable from an About page or guide,
+no post-reset scenario-integrity confirmation beyond the raw counts).
+
+### 10. No demo manifest / no single source of "what's on right now"
+Nothing exposes demo mode, scenario list, integration status and guidance availability
+as one small structured payload the frontend can render consistently (badge tooltip,
+guide, scenario overview, About page all currently would have to duplicate this
+knowledge if built independently).
+
+### 11. Everything is in English; the brief asks for consistent Dutch demo text
+All existing UI copy is English. The brief explicitly asks for consistent Dutch product
+text for the demo-facing additions. Recorded decision (no existing doc answers this,
+and translating the entire already-shipped, already-tested Control Rail UI is out of
+proportion to "add guidance," would touch dozens of files and contradicts "this is not
+a redesign"): **new demo-productization surfaces are written in Dutch** (demo entry
+copy, Demo Guide, scenario overview, About-this-demo page, the demo badge/tooltip,
+plain-language integration-status labels). **Existing operational screens (Dashboard,
+Vehicles, Bookings, Data Quality workbench, Audit, Automation internals) stay in
+English** — they are already shipped, tested, and section 16 explicitly forbids
+rebuilding working screens without functional reason. This mirrors how a real bilingual
+guided demo works: narration in one language, software in whatever it already ships in.
+
+## Scope reminder (not gaps — explicitly out of scope per the brief)
+
+- No RAGcore or MCP Hub live implementation.
+- No new business logic in the 5 resolution flows — only explanatory framing around
+  the existing ones.
+- No full redesign, new component library, new color palette, or full retranslation.
+
+## Plan (implementation batches, matches task list)
+
+1. Fix date anchoring in `seed_loader.py` (shift all seeded dates by `today − anchor`
+   at every reset); switch `dashboard.py::_today()` to real wall-clock date; add a
+   `demo_data_seeded` audit marker recording the anchor/reset moment.
+2. `GET /api/v1/demo/manifest` (org name, demo mode, scenarios, integration status,
+   reset timestamp) + Dutch demo entry screen + permanent demo badge with popover.
+3. Demo Guide (collapsible panel/bottom sheet, 8 steps) + scenario overview (5 cards)
+   on the dashboard.
+4. Layer plain-language Dutch explanation onto the return flow, the 5 DQ panels and the
+   knowledge assistant (fix the RAGcore-naming bug), without touching their logic.
+5. Plain-language integration status labels, richer audit narration for guide-linked
+   events, "Over deze demo" page, reset wired into guide/About/OM menu with a
+   post-reset scenario-integrity check.
+6. Full guided-demo Playwright test + targeted tests per section 19.
+7. Clean-checkout demo drill, docs, Unraid deploy, final evidence with screenshots.
diff --git a/docs/demo-release/demo-concept.md b/docs/demo-release/demo-concept.md
new file mode 100644
index 0000000..a46e52b
--- /dev/null
+++ b/docs/demo-release/demo-concept.md
@@ -0,0 +1,77 @@
+# Demo concept
+
+## The fictional problem
+
+**Northstar Mobility** is a fictional Belgian camper/van rental company with roughly 50
+vehicles, one main location, a rental team, an operations manager, and a small workshop.
+Northstar Mobility does not exist — this name and every customer, vehicle, booking and
+procedure in the demo are synthetic. Before MobilityOps, Northstar Mobility's bookings,
+returns, customer records and maintenance history lived in spreadsheets and verbal
+hand-offs, so problems (duplicate customers, incorrect odometer readings, double-booked
+vehicles) only surfaced late, after they had already caused friction. MobilityOps shows
+how one connected system detects these problems early and lets an Operations Manager
+resolve them under audit, with automation handling the routine follow-up.
+
+## Target audience
+
+Anyone evaluating how MobilityOps approaches operational data-quality and hand-off
+problems for a small rental fleet: Operations Managers, Rental Employees, and reviewers
+assessing the approach. No account setup or backend knowledge is required to start —
+the login screen explains the fictional context and offers a guided path.
+
+## Demo scope
+
+This is a focused proof of concept, not a full ERP. In scope: vehicle and booking
+management, return processing with server-side evaluation, five data-quality detection
+rules each with one bounded resolution flow, a full audit trail, and orchestration via a
+real n8n instance. Explicitly out of scope: accounting, payments, public reservations, a
+generic CRM, inventory, HR, a second RAG stack, or autonomous write actions from any
+external tool.
+
+## What's really implemented
+
+All of the following is functional code, not a mockup or hardcoded screen:
+
+- Role-based authentication and server-verified sessions (Operations Manager, Rental
+  Employee), enforced both server-side and in the frontend's navigation/route guards.
+- Vehicle and booking management, with return preview/commit sharing one authoritative
+  evaluation function so they can never drift.
+- Five data-quality rules (possible duplicate customer, missing required field, odometer
+  regression, booking overlap, vehicle status conflict), each with exactly one bounded,
+  audited resolution endpoint.
+- A full audit trail with before/after state, actor, correlation IDs, and a
+  "view related events" link reusing that correlation.
+- Reliable outbox-based delivery to a real n8n instance, with bounded retries and
+  stale-delivery recovery.
+- Docker Compose deployment and an automated test suite (backend pytest, Ruff, mypy,
+  and a full Playwright end-to-end suite covering the demo experience itself).
+- A demo manifest (`GET /api/v1/demo/manifest`) as the single source of truth for the
+  demo's identity, synthetic-data status, reset state, scenario readiness, and honest
+  per-integration labels — the frontend never hardcodes what mode it's in.
+
+## What's synthetic
+
+The organisation, all customers, vehicles, bookings, maintenance history, the knowledge
+base's procedures, and the five prepared demo scenarios are entirely fictional. No data
+refers to a real person, vehicle, or company. Every seeded email uses the `.test`
+reserved domain. See [`demo-data.md`](demo-data.md) for exactly how this data is
+generated and kept fresh across resets.
+
+## What's not yet live-connected
+
+- **RAGcore**: not connected. The knowledge assistant uses a local, deterministic
+  keyword-matching "demo knowledge base" built from five procedure documents, honestly
+  labelled as such everywhere in the UI (never presented as RAGcore). A
+  `RAGcoreKnowledgeProvider` HTTP adapter exists and is unit-tested, ready to take over
+  the same interface once a real RAGcore backend is available — swapping providers is a
+  configuration change (`KNOWLEDGE_PROVIDER`), not a UI change.
+- **ITWorx MCP Hub**: not connected. Registration is disabled by default
+  (`MCP_HUB_REGISTRATION_ENABLED=false`) and the UI always shows "Not connected" —
+  never a fabricated successful registration.
+
+## Where to go next
+
+- [`demo-scenarios.md`](demo-scenarios.md) — the five guided scenarios and their fixed records.
+- [`demo-data.md`](demo-data.md) — seed strategy and date-anchoring.
+- [`demo-guide.md`](demo-guide.md) — the in-app 8-step guided tour.
+- [`demo-runbook.md`](demo-runbook.md) — how to run, reset, and redeploy the demo.
diff --git a/docs/demo-release/demo-data.md b/docs/demo-release/demo-data.md
new file mode 100644
index 0000000..c454478
--- /dev/null
+++ b/docs/demo-release/demo-data.md
@@ -0,0 +1,83 @@
+# Demo data strategy
+
+## Three separate concepts
+
+It's important to keep these distinct — they solve different problems:
+
+1. **Deterministic records** — every seeded entity has a stable public reference
+   (`BK-DEMO-RETURN`, `DQ-DEMO-DUPLICATE`, `MO-024`, `CUS-0012`, ...). These references
+   never change between seed generations or resets; they are what the five demo
+   scenarios, the Demo Guide, and `docs/13-seed-and-demo-scenarios.md` all link against.
+2. **Date anchoring** — the mechanism that keeps "today"/"near-future"/"currently
+   overlapping" scenarios true to whenever the environment was actually last reset,
+   described below.
+3. **The reset date** — the real wall-clock moment a reset actually happened. This
+   changes every time someone resets; it's the input to date anchoring, not a fixed
+   record.
+
+## Generating the seed dataset
+
+```bash
+python seed/generate_seed.py --anchor 2026-08-01 --seed 20260801
+```
+
+This produces the committed CSVs in `seed/*.csv` with **absolute ISO timestamps**
+authored relative to a fixed anchor date (`2026-08-01`). Target scale: 50 vehicles, 180
+customers (including three duplicate pairs), ~245 historical/current/future bookings,
+realistic inspections and maintenance history, and the fixed quality/workflow scenarios
+described in [`demo-scenarios.md`](demo-scenarios.md). Names, towns and vehicle makes are
+drawn from believable Flemish/Kempen-region pools; all emails use the `.test` domain.
+
+## Date anchoring
+
+`backend/app/seed_loader.py` defines:
+
+```python
+SEED_AUTHORED_ANCHOR = date(2026, 8, 1)  # matches generate_seed.py's --anchor
+```
+
+Every seed/reset computes `shift = today - SEED_AUTHORED_ANCHOR` and applies it to every
+seeded booking, inspection, maintenance and outbox timestamp before insertion. Public
+references and entity relationships are never touched by the shift — only datetime
+columns move. This means:
+
+- `BK-DEMO-RETURN` always ends "today" (or very close to it) relative to whenever you
+  actually reset, not relative to the frozen 2026-08-01 authoring date.
+- `BK-DEMO-NEXT` and the overlap-scenario bookings always read as "near future".
+- The shift is recomputed fresh on every reset, so scenarios never decay as real time
+  passes between resets — this was a real, confirmed bug before this fix (see
+  `docs/demo-release/current-demo-gap-audit.md`, gap #3): the environment would drift
+  further out of sync with every day it wasn't reset, and a reset didn't fix it because
+  nothing re-anchored the underlying stored dates.
+
+`load_seed()` returns the resolved `anchor_date` (real today) and `seeded_at` timestamp,
+and records a `demo_data_seeded` audit event carrying both the resolved anchor and the
+original authoring anchor, so the shift applied on any given reset stays traceable via
+the audit trail.
+
+`dashboard.py::_today()` uses real wall-clock UTC date (not a frozen setting) to filter
+"today's movements", consistent with the shifted data.
+
+## Reset
+
+`POST /api/v1/demo/reset` (Operations Manager only, and only if `DEMO_ALLOW_RESET=true`)
+clears all MobilityOps tables, reloads the seed with a fresh date shift, re-runs the
+data-quality scan, and runs a server-side **scenario-integrity check**
+(`scenario_integrity_report()` in `backend/app/services/demo_manifest.py`) confirming all
+five named scenarios are actually present and ready — recorded in both the response body
+and the `demo_reset` audit event's metadata. Reset only ever affects MobilityOps's own
+tables; it never touches shared n8n, RAGcore, or MCP data, other containers, or volumes.
+
+## Seed-validation tests
+
+`backend/tests/test_seed.py` proves, after every reset:
+
+- S1 (`BK-DEMO-RETURN`/`MO-024`) is active with no end odometer recorded yet.
+- S2 (`CUS-0012`/`CUS-0178`/`DQ-DEMO-DUPLICATE`) is open with matching evidence.
+- S4 (`MO-016`/`BK-DEMO-OVERLAP-A`/`-B`/`DQ-DEMO-OVERLAP`) genuinely overlaps in time.
+- S5 (the seeded failed outbox event) is durably `failed` immediately after reset, not
+  silently auto-healed by the background dispatcher (which only claims `pending` rows).
+- The date-anchoring shift and the `demo_data_seeded` audit marker are both correct.
+
+`backend/tests/test_demo_manifest.py` additionally proves that all five manifest
+scenarios report `ready: true` with no `blocked_reason` right after a fresh reset.
diff --git a/docs/demo-release/demo-guide.md b/docs/demo-release/demo-guide.md
new file mode 100644
index 0000000..39d355f
--- /dev/null
+++ b/docs/demo-release/demo-guide.md
@@ -0,0 +1,71 @@
+# The in-app Demo Guide
+
+## What it is (and isn't)
+
+The Demo Guide is a compact, reusable side panel (a bottom sheet on mobile) that walks an
+Operations Manager through eight fixed steps covering the demo's core functionality. It is
+**not** a generic tutorial engine and **not** a source of business logic — every action it
+prompts is a real action against the real API; the guide only narrates, links, and tracks
+progress. It duplicates no business logic: routes for the two scenario-backed steps
+(return, duplicate-merge) are resolved from the live `GET /api/v1/demo/manifest` response
+rather than hardcoded, so they can never point at a stale or missing record.
+
+## Where it lives
+
+- `frontend/src/data/demoGuideSteps.ts` — the eight step definitions (title, what you'll
+  see, why it matters, the exact start action, the expected outcome, and a `route()`
+  function).
+- `frontend/src/context/DemoGuideContext.tsx` — open/close state and step progress,
+  persisted to `sessionStorage` only (browser-local, never touches auth or business
+  state; a "Demo opnieuw voorbereiden" restart or a new browser session starts fresh).
+- `frontend/src/components/DemoGuide.tsx` — the panel itself and its topbar trigger
+  (`DemoGuideTrigger`, Operations-Manager-only, since all eight steps require that role).
+
+## The eight steps
+
+1. **Understand the operational state** — the dashboard's readiness and attention queue.
+2. **Open the booking needing attention** — `BK-DEMO-RETURN`, resolved from the manifest.
+3. **Process the return with an odometer anomaly** — same booking; the return form is
+   pre-filled with the suspicious reading (see [`demo-scenarios.md`](demo-scenarios.md)
+   scenario 1).
+4. **Handle the created data-quality issue** — the fresh odometer-regression issue that
+   step 3 just created.
+5. **Review and merge the possible duplicate customer** — `DQ-DEMO-DUPLICATE`.
+6. **Ask the procedure assistant a question** — one of the suggested questions.
+7. **Check automation and the audit trail**.
+8. **Review what's real, simulated, or not yet connected** — the About page.
+
+## How progression works
+
+- **"Ga naar deze stap"** navigates to the step's resolved route without marking it done.
+- **"Volgende"** marks the current step complete and advances the index (used for steps
+  with no dedicated in-page continuation, like the knowledge-assistant step).
+- Several real actions (a successful return, a resolved data-quality issue) show their
+  own **"Ga verder met de demo"** button that both completes the current step and
+  navigates straight to the next one — this is how the guide chains through steps 3→4→5
+  without a detour back through the panel's own controls.
+- The step list on the panel lets you jump directly to any step.
+- **"Demo opnieuw voorbereiden"** calls the real reset endpoint, resets the guide's own
+  progress, and returns to the login screen — mirroring the existing sidebar reset
+  control, not a separate implementation.
+
+## A known, deliberate limitation: suggested questions stay in English
+
+The demo knowledge base's five procedure documents (`knowledge/procedures/*.md`) are
+written in English. Verified empirically while building step 6: an equivalent Dutch
+question returned `insufficient` evidence against the demo provider, while the English
+original returned `grounded`. Rather than mistranslate the demo's centerpiece "grounded
+answer" feature into something that silently answers incorrectly, the suggested questions
+on `/knowledge` and this guide's step 6 instructions stay in English, with the guide
+explicitly explaining why in Dutch. Retranslating the procedure documents themselves was
+judged out of scope for a demo-productization pass (see the language-split note in
+`docs/demo-release/current-demo-gap-audit.md`, gap #11).
+
+## Layout note: the panel reserves space, it doesn't overlap content
+
+On desktop the panel is a fixed 400px-wide right-side overlay. `Layout.tsx` adds a
+`guide-open` class to the main workspace while the guide is open, which reserves
+`padding-right` so page content reflows aside instead of sitting underneath the panel —
+this was a real bug found and fixed while building the full guided-demo Playwright test
+(see `PROJECT_STATE.md`, Batch 6): without it, the return form's "Review return" button
+was unclickable while the guide was open at ordinary desktop widths.
diff --git a/docs/demo-release/demo-runbook.md b/docs/demo-release/demo-runbook.md
new file mode 100644
index 0000000..deff09a
--- /dev/null
+++ b/docs/demo-release/demo-runbook.md
@@ -0,0 +1,97 @@
+# Demo runbook
+
+## Starting the demo (any environment)
+
+Open the deployed URL (Unraid review: `http://192.168.10.150:1236`; local:
+`http://localhost:1228`). The login screen names the fictional organisation, states that
+all data is synthetic and all workflows are really implemented, and offers:
+
+- **Start begeleide demo** — logs in as Operations Manager and opens the Demo Guide at
+  step 1.
+- **Verken als Operations Manager** / **Verken als Rental Employee** — free exploration,
+  no guide.
+
+No password is shown or required for either path.
+
+## Five-minute demo (guided)
+
+1. Click **Start begeleide demo**.
+2. Follow steps 1–3: dashboard → the booking needing attention → confirm the pre-filled
+   odometer-anomaly return.
+3. Step 4: resolve the data-quality issue the return just created (any decision is fine
+   for a quick pass — "Retain canonical" is the fastest).
+4. Step 6: ask a suggested knowledge question and show the cited source.
+5. Step 7: show the automation/audit trail link-through.
+6. Close with step 8, the About page's honest real/synthetic/not-connected breakdown.
+
+## Ten-minute demo (guided + one extra scenario)
+
+Do the five-minute path above, then from `/scenarios`:
+
+- Run **scenario 2** (duplicate customer merge) if not already done via the guide's own
+  step 5.
+- Run **scenario 3** (booking overlap) — `/data-quality`, resolve `DQ-DEMO-OVERLAP`.
+- Run **scenario 4** (failed automation retry) — `/automation`, filter to failed, retry.
+
+All five scenarios can be run in any order and are independent of each other.
+
+## Resetting the environment
+
+Any Operations Manager can reset from: the sidebar ("Reset demo data"), the Demo Guide
+panel ("Demo opnieuw voorbereiden"), or the About page (points to the sidebar control).
+Reset requires confirmation, rebuilds the deterministic dataset with a fresh date anchor,
+runs a server-side scenario-integrity check, and signs the acting session out (the server
+invalidates the session as part of reset). It only ever touches MobilityOps's own tables
+— never shared n8n, RAGcore, or MCP data, other containers, or volumes. It can be
+disabled entirely via `DEMO_ALLOW_RESET=false` if an environment must not be rebuildable.
+
+## Redeploying to Unraid
+
+```bash
+# From a clean local checkout on the target branch/commit:
+git archive --format=tar.gz -o /tmp/mobilityops-source.tar.gz HEAD
+scp /tmp/mobilityops-source.tar.gz unraid:/mnt/user/appdata/mobilityops/.deploy/source-<short-sha>.tar.gz
+ssh unraid "cd /mnt/user/appdata/mobilityops \
+  && tar -xzf .deploy/source-<short-sha>.tar.gz \
+  && echo <full-sha> > .deploy/source-revision"
+
+# Rebuild only what changed (api and/or web); db is never rebuilt:
+ssh unraid "cd /mnt/user/appdata/mobilityops \
+  && docker compose -p mobilityops -f compose.yaml -f compose.unraid.yaml up --build -d api web"
+
+# Confirm migrations and reseed:
+ssh unraid "cd /mnt/user/appdata/mobilityops \
+  && docker compose -p mobilityops -f compose.yaml -f compose.unraid.yaml exec -T api python -m alembic current \
+  && docker compose -p mobilityops -f compose.yaml -f compose.unraid.yaml exec -T api python -m app.cli seed --reset"
+```
+
+Extraction preserves the server's existing `.env` and named volumes (Postgres data, n8n
+data) — the tarball never contains `.env` since it's gitignored. Never edit source
+directly on the server; never deploy uncommitted changes.
+
+## Rollback
+
+`.deploy/source-revision` on the server records exactly which commit is live. Prior
+source tarballs remain in `.deploy/` for rollback: extract an earlier
+`source-<short-sha>.tar.gz`, update `source-revision` to match, and re-run the rebuild
+step above. Database rollback is out of scope for this demo (migrations are additive;
+there has been no destructive migration on this branch).
+
+## Server safety (Unraid)
+
+Only touch the `mobilityops` Compose project's own `api`/`web` services (and `db` only
+via migrations, never manually). Never stop other containers, run `docker system prune`,
+delete unrecognised images/networks/volumes, delete the MobilityOps database, overwrite
+the server `.env`, print secrets, start a second permanent n8n instance, or activate
+guessed RAGcore/MCP URLs. PostgreSQL is never exposed externally.
+
+## Troubleshooting
+
+- **A scenario shows "Niet beschikbaar" on `/scenarios`**: it has already been resolved
+  since the last reset (expected once you've worked through it) — reset to restore it.
+- **Knowledge question returns "insufficient evidence"**: check the question is in
+  English and close to one of the suggested phrasings — the demo knowledge base is
+  English-only (see `demo-guide.md`).
+- **n8n shows a failed delivery that isn't the seeded demo one**: check `/automation`'s
+  filter and retry — bounded retries mean it should self-heal within
+  `n8n_max_attempts` attempts, or can be retried manually by an Operations Manager.
diff --git a/docs/demo-release/demo-scenarios.md b/docs/demo-release/demo-scenarios.md
new file mode 100644
index 0000000..02cff0e
--- /dev/null
+++ b/docs/demo-release/demo-scenarios.md
@@ -0,0 +1,71 @@
+# Demo scenarios
+
+Five fixed scenarios are surfaced at `/scenarios` and via `GET /api/v1/demo/manifest`'s
+`scenarios` array, which derives each scenario's `ready`/`blocked_reason` from the actual
+underlying records — never hardcoded. All five are re-findable, using the same public
+references, after every demo reset (see [`demo-data.md`](demo-data.md)).
+
+## 1 — Odometer regression on return
+
+- **Fixed records**: booking `BK-DEMO-RETURN` on vehicle `MO-024`.
+- **Role**: Rental Employee or Operations Manager.
+- **Problem demonstrated**: a return is submitted with an odometer reading lower than the
+  vehicle's canonical reading — usually a data-entry mistake or a return logged against
+  the wrong vehicle.
+- **Flow**: open the booking. The return form is pre-filled with a suspicious reading
+  below `MO-024`'s canonical odometer (the demo never asks a visitor to invent one), with
+  a callout explaining why. Review the server-evaluated preview, then confirm. The
+  canonical odometer is never silently lowered; a data-quality issue is opened
+  automatically and the outcome is queued for delivery to n8n.
+- **Continue**: the result panel links to the vehicle, automation status, and audit
+  trail, plus (inside the guided tour) a "Ga verder met de demo" button.
+
+## 2 — Possible duplicate customer
+
+- **Fixed records**: customers `CUS-0012` and `CUS-0178` (same email/phone), issue
+  `DQ-DEMO-DUPLICATE`.
+- **Role**: Operations Manager (merge is a bounded, audited action).
+- **Problem demonstrated**: two customer profiles that are very likely the same person,
+  registered twice — a risk for split booking history and duplicate contact.
+- **Flow**: open the issue, compare both profiles field by field, choose which survives,
+  and merge. The losing profile becomes a tombstone linked to the survivor; its bookings
+  are rewired. The result is recorded in the audit trail.
+
+## 3 — Overlapping bookings
+
+- **Fixed records**: vehicle `MO-016`, bookings `BK-DEMO-OVERLAP-A`/`BK-DEMO-OVERLAP-B`,
+  issue `DQ-DEMO-OVERLAP`.
+- **Role**: Operations Manager.
+- **Problem demonstrated**: the same vehicle committed to two overlapping reservations —
+  a legacy-import-style conflict that a normal booking command would reject outright.
+- **Flow**: open the issue, choose which of the two bookings to block; the other keeps
+  its current status.
+
+## 4 — Failed automation, retried
+
+- **Fixed record**: a seeded outbox event (`00000000-0000-4000-8000-000000000020`,
+  `BK-H-0020`) that is durably `failed` immediately after every reset — a safe, simulated
+  connection error, not a deliberately destabilised n8n configuration.
+- **Role**: Operations Manager.
+- **Problem demonstrated**: bounded retries and visible failure/recovery state for
+  workflow delivery, rather than a silent drop.
+- **Flow**: open Automation, filter to failed deliveries, retry the event; it moves out
+  of the failed filter once delivered.
+
+## 5 — Grounded procedure question
+
+- **Role**: Rental Employee or Operations Manager.
+- **Problem demonstrated**: an operational question gets an answer with a citation from
+  the demo knowledge base — or an honest "insufficient evidence" if nothing indexed
+  answers it — never an invented answer.
+- **Flow**: open Knowledge, click one of the suggested questions (English, matching the
+  indexed procedure content — see the note in [`demo-guide.md`](demo-guide.md) about why
+  suggested questions stay in English even though the rest of the demo narrates in
+  Dutch), and inspect the cited source and evidence state.
+
+## A sixth scenario exists but isn't one of the five requested
+
+`docs/13-seed-and-demo-scenarios.md`'s **S3** ("missing inspection before next booking",
+vehicle `MO-031`) is also seeded and shows up in the attention queue; it isn't surfaced
+on `/scenarios` because the brief names five specific scenarios, but it remains available
+for anyone exploring the attention queue directly.
diff --git a/docs/final-product-polish/audit.md b/docs/final-product-polish/audit.md
new file mode 100644
index 0000000..f1fff12
--- /dev/null
+++ b/docs/final-product-polish/audit.md
@@ -0,0 +1,173 @@
+# Final product polish — audit
+
+Performed 2026-08-03 against `feat/mobilityops-functional-completion`.
+
+## Commit state
+
+- **Local/branch HEAD**: `4a268c73515dc4f1d56c1aa2f231714654bffbb8`
+- **Deployed on Unraid** (`/mnt/user/appdata/mobilityops/.deploy/source-revision`):
+  `4a268c73515dc4f1d56c1aa2f231714654bffbb8` — **matches exactly**, no drift.
+- **Repository's primary branch is `master`, not `main`** — no branch named `main` exists
+  (`git branch -a` / `git remote show` confirm only `master`, `design/mobilityops-premium-ui`,
+  and `feat/mobilityops-functional-completion`). `origin/master` = local `master` =
+  `e0c7ed60112510687627d20a957af91c8b9db7f8`, unchanged since the functional-completion
+  baseline — this is the baseline to compare against before any future merge.
+- **Evidence-file mismatch found and corrected**: `artifacts/demo-release/final-summary.md`
+  recorded final commit `294a8176d19...` (one commit behind actual HEAD, because its own
+  "record the hash" follow-up commit necessarily couldn't self-reference). Corrected to
+  the verified, unambiguous `4a268c73515dc4f1d56c1aa2f231714654bffbb8`, cross-checked
+  against both `git rev-parse HEAD` and the server's `source-revision`.
+- Containers on Unraid: `api`/`db`/`web` all healthy; migrations at `e7b08389f47f (head)`.
+
+## Remaining "MobilityOps" mentions (user-facing)
+
+- `frontend/index.html:7` — `<title>MobilityOps</title>`; `:6` meta description.
+- `frontend/src/components/Layout.tsx:178` — sidebar brand lockup `<strong>MobilityOps</strong>`.
+- `frontend/src/components/Layout.tsx:232` — global search `aria-label`/visually-hidden
+  label "Search MobilityOps".
+- `frontend/src/components/Layout.tsx:299` — footer `<span>MobilityOps PoC</span>` (also
+  the "PoC" mention to remove).
+- `frontend/src/pages/Login.tsx:27` — the manifest-fallback org description string.
+- `frontend/src/pages/AboutDemo.tsx:32,63,71` — page heading and two body paragraphs.
+- `frontend/src/pages/Knowledge.tsx:108` — empty-state copy.
+- `frontend/src/pages/BookingDetail.tsx:80` — scenario callout copy.
+- `frontend/src/data/demoGuideSteps.ts:91` — step 8's expected-outcome text.
+- `backend/app/services/demo_manifest.py:24` — `ORGANIZATION_DESCRIPTION` (the string
+  `Login.tsx:27` falls back to when the manifest hasn't loaded yet — both need updating
+  together to avoid a flash of stale branding).
+- `backend/app/main.py:36` — FastAPI `title="MobilityOps API"` (visible in the OpenAPI/
+  Swagger UI a reviewer might open; low-risk to rename since it's a display string, not a
+  route or contract field).
+- **`knowledge/procedures/*.md` — user-facing, appears directly in cited answer text**:
+  `02-vehicle-return.md`, `03-damage-handling.md` (also says "PoC"), `05-cleaning-
+  checklist.md`, `07-customer-documents.md` (also says "PoC"), `09-booking-conflicts.md`
+  all say "MobilityOps" in prose that gets quoted verbatim as a knowledge-assistant
+  answer excerpt — these must be rebranded too, not just the app chrome.
+- e2e tests asserting on the string "MobilityOps" that must be updated alongside the
+  rename (not gaps, just dependencies): `demo-accessibility.spec.ts`, `demo-entry.spec.ts`,
+  `guided-demo-full.spec.ts` (About-page heading), `ui-redesign.spec.ts` (4× "Search
+  MobilityOps" combobox name).
+
+**Kept as technical identifiers** (per the brief, not renamed): Git repo `Jens/MobilityOps`,
+local repo folder name, Compose project `mobilityops`, deployment dir
+`/mnt/user/appdata/mobilityops`, Postgres db/user `mobilityops`, `knowledge/manifest.json`'s
+`"workspace": "mobilityops"` (a RAGcore-workspace config value), frontend package name
+`mobilityops-web`, and the internal API route prefix conventions.
+
+## Language problems (no i18n exists at all)
+
+- `frontend/package.json` has no i18n library (`i18next`/`react-i18next`/etc. absent).
+- There is no language switcher anywhere and no persisted language preference.
+- The existing UI mixes English (Dashboard, Vehicles, Bookings, Data Quality workbench,
+  Audit, Automation internals — all shipped in Task-B's demo-productization pass) and
+  Dutch (Login, Demo Guide, Scenarios, About, demo badge — added in the same pass) by a
+  documented, deliberate scope decision at the time. That decision must now be superseded:
+  the brief requires one true default (nl-BE) with working en-GB/fr-BE switching across
+  the **entire** application, so the English-language existing screens are now in scope
+  for translation, not just new surfaces.
+- The demo knowledge base (`knowledge/procedures/*.md`) is English-only; a Dutch or French
+  question against it returns `insufficient` evidence (verified empirically in the prior
+  work) — this is a real gap for the trilingual guided demo requirement.
+
+## Remaining technical user-facing language
+
+- `frontend/src/pages/Automation.tsx:183` — `{r.event_type}` rendered raw (e.g.
+  `vehicle.returned.v1`) in the primary ledger table, no human label.
+- `frontend/src/pages/Automation.tsx:91` — "delivered through the outbox" in primary copy.
+- `frontend/src/pages/Audit.tsx:129` — `{e.correlation_id.slice(0, 8)}` shown as the
+  visible `<summary>` trigger text for technical detail, not a meaningful reference.
+- `frontend/src/pages/DataQualityIssueDetail.tsx:341,366` — "canonical odometer" used
+  directly in primary decision copy, not translated to an operational phrase.
+- No central technical→human terminology mapping exists anywhere in the frontend.
+
+## Demo Guide panel problems
+
+- `frontend/src/components/DemoGuide.tsx` + the `@media (min-width: 701px)` rule in
+  `styles.css` implement exactly **one** behaviour for every desktop/tablet width ≥701px:
+  a fixed 400px right-side panel with `.app-workspace.guide-open { padding-right:
+  min(400px, 92vw) }` reserving space. There is no distinction between "extra-wide
+  desktop, dock + reflow with a guaranteed minimum content width" and "standard desktop/
+  tablet, floating non-modal sheet that auto-collapses to a progress chip" as the brief
+  now requires — today the panel never collapses to a chip at all; it only fully opens
+  or fully closes.
+- "Ga naar deze stap" (`DemoGuide.tsx`'s `goToStepRoute()`) only calls `navigate(...)`; it
+  does not scroll to or focus the relevant target element, and does not auto-collapse the
+  panel afterward.
+- No semantic target anchors exist on pages for the guide to scroll/focus toward.
+- Reduced-motion is not explicitly handled for the panel's open/close or any future
+  collapse/expand transition.
+
+## Data Quality Workbench contrast and hierarchy
+
+- Confirmed by direct inspection of `DataQualityIssueDetail.tsx`: only the odometer-
+  regression decision (lines 349,358) uses the higher-contrast `.check-card` treatment
+  (`background: var(--surface-subtle); border: 1px solid var(--line); padding: 10px 12px`).
+  Every other decision point — `DuplicateCustomerPanel`'s survivor choice (134,143) and
+  per-field merge choice (172,187), and `BookingOverlapPanel`'s block-choice (459) — uses
+  the bare `.checkbox-label` class: a small inline radio with no card background, no
+  border, no selected-state treatment, and no visible risk/consequence copy next to the
+  option. This is the inconsistency the brief describes as "kleine losse radioknoppen in
+  een zwak omlijnde rij."
+- Resolve/defer/reject already have some visual differentiation (`button-primary` for the
+  main resolution action inside each panel; a separate "Defer or reject" section below),
+  but defer and reject are rendered as two identically-weighted plain `<button>` elements
+  with no secondary/tertiary visual distinction from each other.
+- No sticky/always-visible action bar exists within longer resolution panels.
+
+## Automation/audit density
+
+- `frontend/src/pages/Automation.tsx`'s delivery ledger renders every one of the ~20
+  seeded `succeeded` events as an individual flat table row with only a status-text
+  filter (`pending`/`delivering`/`succeeded`/`failed`) — no grouping/summarization of
+  repeated successes, and event references are raw 8-character UUID slices with no
+  meaningful short display reference scheme.
+- `frontend/src/pages/Audit.tsx` shows one row per raw audit event; my prior "View related
+  events" filter (added in the demo-productization pass) lets a user filter down to a
+  correlation group, but does not present that group as one collapsed operational summary
+  by default — a visitor still sees N separate technical rows even after filtering.
+- Before/after is already shown as a computed diff string (`describeChanges()`), not raw
+  JSON, which partially satisfies 8C already — but the diff is a flat semicolon-joined
+  string, not the labelled multi-line "Status: A → B" presentation the brief shows.
+
+## Rows that are not fully clickable
+
+- **Attention Queue** (`Dashboard.tsx:126-146`, `.attention-list li`): only the `<Link>`
+  wrapping the item's title text is interactive; the severity badge, detail text, ref,
+  and chevron are inert. Confirmed by direct markup inspection.
+- **Today's movements** (`Dashboard.tsx:153-161`, `.movement-timeline li`): only the
+  `<Link>` wrapping the booking reference is interactive; each row unambiguously points
+  to one booking, so this qualifies for the same fully-clickable-row treatment.
+- **Recent activity** (`Dashboard.tsx:220-224`, `.recent-list li`): has **no** link at all
+  today, and there is no existing single-record detail page for an individual automation
+  event to point to — out of scope for "make it clickable" per the brief's own
+  "alleen wanneer de volledige rij ondubbelzinnig naar één bestemming verwijst" carve-out;
+  left as-is unless a natural destination is introduced elsewhere in this pass.
+- Scenario cards (`Scenarios.tsx`) already use a single full-card "Start scenario" link
+  per card with no competing interactive elements inside — already compliant, no change
+  needed.
+
+## Plan (implementation order)
+
+1. Rebrand to Fleet Ops (frontend strings, backend description strings, knowledge
+   procedure prose, index.html, e2e assertions) — batch, tested, committed.
+2. i18n architecture: add `i18next`/`react-i18next`, language switcher, persistence,
+   `html lang`, `Intl` formatting, namespaces, fail-fast missing-key check.
+3. Translate all existing screens + new demo surfaces into nl-BE/en-GB/fr-BE.
+4. Backend message-code fields for data-quality reasons/recommended actions/return
+   reasons/integration statuses/audit actions/errors; frontend localizes.
+5. Multilingual knowledge base (5 procedures × 3 locales) + locale-aware provider lookup.
+6. Adaptive Demo Guide: docked-rail / floating-sheet+chip / mobile-bottom-sheet behaviour,
+   scroll-to-target + focus + highlight, reduced motion.
+7. Data Quality Workbench: choice cards everywhere, sticky action bar, de-emphasized
+   defer/reject, contrast fixes.
+8. Central terminology mapping layer (nl/en/fr) used in Automation/Audit/Data-Quality.
+9. Automation ledger grouping/filtering + retry UX narration.
+10. Audit trail human action labels + correlation-grouped summary + labelled diffs.
+11. Fully clickable Attention Queue + Today's movements rows, with tests.
+12. Responsive pass across the 7 required breakpoints × 3 languages.
+13. Full test suite additions (i18n, branding, guide, quality, queue, automation/audit,
+    trilingual guided demo).
+14. Clean-checkout drill.
+15. Deploy feature branch to Unraid for final validation.
+16. Safe merge to `master` (the repository's actual main branch) + redeploy + final
+    evidence at `artifacts/fleet-ops-release/final-summary.md`.
diff --git a/frontend/e2e/_capture-demo-screenshots.spec.ts b/frontend/e2e/_capture-demo-screenshots.spec.ts
new file mode 100644
index 0000000..af34dd4
--- /dev/null
+++ b/frontend/e2e/_capture-demo-screenshots.spec.ts
@@ -0,0 +1,94 @@
+import { expect, test } from "@playwright/test";
+
+// One-off tooling to capture demo-productization evidence screenshots for
+// artifacts/demo-release/final-summary.md. Not part of the regular test suite
+// (prefixed with `_` and excluded from the configured test run via testIgnore).
+
+const OUT = "../artifacts/demo-release/screenshots";
+
+test("capture demo-release evidence screenshots", async ({ page, request }) => {
+  await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  await request.post("/api/v1/demo/reset");
+
+  await page.goto("/login");
+  await expect(page.getByText(/Northstar Mobility/)).toBeVisible();
+  await page.screenshot({ path: `${OUT}/01-demo-entry-desktop.png`, fullPage: true });
+
+  await page.setViewportSize({ width: 390, height: 844 });
+  await page.screenshot({ path: `${OUT}/02-demo-entry-mobile.png` });
+  await page.setViewportSize({ width: 1280, height: 900 });
+
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await expect(page.getByText("Probeer een demonstratiescenario")).toBeVisible();
+  await page.screenshot({ path: `${OUT}/03-dashboard-with-scenarios.png`, fullPage: true });
+
+  await page.getByRole("button", { name: /Demo-gids/ }).click();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+  await page.screenshot({ path: `${OUT}/04-demo-guide.png` });
+  await page.getByRole("button", { name: "Sluiten" }).click();
+
+  await page.goto("/bookings/BK-DEMO-RETURN");
+  await expect(page.getByText("Demonstratiescenario: afwijkende kilometerstand")).toBeVisible();
+  await page.getByRole("button", { name: "Review return" }).click();
+  await expect(page.getByText(/Expected fleet state/)).toBeVisible();
+  await page.screenshot({ path: `${OUT}/05-return-preview.png`, fullPage: true });
+  await page.getByRole("button", { name: "Confirm return" }).click();
+  await expect(page.getByRole("heading", { name: "Return registered" })).toBeVisible();
+  await page.screenshot({ path: `${OUT}/06-return-result.png`, fullPage: true });
+
+  await page.goto("/data-quality");
+  await expect(page.locator(".data-table tbody tr").first()).toBeVisible();
+  await page.locator(".data-table tbody tr").first().locator("a").click();
+  await expect(page.getByText("What's wrong")).toBeVisible();
+  await page.screenshot({ path: `${OUT}/07-data-quality-resolution.png`, fullPage: true });
+  await page.getByRole("radio", { name: /Retain canonical/ }).check();
+  await page.getByRole("button", { name: "Resolve issue" }).click();
+  await expect(page.getByText(/Issue .* resolved/)).toBeVisible();
+
+  await page.goto("/data-quality/DQ-DEMO-DUPLICATE");
+  await expect(page.getByRole("heading", { name: "Compare and merge" })).toBeVisible();
+  await page.screenshot({ path: `${OUT}/08-duplicate-customer-merge.png`, fullPage: true });
+
+  await page.goto("/knowledge");
+  await page.getByRole("button", { name: "What must I do when a vehicle returns with damage?" }).click();
+  await expect(page.getByText("Grounded in cited procedures")).toBeVisible();
+  await page.screenshot({ path: `${OUT}/09-knowledge-assistant.png`, fullPage: true });
+
+  await page.goto("/automation");
+  await expect(page.locator(".integration-cards")).toBeVisible();
+  await page.screenshot({ path: `${OUT}/10-integration-status.png`, fullPage: true });
+  const failedRetry = page.locator(".data-table tbody tr", { hasText: "failed" }).first();
+  if (await failedRetry.count()) {
+    await page.screenshot({ path: `${OUT}/11-automation-retry-before.png`, fullPage: true });
+    await failedRetry.getByRole("button", { name: "Retry" }).click();
+    await page.waitForTimeout(500);
+    await page.screenshot({ path: `${OUT}/11-automation-retry-after.png`, fullPage: true });
+  }
+
+  await page.goto("/audit");
+  await expect(page.locator(".data-table tbody tr").first()).toBeVisible();
+  await page.screenshot({ path: `${OUT}/12-audit-trail.png`, fullPage: true });
+  await page.locator(".data-table tbody tr").first().getByRole("button", { name: "View related events" }).click();
+  await page.screenshot({ path: `${OUT}/13-audit-related-events.png`, fullPage: true });
+
+  await page.goto("/about");
+  await expect(page.getByRole("heading", { name: "Wat MobilityOps wel en niet is" })).toBeVisible();
+  await page.screenshot({ path: `${OUT}/14-about-demo.png`, fullPage: true });
+
+  await page.goto("/dashboard");
+  await page.getByRole("button", { name: /Synthetische demo/ }).click();
+  await expect(page.getByRole("dialog", { name: "Over deze demo-omgeving" })).toBeVisible();
+  await page.screenshot({ path: `${OUT}/15-demo-badge-popover.png` });
+
+  // Final reset, captured, to leave the environment fully restored.
+  await page.keyboard.press("Escape");
+  const resetButton = page.getByRole("button", { name: "Reset demo data" });
+  if (await resetButton.count()) {
+    await resetButton.click();
+    await expect(page.getByRole("button", { name: "Yes, reset" })).toBeVisible();
+    await page.screenshot({ path: `${OUT}/16-reset-confirm.png` });
+    await page.getByRole("button", { name: "Yes, reset" }).click();
+    await expect(page).toHaveURL(/\/login$/);
+  }
+});
diff --git a/frontend/e2e/_capture-screenshots.spec.ts b/frontend/e2e/_capture-screenshots.spec.ts
index 8e62da6..10ffeb0 100644
--- a/frontend/e2e/_capture-screenshots.spec.ts
+++ b/frontend/e2e/_capture-screenshots.spec.ts
@@ -14,7 +14,7 @@ test("capture the seven main pages", async ({ page, request }) => {
   await page.goto("/login");
   await page.screenshot({ path: `${OUT}/1-login.png` });
 
-  await page.getByRole("button", { name: "Open as Operations Manager" }).click();
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
   await expect(page.getByRole("heading", { name: "Operational metrics" })).toBeVisible();
   await page.screenshot({ path: `${OUT}/2-dashboard.png`, fullPage: true });
 
diff --git a/frontend/e2e/clickable-rows.spec.ts b/frontend/e2e/clickable-rows.spec.ts
new file mode 100644
index 0000000..735f36d
--- /dev/null
+++ b/frontend/e2e/clickable-rows.spec.ts
@@ -0,0 +1,105 @@
+import { expect, test, type APIRequestContext } from "@playwright/test";
+
+async function resetDemoData(request: APIRequestContext) {
+  await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  await request.post("/api/v1/demo/reset");
+}
+
+// Verifies the "stretched link" pattern used across the Attention Queue, Today's movements,
+// Vehicles, Bookings and Data Quality tables: the whole row is one activation target, not
+// just its title/reference text, while any secondary in-row link stays independently usable.
+test.beforeEach(async ({ page, request }) => {
+  await resetDemoData(request);
+  await page.addInitScript(() => localStorage.setItem("fleetops.language", "en-GB"));
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Explore as Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+});
+
+test("attention queue row opens its record when clicking empty row space, not just the title", async ({ page }) => {
+  const row = page.locator(".attention-list li.row-clickable").first();
+  await expect(row).toBeVisible();
+  const box = await row.boundingBox();
+  expect(box).not.toBeNull();
+  // Click near the far right edge of the row -- empty space, not the title text or badge.
+  await page.mouse.click(box!.x + box!.width - 10, box!.y + box!.height / 2);
+  await expect(page).toHaveURL(/\/(data-quality|vehicles)\//);
+});
+
+test("attention queue row is keyboard reachable and opens on Enter", async ({ page }) => {
+  const row = page.locator(".attention-list li.row-clickable").first();
+  const link = row.locator(".row-link");
+  await link.focus();
+  await expect(link).toBeFocused();
+  await page.keyboard.press("Enter");
+  await expect(page).toHaveURL(/\/(data-quality|vehicles)\//);
+});
+
+test("today's movements row opens the correct booking on click", async ({ page }) => {
+  const row = page.locator(".movement-timeline li.row-clickable").first();
+  await expect(row).toBeVisible();
+  const box = await row.boundingBox();
+  await page.mouse.click(box!.x + box!.width - 10, box!.y + box!.height / 2);
+  await expect(page).toHaveURL(/\/bookings\/BK-/);
+});
+
+test("vehicles table row opens the vehicle detail from empty row space", async ({ page }) => {
+  await page.goto("/vehicles");
+  const row = page.locator(".data-table tbody tr.row-clickable").first();
+  await expect(row).toBeVisible();
+  const ref = (await row.locator("th").first().innerText()).split("\n")[0].trim();
+  const box = await row.boundingBox();
+  await page.mouse.click(box!.x + box!.width - 10, box!.y + box!.height / 2);
+  await expect(page).toHaveURL(new RegExp(`/vehicles/${ref}$`));
+});
+
+test("bookings table row opens the booking, and the secondary vehicle link stays independently clickable", async ({ page }) => {
+  await page.goto("/bookings");
+  const row = page.locator(".data-table tbody tr.row-clickable").first();
+  await expect(row).toBeVisible();
+  const vehicleLink = row.locator(".cell-link");
+  const vehicleRef = (await vehicleLink.innerText()).trim();
+
+  // Clicking the secondary vehicle-ref link navigates to the vehicle, not the booking --
+  // it must not be swallowed by the row-spanning overlay link sitting behind it.
+  await vehicleLink.click();
+  await expect(page).toHaveURL(new RegExp(`/vehicles/${vehicleRef}$`));
+
+  await page.goto("/bookings");
+  const rowAgain = page.locator(".data-table tbody tr.row-clickable").first();
+  const bookingRef = (await rowAgain.locator("th").first().innerText()).split("\n")[0].trim();
+  const box = await rowAgain.boundingBox();
+  await page.mouse.click(box!.x + box!.width - 10, box!.y + box!.height / 2);
+  await expect(page).toHaveURL(new RegExp(`/bookings/${bookingRef}$`));
+});
+
+test("data quality table row opens the issue detail from empty row space", async ({ page }) => {
+  await page.goto("/data-quality");
+  const row = page.locator(".data-table tbody tr.row-clickable").first();
+  await expect(row).toBeVisible();
+  const ref = (await row.locator("th").first().innerText()).split("\n")[0].trim();
+  const box = await row.boundingBox();
+  await page.mouse.click(box!.x + box!.width - 10, box!.y + box!.height / 2);
+  await expect(page).toHaveURL(new RegExp(`/data-quality/${ref}$`));
+});
+
+test("attention queue row opens the correct record on a mobile viewport tap", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 });
+  await page.goto("/dashboard");
+  const row = page.locator(".attention-list li.row-clickable").first();
+  await expect(row).toBeVisible();
+  const box = await row.boundingBox();
+  // A real touch context needs `hasTouch`, which this shared spec file doesn't opt into;
+  // a mouse click at the same mobile viewport size still exercises the same CSS layout
+  // and click-target logic, since the app has no touch-specific event handling.
+  await page.mouse.click(box!.x + box!.width - 10, box!.y + box!.height / 2);
+  await expect(page).toHaveURL(/\/(data-quality|vehicles)\//);
+});
+
+test("data quality table row has a pointer cursor and a visible focus ring covering the whole row", async ({ page }) => {
+  await page.goto("/data-quality");
+  const row = page.locator(".data-table tbody tr.row-clickable").first();
+  await expect(row).toHaveCSS("cursor", "pointer");
+  await row.locator(".row-link").focus();
+  await expect(row.locator(".row-link")).toBeFocused();
+});
diff --git a/frontend/e2e/demo-accessibility.spec.ts b/frontend/e2e/demo-accessibility.spec.ts
new file mode 100644
index 0000000..af2d696
--- /dev/null
+++ b/frontend/e2e/demo-accessibility.spec.ts
@@ -0,0 +1,87 @@
+import { expect, test } from "@playwright/test";
+
+test.describe.configure({ mode: "serial" });
+
+test("demo guide is usable as a mobile bottom sheet", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 });
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await expect(page).toHaveURL(/\/dashboard/);
+
+  const panel = page.getByRole("dialog", { name: "Gegidste demo" });
+  await expect(panel).toBeVisible();
+  const box = await panel.boundingBox();
+  expect(box).not.toBeNull();
+  // A bottom sheet: anchored to the bottom of the viewport, not a full-height side panel.
+  expect(box!.height).toBeLessThan(800);
+  expect(box!.x).toBeLessThanOrEqual(1);
+
+  await page.getByRole("button", { name: "Volgende" }).click();
+  await expect(page.getByRole("heading", { name: "2. Open een boeking" })).toBeVisible();
+
+  const scrollWidth = await page.evaluate(() => document.documentElement.scrollWidth);
+  const clientWidth = await page.evaluate(() => document.documentElement.clientWidth);
+  expect(scrollWidth).toBeLessThanOrEqual(clientWidth + 1);
+});
+
+test("demo guide does not cover the return form's action buttons on desktop", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await expect(page).toHaveURL(/\/dashboard/);
+  await page.goto("/bookings/BK-DEMO-RETURN");
+
+  const reviewButton = page.getByRole("button", { name: "Retour nakijken" });
+  await expect(reviewButton).toBeVisible();
+  await reviewButton.click({ timeout: 5000 });
+  await expect(page.getByText(/Verwachte wagenparkstatus/)).toBeVisible();
+});
+
+test("demo badge and guide trigger are keyboard reachable and Escape closes them", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+
+  const guideTrigger = page.getByRole("button", { name: /Demo-gids/ });
+  await guideTrigger.focus();
+  await page.keyboard.press("Enter");
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+  await page.keyboard.press("Escape");
+  // The guide panel itself doesn't bind Escape (it's a persistent panel, not a transient
+  // popover), so close it explicitly the way a keyboard user would: activate its own
+  // close control.
+  await page.getByRole("button", { name: "Sluiten" }).click();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeHidden();
+
+  const badgeTrigger = page.getByRole("button", { name: /Synthetische demo/ });
+  await badgeTrigger.focus();
+  await page.keyboard.press("Enter");
+  await expect(page.getByRole("dialog", { name: "Over deze demo-omgeving" })).toBeVisible();
+  await page.keyboard.press("Escape");
+  await expect(page.getByRole("dialog", { name: "Over deze demo-omgeving" })).toBeHidden();
+});
+
+test("key demo pages load without console errors", async ({ page }) => {
+  const errors: string[] = [];
+  page.on("console", (msg) => {
+    if (msg.type() !== "error") return;
+    // The app deliberately probes GET /demo/session on every load to confirm whether a
+    // session cookie is still valid (see AuthContext.tsx); a logged-out visitor's very
+    // first load always logs one benign 401 for this, which the app already handles via
+    // .catch() -- it is not an application error.
+    if (msg.text().includes("401") && msg.text().includes("Unauthorized")) return;
+    errors.push(msg.text());
+  });
+  page.on("pageerror", (err) => errors.push(err.message));
+
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await page.goto("/scenarios");
+  await expect(page.getByRole("heading", { name: "Probeer een demonstratiescenario" })).toBeVisible();
+  await page.goto("/about");
+  await expect(page.getByRole("heading", { name: "Wat Fleet Ops wel en niet is" })).toBeVisible();
+  await page.getByRole("button", { name: /Demo-gids/ }).click();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+
+  expect(errors, `Unexpected console errors: ${errors.join("\n")}`).toEqual([]);
+});
diff --git a/frontend/e2e/demo-entry.spec.ts b/frontend/e2e/demo-entry.spec.ts
new file mode 100644
index 0000000..4b4c7ae
--- /dev/null
+++ b/frontend/e2e/demo-entry.spec.ts
@@ -0,0 +1,61 @@
+import { expect, test } from "@playwright/test";
+
+test.describe.configure({ mode: "serial" });
+
+test("demo entry screen names the fictional org and never shows a password", async ({ page }) => {
+  await page.goto("/login");
+  await expect(page.getByText(/Northstar Mobility/)).toBeVisible();
+  await expect(page.getByText(/Synthetische demo/)).toBeVisible();
+  await expect(page.getByRole("button", { name: "Start begeleide demo" })).toBeVisible();
+  await expect(page.getByRole("button", { name: "Verken als Operations Manager" })).toBeVisible();
+  await expect(page.getByRole("button", { name: "Verken als Rental Employee" })).toBeVisible();
+  await expect(page.locator('input[type="password"]')).toHaveCount(0);
+});
+
+test("start guided demo logs in as Operations Manager and opens the guide at step 1", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  // The ?guide=start marker is a one-shot signal the dashboard strips immediately after
+  // consuming it, so assert on its effect (the guide panel opens at step 1) rather than
+  // the transient URL, which can already be gone by the time this assertion runs.
+  await expect(page).toHaveURL(/\/dashboard/);
+  await expect(page.getByText("Amelie De Ridder")).toBeVisible();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+  await expect(page.getByRole("heading", { name: "1. Begrijp de operationele status" })).toBeVisible();
+});
+
+test("permanent demo badge shows a popover with last reset info and a working About link", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+
+  const trigger = page.getByRole("button", { name: /Synthetische demo/ });
+  await expect(trigger).toBeVisible();
+  await trigger.click();
+  await expect(page.getByRole("dialog", { name: "Over deze demo-omgeving" })).toBeVisible();
+  await expect(page.getByText(/Laatste reset:/)).toBeVisible();
+
+  await page.getByRole("link", { name: /Over deze demo/ }).click();
+  await expect(page).toHaveURL(/\/about$/);
+  await expect(page.getByRole("heading", { name: "Wat Fleet Ops wel en niet is" })).toBeVisible();
+  await expect(page.getByText("Northstar Mobility").first()).toBeVisible();
+  await expect(page.getByText("Demomodus").first()).toBeVisible();
+  await expect(page.getByText("Niet gekoppeld").first()).toBeVisible();
+});
+
+test("badge popover closes on Escape and outside click", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+
+  const trigger = page.getByRole("button", { name: /Synthetische demo/ });
+  await trigger.click();
+  await expect(page.getByRole("dialog")).toBeVisible();
+  await page.keyboard.press("Escape");
+  await expect(page.getByRole("dialog")).toBeHidden();
+
+  await trigger.click();
+  await expect(page.getByRole("dialog")).toBeVisible();
+  await page.mouse.click(10, 10);
+  await expect(page.getByRole("dialog")).toBeHidden();
+});
diff --git a/frontend/e2e/demo-guide.spec.ts b/frontend/e2e/demo-guide.spec.ts
new file mode 100644
index 0000000..2c1e8b2
--- /dev/null
+++ b/frontend/e2e/demo-guide.spec.ts
@@ -0,0 +1,163 @@
+import { expect, test, type APIRequestContext } from "@playwright/test";
+
+async function resetDemoData(request: APIRequestContext) {
+  const login = await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  expect(login.ok()).toBeTruthy();
+  const reset = await request.post("/api/v1/demo/reset");
+  expect(reset.ok()).toBeTruthy();
+}
+
+test.describe.configure({ mode: "serial" });
+
+test("scenario overview lists all 5 scenarios, ready right after a reset", async ({ page, request }) => {
+  await resetDemoData(request);
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await page.goto("/scenarios");
+
+  await expect(page.getByRole("heading", { name: "Probeer een demonstratiescenario" })).toBeVisible();
+  const cards = page.locator(".scenario-card");
+  await expect(cards).toHaveCount(5);
+  for (const label of ["Klaar voor demo"]) {
+    await expect(page.getByText(label).first()).toBeVisible();
+  }
+  await expect(page.getByText("Niet beschikbaar")).toHaveCount(0);
+});
+
+test("starting a scenario navigates to its fixed record", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await page.goto("/scenarios");
+
+  const duplicateCard = page.locator(".scenario-card", { hasText: "dubbele klant" });
+  await duplicateCard.getByRole("link", { name: "Start scenario" }).click();
+  await expect(page).toHaveURL(/\/data-quality\/DQ-DEMO-DUPLICATE$/);
+});
+
+// The default Playwright viewport (1280x720) falls in the "standard desktop/tablet" tier
+// (see useViewportTier.ts): the guide is a floating, non-modal panel that auto-collapses
+// to a persistent progress chip the moment the visitor acts on "Ga naar deze stap".
+test("demo guide: navigating steps, jumping to a step collapses to a chip, and the chip reopens it", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+  await expect(page.getByRole("heading", { name: "1. Begrijp de operationele status" })).toBeVisible();
+
+  await page.getByRole("button", { name: "Volgende" }).click();
+  await expect(page.getByRole("heading", { name: "2. Open een boeking die aandacht nodig heeft" })).toBeVisible();
+
+  await page.getByRole("button", { name: /6\. Stel een vraag/ }).click();
+  await expect(page.getByRole("heading", { name: "6. Stel een vraag aan de procedureassistent" })).toBeVisible();
+
+  await page.getByRole("button", { name: "Ga naar deze stap" }).click();
+  await expect(page).toHaveURL(/\/knowledge$/);
+  // Panel auto-collapses to a persistent chip -- it must never sit over the knowledge
+  // page's primary "Ask" action after navigation.
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeHidden();
+  const chip = page.getByRole("button", { name: /Demo-gids · stap 6 van 8/ });
+  await expect(chip).toBeVisible();
+
+  await chip.click();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+  await expect(page.getByRole("heading", { name: "6. Stel een vraag aan de procedureassistent" })).toBeVisible();
+});
+
+test("the collapsed chip has its own close control, independent of reopening it", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await page.getByRole("button", { name: "Ga naar deze stap" }).click();
+  const chip = page.getByRole("button", { name: /Demo-gids · stap/ });
+  await expect(chip).toBeVisible();
+
+  await page.getByRole("button", { name: "Sluiten" }).click();
+  await expect(chip).toBeHidden();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeHidden();
+});
+
+test("demo guide progress persists across navigation and the trigger shows it", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await page.getByRole("button", { name: "Volgende" }).click();
+  await page.getByRole("button", { name: "Volgende" }).click();
+  await page.getByRole("button", { name: "Demo-gids inklappen" }).click();
+
+  await expect(page.getByRole("button", { name: /^Demo-gids/ }).first()).toContainText("2/8");
+
+  await page.goto("/vehicles");
+  await page.getByRole("button", { name: /^Demo-gids/ }).first().click();
+  await expect(page.getByRole("heading", { name: "3. Verwerk een retour" })).toBeVisible();
+});
+
+test("demo guide is not shown to a rental employee", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Rental Employee" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await expect(page.getByRole("button", { name: /Demo-gids/ })).toHaveCount(0);
+});
+
+test("restarting the demo from the guide resets data and returns to login", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+
+  await page.getByRole("button", { name: "Demo opnieuw voorbereiden" }).click();
+  await expect(page).toHaveURL(/\/login$/, { timeout: 10000 });
+});
+
+test("wide desktop viewport docks the guide as a rail that never collapses to a chip", async ({ page }) => {
+  await page.setViewportSize({ width: 1600, height: 1000 });
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  const panel = page.locator(".demo-guide-panel.is-wide");
+  await expect(panel).toBeVisible();
+
+  await page.getByRole("button", { name: "Ga naar deze stap" }).click();
+  await expect(panel).toBeVisible();
+  await expect(page.locator(".demo-guide-chip")).toHaveCount(0);
+});
+
+test("mobile viewport shows a bottom sheet with collapsed/half/full states and no horizontal overflow", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 });
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  const panel = page.locator(".demo-guide-panel.is-mobile");
+  await expect(panel).toBeVisible();
+  await expect(panel).toHaveClass(/sheet-half/);
+
+  const scrollWidth = await page.evaluate(() => document.documentElement.scrollWidth);
+  const clientWidth = await page.evaluate(() => document.documentElement.clientWidth);
+  expect(scrollWidth).toBeLessThanOrEqual(clientWidth + 1);
+
+  await page.locator(".demo-guide-sheet-handle").click();
+  await expect(panel).toHaveClass(/sheet-full/);
+  await page.locator(".demo-guide-sheet-handle").click();
+  await expect(panel).toHaveClass(/sheet-collapsed/);
+});
+
+test("Escape collapses the standard-tier panel, then closes it", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+
+  await page.keyboard.press("Escape");
+  await expect(page.getByRole("button", { name: /Demo-gids · stap/ })).toBeVisible();
+  await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeHidden();
+
+  await page.keyboard.press("Escape");
+  await expect(page.getByRole("button", { name: /Demo-gids · stap/ })).toBeHidden();
+});
+
+test("going to a step scrolls, focuses and highlights the on-page target", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Start begeleide demo" }).click();
+  await page.getByRole("button", { name: /6\. Stel een vraag/ }).click();
+
+  await page.getByRole("button", { name: "Ga naar deze stap" }).click();
+  await expect(page).toHaveURL(/\/knowledge$/);
+
+  const target = page.locator("#ask-heading");
+  await expect(target).toBeFocused();
+  await expect(target).toHaveClass(/demo-guide-highlight/);
+});
diff --git a/frontend/e2e/demo-legibility.spec.ts b/frontend/e2e/demo-legibility.spec.ts
new file mode 100644
index 0000000..189c247
--- /dev/null
+++ b/frontend/e2e/demo-legibility.spec.ts
@@ -0,0 +1,77 @@
+import { expect, test, type APIRequestContext } from "@playwright/test";
+
+async function resetDemoData(request: APIRequestContext) {
+  const login = await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  expect(login.ok()).toBeTruthy();
+  const reset = await request.post("/api/v1/demo/reset");
+  expect(reset.ok()).toBeTruthy();
+}
+
+test.describe.configure({ mode: "serial" });
+
+test("return flow pre-fills the suspicious odometer reading and explains why", async ({ page, request }) => {
+  await resetDemoData(request);
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await page.goto("/bookings/BK-DEMO-RETURN");
+
+  await expect(page.getByText("Demonstratiescenario: afwijkende kilometerstand")).toBeVisible();
+  const odometerInput = page.getByLabel("Eindkilometerstand (km)");
+  await expect(odometerInput).not.toHaveValue("");
+  const prefilled = Number(await odometerInput.inputValue());
+  expect(prefilled).toBeGreaterThan(0);
+
+  await page.getByRole("button", { name: "Retour nakijken" }).click();
+  await expect(page.getByText(/laatst bevestigde stand/)).toBeVisible();
+  await page.getByRole("button", { name: "Retour bevestigen" }).click();
+  await expect(page.getByRole("heading", { name: "Retour geregistreerd" })).toBeVisible();
+  await expect(page.getByRole("link", { name: "Automatiseringsstatus bekijken" })).toBeVisible();
+  await expect(page.getByRole("link", { name: "Audit trail bekijken" })).toBeVisible();
+});
+
+test("data quality issue detail explains what's wrong and why it matters", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await page.goto("/data-quality/DQ-DEMO-DUPLICATE");
+
+  await expect(page.getByText("Wat is er mis")).toBeVisible();
+  await expect(page.getByText("Waarom dit belangrijk is")).toBeVisible();
+  await expect(page.getByText(/waarschijnlijk dezelfde persoon/)).toBeVisible();
+});
+
+test("data quality list can filter to demo scenarios only", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await page.goto("/data-quality");
+
+  await expect(page.locator(".data-table tbody tr").first()).toBeVisible();
+  const allRows = await page.locator(".data-table tbody tr").count();
+  await page.getByRole("checkbox", { name: "Enkel demoscenario's" }).check();
+  const filteredRows = await page.locator(".data-table tbody tr").count();
+  expect(filteredRows).toBeGreaterThan(0);
+  expect(filteredRows).toBeLessThanOrEqual(allRows);
+  const refs = await page.locator(".data-table tbody tr th a").allTextContents();
+  for (const ref of refs) {
+    expect(ref.startsWith("DQ-DEMO-")).toBeTruthy();
+  }
+});
+
+test("knowledge page suggested question returns a grounded, honestly-labelled answer", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await page.goto("/knowledge");
+
+  // The status badge and retrieval-flow diagram must name the actual active provider
+  // honestly, not the not-yet-connected "RAGcore" -- the honest disclosure note below is
+  // allowed to mention RAGcore by name when explaining it isn't live yet.
+  await expect(page.locator(".knowledge-status strong")).toHaveText("de demokennisbank");
+  await expect(page.locator(".retrieval-flow")).toContainText("de demokennisbank");
+  await expect(page.locator(".knowledge-status")).not.toContainText("RAGcore");
+
+  await page.getByRole("button", { name: "Wie beoordeelt een ongewone kilometerstand?" }).click();
+  await expect(page.getByText("Onderbouwd met geciteerde procedures")).toBeVisible();
+});
diff --git a/frontend/e2e/demo.spec.ts b/frontend/e2e/demo.spec.ts
index 9b926f7..0d3fdf6 100644
--- a/frontend/e2e/demo.spec.ts
+++ b/frontend/e2e/demo.spec.ts
@@ -18,13 +18,13 @@ test("five-minute demo script end to end", async ({ page, request }) => {
 
   await test.step("1. login as Operations Manager", async () => {
     await page.goto("/login");
-    await expect(page.getByText(/Synthetic proof of concept/)).toBeVisible();
-    await page.getByRole("button", { name: "Open as Operations Manager" }).click();
+    await expect(page.getByText(/Synthetische demo/)).toBeVisible();
+    await page.getByRole("button", { name: "Verken als Operations Manager" }).click();
     await expect(page).toHaveURL(/\/dashboard$/);
   });
 
   await test.step("2. verify dashboard metrics are loaded", async () => {
-    await expect(page.getByRole("heading", { name: "Fleet readiness" })).toBeVisible();
+    await expect(page.getByRole("heading", { name: "Wagenparkstatus" })).toBeVisible();
     const metricValues = page.locator(".metric-cell dd");
     await expect(metricValues.first()).toBeVisible();
     const values = await metricValues.allTextContents();
@@ -35,62 +35,61 @@ test("five-minute demo script end to end", async ({ page, request }) => {
   await test.step("3. open active demo booking", async () => {
     await page.goto("/bookings/BK-DEMO-RETURN");
     await expect(page.getByRole("heading", { name: "BK-DEMO-RETURN" })).toBeVisible();
-    await expect(page.getByText("active", { exact: true })).toBeVisible();
+    await expect(page.getByText("actief", { exact: true })).toBeVisible();
   });
 
   await test.step("4. register an odometer-regression return (S1)", async () => {
     const vehicleOdometerText = await page
-      .locator(".detail-grid div", { hasText: "Start odometer" })
+      .locator(".detail-grid div", { hasText: "Startkilometerstand" })
       .locator("dd")
       .textContent();
     const startOdometer = parseInt((vehicleOdometerText ?? "0").replace(/\D/g, ""), 10);
     const lowReading = Math.max(0, startOdometer - 500);
 
-    await page.getByLabel("End odometer (km)").fill(String(lowReading));
-    await page.getByLabel("Fuel level (%)").fill("55");
-    await page.getByRole("button", { name: "Review return" }).click();
-    await expect(page.getByRole("heading", { name: "Review return impact" })).toBeVisible();
-    await page.getByRole("button", { name: "Confirm return" }).click();
+    await page.getByLabel("Eindkilometerstand (km)").fill(String(lowReading));
+    await page.getByLabel("Brandstofniveau (%)").fill("55");
+    await page.getByRole("button", { name: "Retour nakijken" }).click();
+    await expect(page.getByRole("heading", { name: "Retourimpact nakijken" })).toBeVisible();
+    await page.getByRole("button", { name: "Retour bevestigen" }).click();
 
-    await expect(page.getByRole("heading", { name: "Return registered" })).toBeVisible();
+    await expect(page.getByRole("heading", { name: "Retour geregistreerd" })).toBeVisible();
   });
 
   await test.step("5. verify quality issue and queued automation event", async () => {
-    await expect(page.getByText(/DQ-RET-|None created/)).toBeVisible();
-    await expect(page.getByText(/Queued for delivery \(/)).toBeVisible();
+    await expect(page.getByText(/DQ-RET-|Geen aangemaakt/)).toBeVisible();
+    await expect(page.getByText(/Klaargezet voor verwerking \(/)).toBeVisible();
   });
 
   await test.step("6. resolve the duplicate customer scenario (S2)", async () => {
     await page.goto("/data-quality/DQ-DEMO-DUPLICATE");
-    await expect(page.getByRole("heading", { name: "Compare and merge" })).toBeVisible();
-    await page.getByRole("button", { name: /Merge into CUS-0012/ }).click();
-    await page.getByRole("button", { name: "Yes, merge" }).click();
-    await expect(page.getByText("resolved", { exact: true })).toBeVisible();
+    await expect(page.getByRole("heading", { name: "Vergelijken en samenvoegen" })).toBeVisible();
+    await page.getByRole("button", { name: /Samenvoegen met CUS-0012/ }).click();
+    await page.getByRole("button", { name: "Ja, samenvoegen" }).click();
+    await expect(page.locator(".badge.status-resolved")).toBeVisible();
   });
 
   await test.step("7. ask the damage question and inspect citations (S6)", async () => {
     await page.goto("/knowledge");
     await page
-      .getByPlaceholder(/What must I do when a vehicle returns with damage/)
-      .fill("What must I do when a vehicle returns with damage?");
-    await page.getByRole("button", { name: "Ask" }).click();
-    await expect(page.getByText("Grounded in cited procedures")).toBeVisible();
-    await expect(page.getByText("Damage handling procedure").first()).toBeVisible();
-    await expect(page.getByText("Vehicle return procedure").first()).toBeVisible();
+      .getByPlaceholder(/Wat moet ik doen wanneer een voertuig beschadigd terugkomt/)
+      .fill("Wat moet ik doen wanneer een voertuig terugkomt met schade?");
+    await page.getByRole("button", { name: "Vraag stellen" }).click();
+    await expect(page.getByText("Onderbouwd met geciteerde procedures")).toBeVisible();
+    await expect(page.getByText("Procedure schadeafhandeling").first()).toBeVisible();
   });
 
   await test.step("8. inspect audit entries", async () => {
     await page.goto("/audit");
-    await page.getByLabel("Action").fill("return_registered");
-    await expect(page.locator(".data-table tbody tr").first()).toBeVisible();
-    await expect(page.getByText("return registered").first()).toBeVisible();
+    await page.getByLabel("Actie").fill("return_registered");
+    await expect(page.locator(".audit-group-list li").first()).toBeVisible();
+    await expect(page.getByText("Voertuigretour geregistreerd").first()).toBeVisible();
   });
 
   await test.step("9. verify responsive navigation at mobile width", async () => {
     await page.setViewportSize({ width: 360, height: 800 });
     await page.goto("/dashboard");
-    await expect(page.getByText(/Synthetic demo data/).first()).toBeVisible();
-    await expect(page.getByRole("link", { name: "Overview" }).first()).toBeVisible();
+    await expect(page.getByText(/Synthetische demo/).first()).toBeVisible();
+    await expect(page.getByRole("link", { name: "Overzicht" }).first()).toBeVisible();
     const scrollWidth = await page.evaluate(() => document.documentElement.scrollWidth);
     const clientWidth = await page.evaluate(() => document.documentElement.clientWidth);
     expect(scrollWidth).toBeLessThanOrEqual(clientWidth + 1);
diff --git a/frontend/e2e/guided-demo-full.spec.ts b/frontend/e2e/guided-demo-full.spec.ts
new file mode 100644
index 0000000..546ccd8
--- /dev/null
+++ b/frontend/e2e/guided-demo-full.spec.ts
@@ -0,0 +1,108 @@
+import { expect, test, type APIRequestContext } from "@playwright/test";
+
+async function resetDemoData(request: APIRequestContext) {
+  const login = await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  expect(login.ok()).toBeTruthy();
+  const reset = await request.post("/api/v1/demo/reset");
+  expect(reset.ok()).toBeTruthy();
+}
+
+test.describe.configure({ mode: "serial" });
+
+test("full guided demo walkthrough, start to finish, restoring the environment after", async ({
+  page,
+  request,
+}) => {
+  await resetDemoData(request);
+  // Wide desktop viewport: the guide docks as a rail and never auto-collapses to a chip
+  // (see useViewportTier.ts), so this walkthrough can keep interacting with the panel
+  // directly across every step -- the standard-tier auto-collapse behaviour itself is
+  // covered separately in demo-guide.spec.ts.
+  await page.setViewportSize({ width: 1600, height: 1000 });
+
+  await test.step("start the guided demo from the login screen", async () => {
+    await page.goto("/login");
+    await page.getByRole("button", { name: "Start begeleide demo" }).click();
+    await expect(page).toHaveURL(/\/dashboard/);
+    await expect(page.getByRole("dialog", { name: "Gegidste demo" })).toBeVisible();
+  });
+
+  await test.step("step 1: understand the operational state", async () => {
+    await expect(page.getByRole("heading", { name: "1. Begrijp de operationele status" })).toBeVisible();
+    await expect(page.getByRole("heading", { name: "Wagenparkstatus" })).toBeVisible();
+    await page.getByRole("button", { name: "Volgende" }).click();
+  });
+
+  await test.step("step 2: open the booking needing attention", async () => {
+    await expect(page.getByRole("heading", { name: "2. Open een boeking" })).toBeVisible();
+    await page.getByRole("button", { name: "Ga naar deze stap" }).click();
+    await expect(page).toHaveURL(/\/bookings\/BK-DEMO-RETURN$/);
+    await page.getByRole("button", { name: "Volgende" }).click();
+  });
+
+  await test.step("step 3: process the return with the pre-filled odometer anomaly", async () => {
+    await expect(page.getByRole("heading", { name: "3. Verwerk een retour" })).toBeVisible();
+    await expect(page.getByText("Demonstratiescenario: afwijkende kilometerstand")).toBeVisible();
+    await page.getByRole("button", { name: "Retour nakijken" }).click();
+    await expect(page.getByText(/laatst bevestigde stand/)).toBeVisible();
+    await page.getByRole("button", { name: "Retour bevestigen" }).click();
+    await expect(page.getByRole("heading", { name: "Retour geregistreerd" })).toBeVisible();
+    await page.getByRole("button", { name: "Ga verder met de demo" }).click();
+  });
+
+  await test.step("step 4: handle the newly created data-quality issue", async () => {
+    await expect(page).toHaveURL(/\/data-quality$/);
+    await expect(page.getByRole("heading", { name: "4. Bekijk en behandel" })).toBeVisible();
+    const firstIssueLink = page.locator(".data-table tbody tr").first().locator("a");
+    await firstIssueLink.click();
+    await expect(page.getByText("Wat is er mis")).toBeVisible();
+    // The newest issue is the odometer regression this return just created.
+    await page.getByRole("radio", { name: /Laatst bevestigde stand behouden/ }).check();
+    await page.getByRole("button", { name: "Probleem oplossen" }).click();
+    await expect(page.getByText(/Probleem .* opgelost/)).toBeVisible();
+    await page.getByRole("button", { name: "Ga verder met de demo" }).click();
+  });
+
+  await test.step("step 5: review and merge the possible duplicate customer", async () => {
+    await expect(page).toHaveURL(/\/data-quality\/DQ-DEMO-DUPLICATE$/);
+    await expect(page.getByRole("heading", { name: "5. Beoordeel en behandel" })).toBeVisible();
+    await page.getByRole("button", { name: /^Samenvoegen met/ }).click();
+    await page.getByRole("button", { name: "Ja, samenvoegen" }).click();
+    await expect(page.getByText(/Probleem .* opgelost/)).toBeVisible();
+    await page.getByRole("button", { name: "Ga verder met de demo" }).click();
+  });
+
+  await test.step("step 6: ask the procedure assistant a question", async () => {
+    await expect(page).toHaveURL(/\/knowledge$/);
+    await expect(page.getByRole("heading", { name: "6. Stel een vraag" })).toBeVisible();
+    await page.getByRole("button", { name: "Wat moet ik doen wanneer een voertuig terugkomt met schade?" }).click();
+    await expect(page.getByText("Onderbouwd met geciteerde procedures")).toBeVisible();
+    await page.getByRole("button", { name: "Volgende" }).click();
+  });
+
+  await test.step("step 7: check automation and the audit trail", async () => {
+    await expect(page.getByRole("heading", { name: "7. Controleer automatisering" })).toBeVisible();
+    await page.getByRole("button", { name: "Ga naar deze stap" }).click();
+    await expect(page).toHaveURL(/\/automation$/);
+    // Plain-language status only -- never the raw backend state string (e.g. "degraded").
+    await expect(page.locator(".integration-cards")).not.toContainText("degraded");
+    await expect(page.locator(".integration-cards")).not.toContainText("no_evidence");
+    await page.goto("/audit");
+    await expect(page.locator(".audit-group-list li").first()).toBeVisible();
+    await page.getByRole("button", { name: /Demo-gids/ }).click();
+    await page.getByRole("button", { name: "Volgende" }).click();
+  });
+
+  await test.step("step 8: review what's real, simulated, or not yet connected", async () => {
+    await expect(page.getByRole("heading", { name: "8. Bekijk wat echt is" })).toBeVisible();
+    await page.getByRole("button", { name: "Ga naar deze stap" }).click();
+    await expect(page).toHaveURL(/\/about$/);
+    await expect(page.getByRole("heading", { name: "Wat Fleet Ops wel en niet is" })).toBeVisible();
+    await expect(page.getByText("Demomodus", { exact: false }).first()).toBeVisible();
+    await expect(page.getByText("Niet gekoppeld").first()).toBeVisible();
+  });
+
+  await test.step("restore the environment", async () => {
+    await resetDemoData(request);
+  });
+});
diff --git a/frontend/e2e/i18n-coverage.spec.ts b/frontend/e2e/i18n-coverage.spec.ts
new file mode 100644
index 0000000..f5d3079
--- /dev/null
+++ b/frontend/e2e/i18n-coverage.spec.ts
@@ -0,0 +1,73 @@
+import { expect, test } from "@playwright/test";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Pure Node-context checks (no browser needed): every locale must define exactly the
+// same set of translation keys. A missing key would otherwise silently fall back to
+// showing the raw key string in production -- this test makes that impossible to ship.
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LOCALES_DIR = path.resolve(__dirname, "../src/i18n/locales");
+const LANGUAGES = ["nl-BE", "en-GB", "fr-BE"];
+
+function collectKeyPaths(value: unknown, prefix = ""): string[] {
+  if (value === null || typeof value !== "object") {
+    return [prefix];
+  }
+  return Object.entries(value as Record<string, unknown>).flatMap(([key, nested]) =>
+    collectKeyPaths(nested, prefix ? `${prefix}.${key}` : key),
+  );
+}
+
+function loadNamespace(language: string, namespace: string): Record<string, unknown> {
+  const filePath = path.join(LOCALES_DIR, language, `${namespace}.json`);
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+const namespaces = fs
+  .readdirSync(path.join(LOCALES_DIR, "nl-BE"))
+  .filter((f) => f.endsWith(".json"))
+  .map((f) => f.replace(/\.json$/, ""));
+
+test("every locale defines the same translation keys as nl-BE, for every namespace", () => {
+  expect(namespaces.length).toBeGreaterThan(0);
+
+  for (const namespace of namespaces) {
+    const referenceKeys = collectKeyPaths(loadNamespace("nl-BE", namespace)).sort();
+
+    for (const language of LANGUAGES) {
+      if (language === "nl-BE") continue;
+      const keys = collectKeyPaths(loadNamespace(language, namespace)).sort();
+      const missing = referenceKeys.filter((k) => !keys.includes(k));
+      const extra = keys.filter((k) => !referenceKeys.includes(k));
+
+      expect(
+        missing,
+        `${language}/${namespace}.json is missing keys present in nl-BE: ${missing.join(", ")}`,
+      ).toEqual([]);
+      expect(
+        extra,
+        `${language}/${namespace}.json has extra keys not present in nl-BE: ${extra.join(", ")}`,
+      ).toEqual([]);
+    }
+  }
+});
+
+test("no locale file contains an empty string value", () => {
+  for (const language of LANGUAGES) {
+    for (const namespace of namespaces) {
+      const data = loadNamespace(language, namespace);
+      const keys = collectKeyPaths(data);
+      for (const keyPath of keys) {
+        const value = keyPath.split(".").reduce<unknown>((acc, part) => {
+          if (acc && typeof acc === "object") return (acc as Record<string, unknown>)[part];
+          return undefined;
+        }, data);
+        if (typeof value === "string") {
+          expect(value.trim().length, `${language}/${namespace}.json:${keyPath} is empty`).toBeGreaterThan(0);
+        }
+      }
+    }
+  }
+});
diff --git a/frontend/e2e/interactive-elements.spec.ts b/frontend/e2e/interactive-elements.spec.ts
index 143e870..a00160c 100644
--- a/frontend/e2e/interactive-elements.spec.ts
+++ b/frontend/e2e/interactive-elements.spec.ts
@@ -7,9 +7,13 @@ async function resetDemoData(request: APIRequestContext) {
 
 test.describe.configure({ mode: "serial" });
 
+// This file's assertions were authored against the English UI copy; nl-BE is now the
+// app's default for a fresh session, so force English explicitly rather than rewriting
+// every assertion (the equivalent Dutch/French coverage lives in the i18n-specific specs).
 test.beforeEach(async ({ page }) => {
+  await page.addInitScript(() => localStorage.setItem("fleetops.language", "en-GB"));
   await page.goto("/login");
-  await page.getByRole("button", { name: "Open as Operations Manager" }).click();
+  await page.getByRole("button", { name: "Explore as Operations Manager" }).click();
   await expect(page).toHaveURL(/\/dashboard$/);
 });
 
@@ -52,7 +56,7 @@ test("vehicles page: free-text search actually filters the rendered rows", async
   const totalRows = await page.locator(".data-table tbody tr").count();
   expect(totalRows).toBeGreaterThan(1);
 
-  const searchBox = page.getByRole("form", { name: "Filter vehicles" }).getByLabel("Search");
+  const searchBox = page.getByRole("form", { name: "Vehicle fleet" }).getByLabel("Search");
   await searchBox.fill("MO-001");
   await expect(async () => {
     const rows = await page.locator(".data-table tbody tr").count();
@@ -140,7 +144,7 @@ test("data quality page: status and rule-type filters work", async ({ page }) =>
   );
   await expect(page.locator(".data-table tbody tr").first()).toBeVisible();
   const rules = await page.locator(".data-table tbody tr td:nth-child(2)").allTextContents();
-  expect(rules.every((r) => r.includes("possible duplicate customer"))).toBeTruthy();
+  expect(rules.every((r) => r.includes("Possible duplicate customer"))).toBeTruthy();
 
   await page.getByRole("combobox", { name: "Rule type", exact: true }).selectOption("");
   await page.getByRole("combobox", { name: "Status", exact: true }).selectOption("resolved");
@@ -159,7 +163,7 @@ test("data quality issue detail: defer and reject buttons work", async ({ page,
   await firstLink.click();
   await expect(page.getByRole("heading", { name: ref ?? "" })).toBeVisible();
   await page.getByRole("button", { name: "Defer" }).click();
-  await expect(page.getByText("deferred", { exact: true })).toBeVisible();
+  await expect(page.locator(".badge.status-deferred")).toBeVisible();
 });
 
 test("data quality: providing missing fields resolves a vehicle issue", async ({ page, request }) => {
@@ -173,7 +177,7 @@ test("data quality: providing missing fields resolves a vehicle issue", async ({
   await page.getByLabel("Location").fill("Depot");
   await page.getByRole("button", { name: "Save and re-check" }).click();
 
-  await expect(page.getByText("resolved", { exact: true })).toBeVisible();
+  await expect(page.getByText("Resolved").first()).toBeVisible();
 });
 
 test("data quality: resolving a booking overlap blocks one booking", async ({ page, request }) => {
@@ -184,7 +188,7 @@ test("data quality: resolving a booking overlap blocks one booking", async ({ pa
   await page.getByRole("radio", { name: /Block BK-DEMO-OVERLAP-A/ }).check();
   await page.getByRole("button", { name: /^Block BK-DEMO-OVERLAP-A$/ }).click();
 
-  await expect(page.getByText("resolved", { exact: true })).toBeVisible();
+  await expect(page.getByText("Resolved").first()).toBeVisible();
   const booking = await page.request.get("/api/v1/bookings/BK-DEMO-OVERLAP-A");
   expect((await booking.json()).status).toBe("blocked");
 });
@@ -220,7 +224,7 @@ test("data quality: retaining canonical resolves an odometer regression issue",
   await page.getByRole("radio", { name: /Retain canonical/ }).check();
   await page.getByRole("button", { name: "Resolve issue" }).click();
 
-  await expect(page.getByText("resolved", { exact: true })).toBeVisible();
+  await expect(page.getByText("Resolved").first()).toBeVisible();
 });
 
 test("data quality: manual scan runs and shows a result summary", async ({ page, request }) => {
@@ -255,11 +259,11 @@ test("automation page: status filter and retry button work", async ({ page, requ
 
 test("audit page: action filter works", async ({ page }) => {
   await page.goto("/audit");
-  await expect(page.locator(".data-table")).toBeVisible();
+  await expect(page.locator(".audit-group-list")).toBeVisible();
   await page.getByLabel("Action").fill("demo_login");
-  await expect(page.locator(".data-table tbody tr").first()).toBeVisible();
-  const actions = await page.locator(".data-table tbody tr td:nth-child(3)").allTextContents();
-  expect(actions.every((a) => a.includes("demo login"))).toBeTruthy();
+  await expect(page.locator(".audit-group").first()).toBeVisible();
+  const headings = await page.locator(".audit-group-heading strong").allTextContents();
+  expect(headings.every((a) => a === "Logged in")).toBeTruthy();
 });
 
 test("audit page: shows human-readable before/after and a safe entity link", async ({
@@ -284,14 +288,14 @@ test("audit page: shows human-readable before/after and a safe entity link", asy
 
   await page.goto("/audit");
   await page.getByLabel("Action").fill("return_registered");
-  await expect(page.locator(".data-table tbody tr").first()).toBeVisible();
+  const firstGroup = page.locator(".audit-group").first();
+  await expect(firstGroup).toBeVisible();
 
-  const changeCell = page.locator(".data-table tbody tr").first().locator("td").nth(4);
-  await expect(changeCell).toContainText("status");
-  await expect(changeCell).toContainText("returned");
+  const changeDiff = firstGroup.locator(".change-diff");
+  await expect(changeDiff).toContainText(/status/i);
+  await expect(changeDiff).toContainText("returned");
 
-  const entityCell = page.locator(".data-table tbody tr").first().locator("td").nth(3);
-  await expect(entityCell.locator("a")).toHaveAttribute("href", /\/bookings\/BK-/);
+  await expect(firstGroup.locator(".audit-group-meta a")).toHaveAttribute("href", /\/bookings\/BK-/);
 });
 
 test("knowledge page: form submits and clears input", async ({ page }) => {
@@ -340,7 +344,7 @@ test("rental employee role has a restricted nav and cannot reach manager-only pa
   page,
 }) => {
   await page.getByRole("button", { name: "Switch role" }).click();
-  await page.getByRole("button", { name: "Open as Rental Employee" }).click();
+  await page.getByRole("button", { name: "Explore as Rental Employee" }).click();
   await expect(page).toHaveURL(/\/dashboard$/);
 
   // Manager-only nav items are not shown at all, not merely disabled.
@@ -352,16 +356,16 @@ test("rental employee role has a restricted nav and cannot reach manager-only pa
   // message as a defense-in-depth measure, not just a hidden button.
   await page.goto("/automation");
   await expect(
-    page.getByText("Automation delivery status is visible to Operations Managers only."),
+    page.getByText("Automation is visible to Operations Managers only.").first(),
   ).toBeVisible();
 
   await page.goto("/data-quality");
   await expect(
-    page.getByText("Data-quality evidence and resolutions are visible to Operations Managers only."),
+    page.getByText("Data-quality evidence and resolutions are visible to Operations Managers only.").first(),
   ).toBeVisible();
 
   await page.goto("/audit");
-  await expect(page.getByText("Audit history is visible to Operations Managers only.")).toBeVisible();
+  await expect(page.getByText("Audit history is visible to Operations Managers only.").first()).toBeVisible();
 
   await expect(page.getByRole("button", { name: "Reset demo data" })).toHaveCount(0);
 });
@@ -374,7 +378,7 @@ test("operations manager can reset demo data and is returned to login", async ({
   await expect(page).toHaveURL(/\/login$/);
 
   // The reset must not have affected the ability to log back in against fresh data.
-  await page.getByRole("button", { name: "Open as Operations Manager" }).click();
+  await page.getByRole("button", { name: "Explore as Operations Manager" }).click();
   await expect(page).toHaveURL(/\/dashboard$/);
 });
 
@@ -392,7 +396,7 @@ test("rental employee direct API access to manager-only endpoints is rejected",
   page,
 }) => {
   await page.getByRole("button", { name: "Switch role" }).click();
-  await page.getByRole("button", { name: "Open as Rental Employee" }).click();
+  await page.getByRole("button", { name: "Explore as Rental Employee" }).click();
   await expect(page).toHaveURL(/\/dashboard$/);
 
   // page.request shares the browser context's cookies, and (via the web container's
diff --git a/frontend/e2e/responsive-i18n.spec.ts b/frontend/e2e/responsive-i18n.spec.ts
new file mode 100644
index 0000000..65b9c44
--- /dev/null
+++ b/frontend/e2e/responsive-i18n.spec.ts
@@ -0,0 +1,57 @@
+import { expect, test, type APIRequestContext } from "@playwright/test";
+
+async function resetDemoData(request: APIRequestContext) {
+  await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  await request.post("/api/v1/demo/reset");
+}
+
+// Cross-checks the responsive shell across the exact breakpoint matrix from the polish
+// brief (1440x1000, 1280x800, 1024x768, 768x1024, 430x932, 390x844, 360x800) in all three
+// supported languages -- both that nothing overflows horizontally and that the localized
+// heading text still renders (rather than being silently truncated away).
+const BREAKPOINTS: { width: number; height: number }[] = [
+  { width: 1440, height: 1000 },
+  { width: 1280, height: 800 },
+  { width: 1024, height: 768 },
+  { width: 768, height: 1024 },
+  { width: 430, height: 932 },
+  { width: 390, height: 844 },
+  { width: 360, height: 800 },
+];
+
+const LANGUAGES: { code: string; attentionTitle: string }[] = [
+  { code: "nl-BE", attentionTitle: "Aandachtspunten" },
+  { code: "en-GB", attentionTitle: "Attention queue" },
+  { code: "fr-BE", attentionTitle: "File d'attention" },
+];
+
+test.beforeEach(async ({ request }) => {
+  await resetDemoData(request);
+});
+
+for (const language of LANGUAGES) {
+  test.describe(`${language.code}`, () => {
+    for (const bp of BREAKPOINTS) {
+      test(`no horizontal overflow at ${bp.width}x${bp.height}`, async ({ page }) => {
+        await page.addInitScript(
+          (lang) => localStorage.setItem("fleetops.language", lang),
+          language.code,
+        );
+        await page.setViewportSize({ width: bp.width, height: bp.height });
+        await page.goto("/login");
+        await page.getByRole("button", { name: /begeleide demo|guided demo|démo guidée/i }).click();
+        await expect(page).toHaveURL(/\/dashboard/);
+
+        await expect(page.getByRole("heading", { name: language.attentionTitle })).toBeVisible();
+
+        const dimensions = await page.evaluate(() => ({
+          scroll: document.documentElement.scrollWidth,
+          client: document.documentElement.clientWidth,
+        }));
+        expect(dimensions.scroll, `${language.code} @ ${bp.width}x${bp.height}`).toBeLessThanOrEqual(
+          dimensions.client + 1,
+        );
+      });
+    }
+  });
+}
diff --git a/frontend/e2e/ui-redesign.spec.ts b/frontend/e2e/ui-redesign.spec.ts
index 00896f7..3f4934d 100644
--- a/frontend/e2e/ui-redesign.spec.ts
+++ b/frontend/e2e/ui-redesign.spec.ts
@@ -5,10 +5,14 @@ async function resetDemoData(request: APIRequestContext) {
   await request.post("/api/v1/demo/reset");
 }
 
+// This file's assertions were authored against the English UI copy; nl-BE is now the
+// app's default for a fresh session, so force English explicitly rather than rewriting
+// every assertion (the equivalent Dutch/French coverage lives in the i18n-specific specs).
 test.beforeEach(async ({ page, request }) => {
   await resetDemoData(request);
+  await page.addInitScript(() => localStorage.setItem("fleetops.language", "en-GB"));
   await page.goto("/login");
-  await page.getByRole("button", { name: "Open as Operations Manager" }).click();
+  await page.getByRole("button", { name: "Explore as Operations Manager" }).click();
   await expect(page).toHaveURL(/\/dashboard$/);
 });
 
@@ -22,7 +26,7 @@ test("control-centre shell exposes landmarks, persisted readiness and active nav
 
 test("global search supports its keyboard shortcut and finds a vehicle by reference", async ({ page }) => {
   await page.keyboard.press("Control+k");
-  const search = page.getByRole("combobox", { name: "Search MobilityOps" });
+  const search = page.getByRole("combobox", { name: "Search Fleet Ops" });
   await expect(search).toBeFocused();
   await search.fill("MO-024");
   const result = page.getByRole("option", { name: /MO-024/ });
@@ -33,7 +37,7 @@ test("global search supports its keyboard shortcut and finds a vehicle by refere
 });
 
 test("global search supports arrow-key navigation and Enter to select", async ({ page }) => {
-  const search = page.getByRole("combobox", { name: "Search MobilityOps" });
+  const search = page.getByRole("combobox", { name: "Search Fleet Ops" });
   await search.fill("fleet");
   await expect(page.getByRole("option", { name: /Fleet/ })).toBeVisible();
   await search.press("ArrowDown");
@@ -42,7 +46,7 @@ test("global search supports arrow-key navigation and Enter to select", async ({
 });
 
 test("global search shows a no-results state and closes on Escape", async ({ page }) => {
-  const search = page.getByRole("combobox", { name: "Search MobilityOps" });
+  const search = page.getByRole("combobox", { name: "Search Fleet Ops" });
   await search.fill("zzz-nothing-matches-zzz");
   await expect(page.getByText(/No matches for/)).toBeVisible();
   await search.press("Escape");
@@ -50,7 +54,7 @@ test("global search shows a no-results state and closes on Escape", async ({ pag
 });
 
 test("global search finds a booking and a data-quality issue by reference", async ({ page }) => {
-  const search = page.getByRole("combobox", { name: "Search MobilityOps" });
+  const search = page.getByRole("combobox", { name: "Search Fleet Ops" });
   await search.fill("BK-DEMO-RETURN");
   const bookingResult = page.getByRole("option", { name: /BK-DEMO-RETURN/ });
   await expect(bookingResult).toBeVisible();
@@ -83,7 +87,7 @@ test("return review separates capture from irreversible commit", async ({ page }
   // The review step is server-evaluated (not client-guessed), so exactly one non-mutating
   // preview call is expected before any commit.
   expect(previewRequests).toBe(1);
-  await expect(page.getByText("Queue n8n delivery after the local commit")).toBeVisible();
+  await expect(page.getByText("Queue automation after the local commit")).toBeVisible();
 
   await page.getByRole("button", { name: "Edit details" }).click();
   await expect(page.getByLabel("End odometer (km)")).toHaveValue("60000");
diff --git a/frontend/index.html b/frontend/index.html
index 0456058..307c14e 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -1,10 +1,10 @@
 <!doctype html>
-<html lang="en">
+<html lang="nl">
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="description" content="MobilityOps synthetic-data operations proof of concept" />
-    <title>MobilityOps</title>
+    <meta name="description" content="Fleet Ops synthetic-data operations demo" />
+    <title>Fleet Ops</title>
   </head>
   <body>
     <div id="root"></div>
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 34ac772..f24777a 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -8,8 +8,10 @@
       "name": "mobilityops-web",
       "version": "0.0.1",
       "dependencies": {
+        "i18next": "^26.3.6",
         "react": "18.3.1",
         "react-dom": "18.3.1",
+        "react-i18next": "^17.0.11",
         "react-router-dom": "7.18.2"
       },
       "devDependencies": {
@@ -255,6 +257,15 @@
         "@babel/core": "^7.0.0-0"
       }
     },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/template": {
       "version": "7.29.7",
       "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
@@ -1463,6 +1474,43 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/html-parse-stringify": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/html-parse-stringify/-/html-parse-stringify-4.0.1.tgz",
+      "integrity": "sha512-0zHsZJrK7S3K2aucXWL6ycoYJ/iNtIcFHC/nYQgFklPtrv5LpJctIiSCroWZWeuoXvuyFdzp6KzjJQ+OT5MfFw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://locize.com"
+      }
+    },
+    "node_modules/i18next": {
+      "version": "26.3.6",
+      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.6.tgz",
+      "integrity": "sha512-Bu5Z2nAXgfVyM8xvW3jk9EKRIuX37PudsrBViThNFx7CR7aaYTpP01cxNB/E4c4UUzTDiAZRstEhsRfPOL/8xA==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://www.locize.com/i18next"
+        },
+        {
+          "type": "individual",
+          "url": "https://www.i18next.com/how-to/faq#i18next-is-awesome.-how-can-i-support-the-project"
+        },
+        {
+          "type": "individual",
+          "url": "https://www.locize.com"
+        }
+      ],
+      "license": "MIT",
+      "peerDependencies": {
+        "typescript": "^5 || ^6 || ^7"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -1661,6 +1709,33 @@
         "react": "^18.3.1"
       }
     },
+    "node_modules/react-i18next": {
+      "version": "17.0.11",
+      "resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-17.0.11.tgz",
+      "integrity": "sha512-cDtkXgxjuFTWUH6V+aQn1Ve5vDiUztCNPWW5GtSHDccsgRXO1nE6QFWCEmc1KAutrb3OUv87wFShJL5RhUwPXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.29.2",
+        "html-parse-stringify": "^4.0.1",
+        "use-sync-external-store": "^1.6.0"
+      },
+      "peerDependencies": {
+        "i18next": ">= 26.2.0",
+        "react": ">= 16.8.0",
+        "typescript": "^5 || ^6 || ^7"
+      },
+      "peerDependenciesMeta": {
+        "react-dom": {
+          "optional": true
+        },
+        "react-native": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/react-refresh": {
       "version": "0.14.2",
       "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.14.2.tgz",
@@ -1794,7 +1869,7 @@
       "version": "5.6.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.3.tgz",
       "integrity": "sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==",
-      "dev": true,
+      "devOptional": true,
       "license": "Apache-2.0",
       "bin": {
         "tsc": "bin/tsc",
@@ -1835,6 +1910,15 @@
         "browserslist": ">= 4.21.0"
       }
     },
+    "node_modules/use-sync-external-store": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz",
+      "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/vite": {
       "version": "5.4.21",
       "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index e3b346b..d388ef0 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -11,8 +11,10 @@
     "test:e2e": "playwright test"
   },
   "dependencies": {
+    "i18next": "^26.3.6",
     "react": "18.3.1",
     "react-dom": "18.3.1",
+    "react-i18next": "^17.0.11",
     "react-router-dom": "7.18.2"
   },
   "devDependencies": {
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 8f5b257..3cefb0f 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,5 +1,7 @@
 import { Navigate, Route, Routes } from "react-router-dom";
 import { AuthProvider } from "./context/AuthContext";
+import { DemoManifestProvider } from "./context/DemoManifestContext";
+import { DemoGuideProvider } from "./context/DemoGuideContext";
 import { Layout } from "./components/Layout";
 import { RequireAuth } from "./components/RequireAuth";
 import { Login } from "./pages/Login";
@@ -13,33 +15,41 @@ import { DataQualityIssueDetail } from "./pages/DataQualityIssueDetail";
 import { Automation } from "./pages/Automation";
 import { Knowledge } from "./pages/Knowledge";
 import { Audit } from "./pages/Audit";
+import { AboutDemo } from "./pages/AboutDemo";
+import { Scenarios } from "./pages/Scenarios";
 
 export function App() {
   return (
-    <AuthProvider>
-      <Routes>
-        <Route path="/login" element={<Login />} />
-        <Route
-          element={
-            <RequireAuth>
-              <Layout />
-            </RequireAuth>
-          }
-        >
-          <Route path="/dashboard" element={<Dashboard />} />
-          <Route path="/vehicles" element={<Vehicles />} />
-          <Route path="/vehicles/:publicRef" element={<VehicleDetail />} />
-          <Route path="/bookings" element={<Bookings />} />
-          <Route path="/bookings/:publicRef" element={<BookingDetail />} />
-          <Route path="/data-quality" element={<DataQuality />} />
-          <Route path="/data-quality/:publicRef" element={<DataQualityIssueDetail />} />
-          <Route path="/automation" element={<Automation />} />
-          <Route path="/knowledge" element={<Knowledge />} />
-          <Route path="/audit" element={<Audit />} />
-        </Route>
-        <Route path="/" element={<Navigate to="/dashboard" replace />} />
-        <Route path="*" element={<Navigate to="/dashboard" replace />} />
-      </Routes>
-    </AuthProvider>
+    <DemoManifestProvider>
+      <AuthProvider>
+        <DemoGuideProvider>
+          <Routes>
+            <Route path="/login" element={<Login />} />
+            <Route
+              element={
+                <RequireAuth>
+                  <Layout />
+                </RequireAuth>
+              }
+            >
+              <Route path="/dashboard" element={<Dashboard />} />
+              <Route path="/vehicles" element={<Vehicles />} />
+              <Route path="/vehicles/:publicRef" element={<VehicleDetail />} />
+              <Route path="/bookings" element={<Bookings />} />
+              <Route path="/bookings/:publicRef" element={<BookingDetail />} />
+              <Route path="/data-quality" element={<DataQuality />} />
+              <Route path="/data-quality/:publicRef" element={<DataQualityIssueDetail />} />
+              <Route path="/automation" element={<Automation />} />
+              <Route path="/knowledge" element={<Knowledge />} />
+              <Route path="/audit" element={<Audit />} />
+              <Route path="/about" element={<AboutDemo />} />
+              <Route path="/scenarios" element={<Scenarios />} />
+            </Route>
+            <Route path="/" element={<Navigate to="/dashboard" replace />} />
+            <Route path="*" element={<Navigate to="/dashboard" replace />} />
+          </Routes>
+        </DemoGuideProvider>
+      </AuthProvider>
+    </DemoManifestProvider>
   );
 }
diff --git a/frontend/src/api/types.ts b/frontend/src/api/types.ts
index 715e29b..df0bc30 100644
--- a/frontend/src/api/types.ts
+++ b/frontend/src/api/types.ts
@@ -88,7 +88,7 @@ export interface DashboardMetrics {
 export interface AttentionItem {
   kind: string;
   severity: "low" | "medium" | "high";
-  title: string;
+  rule_type: string;
   detail: string;
   link_type: "vehicle" | "booking" | "customer";
   link_ref: string;
@@ -252,6 +252,37 @@ export interface IntegrationStatus {
   mcp_hub: McpHubIntegrationStatus;
 }
 
+export interface DemoScenario {
+  id: string;
+  estimated_minutes: number;
+  required_roles: Role[];
+  start_path: string;
+  ready: boolean;
+  blocked_reason_code: string | null;
+  blocked_reason_params: Record<string, string>;
+}
+
+export interface DemoIntegrationSummary {
+  key: "n8n" | "ragcore" | "mcp_hub";
+  status_code: string;
+  detail_code: string;
+  detail_params: Record<string, string | number>;
+}
+
+export interface DemoManifest {
+  demo_mode: boolean;
+  organization_name: string;
+  timezone: string;
+  synthetic_data: boolean;
+  allow_reset: boolean;
+  last_reset_at: string | null;
+  anchor_date: string | null;
+  guide_available: boolean;
+  required_roles: Role[];
+  scenarios: DemoScenario[];
+  integrations: DemoIntegrationSummary[];
+}
+
 export interface AuditEvent {
   id: string;
   actor_type: string;
diff --git a/frontend/src/components/Badge.tsx b/frontend/src/components/Badge.tsx
index 7cbfc09..d169b99 100644
--- a/frontend/src/components/Badge.tsx
+++ b/frontend/src/components/Badge.tsx
@@ -1,8 +1,10 @@
+import { useTranslation } from "react-i18next";
+
 export function SeverityBadge({ severity }: { severity: "low" | "medium" | "high" }) {
-  const label = severity === "high" ? "High" : severity === "medium" ? "Medium" : "Low";
-  return <span className={`badge severity-${severity}`}>{label} severity</span>;
+  const { t } = useTranslation("quality");
+  return <span className={`badge severity-${severity}`}>{t(`severities.${severity}`)}</span>;
 }
 
-export function StatusBadge({ status }: { status: string }) {
-  return <span className={`badge status-${status}`}>{status.replace(/_/g, " ")}</span>;
+export function StatusBadge({ status, label }: { status: string; label?: string }) {
+  return <span className={`badge status-${status}`}>{label ?? status.replace(/_/g, " ")}</span>;
 }
diff --git a/frontend/src/components/DemoBadge.tsx b/frontend/src/components/DemoBadge.tsx
new file mode 100644
index 0000000..ef47092
--- /dev/null
+++ b/frontend/src/components/DemoBadge.tsx
@@ -0,0 +1,74 @@
+import { useEffect, useRef, useState } from "react";
+import { Link } from "react-router-dom";
+import { Trans, useTranslation } from "react-i18next";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { useLocaleFormat } from "../i18n/format";
+import { Icon } from "./Icons";
+
+export function DemoBadge() {
+  const { t } = useTranslation("demo");
+  const { formatDateTime } = useLocaleFormat();
+  const { manifest } = useDemoManifest();
+  const [open, setOpen] = useState(false);
+  const boxRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    function handleOutsideClick(event: MouseEvent) {
+      if (boxRef.current && !boxRef.current.contains(event.target as Node)) {
+        setOpen(false);
+      }
+    }
+    function handleEscape(event: KeyboardEvent) {
+      if (event.key === "Escape") setOpen(false);
+    }
+    document.addEventListener("mousedown", handleOutsideClick);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mousedown", handleOutsideClick);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, []);
+
+  return (
+    <div className="demo-badge" ref={boxRef}>
+      <button
+        type="button"
+        className="demo-badge-trigger"
+        aria-expanded={open}
+        aria-haspopup="dialog"
+        onClick={() => setOpen((v) => !v)}
+      >
+        <Icon name="shield" />
+        <span>{t("badge.trigger")}</span>
+      </button>
+      {open && (
+        <div className="demo-badge-popover" role="dialog" aria-label={t("badge.dialogLabel")}>
+          <button type="button" className="icon-button demo-badge-close" onClick={() => setOpen(false)} aria-label={t("badge.close")}>
+            <Icon name="x" />
+          </button>
+          <p>
+            {manifest ? (
+              <Trans i18nKey="badge.orgIntro" t={t} values={{ orgName: manifest.organization_name }} components={{ strong: <strong /> }} />
+            ) : (
+              t("badge.orgIntroFallback")
+            )}
+          </p>
+          <p>{t("badge.realWorkflows")}</p>
+          {manifest && (
+            <p className="demo-badge-reset">
+              <Trans
+                i18nKey="badge.lastReset"
+                t={t}
+                values={{ when: manifest.last_reset_at ? formatDateTime(manifest.last_reset_at) : t("badge.unknown") }}
+                components={{ strong: <strong /> }}
+              />
+            </p>
+          )}
+          <Link to="/about" onClick={() => setOpen(false)}>
+            {t("badge.aboutLink")} <Icon name="chevron" />
+          </Link>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/components/DemoGuide.tsx b/frontend/src/components/DemoGuide.tsx
new file mode 100644
index 0000000..55a7caf
--- /dev/null
+++ b/frontend/src/components/DemoGuide.tsx
@@ -0,0 +1,248 @@
+import { useNavigate, useLocation } from "react-router-dom";
+import { useEffect, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { api, ApiError } from "../api/client";
+import { useAuth } from "../context/AuthContext";
+import { useDemoGuide } from "../context/DemoGuideContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { useViewportTier } from "../hooks/useViewportTier";
+import { DEMO_GUIDE_STEPS } from "../data/demoGuideSteps";
+import { Icon } from "./Icons";
+
+export function DemoGuideTrigger() {
+  const { t } = useTranslation("demo");
+  const { user } = useAuth();
+  const { open, toggleGuide, currentIndex, completed, totalSteps } = useDemoGuide();
+
+  if (user?.role !== "operations_manager") return null;
+
+  return (
+    <button
+      type="button"
+      className="demo-guide-trigger"
+      aria-expanded={open}
+      aria-haspopup="dialog"
+      onClick={toggleGuide}
+    >
+      <Icon name="spark" />
+      <span>{t("guide.trigger")}</span>
+      <span className="demo-guide-progress-pill">{completed.size}/{totalSteps}</span>
+      <span className="visually-hidden">, {t("guide.kicker", { current: currentIndex + 1, total: totalSteps })}</span>
+    </button>
+  );
+}
+
+function highlightTarget(selector: string | undefined) {
+  if (!selector) return;
+  const el = document.querySelector<HTMLElement>(selector);
+  if (!el) return;
+  el.scrollIntoView({ behavior: "smooth", block: "center" });
+  const previousTabIndex = el.getAttribute("tabindex");
+  if (!el.hasAttribute("tabindex")) el.setAttribute("tabindex", "-1");
+  el.focus({ preventScroll: true });
+  el.classList.add("demo-guide-highlight");
+  window.setTimeout(() => {
+    el.classList.remove("demo-guide-highlight");
+    if (previousTabIndex === null) el.removeAttribute("tabindex");
+  }, 2200);
+}
+
+export function DemoGuide() {
+  const { t } = useTranslation("demo");
+  const navigate = useNavigate();
+  const location = useLocation();
+  const { logout } = useAuth();
+  const { manifest, refresh } = useDemoManifest();
+  const tier = useViewportTier();
+  const {
+    open,
+    closeGuide,
+    currentIndex,
+    completed,
+    totalSteps,
+    goToStep,
+    completeAndAdvance,
+    restart,
+    collapsedToChip,
+    setCollapsedToChip,
+  } = useDemoGuide();
+  const [resetting, setResetting] = useState(false);
+  const [resetError, setResetError] = useState<string | null>(null);
+  const [mobileSheetState, setMobileSheetState] = useState<"collapsed" | "half" | "full">("half");
+  const pendingTarget = useRef<string | null>(null);
+
+  const step = DEMO_GUIDE_STEPS[currentIndex];
+  const isLastStep = currentIndex === totalSteps - 1;
+
+  useEffect(() => {
+    if (!open) return;
+    function handleKeydown(event: KeyboardEvent) {
+      if (event.key !== "Escape") return;
+      if (tier === "standard" && !collapsedToChip) {
+        setCollapsedToChip(true);
+      } else if (tier === "mobile" && mobileSheetState !== "collapsed") {
+        setMobileSheetState("collapsed");
+      } else {
+        closeGuide();
+      }
+    }
+    document.addEventListener("keydown", handleKeydown);
+    return () => document.removeEventListener("keydown", handleKeydown);
+  }, [open, tier, collapsedToChip, mobileSheetState, closeGuide]);
+
+  useEffect(() => {
+    if (!pendingTarget.current) return;
+    const target = pendingTarget.current;
+    pendingTarget.current = null;
+    const raf = requestAnimationFrame(() => highlightTarget(target));
+    return () => cancelAnimationFrame(raf);
+  }, [location.pathname]);
+
+  if (!open) return null;
+
+  function goToStepRoute() {
+    pendingTarget.current = step.target ?? null;
+    navigate(step.route(manifest));
+    if (tier === "standard") setCollapsedToChip(true);
+    if (tier === "mobile") setMobileSheetState("collapsed");
+  }
+
+  async function handleRestartDemo() {
+    setResetError(null);
+    setResetting(true);
+    try {
+      await api.post("/api/v1/demo/reset");
+      restart();
+      refresh();
+      closeGuide();
+      await logout();
+      navigate("/login");
+    } catch (err) {
+      setResetError(err instanceof ApiError ? err.message : t("guide.restartFailed"));
+    } finally {
+      setResetting(false);
+    }
+  }
+
+  if (tier === "standard" && collapsedToChip) {
+    return (
+      <div className="demo-guide-chip">
+        <button
+          type="button"
+          className="demo-guide-chip-expand"
+          onClick={() => setCollapsedToChip(false)}
+          aria-label={`${t("guide.progressChip", { current: currentIndex + 1, total: totalSteps })}, ${t("guide.expand")}`}
+        >
+          <Icon name="spark" />
+          {t("guide.progressChip", { current: currentIndex + 1, total: totalSteps })}
+          <Icon name="chevron" />
+        </button>
+        <button type="button" className="demo-guide-chip-close" onClick={closeGuide} aria-label={t("guide.close")}>
+          <Icon name="x" />
+        </button>
+      </div>
+    );
+  }
+
+  const panelClassName = [
+    "demo-guide-panel",
+    tier === "wide" ? "is-wide" : "",
+    tier === "mobile" ? `is-mobile sheet-${mobileSheetState}` : "",
+  ]
+    .filter(Boolean)
+    .join(" ");
+
+  return (
+    <aside className={panelClassName} role="dialog" aria-label={t("guide.dialogLabel")}>
+      {tier === "mobile" && (
+        <button
+          type="button"
+          className="demo-guide-sheet-handle"
+          onClick={() =>
+            setMobileSheetState((s) => (s === "collapsed" ? "half" : s === "half" ? "full" : "collapsed"))
+          }
+          aria-label={
+            mobileSheetState === "full"
+              ? t("guide.collapse")
+              : t("guide.expand")
+          }
+        >
+          <span aria-hidden="true" />
+        </button>
+      )}
+
+      <header className="demo-guide-header">
+        <div>
+          <p className="demo-guide-kicker">{t("guide.kicker", { current: currentIndex + 1, total: totalSteps })}</p>
+          <h2>{t(`guide.steps.${step.id}.title`)}</h2>
+        </div>
+        {tier !== "mobile" && (
+          <button
+            type="button"
+            className="icon-button"
+            onClick={tier === "standard" ? () => setCollapsedToChip(true) : closeGuide}
+            aria-label={tier === "standard" ? t("guide.collapse") : t("guide.close")}
+          >
+            <Icon name="x" />
+          </button>
+        )}
+      </header>
+
+      {mobileSheetState !== "collapsed" && (
+        <>
+          <div className="demo-guide-progress-bar" aria-hidden="true">
+            {DEMO_GUIDE_STEPS.map((s, index) => (
+              <span
+                key={s.id}
+                className={
+                  index === currentIndex ? "is-current" : completed.has(s.id) ? "is-done" : ""
+                }
+              />
+            ))}
+          </div>
+
+          {(mobileSheetState !== "half" || tier !== "mobile") && (
+            <div className="demo-guide-body">
+              <p><strong>{t("guide.whatYouWillSee")}</strong><br />{t(`guide.steps.${step.id}.whatYouWillSee`)}</p>
+              <p><strong>{t("guide.whyItMatters")}</strong><br />{t(`guide.steps.${step.id}.whyItMatters`)}</p>
+              <p><strong>{t("guide.startAction")}</strong><br />{t(`guide.steps.${step.id}.startAction`)}</p>
+              <p><strong>{t("guide.expectedOutcome")}</strong><br />{t(`guide.steps.${step.id}.expectedOutcome`)}</p>
+            </div>
+          )}
+
+          {tier !== "mobile" && (
+            <nav className="demo-guide-steps" aria-label={t("guide.allStepsLabel")}>
+              {DEMO_GUIDE_STEPS.map((s, index) => (
+                <button
+                  key={s.id}
+                  type="button"
+                  className={index === currentIndex ? "is-current" : ""}
+                  onClick={() => goToStep(index)}
+                >
+                  {completed.has(s.id) && <Icon name="check" />}
+                  {t(`guide.steps.${s.id}.title`)}
+                </button>
+              ))}
+            </nav>
+          )}
+
+          {resetError && <p className="error" role="alert">{resetError}</p>}
+
+          <footer className="demo-guide-footer">
+            <button type="button" className="button button-secondary" onClick={goToStepRoute}>
+              {t("guide.goToStep")}
+            </button>
+            <button type="button" className="button button-primary" onClick={completeAndAdvance} disabled={isLastStep}>
+              {t("guide.next")}
+            </button>
+            {tier !== "mobile" && (
+              <button type="button" className="demo-guide-restart" onClick={handleRestartDemo} disabled={resetting}>
+                {resetting ? t("guide.restarting") : t("guide.restart")}
+              </button>
+            )}
+          </footer>
+        </>
+      )}
+    </aside>
+  );
+}
diff --git a/frontend/src/components/LanguageSwitcher.tsx b/frontend/src/components/LanguageSwitcher.tsx
new file mode 100644
index 0000000..1d07142
--- /dev/null
+++ b/frontend/src/components/LanguageSwitcher.tsx
@@ -0,0 +1,33 @@
+import { useTranslation } from "react-i18next";
+import {
+  persistLanguage,
+  SUPPORTED_LANGUAGES,
+  type SupportedLanguage,
+} from "../i18n/config";
+
+export function LanguageSwitcher({ compact = false }: { compact?: boolean }) {
+  const { t, i18n } = useTranslation("common");
+  const current = (i18n.language as SupportedLanguage) || "nl-BE";
+
+  function handleChange(next: SupportedLanguage) {
+    void i18n.changeLanguage(next);
+    persistLanguage(next);
+  }
+
+  return (
+    <label className={`language-switcher ${compact ? "language-switcher-compact" : ""}`}>
+      <span className="visually-hidden">{t("language.label")}</span>
+      <select
+        value={current}
+        onChange={(event) => handleChange(event.target.value as SupportedLanguage)}
+        aria-label={t("language.label")}
+      >
+        {SUPPORTED_LANGUAGES.map((lang) => (
+          <option key={lang} value={lang}>
+            {t(`language.${lang}`)}
+          </option>
+        ))}
+      </select>
+    </label>
+  );
+}
diff --git a/frontend/src/components/Layout.tsx b/frontend/src/components/Layout.tsx
index fd109eb..1aa6907 100644
--- a/frontend/src/components/Layout.tsx
+++ b/frontend/src/components/Layout.tsx
@@ -1,9 +1,15 @@
 import { useEffect, useMemo, useRef, useState, type KeyboardEvent as ReactKeyboardEvent } from "react";
 import { NavLink, Outlet, useNavigate } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api, ApiError } from "../api/client";
 import { useAuth } from "../context/AuthContext";
 import type { Role, SearchResultItem } from "../api/types";
 import { BrandMark, Icon, type IconName } from "./Icons";
+import { DemoBadge } from "./DemoBadge";
+import { DemoGuide, DemoGuideTrigger } from "./DemoGuide";
+import { LanguageSwitcher } from "./LanguageSwitcher";
+import { useDemoGuide } from "../context/DemoGuideContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
 
 const SEARCH_ICON: Record<SearchResultItem["type"], IconName> = {
   vehicle: "fleet",
@@ -14,34 +20,36 @@ const SEARCH_ICON: Record<SearchResultItem["type"], IconName> = {
 
 interface NavItem {
   to: string;
-  label: string;
-  shortLabel: string;
+  labelKey: string;
   icon: IconName;
   roles?: Role[];
 }
 
-const NAV_GROUPS: Array<{ label: string; items: NavItem[] }> = [
+const NAV_GROUPS: Array<{ labelKey: string; items: NavItem[] }> = [
   {
-    label: "Operate",
+    labelKey: "groups.operate",
     items: [
-      { to: "/dashboard", label: "Overview", shortLabel: "Overview", icon: "activity" },
-      { to: "/vehicles", label: "Fleet", shortLabel: "Fleet", icon: "fleet" },
-      { to: "/bookings", label: "Bookings", shortLabel: "Bookings", icon: "bookings" },
-      { to: "/data-quality", label: "Data quality", shortLabel: "Quality", icon: "quality", roles: ["operations_manager"] },
+      { to: "/dashboard", labelKey: "items.overview", icon: "activity" },
+      { to: "/vehicles", labelKey: "items.fleet", icon: "fleet" },
+      { to: "/bookings", labelKey: "items.bookings", icon: "bookings" },
+      { to: "/data-quality", labelKey: "items.quality", icon: "quality", roles: ["operations_manager"] },
     ],
   },
   {
-    label: "Assure",
+    labelKey: "groups.assure",
     items: [
-      { to: "/knowledge", label: "Knowledge", shortLabel: "Knowledge", icon: "knowledge" },
-      { to: "/automation", label: "Integrations", shortLabel: "Systems", icon: "integrations", roles: ["operations_manager"] },
-      { to: "/audit", label: "Audit trail", shortLabel: "Audit", icon: "audit", roles: ["operations_manager"] },
+      { to: "/knowledge", labelKey: "items.knowledge", icon: "knowledge" },
+      { to: "/automation", labelKey: "items.integrations", icon: "integrations", roles: ["operations_manager"] },
+      { to: "/audit", labelKey: "items.audit", icon: "audit", roles: ["operations_manager"] },
     ],
   },
 ];
 
 export function Layout() {
+  const { t } = useTranslation(["navigation", "common", "auth"]);
   const { user, logout } = useAuth();
+  const { manifest } = useDemoManifest();
+  const { open: guideOpen, collapsedToChip: guideCollapsed } = useDemoGuide();
   const navigate = useNavigate();
   const [mobileOpen, setMobileOpen] = useState(false);
   const [searchQuery, setSearchQuery] = useState("");
@@ -129,7 +137,7 @@ export function Layout() {
       await logout();
       navigate("/login");
     } catch (err) {
-      setResetError(err instanceof ApiError ? err.message : "Could not reset demo data.");
+      setResetError(err instanceof ApiError ? err.message : t("resetFailed"));
       setResetConfirming(false);
     } finally {
       setResetting(false);
@@ -164,23 +172,26 @@ export function Layout() {
 
   return (
     <div className="app-shell">
-      <a className="skip-link" href="#main-content">Skip to main content</a>
+      <a className="skip-link" href="#main-content">{t("skipToContent")}</a>
 
       <aside className={`sidebar ${mobileOpen ? "is-open" : ""}`}>
         <div className="brand-lockup">
           <BrandMark className="brand-mark" />
-          <div><strong>MobilityOps</strong><span>Control centre</span></div>
+          <div><strong>{t("common:appName")}</strong><span>{t("common:brandTagline")}</span></div>
         </div>
-        <nav aria-label="Primary navigation">
+        <div className="sidebar-language">
+          <LanguageSwitcher />
+        </div>
+        <nav aria-label={t("primaryNavLabel")}>
           {navGroups.map((group) => (
-            <div className="nav-group" key={group.label}>
-              <p>{group.label}</p>
+            <div className="nav-group" key={group.labelKey}>
+              <p>{t(group.labelKey)}</p>
               <ul>
                 {group.items.map((item) => (
                   <li key={item.to}>
                     <NavLink to={item.to} onClick={() => setMobileOpen(false)}>
                       <Icon name={item.icon} />
-                      <span>{item.label}</span>
+                      <span>{t(item.labelKey)}</span>
                     </NavLink>
                   </li>
                 ))}
@@ -190,23 +201,23 @@ export function Layout() {
         </nav>
         <div className="sidebar-foot">
           <span className="environment-dot" />
-          <div><strong>Demo environment</strong><span>Synthetic data only</span></div>
+          <div><strong>{t("sidebarEnvironment")}</strong><span>{t("sidebarEnvironmentDetail")}</span></div>
         </div>
-        {user?.role === "operations_manager" && (
+        {user?.role === "operations_manager" && manifest?.allow_reset !== false && (
           <div className="sidebar-reset">
             {resetError && <p className="error" role="alert">{resetError}</p>}
             {!resetConfirming ? (
               <button type="button" className="button button-secondary" onClick={() => setResetConfirming(true)}>
-                Reset demo data
+                {t("resetDemoData")}
               </button>
             ) : (
-              <div className="confirm-bar" role="alertdialog" aria-label="Confirm demo reset">
-                <p>All synthetic changes will be discarded and deterministic demo data restored. You will be signed out.</p>
+              <div className="confirm-bar" role="alertdialog" aria-label={t("resetConfirmTitle")}>
+                <p>{t("resetConfirmBody")}</p>
                 <button type="button" onClick={handleDemoReset} disabled={resetting}>
-                  {resetting ? "Resetting…" : "Yes, reset"}
+                  {resetting ? t("resetting") : t("resetConfirmYes")}
                 </button>
                 <button type="button" onClick={() => setResetConfirming(false)} disabled={resetting}>
-                  Cancel
+                  {t("resetCancel")}
                 </button>
               </div>
             )}
@@ -214,16 +225,16 @@ export function Layout() {
         )}
       </aside>
 
-      {mobileOpen && <button className="nav-scrim" aria-label="Close navigation" onClick={() => setMobileOpen(false)} />}
+      {mobileOpen && <button className="nav-scrim" aria-label={t("closeNavigation")} onClick={() => setMobileOpen(false)} />}
 
-      <div className="app-workspace">
+      <div className={`app-workspace ${guideOpen ? "guide-open" : ""} ${guideOpen && guideCollapsed ? "guide-collapsed" : ""}`}>
         <header className="topbar">
-          <button className="icon-button mobile-menu" type="button" onClick={() => setMobileOpen(true)} aria-label="Open navigation">
+          <button className="icon-button mobile-menu" type="button" onClick={() => setMobileOpen(true)} aria-label={t("openNavigation")}>
             <Icon name="menu" />
           </button>
           <div className="global-search" role="search" ref={searchBox}>
             <Icon name="search" />
-            <label className="visually-hidden" htmlFor="global-search-input">Search MobilityOps</label>
+            <label className="visually-hidden" htmlFor="global-search-input">{t("searchLabel")}</label>
             <input
               id="global-search-input"
               ref={searchInput}
@@ -234,7 +245,7 @@ export function Layout() {
               aria-autocomplete="list"
               aria-activedescendant={activeIndex >= 0 ? `search-result-${activeIndex}` : undefined}
               value={searchQuery}
-              placeholder="Search fleet, booking or section…"
+              placeholder={t("searchPlaceholder")}
               onFocus={() => setSearchOpen(true)}
               onChange={(event) => {
                 setSearchQuery(event.target.value);
@@ -242,13 +253,13 @@ export function Layout() {
               }}
               onKeyDown={handleSearchKeyDown}
             />
-            <kbd>Ctrl K</kbd>
+            <kbd>{t("searchShortcutHint")}</kbd>
             {searchOpen && searchQuery.trim() && (
               <div className="search-results" id="global-search-results" role="listbox">
-                {searchLoading && <p className="search-status">Searching…</p>}
-                {!searchLoading && searchError && <p className="search-status">Search is unavailable right now.</p>}
+                {searchLoading && <p className="search-status">{t("searchSearching")}</p>}
+                {!searchLoading && searchError && <p className="search-status">{t("searchUnavailable")}</p>}
                 {!searchLoading && !searchError && searchResults.length === 0 && (
-                  <p className="search-status">No matches for "{searchQuery.trim()}".</p>
+                  <p className="search-status">{t("searchNoResults", { query: searchQuery.trim() })}</p>
                 )}
                 {!searchLoading &&
                   !searchError &&
@@ -274,36 +285,40 @@ export function Layout() {
             )}
           </div>
           <div className="topbar-meta">
-            <span className="timezone"><Icon name="clock" /> Europe/Brussels</span>
+            <LanguageSwitcher compact />
+            <DemoGuideTrigger />
+            <DemoBadge />
+            <span className="timezone"><Icon name="clock" /> {t("common:timezone")}</span>
             {user && (
               <div className="operator">
                 <span className="avatar">{user.display_name.split(" ").map((name) => name[0]).join("").slice(0, 2)}</span>
-                <span><strong>{user.display_name}</strong><small>{user.role === "operations_manager" ? "Operations manager" : "Rental employee"}</small></span>
+                <span><strong>{user.display_name}</strong><small>{user.role === "operations_manager" ? t("auth:roleOperationsManager") : t("auth:roleRentalEmployee")}</small></span>
               </div>
             )}
-            <button className="icon-button" type="button" onClick={handleLogout} aria-label="Switch role" title="Switch demo role">
+            <button className="icon-button" type="button" onClick={handleLogout} aria-label={t("switchRole")} title={t("switchRoleTitle")}>
               <Icon name="logout" />
             </button>
           </div>
         </header>
 
-        <p className="demo-banner"><Icon name="shield" /> Synthetic demo data · no real customer or vehicle information</p>
         <main id="main-content" tabIndex={-1}><Outlet /></main>
-        <footer className="app-footer"><span>MobilityOps PoC</span><span>Europe/Brussels · Synthetic demo data</span></footer>
+        <footer className="app-footer"><span>{t("common:footer.productLine")}</span><span>{t("common:footer.locale")}</span></footer>
       </div>
 
-      <nav className="mobile-nav" aria-label="Mobile navigation">
+      <nav className="mobile-nav" aria-label={t("mobileNavLabel")}>
         {mobileItems.map((item) => (
           <NavLink key={item.to} to={item.to}>
             <Icon name={item.icon} />
-            <span>{item.shortLabel}</span>
+            <span>{t(item.labelKey)}</span>
           </NavLink>
         ))}
         <button type="button" onClick={() => setMobileOpen(true)}>
           <Icon name="menu" />
-          <span>More</span>
+          <span>{t("more")}</span>
         </button>
       </nav>
+
+      <DemoGuide />
     </div>
   );
 }
diff --git a/frontend/src/components/PageChrome.tsx b/frontend/src/components/PageChrome.tsx
index c2eb648..acad7a3 100644
--- a/frontend/src/components/PageChrome.tsx
+++ b/frontend/src/components/PageChrome.tsx
@@ -1,4 +1,5 @@
 import type { ReactNode } from "react";
+import { useTranslation } from "react-i18next";
 import { Icon, type IconName } from "./Icons";
 
 export function PageHeader({
@@ -28,15 +29,17 @@ export function SectionHeading({
   title,
   description,
   action,
+  headingId,
 }: {
   title: string;
   description?: string;
   action?: ReactNode;
+  headingId?: string;
 }) {
   return (
     <div className="section-heading">
       <div>
-        <h2>{title}</h2>
+        <h2 id={headingId}>{title}</h2>
         {description && <p>{description}</p>}
       </div>
       {action}
@@ -44,20 +47,22 @@ export function SectionHeading({
   );
 }
 
-export function LoadingState({ label = "Loading workspace…" }: { label?: string }) {
+export function LoadingState({ label }: { label?: string }) {
+  const { t } = useTranslation("common");
   return (
     <div className="state-panel" role="status">
       <span className="spinner" aria-hidden="true" />
-      <p>{label}</p>
+      <p>{label ?? t("states.loadingDefault")}</p>
     </div>
   );
 }
 
 export function ErrorState({ message }: { message: string }) {
+  const { t } = useTranslation("common");
   return (
     <div className="state-panel state-error" role="alert">
       <Icon name="alert" />
-      <div><strong>We couldn’t load this workspace.</strong><p>{message}</p></div>
+      <div><strong>{t("states.errorTitle")}</strong><p>{message}</p></div>
     </div>
   );
 }
diff --git a/frontend/src/components/RequireAuth.tsx b/frontend/src/components/RequireAuth.tsx
index d967baf..6330da7 100644
--- a/frontend/src/components/RequireAuth.tsx
+++ b/frontend/src/components/RequireAuth.tsx
@@ -8,7 +8,7 @@ export function RequireAuth({ children }: { children: ReactNode }) {
   if (loading) {
     return (
       <div className="page">
-        <LoadingState label="Verifying session…" />
+        <LoadingState />
       </div>
     );
   }
diff --git a/frontend/src/components/ReturnForm.tsx b/frontend/src/components/ReturnForm.tsx
index 1ef68bc..724504f 100644
--- a/frontend/src/components/ReturnForm.tsx
+++ b/frontend/src/components/ReturnForm.tsx
@@ -1,8 +1,13 @@
 import { useState, type FormEvent } from "react";
-import { Link } from "react-router-dom";
+import { Link, useNavigate } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api, ApiError } from "../api/client";
 import type { RegisterReturnRequest, RegisterReturnResult, ReturnPreviewResult } from "../api/types";
 import { useAuth } from "../context/AuthContext";
+import { useDemoGuide } from "../context/DemoGuideContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { useLocaleFormat } from "../i18n/format";
+import { DEMO_GUIDE_STEPS } from "../data/demoGuideSteps";
 import { Icon } from "./Icons";
 import { StatusBadge } from "./Badge";
 
@@ -13,16 +18,27 @@ function newIdempotencyKey(): string {
 }
 
 export function ReturnResultPanel({ result }: { result: RegisterReturnResult }) {
+  const { t } = useTranslation("returns");
   const { user } = useAuth();
+  const navigate = useNavigate();
+  const { manifest } = useDemoManifest();
+  const { open: guideOpen, currentIndex, completeAndAdvance } = useDemoGuide();
   const canSeeQualityIssue = user?.role === "operations_manager";
+
+  function continueDemo() {
+    completeAndAdvance();
+    const nextIndex = Math.min(currentIndex + 1, DEMO_GUIDE_STEPS.length - 1);
+    navigate(DEMO_GUIDE_STEPS[nextIndex].route(manifest));
+  }
+
   return (
     <section className="panel return-result success-panel" aria-labelledby="return-result-heading" aria-live="polite">
-      <div className="result-heading"><span><Icon name="check" /></span><div><p className="page-eyebrow">Committed locally</p><h2 id="return-result-heading">Return registered</h2></div></div>
+      <div className="result-heading"><span><Icon name="check" /></span><div><p className="page-eyebrow">{t("result.committedLocally")}</p><h2 id="return-result-heading">{t("result.heading")}</h2></div></div>
       <dl className="detail-grid">
-        <div><dt>Inspection</dt><dd>{result.inspection_ref}</dd></div>
-        <div><dt>Resulting vehicle status</dt><dd><StatusBadge status={result.resulting_vehicle_status} /></dd></div>
+        <div><dt>{t("result.inspection")}</dt><dd>{result.inspection_ref}</dd></div>
+        <div><dt>{t("result.resultingStatus")}</dt><dd><StatusBadge status={result.resulting_vehicle_status} label={t(`fleet:statuses.${result.resulting_vehicle_status}`, { defaultValue: result.resulting_vehicle_status })} /></dd></div>
         <div>
-          <dt>Quality issue</dt>
+          <dt>{t("result.qualityIssue")}</dt>
           <dd>
             {result.quality_issue_ref ? (
               canSeeQualityIssue ? (
@@ -31,36 +47,39 @@ export function ReturnResultPanel({ result }: { result: RegisterReturnResult })
                 result.quality_issue_ref
               )
             ) : (
-              "None created"
+              t("result.noneCreated")
             )}
           </dd>
         </div>
         <div>
-          <dt>Automation event</dt>
-          <dd>
-            Queued for delivery ({result.workflow_event_id.slice(0, 8)}) — local commit succeeded;
-            n8n delivery is asynchronous and not yet confirmed.
-          </dd>
+          <dt>{t("result.automationEvent")}</dt>
+          <dd>{t("result.queuedForDelivery", { ref: result.workflow_event_id.slice(0, 8) })}</dd>
         </div>
         <div>
-          <dt>Next booking risk</dt>
+          <dt>{t("result.nextBookingRisk")}</dt>
           <dd>
             {result.next_booking_risk
-              ? `${result.next_booking_risk.booking_ref} ${result.next_booking_risk.at_risk ? "— may be affected" : "— low risk"}`
-              : "No upcoming booking for this vehicle"}
+              ? t("result.nextBookingRiskValue", {
+                  ref: result.next_booking_risk.booking_ref,
+                  status: result.next_booking_risk.at_risk ? t("result.atRisk") : t("result.lowRisk"),
+                })
+              : t("result.noUpcomingBooking")}
           </dd>
         </div>
       </dl>
       {result.odometer_regression && (
-        <p className="error" role="alert">
-          The submitted odometer reading was below the vehicle&apos;s canonical odometer. It was
-          recorded as-is; the canonical odometer was not changed, and a data-quality issue was
-          opened for review.
-        </p>
+        <p className="error" role="alert">{t("result.odometerRegressionNotice")}</p>
       )}
-      <p>
-        <Link className="button button-secondary" to={`/vehicles/${result.vehicle_ref}`}>View vehicle {result.vehicle_ref}<Icon name="chevron" /></Link>
-      </p>
+      <div className="result-links">
+        <Link className="button button-secondary" to={`/vehicles/${result.vehicle_ref}`}>{t("result.viewVehicle", { ref: result.vehicle_ref })}<Icon name="chevron" /></Link>
+        <Link className="button button-secondary" to="/automation">{t("result.viewAutomation")}<Icon name="chevron" /></Link>
+        <Link className="button button-secondary" to="/audit">{t("result.viewAudit")}<Icon name="chevron" /></Link>
+        {guideOpen && (
+          <button type="button" className="button button-primary" onClick={continueDemo}>
+            {t("result.continueDemo")} <Icon name="chevron" />
+          </button>
+        )}
+      </div>
     </section>
   );
 }
@@ -68,11 +87,15 @@ export function ReturnResultPanel({ result }: { result: RegisterReturnResult })
 export function ReturnForm({
   bookingRef,
   onRegistered,
+  suggestedOdometerKm,
 }: {
   bookingRef: string;
   onRegistered: (result: RegisterReturnResult) => void;
+  suggestedOdometerKm?: number;
 }) {
-  const [odometer, setOdometer] = useState("");
+  const { t } = useTranslation(["returns", "errors"]);
+  const { formatNumber, formatDateTime } = useLocaleFormat();
+  const [odometer, setOdometer] = useState(suggestedOdometerKm !== undefined ? String(suggestedOdometerKm) : "");
   const [fuel, setFuel] = useState("50");
   const [cleanlinessOk, setCleanlinessOk] = useState(true);
   const [damageReported, setDamageReported] = useState(false);
@@ -109,9 +132,7 @@ export function ReturnForm({
         setPreview(evaluated);
         setStep("review");
       } catch (err) {
-        setError(
-          err instanceof ApiError ? err.message : "Could not evaluate this return. Please try again.",
-        );
+        setError(err instanceof ApiError ? err.message : t("errors:generic"));
       } finally {
         setPreviewing(false);
       }
@@ -127,11 +148,7 @@ export function ReturnForm({
       );
       onRegistered(registered);
     } catch (err) {
-      if (err instanceof ApiError) {
-        setError(err.message);
-      } else {
-        setError("Could not register the return. Please try again.");
-      }
+      setError(err instanceof ApiError ? err.message : t("errors:generic"));
     } finally {
       setSubmitting(false);
     }
@@ -139,13 +156,13 @@ export function ReturnForm({
 
   return (
     <form className="panel return-form" onSubmit={handleSubmit} aria-labelledby="return-form-heading">
-      <div className="return-progress" aria-label="Return registration progress"><span className="is-complete"><i>1</i> Capture</span><b /><span className={step === "review" ? "is-active" : ""}><i>2</i> Review</span><b /><span><i>3</i> Result</span></div>
-      <div className="section-heading"><div><p className="page-eyebrow">Booking {bookingRef}</p><h2 id="return-form-heading">{step === "capture" ? "Register vehicle return" : "Review return impact"}</h2><p>{step === "capture" ? "Record the hand-back condition. The next step evaluates the exact operational consequences before anything is committed." : "This is the server's authoritative evaluation of what committing will do — confirm before it updates fleet state and queues automation."}</p></div></div>
+      <div className="return-progress" aria-label={t("progress.ariaLabel")}><span className="is-complete"><i>1</i> {t("progress.capture")}</span><b /><span className={step === "review" ? "is-active" : ""}><i>2</i> {t("progress.review")}</span><b /><span><i>3</i> {t("progress.result")}</span></div>
+      <div className="section-heading"><div><p className="page-eyebrow">{bookingRef}</p><h2 id="return-form-heading">{step === "capture" ? t("capture.heading") : t("review.heading")}</h2><p>{step === "capture" ? t("capture.description") : t("review.description")}</p></div></div>
       {error && <p className="error" role="alert">{error}</p>}
 
       {step === "capture" ? <div className="return-capture">
       <div className="form-grid"><label>
-        End odometer (km)
+        {t("capture.endOdometer")}
         <input
           type="number"
           required
@@ -156,7 +173,7 @@ export function ReturnForm({
       </label>
 
       <label>
-        Fuel level (%)
+        {t("capture.fuelLevel")}
         <input
           type="number"
           required
@@ -167,13 +184,13 @@ export function ReturnForm({
         />
       </label></div>
 
-      <fieldset className="condition-fieldset"><legend>Vehicle condition</legend><label className="checkbox-label check-card">
+      <fieldset className="condition-fieldset"><legend>{t("capture.conditionLegend")}</legend><label className="checkbox-label check-card">
         <input
           type="checkbox"
           checked={cleanlinessOk}
           onChange={(e) => setCleanlinessOk(e.target.checked)}
         />
-        Cleanliness acceptable
+        {t("capture.cleanlinessOk")}
       </label>
 
       <label className="checkbox-label check-card">
@@ -182,7 +199,7 @@ export function ReturnForm({
           checked={damageReported}
           onChange={(e) => setDamageReported(e.target.checked)}
         />
-        Damage reported
+        {t("capture.damageReported")}
       </label>
 
       <label className="checkbox-label check-card">
@@ -191,48 +208,50 @@ export function ReturnForm({
           checked={technicalWarning}
           onChange={(e) => setTechnicalWarning(e.target.checked)}
         />
-        Technical warning
+        {t("capture.technicalWarning")}
       </label></fieldset>
 
       <label>
-        Notes
+        {t("capture.notes")}
         <textarea value={notes} onChange={(e) => setNotes(e.target.value)} maxLength={2000} rows={3} />
       </label></div> : preview && <div className="return-review" aria-live="polite">
-        <dl className="review-facts"><div><dt>Odometer</dt><dd>{Number(odometer).toLocaleString("en-GB")} km</dd></div><div><dt>Fuel</dt><dd>{fuel}%</dd></div><div><dt>Cleanliness</dt><dd>{cleanlinessOk ? "Accepted" : "Follow-up needed"}</dd></div><div><dt>Damage</dt><dd>{damageReported ? "Reported" : "None reported"}</dd></div><div><dt>Technical warning</dt><dd>{technicalWarning ? "Reported" : "None reported"}</dd></div></dl>
+        <dl className="review-facts"><div><dt>{t("review.odometer")}</dt><dd>{formatNumber(Number(odometer))} km</dd></div><div><dt>{t("review.fuel")}</dt><dd>{fuel}%</dd></div><div><dt>{t("review.cleanliness")}</dt><dd>{cleanlinessOk ? t("review.cleanlinessAccepted") : t("review.cleanlinessFollowUp")}</dd></div><div><dt>{t("review.damage")}</dt><dd>{damageReported ? t("review.damageReported") : t("review.damageNone")}</dd></div><div><dt>{t("review.technicalWarning")}</dt><dd>{technicalWarning ? t("review.technicalWarningReported") : t("review.technicalWarningNone")}</dd></div></dl>
         <div className={`impact-preview ${preview.attention_reasons.length > 0 ? "impact-warning" : "impact-ready"}`}>
           <Icon name={preview.attention_reasons.length > 0 ? "alert" : "check"} />
           <div>
-            <strong>Expected fleet state: <StatusBadge status={preview.resulting_vehicle_status} /></strong>
+            <strong>{t("review.expectedState")} <StatusBadge status={preview.resulting_vehicle_status} label={t(`fleet:statuses.${preview.resulting_vehicle_status}`, { defaultValue: preview.resulting_vehicle_status })} /></strong>
             <p>{preview.status_reason}</p>
           </div>
         </div>
         {preview.odometer_regression && (
           <p className="error" role="alert">
-            Submitted odometer ({preview.submitted_odometer_km.toLocaleString("en-GB")} km) is below
-            the canonical reading ({preview.canonical_odometer_km.toLocaleString("en-GB")} km). The
-            canonical odometer will not change, and a data-quality issue will be opened.
+            {t("review.odometerRegressionWarning", {
+              submitted: formatNumber(preview.submitted_odometer_km),
+              canonical: formatNumber(preview.canonical_odometer_km),
+            })}
           </p>
         )}
         {preview.next_booking_risk && (
           <p className={preview.next_booking_risk.at_risk ? "error" : undefined} role={preview.next_booking_risk.at_risk ? "alert" : undefined}>
-            Next booking {preview.next_booking_risk.booking_ref} starts{" "}
-            {new Date(preview.next_booking_risk.starts_at).toLocaleString("en-GB", { timeZone: "Europe/Brussels" })}
-            {preview.next_booking_risk.at_risk ? " — may be affected by this return." : " — low risk."}
+            {t(preview.next_booking_risk.at_risk ? "review.nextBookingRisk" : "review.nextBookingLowRisk", {
+              ref: preview.next_booking_risk.booking_ref,
+              when: formatDateTime(preview.next_booking_risk.starts_at),
+            })}
           </p>
         )}
-        <ul className="commit-list"><li><Icon name="check" /> Create a return inspection</li><li><Icon name="check" /> Update the booking and vehicle atomically</li><li><Icon name="check" /> Queue n8n delivery after the local commit</li></ul>
+        <ul className="commit-list"><li><Icon name="check" /> {t("review.commitList.inspection")}</li><li><Icon name="check" /> {t("review.commitList.updateAtomic")}</li><li><Icon name="check" /> {t("review.commitList.queueAutomation")}</li></ul>
       </div>}
 
       <div className="form-actions">
-        {step === "review" && <button className="button button-secondary" type="button" onClick={() => setStep("capture")} disabled={submitting}><Icon name="arrow-left" /> Edit details</button>}
+        {step === "review" && <button className="button button-secondary" type="button" onClick={() => setStep("capture")} disabled={submitting}><Icon name="arrow-left" /> {t("review.editDetails")}</button>}
         <button className="button button-primary" type="submit" disabled={submitting || previewing}>
           {step === "capture"
             ? previewing
-              ? "Evaluating…"
-              : "Review return"
+              ? t("capture.evaluating")
+              : t("capture.reviewReturn")
             : submitting
-              ? "Registering…"
-              : "Confirm return"}{" "}
+              ? t("review.registering")
+              : t("review.confirmReturn")}{" "}
           {step === "capture" && !previewing && <Icon name="chevron" />}
         </button>
       </div>
diff --git a/frontend/src/context/DemoGuideContext.tsx b/frontend/src/context/DemoGuideContext.tsx
new file mode 100644
index 0000000..b1271c2
--- /dev/null
+++ b/frontend/src/context/DemoGuideContext.tsx
@@ -0,0 +1,117 @@
+import { createContext, useCallback, useContext, useEffect, useState, type ReactNode } from "react";
+import { DEMO_GUIDE_STEPS } from "../data/demoGuideSteps";
+
+const STORAGE_KEY = "mobilityops.demo-guide-progress";
+
+interface StoredProgress {
+  currentIndex: number;
+  completed: string[];
+}
+
+function readProgress(): StoredProgress {
+  try {
+    const raw = sessionStorage.getItem(STORAGE_KEY);
+    if (!raw) return { currentIndex: 0, completed: [] };
+    const parsed = JSON.parse(raw) as StoredProgress;
+    return { currentIndex: parsed.currentIndex ?? 0, completed: parsed.completed ?? [] };
+  } catch {
+    return { currentIndex: 0, completed: [] };
+  }
+}
+
+function writeProgress(progress: StoredProgress) {
+  sessionStorage.setItem(STORAGE_KEY, JSON.stringify(progress));
+}
+
+interface DemoGuideState {
+  open: boolean;
+  currentIndex: number;
+  completed: Set<string>;
+  totalSteps: number;
+  collapsedToChip: boolean;
+  setCollapsedToChip: (value: boolean) => void;
+  openGuide: () => void;
+  closeGuide: () => void;
+  toggleGuide: () => void;
+  goToStep: (index: number) => void;
+  completeAndAdvance: () => void;
+  restart: () => void;
+}
+
+const DemoGuideContext = createContext<DemoGuideState | undefined>(undefined);
+
+export function DemoGuideProvider({ children }: { children: ReactNode }) {
+  const [open, setOpen] = useState(false);
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const [completed, setCompleted] = useState<Set<string>>(new Set());
+  const [collapsedToChip, setCollapsedToChip] = useState(false);
+
+  useEffect(() => {
+    const stored = readProgress();
+    setCurrentIndex(stored.currentIndex);
+    setCompleted(new Set(stored.completed));
+  }, []);
+
+  const persist = useCallback((index: number, done: Set<string>) => {
+    writeProgress({ currentIndex: index, completed: Array.from(done) });
+  }, []);
+
+  const goToStep = useCallback(
+    (index: number) => {
+      const clamped = Math.max(0, Math.min(index, DEMO_GUIDE_STEPS.length - 1));
+      setCurrentIndex(clamped);
+      persist(clamped, completed);
+    },
+    [completed, persist],
+  );
+
+  const completeAndAdvance = useCallback(() => {
+    setCompleted((prev) => {
+      const next = new Set(prev);
+      next.add(DEMO_GUIDE_STEPS[currentIndex].id);
+      const nextIndex = Math.min(currentIndex + 1, DEMO_GUIDE_STEPS.length - 1);
+      persist(nextIndex, next);
+      setCurrentIndex(nextIndex);
+      return next;
+    });
+  }, [currentIndex, persist]);
+
+  const restart = useCallback(() => {
+    setCurrentIndex(0);
+    setCompleted(new Set());
+    writeProgress({ currentIndex: 0, completed: [] });
+  }, []);
+
+  return (
+    <DemoGuideContext.Provider
+      value={{
+        open,
+        currentIndex,
+        completed,
+        totalSteps: DEMO_GUIDE_STEPS.length,
+        collapsedToChip,
+        setCollapsedToChip,
+        openGuide: () => {
+          setCollapsedToChip(false);
+          setOpen(true);
+        },
+        closeGuide: () => setOpen(false),
+        toggleGuide: () => {
+          setCollapsedToChip(false);
+          setOpen((v) => !v);
+        },
+        goToStep,
+        completeAndAdvance,
+        restart,
+      }}
+    >
+      {children}
+    </DemoGuideContext.Provider>
+  );
+}
+
+export function useDemoGuide(): DemoGuideState {
+  const ctx = useContext(DemoGuideContext);
+  if (!ctx) throw new Error("useDemoGuide must be used within DemoGuideProvider");
+  return ctx;
+}
diff --git a/frontend/src/context/DemoManifestContext.tsx b/frontend/src/context/DemoManifestContext.tsx
new file mode 100644
index 0000000..74b02a3
--- /dev/null
+++ b/frontend/src/context/DemoManifestContext.tsx
@@ -0,0 +1,52 @@
+import { createContext, useContext, useEffect, useState, type ReactNode } from "react";
+import { api } from "../api/client";
+import type { DemoManifest } from "../api/types";
+
+interface DemoManifestState {
+  manifest: DemoManifest | null;
+  loading: boolean;
+  refresh: () => void;
+}
+
+const DemoManifestContext = createContext<DemoManifestState | undefined>(undefined);
+
+export function DemoManifestProvider({ children }: { children: ReactNode }) {
+  const [manifest, setManifest] = useState<DemoManifest | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [version, setVersion] = useState(0);
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    // Public endpoint by design: the demo-entry screen needs this before any session
+    // exists, so it is never gated behind auth.
+    api
+      .get<DemoManifest>("/api/v1/demo/manifest")
+      .then((result) => {
+        if (!cancelled) setManifest(result);
+      })
+      .catch(() => {
+        if (!cancelled) setManifest(null);
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [version]);
+
+  return (
+    <DemoManifestContext.Provider
+      value={{ manifest, loading, refresh: () => setVersion((v) => v + 1) }}
+    >
+      {children}
+    </DemoManifestContext.Provider>
+  );
+}
+
+export function useDemoManifest(): DemoManifestState {
+  const ctx = useContext(DemoManifestContext);
+  if (!ctx) throw new Error("useDemoManifest must be used within DemoManifestProvider");
+  return ctx;
+}
diff --git a/frontend/src/data/demoGuideSteps.ts b/frontend/src/data/demoGuideSteps.ts
new file mode 100644
index 0000000..28f6e58
--- /dev/null
+++ b/frontend/src/data/demoGuideSteps.ts
@@ -0,0 +1,39 @@
+import type { DemoManifest } from "../api/types";
+
+export interface DemoGuideStep {
+  id: string;
+  /** Resolves the route to link to, using live manifest data where a scenario supplies
+   * a concrete record (booking/issue ref) instead of hardcoding one that could drift. */
+  route: (manifest: DemoManifest | null) => string;
+  /** CSS selector for the on-page element this step is about. After navigating, the guide
+   * scrolls it into view, moves keyboard focus to it and applies a brief highlight -- this
+   * only works because the target already carries a stable id/class in the page itself, so
+   * a missing target (selector not found post-navigation) is a silent no-op, never an error. */
+  target?: string;
+}
+
+export const DEMO_GUIDE_STEPS: DemoGuideStep[] = [
+  { id: "understand-state", route: () => "/dashboard", target: "#attention-heading" },
+  {
+    id: "open-booking",
+    route: (manifest) =>
+      manifest?.scenarios.find((s) => s.id === "return-anomaly")?.start_path ?? "/bookings",
+    target: ".record-surface",
+  },
+  {
+    id: "process-return",
+    route: (manifest) =>
+      manifest?.scenarios.find((s) => s.id === "return-anomaly")?.start_path ?? "/bookings",
+    target: "#return-form-heading",
+  },
+  { id: "handle-quality-issue", route: () => "/data-quality", target: ".table-shell" },
+  {
+    id: "merge-duplicate",
+    route: (manifest) =>
+      manifest?.scenarios.find((s) => s.id === "duplicate-customer")?.start_path ?? "/data-quality",
+    target: "#compare-heading",
+  },
+  { id: "ask-knowledge", route: () => "/knowledge", target: "#ask-heading" },
+  { id: "check-automation-audit", route: () => "/automation", target: ".integration-cards" },
+  { id: "review-real-vs-simulated", route: () => "/about", target: ".about-cta" },
+];
diff --git a/frontend/src/data/integrationLabels.ts b/frontend/src/data/integrationLabels.ts
new file mode 100644
index 0000000..ab07d26
--- /dev/null
+++ b/frontend/src/data/integrationLabels.ts
@@ -0,0 +1,19 @@
+import type { IntegrationStatus } from "../api/types";
+
+// Plain-language status per section 12 of the demo brief: a visitor shouldn't have to
+// decode raw backend state strings to tell whether an integration is actually working.
+// `statusClass` maps onto an existing `.status-*` CSS modifier so the badge keeps
+// correct colour-coding; `labelKey` resolves to a localized label via the
+// `integrations:statusLabels.*` namespace (see i18n/locales/*/integrations.json).
+export const N8N_STATE_META: Record<IntegrationStatus["n8n"]["state"], { statusClass: string; labelKey: string }> = {
+  disabled: { statusClass: "not_configured", labelKey: "notConnected" },
+  unavailable: { statusClass: "unavailable", labelKey: "deliveryFailed" },
+  degraded: { statusClass: "needs_attention", labelKey: "retryAvailable" },
+  operational: { statusClass: "available", labelKey: "operational" },
+  no_evidence: { statusClass: "no_events", labelKey: "prepared" },
+};
+
+export const MCP_STATE_META: Record<IntegrationStatus["mcp_hub"]["state"], { statusClass: string; labelKey: string }> = {
+  not_configured: { statusClass: "not_configured", labelKey: "notConnected" },
+  configured: { statusClass: "no_events", labelKey: "prepared" },
+};
diff --git a/frontend/src/hooks/useViewportTier.ts b/frontend/src/hooks/useViewportTier.ts
new file mode 100644
index 0000000..a606aaf
--- /dev/null
+++ b/frontend/src/hooks/useViewportTier.ts
@@ -0,0 +1,36 @@
+import { useEffect, useState } from "react";
+
+export type ViewportTier = "wide" | "standard" | "mobile";
+
+// Breakpoints reuse the app's existing, already-measured layout thresholds (see
+// styles.css): 700px is where the sidebar collapses into the mobile bottom nav, and
+// 1440px is the largest width in the project's own responsive test matrix -- chosen as
+// the "extra-wide desktop" floor rather than an arbitrary new number.
+const MOBILE_QUERY = "(max-width: 700px)";
+const WIDE_QUERY = "(min-width: 1440px)";
+
+function computeTier(): ViewportTier {
+  if (typeof window === "undefined") return "standard";
+  if (window.matchMedia(MOBILE_QUERY).matches) return "mobile";
+  if (window.matchMedia(WIDE_QUERY).matches) return "wide";
+  return "standard";
+}
+
+export function useViewportTier(): ViewportTier {
+  const [tier, setTier] = useState<ViewportTier>(computeTier);
+
+  useEffect(() => {
+    const mobile = window.matchMedia(MOBILE_QUERY);
+    const wide = window.matchMedia(WIDE_QUERY);
+    const update = () => setTier(computeTier());
+    mobile.addEventListener("change", update);
+    wide.addEventListener("change", update);
+    update();
+    return () => {
+      mobile.removeEventListener("change", update);
+      wide.removeEventListener("change", update);
+    };
+  }, []);
+
+  return tier;
+}
diff --git a/frontend/src/i18n/config.ts b/frontend/src/i18n/config.ts
new file mode 100644
index 0000000..56a5de2
--- /dev/null
+++ b/frontend/src/i18n/config.ts
@@ -0,0 +1,161 @@
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+
+import commonNl from "./locales/nl-BE/common.json";
+import authNl from "./locales/nl-BE/auth.json";
+import navigationNl from "./locales/nl-BE/navigation.json";
+import dashboardNl from "./locales/nl-BE/dashboard.json";
+import fleetNl from "./locales/nl-BE/fleet.json";
+import bookingsNl from "./locales/nl-BE/bookings.json";
+import returnsNl from "./locales/nl-BE/returns.json";
+import qualityNl from "./locales/nl-BE/quality.json";
+import knowledgeNl from "./locales/nl-BE/knowledge.json";
+import integrationsNl from "./locales/nl-BE/integrations.json";
+import auditNl from "./locales/nl-BE/audit.json";
+import demoNl from "./locales/nl-BE/demo.json";
+import errorsNl from "./locales/nl-BE/errors.json";
+import accessibilityNl from "./locales/nl-BE/accessibility.json";
+
+import commonEn from "./locales/en-GB/common.json";
+import authEn from "./locales/en-GB/auth.json";
+import navigationEn from "./locales/en-GB/navigation.json";
+import dashboardEn from "./locales/en-GB/dashboard.json";
+import fleetEn from "./locales/en-GB/fleet.json";
+import bookingsEn from "./locales/en-GB/bookings.json";
+import returnsEn from "./locales/en-GB/returns.json";
+import qualityEn from "./locales/en-GB/quality.json";
+import knowledgeEn from "./locales/en-GB/knowledge.json";
+import integrationsEn from "./locales/en-GB/integrations.json";
+import auditEn from "./locales/en-GB/audit.json";
+import demoEn from "./locales/en-GB/demo.json";
+import errorsEn from "./locales/en-GB/errors.json";
+import accessibilityEn from "./locales/en-GB/accessibility.json";
+
+import commonFr from "./locales/fr-BE/common.json";
+import authFr from "./locales/fr-BE/auth.json";
+import navigationFr from "./locales/fr-BE/navigation.json";
+import dashboardFr from "./locales/fr-BE/dashboard.json";
+import fleetFr from "./locales/fr-BE/fleet.json";
+import bookingsFr from "./locales/fr-BE/bookings.json";
+import returnsFr from "./locales/fr-BE/returns.json";
+import qualityFr from "./locales/fr-BE/quality.json";
+import knowledgeFr from "./locales/fr-BE/knowledge.json";
+import integrationsFr from "./locales/fr-BE/integrations.json";
+import auditFr from "./locales/fr-BE/audit.json";
+import demoFr from "./locales/fr-BE/demo.json";
+import errorsFr from "./locales/fr-BE/errors.json";
+import accessibilityFr from "./locales/fr-BE/accessibility.json";
+
+export const SUPPORTED_LANGUAGES = ["nl-BE", "en-GB", "fr-BE"] as const;
+export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+export const DEFAULT_LANGUAGE: SupportedLanguage = "nl-BE";
+export const LANGUAGE_STORAGE_KEY = "fleetops.language";
+
+export const NAMESPACES = [
+  "common",
+  "auth",
+  "navigation",
+  "dashboard",
+  "fleet",
+  "bookings",
+  "returns",
+  "quality",
+  "knowledge",
+  "integrations",
+  "audit",
+  "demo",
+  "errors",
+  "accessibility",
+] as const;
+
+function readStoredLanguage(): SupportedLanguage {
+  try {
+    const stored = window.localStorage.getItem(LANGUAGE_STORAGE_KEY);
+    if (stored && (SUPPORTED_LANGUAGES as readonly string[]).includes(stored)) {
+      return stored as SupportedLanguage;
+    }
+  } catch {
+    // localStorage unavailable (e.g. private-mode edge cases) -- fall back to default.
+  }
+  return DEFAULT_LANGUAGE;
+}
+
+export function persistLanguage(language: SupportedLanguage): void {
+  try {
+    window.localStorage.setItem(LANGUAGE_STORAGE_KEY, language);
+  } catch {
+    // Best effort only; the in-memory i18next language still changes for this session.
+  }
+}
+
+void i18n
+  .use(initReactI18next)
+  .init({
+    lng: readStoredLanguage(),
+    fallbackLng: DEFAULT_LANGUAGE,
+    supportedLngs: SUPPORTED_LANGUAGES,
+    ns: NAMESPACES,
+    defaultNS: "common",
+    // A missing key must never render silently as empty/blank text -- surface it loudly
+    // (the key itself) so it's caught immediately in development and by the
+    // translation-coverage test, rather than shipping a blank UI label.
+    returnEmptyString: false,
+    interpolation: { escapeValue: false },
+    resources: {
+      "nl-BE": {
+        common: commonNl,
+        auth: authNl,
+        navigation: navigationNl,
+        dashboard: dashboardNl,
+        fleet: fleetNl,
+        bookings: bookingsNl,
+        returns: returnsNl,
+        quality: qualityNl,
+        knowledge: knowledgeNl,
+        integrations: integrationsNl,
+        audit: auditNl,
+        demo: demoNl,
+        errors: errorsNl,
+        accessibility: accessibilityNl,
+      },
+      "en-GB": {
+        common: commonEn,
+        auth: authEn,
+        navigation: navigationEn,
+        dashboard: dashboardEn,
+        fleet: fleetEn,
+        bookings: bookingsEn,
+        returns: returnsEn,
+        quality: qualityEn,
+        knowledge: knowledgeEn,
+        integrations: integrationsEn,
+        audit: auditEn,
+        demo: demoEn,
+        errors: errorsEn,
+        accessibility: accessibilityEn,
+      },
+      "fr-BE": {
+        common: commonFr,
+        auth: authFr,
+        navigation: navigationFr,
+        dashboard: dashboardFr,
+        fleet: fleetFr,
+        bookings: bookingsFr,
+        returns: returnsFr,
+        quality: qualityFr,
+        knowledge: knowledgeFr,
+        integrations: integrationsFr,
+        audit: auditFr,
+        demo: demoFr,
+        errors: errorsFr,
+        accessibility: accessibilityFr,
+      },
+    },
+  });
+
+document.documentElement.lang = i18n.language;
+i18n.on("languageChanged", (lng) => {
+  document.documentElement.lang = lng;
+});
+
+export default i18n;
diff --git a/frontend/src/i18n/format.ts b/frontend/src/i18n/format.ts
new file mode 100644
index 0000000..ca9e96a
--- /dev/null
+++ b/frontend/src/i18n/format.ts
@@ -0,0 +1,37 @@
+import { useTranslation } from "react-i18next";
+
+const TIME_ZONE = "Europe/Brussels";
+
+export function useLocaleFormat() {
+  const { i18n } = useTranslation();
+  const locale = i18n.language || "nl-BE";
+
+  return {
+    locale,
+    formatDate(value: string | Date): string {
+      return new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeZone: TIME_ZONE }).format(
+        new Date(value),
+      );
+    },
+    formatShortDate(value: string | Date): string {
+      return new Intl.DateTimeFormat(locale, { day: "2-digit", month: "short", timeZone: TIME_ZONE }).format(
+        new Date(value),
+      );
+    },
+    formatDateTime(value: string | Date): string {
+      return new Intl.DateTimeFormat(locale, {
+        dateStyle: "medium",
+        timeStyle: "short",
+        timeZone: TIME_ZONE,
+      }).format(new Date(value));
+    },
+    formatTime(value: string | Date): string {
+      return new Intl.DateTimeFormat(locale, { hour: "2-digit", minute: "2-digit", timeZone: TIME_ZONE }).format(
+        new Date(value),
+      );
+    },
+    formatNumber(value: number): string {
+      return new Intl.NumberFormat(locale).format(value);
+    },
+  };
+}
diff --git a/frontend/src/i18n/locales/en-GB/accessibility.json b/frontend/src/i18n/locales/en-GB/accessibility.json
new file mode 100644
index 0000000..74b84a0
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/accessibility.json
@@ -0,0 +1,7 @@
+{
+  "openRow": "Open: {{label}}",
+  "reducedMotion": "Reduced motion active",
+  "closeDialog": "Close dialog",
+  "expandSection": "Expand section",
+  "collapseSection": "Collapse section"
+}
diff --git a/frontend/src/i18n/locales/en-GB/audit.json b/frontend/src/i18n/locales/en-GB/audit.json
new file mode 100644
index 0000000..2dfcae1
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/audit.json
@@ -0,0 +1,64 @@
+{
+  "eyebrow": "Assure / Immutable history",
+  "title": "Audit trail",
+  "description": "Trace important state changes, actors and correlation references.",
+  "actionFilterLabel": "Action",
+  "actionFilterPlaceholder": "e.g. demo_login",
+  "managerOnly": "The audit trail is visible to Operations Managers only.",
+  "managerOnlyDetail": "Audit history is visible to Operations Managers only.",
+  "loading": "Loading audit trail…",
+  "unavailable": "Audit trail is unavailable right now.",
+  "empty": "No audit events found",
+  "emptyDetail": "Adjust the action filter.",
+  "relatedFilterActive": "Showing only events linked to this action ({{count}} related events).",
+  "clearFilter": "Clear this filter",
+  "count": "{{count}} events",
+  "storedRendered": "UTC stored · Brussels rendered",
+  "columns": {
+    "when": "When",
+    "actor": "Actor",
+    "action": "Action",
+    "entity": "Entity",
+    "change": "Change",
+    "followUp": "Follow-up",
+    "details": "Details"
+  },
+  "viewRelatedEvents": "View related events",
+  "noChangeDetail": "No recorded change detail.",
+  "noFieldChange": "No field-level change detected.",
+  "reference": "Reference",
+  "relatedEventsCount": "{{count}} linked event",
+  "relatedEventsCount_other": "{{count}} linked events",
+  "showTechnicalEvents": "Show {{count}} technical event",
+  "showTechnicalEvents_other": "Show {{count}} technical events",
+  "hideTechnicalEvents": "Hide technical events",
+  "technicalDetails": "Technical details",
+  "fullReference": "Full reference",
+  "correlationId": "Correlation ID",
+  "diff": {
+    "setTo": "{{field}}: set to {{value}}",
+    "was": "{{field}}: was {{value}}",
+    "changed": "{{field}}: {{before}} → {{after}}"
+  },
+  "actions": {
+    "demo_login": "Logged in",
+    "demo_logout": "Logged out",
+    "demo_reset": "Demo data reset",
+    "demo_data_seeded": "Demo data seeded",
+    "return_registered": "Vehicle return registered",
+    "vehicle_status_changed": "Vehicle status changed",
+    "data_quality_issue_resolved": "Data-quality issue resolved",
+    "data_quality_issue_deferred": "Data-quality issue deferred",
+    "data_quality_issue_rejected": "Data-quality issue rejected",
+    "data_quality_fields_provided": "Missing fields provided",
+    "data_quality_odometer_corrected": "Odometer corrected",
+    "data_quality_odometer_retained": "Canonical odometer retained",
+    "data_quality_status_applied": "Recommended status applied",
+    "data_quality_booking_blocked": "Booking blocked",
+    "data_quality_scan_run": "Quality scan run",
+    "customer_merged": "Customers merged",
+    "workflow_retry": "Automation retried",
+    "knowledge_question_asked": "Knowledge question asked",
+    "mcp_tool_request": "MCP tool called"
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/auth.json b/frontend/src/i18n/locales/en-GB/auth.json
new file mode 100644
index 0000000..29b5e44
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/auth.json
@@ -0,0 +1,23 @@
+{
+  "brandTagline": "Control Centre",
+  "orgLine": "Demo organisation: {{orgName}} (fictional)",
+  "headline1": "Every hand-off.",
+  "headline2": "One clear view.",
+  "defaultDescription": "Fleet Ops brings vehicle, booking and operational data together, supports rental processes, detects data-quality problems and automates controlled follow-up steps.",
+  "footnote": "Synthetic demo · no real customer or vehicle data · resettable at any time",
+  "accessEyebrow": "Demo access",
+  "accessHeading": "Choose how to start",
+  "accessIntro": "No password needed. Each role opens a scoped synthetic environment — all workflows and controls are really implemented.",
+  "startGuidedDemo": "Start guided demo",
+  "exploreAsOperationsManager": "Explore as Operations Manager",
+  "exploreAsOperationsManagerDetail": "Full overview, quality resolution and retries",
+  "exploreAsRentalEmployee": "Explore as Rental Employee",
+  "exploreAsRentalEmployeeDetail": "Bookings, returns, fleet and procedures",
+  "safeByDesignTitle": "Safe by design",
+  "safeByDesignDetail": "Every action is logged and is resettable in this demo.",
+  "loginFailed": "The demo session could not be started. The API may be unreachable.",
+  "roleOperationsManager": "Operations manager",
+  "roleRentalEmployee": "Rental employee",
+  "switchRole": "Switch role",
+  "logout": "Log out"
+}
diff --git a/frontend/src/i18n/locales/en-GB/bookings.json b/frontend/src/i18n/locales/en-GB/bookings.json
new file mode 100644
index 0000000..6174172
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/bookings.json
@@ -0,0 +1,52 @@
+{
+  "list": {
+    "eyebrow": "Operations / Schedule",
+    "title": "Bookings",
+    "description": "Review active rental windows and upcoming vehicle commitments.",
+    "searchLabel": "Search",
+    "searchPlaceholder": "Booking, customer or vehicle",
+    "statusLabel": "Status",
+    "statusAll": "All statuses",
+    "loading": "Loading booking ledger…",
+    "empty": "No bookings found",
+    "emptyDetail": "Adjust the booking status filter.",
+    "noMatch": "No matching bookings",
+    "noMatchDetail": "Try a broader search term.",
+    "unavailable": "Booking list is unavailable right now.",
+    "count": "{{count}} bookings",
+    "pageOf": "Page {{page}} of {{total}}",
+    "columns": {
+      "reference": "Reference",
+      "customer": "Customer",
+      "vehicle": "Vehicle",
+      "window": "Window",
+      "status": "Status"
+    },
+    "paginationLabel": "Booking pages",
+    "previous": "Previous",
+    "next": "Next",
+    "rangeOf": "{{from}}–{{to}} of {{total}}"
+  },
+  "statuses": {
+    "reserved": "reserved",
+    "active": "active",
+    "returned": "returned",
+    "cancelled": "cancelled",
+    "blocked": "blocked"
+  },
+  "detail": {
+    "backLink": "Booking ledger",
+    "eyebrow": "Bookings / Rental record",
+    "notFound": "This booking could not be found.",
+    "loading": "Loading booking record…",
+    "customer": "Customer",
+    "vehicle": "Vehicle",
+    "starts": "Starts",
+    "ends": "Ends",
+    "startOdometer": "Start odometer",
+    "endOdometer": "End odometer",
+    "requirementsComplete": "Requirements complete",
+    "yes": "Yes",
+    "no": "No"
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/common.json b/frontend/src/i18n/locales/en-GB/common.json
new file mode 100644
index 0000000..432ce01
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/common.json
@@ -0,0 +1,44 @@
+{
+  "appName": "Fleet Ops",
+  "orgName": "Northstar Mobility",
+  "brandTagline": "Control Centre",
+  "actions": {
+    "save": "Save",
+    "cancel": "Cancel",
+    "confirm": "Confirm",
+    "close": "Close",
+    "back": "Back",
+    "next": "Next",
+    "retry": "Retry",
+    "reset": "Reset",
+    "yes": "Yes",
+    "no": "No",
+    "viewDetails": "View details",
+    "technicalDetails": "Technical details"
+  },
+  "status": {
+    "loading": "Loading…",
+    "saving": "Saving…",
+    "error": "Something went wrong",
+    "success": "Success",
+    "noResults": "No results"
+  },
+  "states": {
+    "loadingDefault": "Loading workspace…",
+    "errorTitle": "We couldn't load this workspace."
+  },
+  "timezone": "Europe/Brussels",
+  "language": {
+    "label": "Language",
+    "nl-BE": "Nederlands",
+    "en-GB": "English",
+    "fr-BE": "Français"
+  },
+  "footer": {
+    "productLine": "Fleet Ops Demo",
+    "locale": "Europe/Brussels · Synthetic demo data"
+  },
+  "demo": {
+    "syntheticBadge": "Synthetic demo"
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/dashboard.json b/frontend/src/i18n/locales/en-GB/dashboard.json
new file mode 100644
index 0000000..97fdd98
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/dashboard.json
@@ -0,0 +1,67 @@
+{
+  "eyebrow": "Operations / Live overview",
+  "title": "Good morning. Here's the fleet.",
+  "description": "Readiness, exceptions and hand-offs across today's operation.",
+  "viewFleet": "View fleet",
+  "demoStart": {
+    "title": "Try a demonstration scenario",
+    "readyCount": "{{ready}} of {{total}} scenarios ready for demo.",
+    "readyCountFallback": "Five focused scenarios.",
+    "startGuide": "Start demo guide",
+    "resumeGuide": "Continue demo guide ({{current}}/{{total}})",
+    "viewScenarios": "View scenarios"
+  },
+  "readiness": {
+    "title": "Fleet readiness",
+    "description": "Live from persisted vehicle state",
+    "openFleet": "Open fleet",
+    "available": "Available",
+    "rented": "Rented",
+    "cleaning": "Cleaning",
+    "maintenance": "Maintenance",
+    "blocked": "Blocked"
+  },
+  "attention": {
+    "title": "Attention queue",
+    "description": "{{openIssues}} open quality issues · {{workflowExceptions}} workflow exceptions",
+    "reviewQueue": "Review queue",
+    "filterPlaceholder": "Filter issues…",
+    "filterAriaLabel": "Search attention queue",
+    "severityAll": "All severity",
+    "severityHigh": "Critical",
+    "severityMedium": "Warning",
+    "severityLow": "Info",
+    "severityAriaLabel": "Severity",
+    "empty": "No issues match this filter.",
+    "openRecord": "Open {{title}}"
+  },
+  "movements": {
+    "title": "Today's movements",
+    "description": "Departures and returns in Europe/Brussels",
+    "allBookings": "All bookings",
+    "empty": "No movements scheduled today.",
+    "departure": "departure",
+    "return": "return",
+    "openBooking": "Open booking {{ref}}"
+  },
+  "integrationPulse": {
+    "title": "Integration pulse",
+    "description": "Current evidence from connected services",
+    "systemDetail": "System detail",
+    "n8nTitle": "n8n delivery",
+    "n8nSummary": "{{succeeded}} succeeded · {{failed}} failed",
+    "n8nLatest": "Latest event {{ref}}",
+    "n8nNoEvidence": "No workflow evidence recorded",
+    "knowledgeTitle": "Knowledge assistant",
+    "knowledgeSummary": "{{count}} procedures indexed",
+    "knowledgeUnavailable": "Health check unavailable",
+    "mcpTitle": "MCP Hub",
+    "mcpEnabled": "Registration enabled",
+    "mcpNotConnected": "Not yet connected"
+  },
+  "recent": {
+    "title": "Recent activity",
+    "description": "Latest audited workflow changes",
+    "empty": "No automation activity recorded."
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/demo.json b/frontend/src/i18n/locales/en-GB/demo.json
new file mode 100644
index 0000000..503cdae
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/demo.json
@@ -0,0 +1,189 @@
+{
+  "badge": {
+    "trigger": "Synthetic demo",
+    "dialogLabel": "About this demo environment",
+    "close": "Close",
+    "orgIntro": "<strong>{{orgName}}</strong> is a fictional organisation. All names, vehicles and bookings are synthetic.",
+    "orgIntroFallback": "All names, vehicles and bookings in this environment are synthetic.",
+    "realWorkflows": "The workflows, controls and automation are really implemented — only the data is invented.",
+    "lastReset": "Last reset: <strong>{{when}}</strong> · this environment is resettable at any time.",
+    "aboutLink": "About this demo",
+    "unknown": "unknown"
+  },
+  "guide": {
+    "dialogLabel": "Guided demo",
+    "trigger": "Demo guide",
+    "kicker": "Guided demo · step {{current}} of {{total}}",
+    "whatYouWillSee": "What you'll see",
+    "whyItMatters": "Why it matters",
+    "startAction": "Get started",
+    "expectedOutcome": "Expected outcome",
+    "goToStep": "Go to this step",
+    "next": "Next",
+    "close": "Close",
+    "restart": "Prepare demo again",
+    "restarting": "Restarting…",
+    "restartFailed": "Could not restart the demo.",
+    "allStepsLabel": "All steps",
+    "progressChip": "Demo guide · step {{current}} of {{total}}",
+    "expand": "Expand demo guide",
+    "collapse": "Collapse demo guide",
+    "steps": {
+      "understand-state": {
+        "title": "1. Understand the operational state",
+        "whatYouWillSee": "The dashboard shows fleet readiness, open attention points and today's movements.",
+        "whyItMatters": "An Operations Manager starts every day with this overview to decide where to step in.",
+        "startAction": "Open the dashboard and review the attention queue and today's timeline.",
+        "expectedOutcome": "You see which bookings, vehicles or data-quality issues need attention."
+      },
+      "open-booking": {
+        "title": "2. Open the booking needing attention",
+        "whatYouWillSee": "Booking BK-DEMO-RETURN, active and due for return today.",
+        "whyItMatters": "Returns are the moment incorrect odometer readings or damage first become visible.",
+        "startAction": "Open the booking from the dashboard or the booking list.",
+        "expectedOutcome": "You see the booking details and the button to process the return."
+      },
+      "process-return": {
+        "title": "3. Process a return with an odometer anomaly",
+        "whatYouWillSee": "A return form pre-filled with a suspicious odometer reading below the last known reading.",
+        "whyItMatters": "A falling odometer signals a data-entry mistake or a mixed-up vehicle — this must be caught before release.",
+        "startAction": "Submit the return with the suggested value and review the server preview before confirming.",
+        "expectedOutcome": "The return is processed, the vehicle gets an appropriate status, and a data-quality issue is created automatically."
+      },
+      "handle-quality-issue": {
+        "title": "4. Handle the created data-quality issue",
+        "whatYouWillSee": "A new 'odometer regression' issue at the top of the work queue.",
+        "whyItMatters": "Every detected issue has one bounded resolution step — nothing is silently auto-corrected.",
+        "startAction": "Open the data-quality overview and choose the newest issue.",
+        "expectedOutcome": "You see the recommended action, choose a resolution, and the issue resolves with an audit trail."
+      },
+      "merge-duplicate": {
+        "title": "5. Review and handle a possible duplicate customer",
+        "whatYouWillSee": "Two customer profiles with the same email and phone number, compared side by side.",
+        "whyItMatters": "Duplicate customers split booking history and confuse communication.",
+        "startAction": "Compare both profiles and choose which one survives.",
+        "expectedOutcome": "The profiles are merged, bookings are rewired, and the losing profile becomes a tombstone."
+      },
+      "ask-knowledge": {
+        "title": "6. Ask the procedure assistant a question",
+        "whatYouWillSee": "An answer with citation from the scoped demo knowledge base.",
+        "whyItMatters": "Staff need a quick, grounded answer about procedures, without guessing.",
+        "startAction": "Click one of the suggested questions, in the current interface language.",
+        "expectedOutcome": "You see the answer, the procedure used, and the source text — or an honest 'insufficient information' if none exists."
+      },
+      "check-automation-audit": {
+        "title": "7. Check automation and the audit trail",
+        "whatYouWillSee": "The delivery status of your return's automation job, and its related audit events.",
+        "whyItMatters": "Every important action must be traceable: who did what, when, and what followed.",
+        "startAction": "Open Integrations to see delivery status, and Audit trail for the full record.",
+        "expectedOutcome": "You see a successful (or recoverable) delivery and a readable audit trail of your actions."
+      },
+      "review-real-vs-simulated": {
+        "title": "8. Review what's real, simulated, or not yet connected",
+        "whatYouWillSee": "An overview of what's functionally implemented in this demo, what's synthetic, and which integrations aren't live yet.",
+        "whyItMatters": "A demo is only convincing if visitors can verify for themselves what really works and what's still ahead.",
+        "startAction": "Read the 'About this demo' page.",
+        "expectedOutcome": "You can explain yourself what Fleet Ops is and isn't, with no verbal explanation needed."
+      }
+    }
+  },
+  "scenarios": {
+    "eyebrow": "Demonstration scenarios",
+    "title": "Try a demonstration scenario",
+    "description": "Five focused scenarios that always use the same fixed bookings, customers and vehicles — always re-findable after a reset.",
+    "loading": "Loading scenarios…",
+    "ready": "Ready for demo",
+    "notReady": "Not available",
+    "duration": "Duration",
+    "durationValue": "± {{minutes}} min",
+    "role": "Role",
+    "demonstrates": "Demonstrates:",
+    "requiresRole": "Requires role: {{roles}}.",
+    "startScenario": "Start scenario",
+    "roleOr": "{{a}} or {{b}}",
+    "roles": {
+      "operations_manager": "Operations Manager",
+      "rental_employee": "Rental Employee"
+    },
+    "items": {
+      "return-anomaly": {
+        "title": "Return with an odometer anomaly",
+        "problem": "A vehicle comes back with an odometer reading lower than the last recorded reading — a sign of a data-entry mistake or a mixed-up vehicle.",
+        "demonstrates": "Return processing, automatic data-quality detection, and the audit trail it produces."
+      },
+      "duplicate-customer": {
+        "title": "Merge a possible duplicate customer",
+        "problem": "Two customer profiles share the same email address and phone number — likely the same person, registered twice.",
+        "demonstrates": "Merging customers while preserving booking history and the audit trail."
+      },
+      "booking-overlap": {
+        "title": "Resolve overlapping bookings",
+        "problem": "One vehicle is double-booked for overlapping periods — a scheduling error that must be resolved before departure.",
+        "demonstrates": "Detection and controlled resolution of scheduling conflicts."
+      },
+      "automation-retry": {
+        "title": "Retry a failed automation job",
+        "problem": "One earlier event could not be delivered to the automation job due to a simulated connection error.",
+        "demonstrates": "Reliable delivery with bounded retries and visible failure status."
+      },
+      "knowledge-question": {
+        "title": "Ask a procedure question",
+        "problem": "An employee isn't sure which procedure applies to a specific operational situation.",
+        "demonstrates": "Source-grounded answers from a scoped demo knowledge base."
+      }
+    },
+    "blockedReasons": {
+      "bookingNotFound": "Demo booking BK-DEMO-RETURN not found. {{resetHint}}",
+      "bookingAlreadyProcessed": "This booking has already been processed since the last reset. {{resetHint}}",
+      "duplicateIssueNotFound": "Demo issue DQ-DEMO-DUPLICATE not found. {{resetHint}}",
+      "issueAlreadyResolved": "This issue has already been resolved since the last reset. {{resetHint}}",
+      "overlapIssueNotFound": "Demo issue DQ-DEMO-OVERLAP not found. {{resetHint}}",
+      "failedEventNotFound": "The simulated failed event was not found. {{resetHint}}",
+      "eventAlreadyRecovered": "This event has already been recovered since the last reset. {{resetHint}}",
+      "knowledgeUnavailable": "The demo knowledge base is currently unavailable.",
+      "resetHint": "Reset the demo data to make this scenario available again."
+    }
+  },
+  "about": {
+    "eyebrow": "About this demo",
+    "title": "What Fleet Ops is and isn't",
+    "description": "{{orgName}} is a fictional rental organisation that makes this demo tangible — not a real company.",
+    "loading": "Loading demo information…",
+    "ctaTitle": "Prefer to jump right in?",
+    "ctaBody": "The guided demo walks through all eight steps above in practice.",
+    "ctaButton": "Start guided demo",
+    "problemTitle": "The fictional problem",
+    "problemBody": "{{orgName}} rents around 50 campers and vans from one main location. Bookings, returns, customer records and maintenance used to live in separate spreadsheets and verbal hand-offs, so problems (duplicate customers, incorrect odometer readings, double-booked vehicles) only surfaced late. Fleet Ops shows how one connected system flags these problems early and lets them be resolved under control.",
+    "scopeTitle": "Who it's for and its scope",
+    "scopeBody": "This demo is for anyone who wants to see how Fleet Ops tackles operational problems at a small rental company: Operations Managers and Rental Employees, and anyone evaluating the approach. The scope is deliberately focused on one connected proof of concept — no accounting, no payments, no public reservations, no full CRM or ERP.",
+    "realTitle": "What really works",
+    "realBody": "Everything below is functional code, not just a mockup: role-based access and sessions, vehicle and booking management, return processing with server-side validation, five data-quality rules each with its own resolution step, a full audit trail, automated delivery to n8n with bounded retries, Docker-based deployment, and an automated test suite (backend and Playwright end-to-end).",
+    "syntheticTitle": "What's synthetic",
+    "syntheticBody": "The organisation, all customers, vehicles, bookings, maintenance history, procedures in the knowledge base, and the pre-set-up scenarios are entirely invented. No data refers to a real person, vehicle or company; email addresses only use the {{testDomain}} test domain.",
+    "architectureTitle": "Architecture in brief",
+    "architectureBody": "A React/TypeScript frontend talks to a FastAPI backend (PostgreSQL via SQLAlchemy/Alembic migrations); important business rules live in the backend, not in n8n or in prompts. Returns and other events are committed locally first and only then delivered asynchronously to n8n through an automation job, so a temporary automation outage never blocks an operational action.",
+    "securityTitle": "Security and access",
+    "securityBody": "Access runs through signed, HTTP-only session cookies per role; each role is bound to a set of allowed routes, both enforced server-side and reflected in navigation. Important state changes are always checked and logged — never silently auto-corrected.",
+    "testingTitle": "How this is tested",
+    "testingBody": "An automated backend test suite covers business rules and API contracts; a full Playwright end-to-end suite covers the user flows, including this demo experience itself in three languages. Every change is also validated against a clean checkout (empty database, rebuilt from seed data) before deployment.",
+    "integrationsTitle": "Integrations — honestly labelled",
+    "integrationsDescription": "What's operational, what's demo mode, and what's not yet connected.",
+    "resetTitle": "Restoring the demo environment",
+    "resetBodyManager": "The environment can be reset to its starting state at any time. Last reset: <strong>{{when}}</strong>. Use <strong>Reset demo data</strong> in the sidebar to start over.",
+    "resetBodyEmployee": "The environment can be reset to its starting state at any time. Last reset: <strong>{{when}}</strong>. An Operations Manager can reset the demo environment via the sidebar.",
+    "limitationsTitle": "Limitations",
+    "limitationsBody": "This is a focused proof of concept, not a full ERP. RAGcore and the ITWorx MCP Hub are not yet live-connected; the knowledge assistant uses a local, scoped demo knowledge base instead of a live RAGcore environment.",
+    "unknown": "unknown"
+  },
+  "integrationSummary": {
+    "titles": {
+      "n8n": "Automation (n8n)",
+      "ragcore": "Knowledge assistant (RAGcore)",
+      "mcp_hub": "ITWorx MCP Hub"
+    },
+    "n8nDetail": "{{succeeded}} succeeded · {{failed}} failed · {{pending}} pending.",
+    "ragcoreDetail": "{{count}} procedures indexed in {{collection}}.",
+    "mcpDetailEnabled": "Prepared for future, controlled tool calls from the Hub.",
+    "mcpDetailNotConnected": "Not yet connected — prepared for future controlled tool calls from the Hub."
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/errors.json b/frontend/src/i18n/locales/en-GB/errors.json
new file mode 100644
index 0000000..cfb909b
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/errors.json
@@ -0,0 +1,8 @@
+{
+  "generic": "Something went wrong. Please try again.",
+  "workspaceLoadFailed": "We couldn't load this workspace.",
+  "unauthorized": "Your session has expired. Please log in again.",
+  "forbidden": "You don't have access to this section.",
+  "notFound": "This record could not be found.",
+  "networkUnavailable": "The connection to the server is currently unavailable."
+}
diff --git a/frontend/src/i18n/locales/en-GB/fleet.json b/frontend/src/i18n/locales/en-GB/fleet.json
new file mode 100644
index 0000000..c36f9eb
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/fleet.json
@@ -0,0 +1,68 @@
+{
+  "list": {
+    "eyebrow": "Fleet / Registry",
+    "title": "Vehicle fleet",
+    "description": "Live operational state, location and service readiness.",
+    "searchLabel": "Search",
+    "searchPlaceholder": "Reference, make or location",
+    "statusLabel": "Status",
+    "statusAll": "All statuses",
+    "attentionOnly": "Attention only",
+    "loading": "Loading fleet registry…",
+    "empty": "No vehicles found",
+    "emptyDetail": "Adjust the current fleet filters.",
+    "noMatch": "No matching vehicles",
+    "noMatchDetail": "Try a broader search term.",
+    "unavailable": "Vehicle list is unavailable right now.",
+    "count": "{{count}} vehicles",
+    "persisted": "Persisted fleet data",
+    "columns": {
+      "reference": "Reference",
+      "makeModel": "Make / model",
+      "location": "Location",
+      "status": "Status",
+      "odometer": "Odometer (km)",
+      "attention": "Attention"
+    },
+    "needsAttention": "Needs attention"
+  },
+  "statuses": {
+    "available": "available",
+    "rented": "rented",
+    "cleaning": "cleaning",
+    "maintenance": "maintenance",
+    "blocked": "blocked"
+  },
+  "detail": {
+    "backLink": "Fleet registry",
+    "eyebrow": "Fleet / Vehicle record",
+    "notFound": "This vehicle could not be found.",
+    "loading": "Loading vehicle record…",
+    "needsAttention": "Needs attention",
+    "tabs": {
+      "overview": "Overview",
+      "bookings": "Bookings",
+      "inspections": "Inspections",
+      "maintenance": "Maintenance",
+      "quality": "Quality"
+    },
+    "tabsAriaLabel": "Vehicle sections",
+    "overview": {
+      "registration": "Registration",
+      "modelYear": "Model year",
+      "location": "Location",
+      "odometer": "Odometer",
+      "nextService": "Next service",
+      "active": "Active"
+    },
+    "yes": "Yes",
+    "no": "No",
+    "noBookings": "No bookings recorded.",
+    "noInspections": "No inspections recorded.",
+    "noMaintenance": "No maintenance records.",
+    "noQualityIssues": "No quality issues recorded.",
+    "fuel": "Fuel {{percent}}%",
+    "damage": "Damage",
+    "technicalWarning": "Technical warning"
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/integrations.json b/frontend/src/i18n/locales/en-GB/integrations.json
new file mode 100644
index 0000000..b3f8ab1
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/integrations.json
@@ -0,0 +1,70 @@
+{
+  "eyebrow": "Assure / Integrations",
+  "title": "Integration control",
+  "description": "Monitor delivery health, graceful degradation and retryable workflow events.",
+  "cards": {
+    "orchestrationKicker": "Orchestration",
+    "n8nTitle": "n8n delivery",
+    "n8nSummary": "{{succeeded}} succeeded · {{failed}} failed · {{pending}} pending · {{delivering}} delivering",
+    "n8nFallback": "Return events are committed locally first and then delivered through the automation job.",
+    "knowledgeKicker": "Knowledge",
+    "knowledgeTitle": "Knowledge assistant",
+    "knowledgeSummaryDemo": "Demo knowledge base · {{count}} procedures indexed in {{collection}}.",
+    "knowledgeSummaryRagcore": "RAGcore · {{count}} procedures indexed in {{collection}}.",
+    "knowledgeUnavailable": "Health evidence is currently unavailable.",
+    "gatewayKicker": "Tool gateway",
+    "mcpTitle": "MCP Hub",
+    "mcpEnabled": "Registration is enabled for this deployment.",
+    "mcpNotConnected": "Not yet connected — prepared for future controlled tool calls from the Hub."
+  },
+  "statusLabels": {
+    "notConnected": "Not connected",
+    "deliveryFailed": "Delivery failed",
+    "retryAvailable": "Retry available",
+    "operational": "Operational",
+    "prepared": "Prepared",
+    "demoMode": "Demo mode",
+    "unavailable": "Unavailable"
+  },
+  "ledger": {
+    "title": "Automation jobs",
+    "description": "Persisted automation attempts with the latest failure evidence.",
+    "filterLabel": "View",
+    "filterNeedsAttention": "Needs attention",
+    "filterRecent": "Recent",
+    "filterSucceeded": "Succeeded",
+    "filterAll": "All",
+    "statusFilterLabel": "Status",
+    "statusAll": "All statuses",
+    "statusPending": "Pending",
+    "statusDelivering": "Delivering",
+    "statusSucceeded": "Succeeded",
+    "statusFailed": "Failed",
+    "unavailable": "Automation jobs are unavailable right now.",
+    "managerOnly": "Automation is visible to Operations Managers only.",
+    "loading": "Loading automation jobs…",
+    "empty": "No automation jobs match this filter.",
+    "count": "{{count}} workflow events",
+    "boundedRetries": "Bounded retries",
+    "groupedSucceeded": "{{count}} succeeded vehicle-return jobs",
+    "showIndividually": "Show individual jobs",
+    "hideIndividually": "Hide individual jobs",
+    "columns": {
+      "event": "Job",
+      "type": "Type",
+      "booking": "Booking",
+      "status": "Status",
+      "attempts": "Attempts",
+      "lastError": "Last error",
+      "when": "When",
+      "action": "Action"
+    },
+    "retry": "Retry",
+    "retrying": "Retrying…",
+    "retryFailed": "Could not retry this delivery.",
+    "noAction": "—",
+    "eventTypes": {
+      "vehicle.returned.v1": "Vehicle return processed"
+    }
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/knowledge.json b/frontend/src/i18n/locales/en-GB/knowledge.json
new file mode 100644
index 0000000..80e5c53
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/knowledge.json
@@ -0,0 +1,41 @@
+{
+  "eyebrow": "Assure / Grounded knowledge",
+  "title": "Procedure knowledge",
+  "description": "Ask operational questions. Answers are shown only when {{provider}} returns sufficient cited evidence.",
+  "providerDemo": "the demo knowledge base",
+  "providerRagcore": "RAGcore",
+  "statusAvailable": "Available",
+  "statusUnavailable": "Unavailable",
+  "proceduresIndexed": "{{count}} procedures indexed",
+  "providerNote": "This demo answers from a small, fixed set of indexed procedures — not a live RAGcore connection. A live RAGcore backend will later take over the same interface without changing how this page works.",
+  "askHeading": "Ask a procedure question",
+  "askSubheading": "Retrieval → evidence check → grounded answer",
+  "questionLabel": "Question",
+  "questionPlaceholder": "e.g. What must I do when a vehicle returns with damage?",
+  "ask": "Ask",
+  "asking": "Asking…",
+  "askFailed": "Could not reach the knowledge service.",
+  "suggestedLabel": "Try one:",
+  "suggestedQuestions": [
+    "What must I do when a vehicle returns with damage?",
+    "How do I register a vehicle return?",
+    "When may a vehicle be made available again?",
+    "Who reviews an unusual odometer reading?",
+    "Which checks are required before checkout?"
+  ],
+  "emptyTitle": "Evidence before answers",
+  "emptyDescription": "Ask about returns, damage, inspections or another indexed procedure. Fleet Ops will not invent an answer when evidence is missing.",
+  "retrievalFlow": {
+    "question": "Question",
+    "sources": "Sources",
+    "answer": "Answer"
+  },
+  "questionLabelExchange": "Question",
+  "evidenceStates": {
+    "grounded": "Grounded in cited procedures",
+    "insufficient": "Insufficient evidence",
+    "unavailable": "Knowledge service unavailable"
+  },
+  "unavailableBody": "The knowledge service is currently unreachable. Operational features are unaffected — try again later.",
+  "sourceVersion": "v{{version}}"
+}
diff --git a/frontend/src/i18n/locales/en-GB/navigation.json b/frontend/src/i18n/locales/en-GB/navigation.json
new file mode 100644
index 0000000..03fba39
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/navigation.json
@@ -0,0 +1,39 @@
+{
+  "skipToContent": "Skip to main content",
+  "groups": {
+    "operate": "Operate",
+    "assure": "Assure"
+  },
+  "items": {
+    "overview": "Overview",
+    "fleet": "Fleet",
+    "bookings": "Bookings",
+    "quality": "Data quality",
+    "knowledge": "Knowledge",
+    "integrations": "Integrations",
+    "audit": "Audit trail"
+  },
+  "primaryNavLabel": "Primary navigation",
+  "mobileNavLabel": "Mobile navigation",
+  "more": "More",
+  "openNavigation": "Open navigation",
+  "closeNavigation": "Close navigation",
+  "sidebarEnvironment": "Demo environment",
+  "sidebarEnvironmentDetail": "Synthetic data only",
+  "resetDemoData": "Reset demo data",
+  "resetConfirmTitle": "Confirm demo reset",
+  "resetConfirmBody": "All synthetic changes will be discarded and deterministic demo data restored. You will be signed out.",
+  "resetting": "Resetting…",
+  "resetConfirmYes": "Yes, reset",
+  "resetCancel": "Cancel",
+  "resetFailed": "Could not reset demo data.",
+  "searchLabel": "Search Fleet Ops",
+  "searchPlaceholder": "Search fleet, booking or section…",
+  "searchShortcutHint": "Ctrl K",
+  "searchSearching": "Searching…",
+  "searchUnavailable": "Search is unavailable right now.",
+  "searchNoResults": "No matches for \"{{query}}\".",
+  "switchRole": "Switch role",
+  "switchRoleTitle": "Switch demo role",
+  "languageSwitcherLabel": "Change language"
+}
diff --git a/frontend/src/i18n/locales/en-GB/quality.json b/frontend/src/i18n/locales/en-GB/quality.json
new file mode 100644
index 0000000..7f9a1c7
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/quality.json
@@ -0,0 +1,192 @@
+{
+  "list": {
+    "eyebrow": "Assure / Workbench",
+    "title": "Data quality",
+    "description": "Resolve evidence-backed exceptions before they disrupt operations.",
+    "runScan": "Run quality scan",
+    "confirmScanTitle": "Confirm quality scan",
+    "confirmScanBody": "Run the deterministic scan across all five rule types now?",
+    "scanning": "Scanning…",
+    "confirmScanYes": "Yes, run scan",
+    "cancel": "Cancel",
+    "scanComplete": "Scan complete: {{summary}}",
+    "scanNoNew": "no new issues found (existing open issues are not recreated).",
+    "scanFailed": "Could not run the quality scan.",
+    "statusLabel": "Status",
+    "statusAll": "All statuses",
+    "statusOpen": "Open",
+    "statusDeferred": "Deferred",
+    "statusResolved": "Resolved",
+    "statusRejected": "Rejected",
+    "ruleTypeLabel": "Rule type",
+    "ruleTypeAll": "All rule types",
+    "demoScenariosOnly": "Demo scenarios only",
+    "loading": "Loading quality workbench…",
+    "queueClear": "Queue is clear",
+    "noIssuesMatch": "No issues match the current filters.",
+    "noDemoIssuesMatch": "No demo-scenario issues match",
+    "noDemoIssuesMatchDetail": "Uncheck 'Demo scenarios only' to see the full queue.",
+    "unavailable": "Data-quality issues are unavailable right now.",
+    "count": "{{count}} issues",
+    "evidenceBacked": "Evidence-backed detection",
+    "columns": {
+      "reference": "Reference",
+      "rule": "Rule",
+      "entity": "Entity",
+      "severity": "Severity",
+      "status": "Status"
+    }
+  },
+  "ruleTypes": {
+    "possible_duplicate_customer": "Possible duplicate customer",
+    "missing_required_field": "Missing required field",
+    "odometer_regression": "Odometer regression",
+    "booking_overlap": "Booking overlap",
+    "vehicle_status_conflict": "Vehicle status conflict"
+  },
+  "severities": {
+    "high": "Critical",
+    "medium": "Warning",
+    "low": "Info"
+  },
+  "detail": {
+    "backLink": "Quality workbench",
+    "eyebrow": "Quality / {{rule}}",
+    "title": "Review persisted evidence and record an audited resolution.",
+    "notFound": "This issue could not be found.",
+    "loading": "Loading issue evidence…",
+    "managerOnly": "The quality workbench is visible to Operations Managers only.",
+    "managerOnlyDetail": "Data-quality evidence and resolutions are visible to Operations Managers only.",
+    "summary": {
+      "rule": "Rule",
+      "entity": "Entity",
+      "evidenceSummary": "Evidence summary"
+    },
+    "resolved": {
+      "title": "Issue {{ref}} resolved",
+      "body": "The change has been applied and is recorded in the audit trail.",
+      "viewAudit": "View audit trail",
+      "viewVehicle": "View vehicle",
+      "continueDemo": "Continue the demo"
+    },
+    "deferOrReject": {
+      "heading": "Defer or reject",
+      "description": "Defer to review later, or reject if this is not a real issue.",
+      "defer": "Defer",
+      "reject": "Reject",
+      "deferFailed": "Could not defer this issue.",
+      "rejectFailed": "Could not reject this issue."
+    },
+    "explainer": {
+      "whatIsWrong": "What's wrong",
+      "whyItMatters": "Why it matters",
+      "possible_duplicate_customer": {
+        "whatIsWrong": "Two customer profiles share identifying details (email, phone or a very similar name) strongly enough that they are likely the same person, registered twice.",
+        "whyItMatters": "Duplicate customers split booking history across two records, risk duplicate billing, and confuse support conversations."
+      },
+      "missing_required_field": {
+        "whatIsWrong": "This record is missing information that's required for normal operation (for example, a customer with neither an email nor a phone number on file).",
+        "whyItMatters": "Without this data, the business can't reach the customer, or can't reliably identify the vehicle for compliance and hand-off checks."
+      },
+      "odometer_regression": {
+        "whatIsWrong": "A submitted odometer reading is lower than the vehicle's last known (canonical) reading.",
+        "whyItMatters": "A falling odometer usually means a data-entry mistake or that readings were recorded against the wrong vehicle. Letting it through silently would corrupt maintenance scheduling and resale mileage history."
+      },
+      "booking_overlap": {
+        "whatIsWrong": "The same vehicle is committed to two bookings whose date ranges overlap.",
+        "whyItMatters": "Only one of these bookings can actually be honoured. Left unresolved, a customer would arrive to find their vehicle already out with someone else."
+      },
+      "vehicle_status_conflict": {
+        "whatIsWrong": "This vehicle's stored operational status doesn't match what its own booking and inspection history implies it should be.",
+        "whyItMatters": "An incorrect status can make an unavailable vehicle appear bookable, or keep an available vehicle hidden from the fleet."
+      }
+    },
+    "duplicateCustomer": {
+      "heading": "Compare and merge",
+      "description": "Choose the canonical customer and review each conflicting field.",
+      "keepAsSurvivor": "Keep as survivor",
+      "differs": "Differs",
+      "match": "Match",
+      "mergePreview": "{{loser}} will become a tombstone linked to {{survivor}}; its bookings will be rewired.",
+      "mergeInto": "Merge into {{ref}}",
+      "confirmMergeTitle": "Confirm merge",
+      "confirmMergeBody": "Merge {{loser}} into {{survivor}}? This cannot be undone.",
+      "merging": "Merging…",
+      "confirmMergeYes": "Yes, merge",
+      "mergeFailed": "Could not merge these customers.",
+      "bothMissing": "Both customers in this comparison could not be loaded.",
+      "fieldColumn": "Field",
+      "fields": {
+        "first_name": "First name",
+        "last_name": "Last name",
+        "email": "Email",
+        "phone": "Phone",
+        "postal_code": "Postal code",
+        "city": "City"
+      }
+    },
+    "missingField": {
+      "heading": "Provide the missing fields",
+      "description": "Complete the record for {{ref}}. The issue resolves automatically once nothing required is missing.",
+      "atLeastOne": "At least one of email or phone is required.",
+      "saveAndRecheck": "Save and re-check",
+      "saving": "Saving…",
+      "saveFailed": "Could not save these fields.",
+      "fields": {
+        "first_name": "First name",
+        "last_name": "Last name",
+        "email": "Email",
+        "phone": "Phone",
+        "registration_number": "Registration number",
+        "make": "Make",
+        "model": "Model",
+        "location": "Location"
+      }
+    },
+    "odometerRegression": {
+      "heading": "Resolve the odometer regression",
+      "description": "The canonical odometer is never lowered automatically -- choose how to reconcile it.",
+      "canonicalOdometer": "Canonical odometer",
+      "decisionLegend": "Decision",
+      "retainCanonical": "Retain canonical reading",
+      "retainCanonicalDetail": "Treat the submitted reading as erroneous; nothing changes on the vehicle record.",
+      "correctReading": "Correct the reading",
+      "correctReadingDetail": "Update both the booking and the canonical odometer with the correct value.",
+      "noBookingAttached": "No related booking is attached to this issue, so only 'retain canonical' is available.",
+      "booking": "Booking",
+      "correctedOdometer": "Corrected odometer (km)",
+      "note": "Note",
+      "resolving": "Resolving…",
+      "resolveIssue": "Resolve issue",
+      "resolveFailed": "Could not resolve this issue."
+    },
+    "bookingOverlap": {
+      "heading": "Resolve the booking overlap",
+      "description": "Block one of the two overlapping commitments. The other keeps its current status.",
+      "columns": {
+        "booking": "Booking",
+        "window": "Window",
+        "status": "Status",
+        "blockThis": "Block this one"
+      },
+      "blockLabel": "Block {{ref}}",
+      "note": "Note",
+      "resolving": "Resolving…",
+      "blockButton": "Block {{ref}}",
+      "blockButtonFallback": "Block booking",
+      "resolveFailed": "Could not resolve this overlap."
+    },
+    "vehicleStatusConflict": {
+      "heading": "Resolve the status conflict",
+      "description": "One authoritative rule recommends a corrected operational status for this vehicle.",
+      "currentStatus": "Current status",
+      "calculateAndApply": "Calculate and apply recommended status",
+      "confirmTitle": "Confirm status change",
+      "confirmBody": "Apply the authoritative recommended status for this vehicle?",
+      "applying": "Applying…",
+      "confirmYes": "Yes, apply",
+      "applied": "Applied {{status}} — {{reason}}",
+      "applyFailed": "Could not apply a recommended status."
+    }
+  }
+}
diff --git a/frontend/src/i18n/locales/en-GB/returns.json b/frontend/src/i18n/locales/en-GB/returns.json
new file mode 100644
index 0000000..d6913f9
--- /dev/null
+++ b/frontend/src/i18n/locales/en-GB/returns.json
@@ -0,0 +1,73 @@
+{
+  "progress": {
+    "capture": "Capture",
+    "review": "Review",
+    "result": "Result",
+    "ariaLabel": "Return registration progress"
+  },
+  "capture": {
+    "heading": "Register vehicle return",
+    "description": "Record the hand-back condition. The next step evaluates the exact operational consequences before anything is committed.",
+    "endOdometer": "End odometer (km)",
+    "fuelLevel": "Fuel level (%)",
+    "conditionLegend": "Vehicle condition",
+    "cleanlinessOk": "Cleanliness acceptable",
+    "damageReported": "Damage reported",
+    "technicalWarning": "Technical warning",
+    "notes": "Notes",
+    "evaluating": "Evaluating…",
+    "reviewReturn": "Review return"
+  },
+  "review": {
+    "heading": "Review return impact",
+    "description": "This is the server's authoritative evaluation of what committing will do — confirm before it updates fleet state and queues automation.",
+    "odometer": "Odometer",
+    "fuel": "Fuel",
+    "cleanliness": "Cleanliness",
+    "cleanlinessAccepted": "Accepted",
+    "cleanlinessFollowUp": "Follow-up needed",
+    "damage": "Damage",
+    "damageReported": "Reported",
+    "damageNone": "None reported",
+    "technicalWarning": "Technical warning",
+    "technicalWarningReported": "Reported",
+    "technicalWarningNone": "None reported",
+    "expectedState": "Expected fleet state:",
+    "odometerRegressionWarning": "Submitted odometer ({{submitted}} km) is below the canonical reading ({{canonical}} km). The canonical odometer will not change, and a data-quality issue will be opened.",
+    "nextBookingRisk": "Next booking {{ref}} starts {{when}} — may be affected by this return.",
+    "nextBookingLowRisk": "Next booking {{ref}} starts {{when}} — low risk.",
+    "commitList": {
+      "inspection": "Create a return inspection",
+      "updateAtomic": "Update the booking and vehicle atomically",
+      "queueAutomation": "Queue automation after the local commit"
+    },
+    "editDetails": "Edit details",
+    "registering": "Registering…",
+    "confirmReturn": "Confirm return"
+  },
+  "result": {
+    "committedLocally": "Committed locally",
+    "heading": "Return registered",
+    "inspection": "Inspection",
+    "resultingStatus": "Resulting vehicle status",
+    "qualityIssue": "Quality issue",
+    "noneCreated": "None created",
+    "automationEvent": "Automation job",
+    "queuedForDelivery": "Queued for delivery ({{ref}}) — local commit succeeded; automation delivery is asynchronous and not yet confirmed.",
+    "nextBookingRisk": "Next booking risk",
+    "nextBookingRiskValue": "{{ref}} {{status}}",
+    "atRisk": "— may be affected",
+    "lowRisk": "— low risk",
+    "noUpcomingBooking": "No upcoming booking for this vehicle",
+    "odometerRegressionNotice": "The submitted odometer reading was below the vehicle's canonical odometer. It was recorded as-is; the canonical odometer was not changed, and a data-quality issue was opened for review.",
+    "viewVehicle": "View vehicle {{ref}}",
+    "viewAutomation": "View automation status",
+    "viewAudit": "View audit trail",
+    "continueDemo": "Continue the demo"
+  },
+  "scenario": {
+    "title": "Demo scenario: odometer anomaly",
+    "body": "This vehicle currently reads {{odometer}} km. The form below is pre-filled with a return reading below that — a sign of a data-entry mistake or a mixed-up vehicle. Confirm the return to see how Fleet Ops detects and handles this.",
+    "preparing": "Preparing scenario…"
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/accessibility.json b/frontend/src/i18n/locales/fr-BE/accessibility.json
new file mode 100644
index 0000000..89c94db
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/accessibility.json
@@ -0,0 +1,7 @@
+{
+  "openRow": "Ouvrir : {{label}}",
+  "reducedMotion": "Mouvement réduit actif",
+  "closeDialog": "Fermer la boîte de dialogue",
+  "expandSection": "Déplier la section",
+  "collapseSection": "Replier la section"
+}
diff --git a/frontend/src/i18n/locales/fr-BE/audit.json b/frontend/src/i18n/locales/fr-BE/audit.json
new file mode 100644
index 0000000..dc72532
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/audit.json
@@ -0,0 +1,64 @@
+{
+  "eyebrow": "Assurance / Historique immuable",
+  "title": "Piste d'audit",
+  "description": "Suivez les changements d'état importants, les acteurs et les références corrélées.",
+  "actionFilterLabel": "Action",
+  "actionFilterPlaceholder": "p. ex. demo_login",
+  "managerOnly": "La piste d'audit est visible uniquement pour les Operations Managers.",
+  "managerOnlyDetail": "L'historique d'audit est visible uniquement pour les Operations Managers.",
+  "loading": "Chargement de la piste d'audit…",
+  "unavailable": "La piste d'audit est actuellement indisponible.",
+  "empty": "Aucun événement d'audit trouvé",
+  "emptyDetail": "Ajustez le filtre d'action.",
+  "relatedFilterActive": "Affichage uniquement des événements liés à cette action ({{count}} événements liés).",
+  "clearFilter": "Effacer ce filtre",
+  "count": "{{count}} événements",
+  "storedRendered": "Stocké en UTC · Affiché en heure de Bruxelles",
+  "columns": {
+    "when": "Quand",
+    "actor": "Acteur",
+    "action": "Action",
+    "entity": "Entité",
+    "change": "Changement",
+    "followUp": "Suite",
+    "details": "Détails"
+  },
+  "viewRelatedEvents": "Voir les événements liés",
+  "noChangeDetail": "Aucun détail de changement enregistré.",
+  "noFieldChange": "Aucun changement au niveau des champs détecté.",
+  "reference": "Référence",
+  "relatedEventsCount": "{{count}} événement lié",
+  "relatedEventsCount_other": "{{count}} événements liés",
+  "showTechnicalEvents": "Afficher {{count}} événement technique",
+  "showTechnicalEvents_other": "Afficher {{count}} événements techniques",
+  "hideTechnicalEvents": "Masquer les événements techniques",
+  "technicalDetails": "Détails techniques",
+  "fullReference": "Référence complète",
+  "correlationId": "ID de corrélation",
+  "diff": {
+    "setTo": "{{field}} : défini à {{value}}",
+    "was": "{{field}} : était {{value}}",
+    "changed": "{{field}} : {{before}} → {{after}}"
+  },
+  "actions": {
+    "demo_login": "Connecté",
+    "demo_logout": "Déconnecté",
+    "demo_reset": "Données de démo réinitialisées",
+    "demo_data_seeded": "Données de démo chargées",
+    "return_registered": "Retour de véhicule enregistré",
+    "vehicle_status_changed": "Statut du véhicule modifié",
+    "data_quality_issue_resolved": "Problème de qualité résolu",
+    "data_quality_issue_deferred": "Problème de qualité reporté",
+    "data_quality_issue_rejected": "Problème de qualité rejeté",
+    "data_quality_fields_provided": "Champs manquants complétés",
+    "data_quality_odometer_corrected": "Kilométrage corrigé",
+    "data_quality_odometer_retained": "Kilométrage de référence conservé",
+    "data_quality_status_applied": "Statut recommandé appliqué",
+    "data_quality_booking_blocked": "Réservation bloquée",
+    "data_quality_scan_run": "Contrôle qualité exécuté",
+    "customer_merged": "Clients fusionnés",
+    "workflow_retry": "Automatisation retentée",
+    "knowledge_question_asked": "Question de connaissance posée",
+    "mcp_tool_request": "Outil MCP appelé"
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/auth.json b/frontend/src/i18n/locales/fr-BE/auth.json
new file mode 100644
index 0000000..2b7695e
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/auth.json
@@ -0,0 +1,23 @@
+{
+  "brandTagline": "Centre de contrôle",
+  "orgLine": "Organisation de démo : {{orgName}} (fictive)",
+  "headline1": "Chaque transfert.",
+  "headline2": "Une vue claire.",
+  "defaultDescription": "Fleet Ops rassemble les données de véhicules, de réservations et d'exploitation, soutient les processus de location, détecte les problèmes de qualité des données et automatise les suites contrôlées.",
+  "footnote": "Démo synthétique · aucune donnée client ou véhicule réelle · réinitialisable à tout moment",
+  "accessEyebrow": "Accès démo",
+  "accessHeading": "Choisissez comment démarrer",
+  "accessIntro": "Aucun mot de passe requis. Chaque rôle ouvre un environnement synthétique délimité — tous les workflows et contrôles sont réellement implémentés.",
+  "startGuidedDemo": "Démarrer la démo guidée",
+  "exploreAsOperationsManager": "Explorer en tant qu'Operations Manager",
+  "exploreAsOperationsManagerDetail": "Vue d'ensemble complète, résolution qualité et nouvelles tentatives",
+  "exploreAsRentalEmployee": "Explorer en tant que Rental Employee",
+  "exploreAsRentalEmployeeDetail": "Réservations, retours, flotte et procédures",
+  "safeByDesignTitle": "Conçu pour la sécurité",
+  "safeByDesignDetail": "Chaque action est enregistrée et peut être réinitialisée dans cette démo.",
+  "loginFailed": "La session de démo n'a pas pu démarrer. L'API est peut-être inaccessible.",
+  "roleOperationsManager": "Operations manager",
+  "roleRentalEmployee": "Rental employee",
+  "switchRole": "Changer de rôle",
+  "logout": "Déconnexion"
+}
diff --git a/frontend/src/i18n/locales/fr-BE/bookings.json b/frontend/src/i18n/locales/fr-BE/bookings.json
new file mode 100644
index 0000000..51e1e2f
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/bookings.json
@@ -0,0 +1,52 @@
+{
+  "list": {
+    "eyebrow": "Exploitation / Planning",
+    "title": "Réservations",
+    "description": "Consultez les périodes de location actives et les engagements de véhicules à venir.",
+    "searchLabel": "Rechercher",
+    "searchPlaceholder": "Réservation, client ou véhicule",
+    "statusLabel": "Statut",
+    "statusAll": "Tous les statuts",
+    "loading": "Chargement du registre des réservations…",
+    "empty": "Aucune réservation trouvée",
+    "emptyDetail": "Ajustez le filtre de statut des réservations.",
+    "noMatch": "Aucune réservation correspondante",
+    "noMatchDetail": "Essayez un terme de recherche plus large.",
+    "unavailable": "La liste des réservations est actuellement indisponible.",
+    "count": "{{count}} réservations",
+    "pageOf": "Page {{page}} sur {{total}}",
+    "columns": {
+      "reference": "Référence",
+      "customer": "Client",
+      "vehicle": "Véhicule",
+      "window": "Période",
+      "status": "Statut"
+    },
+    "paginationLabel": "Pages de réservations",
+    "previous": "Précédent",
+    "next": "Suivant",
+    "rangeOf": "{{from}}–{{to}} sur {{total}}"
+  },
+  "statuses": {
+    "reserved": "réservé",
+    "active": "actif",
+    "returned": "retourné",
+    "cancelled": "annulé",
+    "blocked": "bloqué"
+  },
+  "detail": {
+    "backLink": "Registre des réservations",
+    "eyebrow": "Réservations / Fiche de location",
+    "notFound": "Cette réservation est introuvable.",
+    "loading": "Chargement de la fiche de réservation…",
+    "customer": "Client",
+    "vehicle": "Véhicule",
+    "starts": "Début",
+    "ends": "Fin",
+    "startOdometer": "Kilométrage de départ",
+    "endOdometer": "Kilométrage de retour",
+    "requirementsComplete": "Exigences complètes",
+    "yes": "Oui",
+    "no": "Non"
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/common.json b/frontend/src/i18n/locales/fr-BE/common.json
new file mode 100644
index 0000000..74c52e9
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/common.json
@@ -0,0 +1,44 @@
+{
+  "appName": "Fleet Ops",
+  "orgName": "Northstar Mobility",
+  "brandTagline": "Centre de contrôle",
+  "actions": {
+    "save": "Enregistrer",
+    "cancel": "Annuler",
+    "confirm": "Confirmer",
+    "close": "Fermer",
+    "back": "Retour",
+    "next": "Suivant",
+    "retry": "Réessayer",
+    "reset": "Réinitialiser",
+    "yes": "Oui",
+    "no": "Non",
+    "viewDetails": "Voir les détails",
+    "technicalDetails": "Détails techniques"
+  },
+  "status": {
+    "loading": "Chargement…",
+    "saving": "Enregistrement…",
+    "error": "Une erreur est survenue",
+    "success": "Réussi",
+    "noResults": "Aucun résultat"
+  },
+  "states": {
+    "loadingDefault": "Chargement de l'espace de travail…",
+    "errorTitle": "Impossible de charger cet espace de travail."
+  },
+  "timezone": "Europe/Bruxelles",
+  "language": {
+    "label": "Langue",
+    "nl-BE": "Nederlands",
+    "en-GB": "English",
+    "fr-BE": "Français"
+  },
+  "footer": {
+    "productLine": "Fleet Ops Demo",
+    "locale": "Europe/Bruxelles · Données de démonstration synthétiques"
+  },
+  "demo": {
+    "syntheticBadge": "Démo synthétique"
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/dashboard.json b/frontend/src/i18n/locales/fr-BE/dashboard.json
new file mode 100644
index 0000000..97c8e6b
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/dashboard.json
@@ -0,0 +1,67 @@
+{
+  "eyebrow": "Exploitation / Aperçu en direct",
+  "title": "Bonjour. Voici votre flotte.",
+  "description": "Disponibilité, exceptions et transferts de l'activité en cours.",
+  "viewFleet": "Voir la flotte",
+  "demoStart": {
+    "title": "Essayer un scénario de démonstration",
+    "readyCount": "{{ready}} scénarios sur {{total}} prêts pour la démo.",
+    "readyCountFallback": "Cinq scénarios ciblés.",
+    "startGuide": "Démarrer le guide de démo",
+    "resumeGuide": "Poursuivre le guide de démo ({{current}}/{{total}})",
+    "viewScenarios": "Voir les scénarios"
+  },
+  "readiness": {
+    "title": "Disponibilité de la flotte",
+    "description": "En direct depuis l'état persistant des véhicules",
+    "openFleet": "Ouvrir la flotte",
+    "available": "Disponible",
+    "rented": "Loué",
+    "cleaning": "Nettoyage",
+    "maintenance": "Entretien",
+    "blocked": "Bloqué"
+  },
+  "attention": {
+    "title": "File d'attention",
+    "description": "{{openIssues}} problèmes de qualité ouverts · {{workflowExceptions}} exceptions de workflow",
+    "reviewQueue": "Examiner la file",
+    "filterPlaceholder": "Filtrer les problèmes…",
+    "filterAriaLabel": "Rechercher dans la file d'attention",
+    "severityAll": "Toute gravité",
+    "severityHigh": "Critique",
+    "severityMedium": "Avertissement",
+    "severityLow": "Info",
+    "severityAriaLabel": "Gravité",
+    "empty": "Aucun problème ne correspond à ce filtre.",
+    "openRecord": "Ouvrir {{title}}"
+  },
+  "movements": {
+    "title": "Mouvements du jour",
+    "description": "Départs et retours en Europe/Bruxelles",
+    "allBookings": "Toutes les réservations",
+    "empty": "Aucun mouvement prévu aujourd'hui.",
+    "departure": "départ",
+    "return": "retour",
+    "openBooking": "Ouvrir la réservation {{ref}}"
+  },
+  "integrationPulse": {
+    "title": "État des intégrations",
+    "description": "Preuves actuelles des services connectés",
+    "systemDetail": "Détail du système",
+    "n8nTitle": "Livraison n8n",
+    "n8nSummary": "{{succeeded}} réussies · {{failed}} échouées",
+    "n8nLatest": "Dernier événement {{ref}}",
+    "n8nNoEvidence": "Aucune preuve d'automatisation enregistrée",
+    "knowledgeTitle": "Assistant de connaissances",
+    "knowledgeSummary": "{{count}} procédures indexées",
+    "knowledgeUnavailable": "Vérification de santé indisponible",
+    "mcpTitle": "MCP Hub",
+    "mcpEnabled": "Enregistrement activé",
+    "mcpNotConnected": "Pas encore connecté"
+  },
+  "recent": {
+    "title": "Activité récente",
+    "description": "Derniers changements de workflow audités",
+    "empty": "Aucune activité d'automatisation enregistrée."
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/demo.json b/frontend/src/i18n/locales/fr-BE/demo.json
new file mode 100644
index 0000000..18874ed
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/demo.json
@@ -0,0 +1,189 @@
+{
+  "badge": {
+    "trigger": "Démo synthétique",
+    "dialogLabel": "À propos de cet environnement de démo",
+    "close": "Fermer",
+    "orgIntro": "<strong>{{orgName}}</strong> est une organisation fictive. Tous les noms, véhicules et réservations sont synthétiques.",
+    "orgIntroFallback": "Tous les noms, véhicules et réservations de cet environnement sont synthétiques.",
+    "realWorkflows": "Les workflows, contrôles et l'automatisation sont réellement implémentés — seules les données sont inventées.",
+    "lastReset": "Dernière réinitialisation : <strong>{{when}}</strong> · cet environnement peut être réinitialisé à tout moment.",
+    "aboutLink": "À propos de cette démo",
+    "unknown": "inconnu"
+  },
+  "guide": {
+    "dialogLabel": "Démo guidée",
+    "trigger": "Guide de démo",
+    "kicker": "Démo guidée · étape {{current}} sur {{total}}",
+    "whatYouWillSee": "Ce que vous allez voir",
+    "whyItMatters": "Pourquoi c'est important",
+    "startAction": "Pour commencer",
+    "expectedOutcome": "Résultat attendu",
+    "goToStep": "Aller à cette étape",
+    "next": "Suivant",
+    "close": "Fermer",
+    "restart": "Préparer à nouveau la démo",
+    "restarting": "Réinitialisation…",
+    "restartFailed": "Impossible de réinitialiser la démo.",
+    "allStepsLabel": "Toutes les étapes",
+    "progressChip": "Guide de démo · étape {{current}} sur {{total}}",
+    "expand": "Déplier le guide de démo",
+    "collapse": "Replier le guide de démo",
+    "steps": {
+      "understand-state": {
+        "title": "1. Comprendre l'état opérationnel",
+        "whatYouWillSee": "Le tableau de bord affiche la disponibilité de la flotte, les points d'attention ouverts et les mouvements du jour.",
+        "whyItMatters": "Un Operations Manager commence chaque journée par cet aperçu pour décider où intervenir.",
+        "startAction": "Ouvrez le tableau de bord et consultez la file d'attention et la chronologie du jour.",
+        "expectedOutcome": "Vous voyez quelles réservations, véhicules ou problèmes de qualité nécessitent de l'attention."
+      },
+      "open-booking": {
+        "title": "2. Ouvrir la réservation nécessitant de l'attention",
+        "whatYouWillSee": "La réservation BK-DEMO-RETURN, active et à retourner aujourd'hui.",
+        "whyItMatters": "Les retours sont le moment où les kilométrages incorrects ou les dommages deviennent visibles pour la première fois.",
+        "startAction": "Ouvrez la réservation depuis le tableau de bord ou la liste des réservations.",
+        "expectedOutcome": "Vous voyez les détails de la réservation et le bouton pour traiter le retour."
+      },
+      "process-return": {
+        "title": "3. Traiter un retour avec une anomalie de kilométrage",
+        "whatYouWillSee": "Un formulaire de retour pré-rempli avec un relevé de kilométrage suspect, inférieur au dernier relevé connu.",
+        "whyItMatters": "Un kilométrage en baisse signale une erreur de saisie ou un véhicule confondu — cela doit être détecté avant la libération.",
+        "startAction": "Soumettez le retour avec la valeur suggérée et examinez l'aperçu du serveur avant de confirmer.",
+        "expectedOutcome": "Le retour est traité, le véhicule reçoit un statut approprié, et un problème de qualité des données est créé automatiquement."
+      },
+      "handle-quality-issue": {
+        "title": "4. Traiter le problème de qualité créé",
+        "whatYouWillSee": "Un nouveau problème « anomalie de kilométrage » en haut de la file de travail.",
+        "whyItMatters": "Chaque problème détecté a une étape de résolution unique et délimitée — rien n'est corrigé automatiquement en silence.",
+        "startAction": "Ouvrez l'aperçu qualité des données et choisissez le problème le plus récent.",
+        "expectedOutcome": "Vous voyez l'action recommandée, choisissez une résolution, et le problème se résout avec une piste d'audit."
+      },
+      "merge-duplicate": {
+        "title": "5. Examiner et traiter un client potentiellement en double",
+        "whatYouWillSee": "Deux profils clients avec le même e-mail et numéro de téléphone, comparés côte à côte.",
+        "whyItMatters": "Les clients en double divisent l'historique de réservation et compliquent la communication.",
+        "startAction": "Comparez les deux profils et choisissez celui qui doit survivre.",
+        "expectedOutcome": "Les profils sont fusionnés, les réservations sont transférées, et le profil perdant devient une fiche archivée."
+      },
+      "ask-knowledge": {
+        "title": "6. Poser une question à l'assistant de procédures",
+        "whatYouWillSee": "Une réponse avec citation issue de la base de connaissances de démo délimitée.",
+        "whyItMatters": "Le personnel a besoin d'une réponse rapide et étayée sur les procédures, sans deviner.",
+        "startAction": "Cliquez sur l'une des questions suggérées, dans la langue actuelle de l'interface.",
+        "expectedOutcome": "Vous voyez la réponse, la procédure utilisée et le texte source — ou un honnête « informations insuffisantes » si aucune n'existe."
+      },
+      "check-automation-audit": {
+        "title": "7. Vérifier l'automatisation et la piste d'audit",
+        "whatYouWillSee": "Le statut de livraison de la tâche d'automatisation de votre retour, et ses événements d'audit liés.",
+        "whyItMatters": "Chaque action importante doit être traçable : qui a fait quoi, quand, et ce qui a suivi.",
+        "startAction": "Ouvrez Intégrations pour voir le statut de livraison, et Piste d'audit pour l'historique complet.",
+        "expectedOutcome": "Vous voyez une livraison réussie (ou récupérable) et une piste d'audit lisible de vos actions."
+      },
+      "review-real-vs-simulated": {
+        "title": "8. Passer en revue ce qui est réel, simulé ou pas encore connecté",
+        "whatYouWillSee": "Un aperçu de ce qui est fonctionnellement implémenté dans cette démo, ce qui est synthétique, et quelles intégrations ne sont pas encore en direct.",
+        "whyItMatters": "Une démo n'est convaincante que si les visiteurs peuvent vérifier eux-mêmes ce qui fonctionne réellement et ce qui reste à venir.",
+        "startAction": "Lisez la page « À propos de cette démo ».",
+        "expectedOutcome": "Vous pouvez expliquer vous-même ce que Fleet Ops est et n'est pas, sans explication verbale nécessaire."
+      }
+    }
+  },
+  "scenarios": {
+    "eyebrow": "Scénarios de démonstration",
+    "title": "Essayer un scénario de démonstration",
+    "description": "Cinq scénarios ciblés qui utilisent toujours les mêmes réservations, clients et véhicules fixes — toujours retrouvables après une réinitialisation.",
+    "loading": "Chargement des scénarios…",
+    "ready": "Prêt pour la démo",
+    "notReady": "Non disponible",
+    "duration": "Durée",
+    "durationValue": "± {{minutes}} min",
+    "role": "Rôle",
+    "demonstrates": "Démontre :",
+    "requiresRole": "Nécessite le rôle : {{roles}}.",
+    "startScenario": "Démarrer le scénario",
+    "roleOr": "{{a}} ou {{b}}",
+    "roles": {
+      "operations_manager": "Operations Manager",
+      "rental_employee": "Rental Employee"
+    },
+    "items": {
+      "return-anomaly": {
+        "title": "Retour avec anomalie de kilométrage",
+        "problem": "Un véhicule revient avec un relevé de kilométrage inférieur au dernier relevé enregistré — un signe d'erreur de saisie ou de véhicule confondu.",
+        "demonstrates": "Le traitement du retour, la détection automatique de problèmes de qualité des données et la piste d'audit qui en résulte."
+      },
+      "duplicate-customer": {
+        "title": "Fusionner un possible client en double",
+        "problem": "Deux fiches client partagent la même adresse e-mail et le même numéro de téléphone — probablement la même personne, enregistrée deux fois.",
+        "demonstrates": "La fusion de clients avec conservation de l'historique des réservations et de la piste d'audit."
+      },
+      "booking-overlap": {
+        "title": "Résoudre des réservations qui se chevauchent",
+        "problem": "Un véhicule est réservé en double pour des périodes qui se chevauchent — une erreur de planification à résoudre avant le départ.",
+        "demonstrates": "La détection et la résolution contrôlée des conflits de planification."
+      },
+      "automation-retry": {
+        "title": "Relancer une tâche d'automatisation échouée",
+        "problem": "Un événement précédent n'a pas pu être livré à l'automatisation en raison d'une erreur de connexion simulée.",
+        "demonstrates": "Une livraison fiable avec des nouvelles tentatives limitées et un statut d'échec visible."
+      },
+      "knowledge-question": {
+        "title": "Poser une question de procédure",
+        "problem": "Un employé n'est pas sûr de la procédure applicable à une situation opérationnelle précise.",
+        "demonstrates": "Des réponses étayées par les sources, issues d'une base de connaissances de démo délimitée."
+      }
+    },
+    "blockedReasons": {
+      "bookingNotFound": "Réservation de démo BK-DEMO-RETURN introuvable. {{resetHint}}",
+      "bookingAlreadyProcessed": "Cette réservation a déjà été traitée depuis la dernière réinitialisation. {{resetHint}}",
+      "duplicateIssueNotFound": "Problème de démo DQ-DEMO-DUPLICATE introuvable. {{resetHint}}",
+      "issueAlreadyResolved": "Ce problème a déjà été résolu depuis la dernière réinitialisation. {{resetHint}}",
+      "overlapIssueNotFound": "Problème de démo DQ-DEMO-OVERLAP introuvable. {{resetHint}}",
+      "failedEventNotFound": "L'événement simulé en échec est introuvable. {{resetHint}}",
+      "eventAlreadyRecovered": "Cet événement a déjà été rétabli depuis la dernière réinitialisation. {{resetHint}}",
+      "knowledgeUnavailable": "La base de connaissances de démo est actuellement indisponible.",
+      "resetHint": "Réinitialisez les données de démo pour rendre ce scénario à nouveau disponible."
+    }
+  },
+  "about": {
+    "eyebrow": "À propos de cette démo",
+    "title": "Ce que Fleet Ops est et n'est pas",
+    "description": "{{orgName}} est une organisation de location fictive qui rend cette démo concrète — pas une véritable entreprise.",
+    "loading": "Chargement des informations de démo…",
+    "ctaTitle": "Vous préférez vous lancer directement ?",
+    "ctaBody": "La démo guidée parcourt les huit étapes ci-dessus en pratique.",
+    "ctaButton": "Démarrer la démo guidée",
+    "problemTitle": "Le problème fictif",
+    "problemBody": "{{orgName}} loue environ 50 campings-cars et fourgonnettes depuis un site principal. Les réservations, retours, fiches clients et l'entretien vivaient jusqu'ici dans des feuilles de calcul séparées et des échanges verbaux, si bien que les problèmes (clients en double, kilométrages incorrects, véhicules réservés en double) n'apparaissaient que tardivement. Fleet Ops montre comment un système unique et connecté signale ces problèmes tôt et permet de les résoudre de façon contrôlée.",
+    "scopeTitle": "Pour qui et avec quelle portée",
+    "scopeBody": "Cette démo s'adresse à quiconque veut voir comment Fleet Ops traite les problèmes opérationnels d'un petit loueur : Operations Managers et Rental Employees, et toute personne évaluant l'approche. La portée est délibérément limitée à une preuve de concept unique et cohérente — pas de comptabilité, pas de paiements, pas de réservations publiques, pas de CRM ou ERP complet.",
+    "realTitle": "Ce qui fonctionne réellement",
+    "realBody": "Tout ce qui suit est du code fonctionnel, pas seulement une maquette : accès et sessions basés sur les rôles, gestion des véhicules et réservations, traitement des retours avec validation côté serveur, cinq règles de qualité des données avec chacune sa propre étape de résolution, une piste d'audit complète, une livraison automatisée vers n8n avec nouvelles tentatives limitées, un déploiement basé sur Docker, et une suite de tests automatisés (backend et Playwright de bout en bout).",
+    "syntheticTitle": "Ce qui est synthétique",
+    "syntheticBody": "L'organisation, tous les clients, véhicules, réservations, historiques d'entretien, procédures de la base de connaissances et les scénarios préconfigurés sont entièrement inventés. Aucune donnée ne fait référence à une personne, un véhicule ou une entreprise réels ; les adresses e-mail utilisent uniquement le domaine de test {{testDomain}}.",
+    "architectureTitle": "Architecture en bref",
+    "architectureBody": "Un frontend React/TypeScript communique avec un backend FastAPI (PostgreSQL via des migrations SQLAlchemy/Alembic) ; les règles métier importantes vivent dans le backend, pas dans n8n ni dans des prompts. Les retours et autres événements sont d'abord validés localement, puis livrés de façon asynchrone à n8n via une tâche d'automatisation, de sorte qu'une panne temporaire de l'automatisation ne bloque jamais une action opérationnelle.",
+    "securityTitle": "Sécurité et accès",
+    "securityBody": "L'accès passe par des cookies de session signés, HTTP-only, par rôle ; chaque rôle est lié à un ensemble de routes autorisées, appliqué côté serveur et reflété dans la navigation. Les changements d'état importants sont toujours vérifiés et enregistrés — jamais corrigés automatiquement en silence.",
+    "testingTitle": "Comment cela est testé",
+    "testingBody": "Une suite de tests backend automatisée couvre les règles métier et les contrats d'API ; une suite Playwright de bout en bout complète couvre les parcours utilisateurs, y compris cette expérience de démo elle-même en trois langues. Chaque modification est également validée sur une installation propre (base de données vide, reconstruite à partir des données initiales) avant le déploiement.",
+    "integrationsTitle": "Intégrations — étiquetées honnêtement",
+    "integrationsDescription": "Ce qui est opérationnel, ce qui est en mode démo, et ce qui n'est pas encore connecté.",
+    "resetTitle": "Restaurer l'environnement de démo",
+    "resetBodyManager": "L'environnement peut être réinitialisé à son état de départ à tout moment. Dernière réinitialisation : <strong>{{when}}</strong>. Utilisez <strong>Réinitialiser les données de démo</strong> dans la barre latérale pour recommencer.",
+    "resetBodyEmployee": "L'environnement peut être réinitialisé à son état de départ à tout moment. Dernière réinitialisation : <strong>{{when}}</strong>. Un Operations Manager peut réinitialiser l'environnement de démo via la barre latérale.",
+    "limitationsTitle": "Limitations",
+    "limitationsBody": "Ceci est une preuve de concept ciblée, pas un ERP complet. RAGcore et l'ITWorx MCP Hub ne sont pas encore connectés en direct ; l'assistant de connaissances utilise une base de connaissances de démo locale et délimitée au lieu d'un environnement RAGcore en direct.",
+    "unknown": "inconnu"
+  },
+  "integrationSummary": {
+    "titles": {
+      "n8n": "Automatisation (n8n)",
+      "ragcore": "Assistant de connaissances (RAGcore)",
+      "mcp_hub": "ITWorx MCP Hub"
+    },
+    "n8nDetail": "{{succeeded}} réussi(s) · {{failed}} échoué(s) · {{pending}} en attente.",
+    "ragcoreDetail": "{{count}} procédures indexées dans {{collection}}.",
+    "mcpDetailEnabled": "Préparé pour de futurs appels d'outils contrôlés depuis le Hub.",
+    "mcpDetailNotConnected": "Pas encore connecté — préparé pour de futurs appels d'outils contrôlés depuis le Hub."
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/errors.json b/frontend/src/i18n/locales/fr-BE/errors.json
new file mode 100644
index 0000000..b3cdec1
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/errors.json
@@ -0,0 +1,8 @@
+{
+  "generic": "Une erreur est survenue. Veuillez réessayer.",
+  "workspaceLoadFailed": "Nous n'avons pas pu charger cet espace de travail.",
+  "unauthorized": "Votre session a expiré. Veuillez vous reconnecter.",
+  "forbidden": "Vous n'avez pas accès à cette section.",
+  "notFound": "Cette fiche est introuvable.",
+  "networkUnavailable": "La connexion au serveur est actuellement indisponible."
+}
diff --git a/frontend/src/i18n/locales/fr-BE/fleet.json b/frontend/src/i18n/locales/fr-BE/fleet.json
new file mode 100644
index 0000000..5678d7c
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/fleet.json
@@ -0,0 +1,68 @@
+{
+  "list": {
+    "eyebrow": "Flotte / Registre",
+    "title": "Flotte de véhicules",
+    "description": "État opérationnel en direct, localisation et disponibilité pour l'entretien.",
+    "searchLabel": "Rechercher",
+    "searchPlaceholder": "Référence, marque ou localisation",
+    "statusLabel": "Statut",
+    "statusAll": "Tous les statuts",
+    "attentionOnly": "Attention uniquement",
+    "loading": "Chargement du registre de la flotte…",
+    "empty": "Aucun véhicule trouvé",
+    "emptyDetail": "Ajustez les filtres de flotte actuels.",
+    "noMatch": "Aucun véhicule correspondant",
+    "noMatchDetail": "Essayez un terme de recherche plus large.",
+    "unavailable": "La liste des véhicules est actuellement indisponible.",
+    "count": "{{count}} véhicules",
+    "persisted": "Données de flotte persistantes",
+    "columns": {
+      "reference": "Référence",
+      "makeModel": "Marque / modèle",
+      "location": "Localisation",
+      "status": "Statut",
+      "odometer": "Kilométrage (km)",
+      "attention": "Attention"
+    },
+    "needsAttention": "Nécessite de l'attention"
+  },
+  "statuses": {
+    "available": "disponible",
+    "rented": "loué",
+    "cleaning": "nettoyage",
+    "maintenance": "entretien",
+    "blocked": "bloqué"
+  },
+  "detail": {
+    "backLink": "Registre de la flotte",
+    "eyebrow": "Flotte / Fiche véhicule",
+    "notFound": "Ce véhicule est introuvable.",
+    "loading": "Chargement de la fiche véhicule…",
+    "needsAttention": "Nécessite de l'attention",
+    "tabs": {
+      "overview": "Aperçu",
+      "bookings": "Réservations",
+      "inspections": "Inspections",
+      "maintenance": "Entretien",
+      "quality": "Qualité"
+    },
+    "tabsAriaLabel": "Sections du véhicule",
+    "overview": {
+      "registration": "Immatriculation",
+      "modelYear": "Année du modèle",
+      "location": "Localisation",
+      "odometer": "Kilométrage",
+      "nextService": "Prochain entretien",
+      "active": "Actif"
+    },
+    "yes": "Oui",
+    "no": "Non",
+    "noBookings": "Aucune réservation enregistrée.",
+    "noInspections": "Aucune inspection enregistrée.",
+    "noMaintenance": "Aucun historique d'entretien.",
+    "noQualityIssues": "Aucun problème de qualité enregistré.",
+    "fuel": "Carburant {{percent}}%",
+    "damage": "Dommage",
+    "technicalWarning": "Avertissement technique"
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/integrations.json b/frontend/src/i18n/locales/fr-BE/integrations.json
new file mode 100644
index 0000000..9d775cc
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/integrations.json
@@ -0,0 +1,70 @@
+{
+  "eyebrow": "Assurance / Intégrations",
+  "title": "Contrôle des intégrations",
+  "description": "Surveillez la santé des livraisons, la dégradation contrôlée et les événements de workflow réessayables.",
+  "cards": {
+    "orchestrationKicker": "Orchestration",
+    "n8nTitle": "Livraison n8n",
+    "n8nSummary": "{{succeeded}} réussies · {{failed}} échouées · {{pending}} en attente · {{delivering}} en cours",
+    "n8nFallback": "Les événements de retour sont d'abord validés localement, puis livrés via la tâche d'automatisation.",
+    "knowledgeKicker": "Connaissances",
+    "knowledgeTitle": "Assistant de connaissances",
+    "knowledgeSummaryDemo": "Base de connaissances de démo · {{count}} procédures indexées dans {{collection}}.",
+    "knowledgeSummaryRagcore": "RAGcore · {{count}} procédures indexées dans {{collection}}.",
+    "knowledgeUnavailable": "Preuves de santé actuellement indisponibles.",
+    "gatewayKicker": "Passerelle d'outils",
+    "mcpTitle": "MCP Hub",
+    "mcpEnabled": "L'enregistrement est activé pour ce déploiement.",
+    "mcpNotConnected": "Pas encore connecté — préparé pour de futurs appels d'outils contrôlés depuis le Hub."
+  },
+  "statusLabels": {
+    "notConnected": "Non connecté",
+    "deliveryFailed": "Livraison échouée",
+    "retryAvailable": "Nouvelle tentative possible",
+    "operational": "Opérationnel",
+    "prepared": "Préparé",
+    "demoMode": "Mode démo",
+    "unavailable": "Indisponible"
+  },
+  "ledger": {
+    "title": "Tâches d'automatisation",
+    "description": "Tentatives d'automatisation enregistrées avec les dernières preuves d'échec.",
+    "filterLabel": "Vue",
+    "filterNeedsAttention": "Nécessite de l'attention",
+    "filterRecent": "Récent",
+    "filterSucceeded": "Réussi",
+    "filterAll": "Tout",
+    "statusFilterLabel": "Statut",
+    "statusAll": "Tous les statuts",
+    "statusPending": "En attente",
+    "statusDelivering": "En cours",
+    "statusSucceeded": "Réussi",
+    "statusFailed": "Échoué",
+    "unavailable": "Les tâches d'automatisation sont actuellement indisponibles.",
+    "managerOnly": "L'automatisation est visible uniquement pour les Operations Managers.",
+    "loading": "Chargement des tâches d'automatisation…",
+    "empty": "Aucune tâche d'automatisation ne correspond à ce filtre.",
+    "count": "{{count}} événements de workflow",
+    "boundedRetries": "Nouvelles tentatives limitées",
+    "groupedSucceeded": "{{count}} retours de véhicules traités avec succès",
+    "showIndividually": "Afficher les tâches individuelles",
+    "hideIndividually": "Masquer les tâches individuelles",
+    "columns": {
+      "event": "Tâche",
+      "type": "Type",
+      "booking": "Réservation",
+      "status": "Statut",
+      "attempts": "Tentatives",
+      "lastError": "Dernière erreur",
+      "when": "Quand",
+      "action": "Action"
+    },
+    "retry": "Réessayer",
+    "retrying": "Nouvelle tentative…",
+    "retryFailed": "Impossible de réessayer cette livraison.",
+    "noAction": "—",
+    "eventTypes": {
+      "vehicle.returned.v1": "Retour de véhicule traité"
+    }
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/knowledge.json b/frontend/src/i18n/locales/fr-BE/knowledge.json
new file mode 100644
index 0000000..60f935d
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/knowledge.json
@@ -0,0 +1,41 @@
+{
+  "eyebrow": "Assurance / Connaissances étayées",
+  "title": "Connaissance des procédures",
+  "description": "Posez des questions opérationnelles. Les réponses ne s'affichent que lorsque {{provider}} renvoie suffisamment de preuves citées.",
+  "providerDemo": "la base de connaissances de démo",
+  "providerRagcore": "RAGcore",
+  "statusAvailable": "Disponible",
+  "statusUnavailable": "Indisponible",
+  "proceduresIndexed": "{{count}} procédures indexées",
+  "providerNote": "Cette démo répond à partir d'un petit ensemble fixe de procédures indexées — pas d'une connexion RAGcore en direct. Un backend RAGcore en direct reprendra plus tard la même interface sans changer le fonctionnement de cette page.",
+  "askHeading": "Poser une question de procédure",
+  "askSubheading": "Recherche → vérification des preuves → réponse étayée",
+  "questionLabel": "Question",
+  "questionPlaceholder": "p. ex. Que dois-je faire quand un véhicule revient endommagé ?",
+  "ask": "Demander",
+  "asking": "Question en cours…",
+  "askFailed": "Impossible de joindre le service de connaissances.",
+  "suggestedLabel": "Essayez :",
+  "suggestedQuestions": [
+    "Que dois-je faire quand un véhicule revient avec des dommages ?",
+    "Comment enregistrer le retour d'un véhicule ?",
+    "Quand un véhicule peut-il redevenir disponible ?",
+    "Qui examine un relevé de kilométrage inhabituel ?",
+    "Quels contrôles sont requis avant le départ ?"
+  ],
+  "emptyTitle": "Des preuves avant les réponses",
+  "emptyDescription": "Posez des questions sur les retours, les dommages, les inspections ou une autre procédure indexée. Fleet Ops n'invente jamais de réponse en l'absence de preuves.",
+  "retrievalFlow": {
+    "question": "Question",
+    "sources": "Sources",
+    "answer": "Réponse"
+  },
+  "questionLabelExchange": "Question",
+  "evidenceStates": {
+    "grounded": "Étayé par des procédures citées",
+    "insufficient": "Preuves insuffisantes",
+    "unavailable": "Service de connaissances indisponible"
+  },
+  "unavailableBody": "Le service de connaissances est actuellement inaccessible. Les fonctions opérationnelles ne sont pas affectées — réessayez plus tard.",
+  "sourceVersion": "v{{version}}"
+}
diff --git a/frontend/src/i18n/locales/fr-BE/navigation.json b/frontend/src/i18n/locales/fr-BE/navigation.json
new file mode 100644
index 0000000..2c648d3
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/navigation.json
@@ -0,0 +1,39 @@
+{
+  "skipToContent": "Aller au contenu principal",
+  "groups": {
+    "operate": "Exploiter",
+    "assure": "Assurer"
+  },
+  "items": {
+    "overview": "Aperçu",
+    "fleet": "Flotte",
+    "bookings": "Réservations",
+    "quality": "Qualité des données",
+    "knowledge": "Connaissances",
+    "integrations": "Intégrations",
+    "audit": "Piste d'audit"
+  },
+  "primaryNavLabel": "Navigation principale",
+  "mobileNavLabel": "Navigation mobile",
+  "more": "Plus",
+  "openNavigation": "Ouvrir la navigation",
+  "closeNavigation": "Fermer la navigation",
+  "sidebarEnvironment": "Environnement de démo",
+  "sidebarEnvironmentDetail": "Données synthétiques uniquement",
+  "resetDemoData": "Réinitialiser les données de démo",
+  "resetConfirmTitle": "Confirmer la réinitialisation",
+  "resetConfirmBody": "Toutes les modifications synthétiques seront annulées et les données de démo déterministes restaurées. Vous serez déconnecté.",
+  "resetting": "Réinitialisation…",
+  "resetConfirmYes": "Oui, réinitialiser",
+  "resetCancel": "Annuler",
+  "resetFailed": "Impossible de réinitialiser les données de démo.",
+  "searchLabel": "Rechercher dans Fleet Ops",
+  "searchPlaceholder": "Rechercher flotte, réservation ou section…",
+  "searchShortcutHint": "Ctrl K",
+  "searchSearching": "Recherche…",
+  "searchUnavailable": "La recherche est momentanément indisponible.",
+  "searchNoResults": "Aucun résultat pour « {{query}} ».",
+  "switchRole": "Changer de rôle",
+  "switchRoleTitle": "Changer de rôle de démo",
+  "languageSwitcherLabel": "Changer de langue"
+}
diff --git a/frontend/src/i18n/locales/fr-BE/quality.json b/frontend/src/i18n/locales/fr-BE/quality.json
new file mode 100644
index 0000000..215d06b
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/quality.json
@@ -0,0 +1,192 @@
+{
+  "list": {
+    "eyebrow": "Assurance / Atelier",
+    "title": "Qualité des données",
+    "description": "Résolvez les exceptions étayées par des preuves avant qu'elles ne perturbent l'exploitation.",
+    "runScan": "Lancer le contrôle qualité",
+    "confirmScanTitle": "Confirmer le contrôle qualité",
+    "confirmScanBody": "Lancer maintenant le contrôle déterministe sur les cinq types de règles ?",
+    "scanning": "Analyse en cours…",
+    "confirmScanYes": "Oui, lancer",
+    "cancel": "Annuler",
+    "scanComplete": "Contrôle terminé : {{summary}}",
+    "scanNoNew": "aucun nouveau problème trouvé (les problèmes ouverts existants ne sont pas recréés).",
+    "scanFailed": "Impossible d'exécuter le contrôle qualité.",
+    "statusLabel": "Statut",
+    "statusAll": "Tous les statuts",
+    "statusOpen": "Ouvert",
+    "statusDeferred": "Reporté",
+    "statusResolved": "Résolu",
+    "statusRejected": "Rejeté",
+    "ruleTypeLabel": "Type de règle",
+    "ruleTypeAll": "Tous les types de règles",
+    "demoScenariosOnly": "Scénarios de démo uniquement",
+    "loading": "Chargement de l'atelier qualité…",
+    "queueClear": "La file est vide",
+    "noIssuesMatch": "Aucun problème ne correspond aux filtres actuels.",
+    "noDemoIssuesMatch": "Aucun problème de scénario de démo ne correspond",
+    "noDemoIssuesMatchDetail": "Décochez « Scénarios de démo uniquement » pour voir la file complète.",
+    "unavailable": "Les problèmes de qualité des données sont actuellement indisponibles.",
+    "count": "{{count}} problèmes",
+    "evidenceBacked": "Détection étayée par des preuves",
+    "columns": {
+      "reference": "Référence",
+      "rule": "Règle",
+      "entity": "Entité",
+      "severity": "Gravité",
+      "status": "Statut"
+    }
+  },
+  "ruleTypes": {
+    "possible_duplicate_customer": "Client peut-être en double",
+    "missing_required_field": "Champ obligatoire manquant",
+    "odometer_regression": "Anomalie de kilométrage",
+    "booking_overlap": "Chevauchement de réservations",
+    "vehicle_status_conflict": "Conflit de statut du véhicule"
+  },
+  "severities": {
+    "high": "Critique",
+    "medium": "Avertissement",
+    "low": "Info"
+  },
+  "detail": {
+    "backLink": "Atelier qualité",
+    "eyebrow": "Qualité / {{rule}}",
+    "title": "Examinez les preuves enregistrées et consignez une résolution auditée.",
+    "notFound": "Ce problème est introuvable.",
+    "loading": "Chargement des preuves du problème…",
+    "managerOnly": "L'atelier qualité est visible uniquement pour les Operations Managers.",
+    "managerOnlyDetail": "Les preuves et résolutions de qualité des données sont visibles uniquement pour les Operations Managers.",
+    "summary": {
+      "rule": "Règle",
+      "entity": "Entité",
+      "evidenceSummary": "Résumé des preuves"
+    },
+    "resolved": {
+      "title": "Problème {{ref}} résolu",
+      "body": "La modification a été appliquée et enregistrée dans la piste d'audit.",
+      "viewAudit": "Voir la piste d'audit",
+      "viewVehicle": "Voir le véhicule",
+      "continueDemo": "Poursuivre la démo"
+    },
+    "deferOrReject": {
+      "heading": "Reporter ou rejeter",
+      "description": "Reportez pour un examen ultérieur, ou rejetez si ce n'est pas un véritable problème.",
+      "defer": "Reporter",
+      "reject": "Rejeter",
+      "deferFailed": "Impossible de reporter ce problème.",
+      "rejectFailed": "Impossible de rejeter ce problème."
+    },
+    "explainer": {
+      "whatIsWrong": "Ce qui ne va pas",
+      "whyItMatters": "Pourquoi c'est important",
+      "possible_duplicate_customer": {
+        "whatIsWrong": "Deux profils clients partagent des données d'identification (e-mail, téléphone ou un nom très similaire) suffisamment fortement pour qu'il s'agisse probablement de la même personne, enregistrée deux fois.",
+        "whyItMatters": "Les clients en double répartissent l'historique de réservation entre deux fiches, risquent une double facturation et compliquent les échanges avec le support."
+      },
+      "missing_required_field": {
+        "whatIsWrong": "Cette fiche manque d'informations requises pour un fonctionnement normal (par exemple, un client sans e-mail ni numéro de téléphone enregistré).",
+        "whyItMatters": "Sans ces données, l'entreprise ne peut pas contacter le client, ni identifier de façon fiable le véhicule pour les contrôles de conformité et de remise."
+      },
+      "odometer_regression": {
+        "whatIsWrong": "Un relevé de kilométrage soumis est inférieur au dernier relevé connu (de référence) du véhicule.",
+        "whyItMatters": "Un kilométrage en baisse signifie généralement une erreur de saisie ou que les relevés ont été enregistrés pour le mauvais véhicule. Laisser passer cela silencieusement corromprait la planification de l'entretien et l'historique kilométrique à la revente."
+      },
+      "booking_overlap": {
+        "whatIsWrong": "Le même véhicule est engagé sur deux réservations dont les périodes se chevauchent.",
+        "whyItMatters": "Une seule de ces réservations peut réellement être honorée. Non résolu, un client arriverait pour constater que son véhicule est déjà chez quelqu'un d'autre."
+      },
+      "vehicle_status_conflict": {
+        "whatIsWrong": "Le statut opérationnel enregistré de ce véhicule ne correspond pas à ce que son propre historique de réservations et d'inspections implique.",
+        "whyItMatters": "Un statut incorrect peut faire apparaître un véhicule indisponible comme réservable, ou masquer un véhicule disponible de la flotte."
+      }
+    },
+    "duplicateCustomer": {
+      "heading": "Comparer et fusionner",
+      "description": "Choisissez le client de référence et examinez chaque champ divergent.",
+      "keepAsSurvivor": "Conserver comme fiche principale",
+      "differs": "Diffère",
+      "match": "Identique",
+      "mergePreview": "{{loser}} deviendra une fiche archivée liée à {{survivor}} ; ses réservations seront transférées.",
+      "mergeInto": "Fusionner avec {{ref}}",
+      "confirmMergeTitle": "Confirmer la fusion",
+      "confirmMergeBody": "Fusionner {{loser}} avec {{survivor}} ? Cette action est irréversible.",
+      "merging": "Fusion en cours…",
+      "confirmMergeYes": "Oui, fusionner",
+      "mergeFailed": "Impossible de fusionner ces clients.",
+      "bothMissing": "Les deux clients de cette comparaison n'ont pas pu être chargés.",
+      "fieldColumn": "Champ",
+      "fields": {
+        "first_name": "Prénom",
+        "last_name": "Nom",
+        "email": "E-mail",
+        "phone": "Téléphone",
+        "postal_code": "Code postal",
+        "city": "Ville"
+      }
+    },
+    "missingField": {
+      "heading": "Compléter les champs manquants",
+      "description": "Complétez la fiche pour {{ref}}. Le problème se résout automatiquement dès qu'aucune donnée requise ne manque.",
+      "atLeastOne": "Au moins un e-mail ou un numéro de téléphone est requis.",
+      "saveAndRecheck": "Enregistrer et revérifier",
+      "saving": "Enregistrement…",
+      "saveFailed": "Impossible d'enregistrer ces champs.",
+      "fields": {
+        "first_name": "Prénom",
+        "last_name": "Nom",
+        "email": "E-mail",
+        "phone": "Téléphone",
+        "registration_number": "Numéro d'immatriculation",
+        "make": "Marque",
+        "model": "Modèle",
+        "location": "Localisation"
+      }
+    },
+    "odometerRegression": {
+      "heading": "Résoudre l'anomalie de kilométrage",
+      "description": "Le kilométrage de référence n'est jamais abaissé automatiquement — choisissez comment le régulariser.",
+      "canonicalOdometer": "Kilométrage de référence",
+      "decisionLegend": "Décision",
+      "retainCanonical": "Conserver le relevé de référence",
+      "retainCanonicalDetail": "Considérer le relevé soumis comme erroné ; rien ne change sur la fiche du véhicule.",
+      "correctReading": "Corriger le relevé",
+      "correctReadingDetail": "Mettre à jour à la fois la réservation et le kilométrage de référence avec la valeur correcte.",
+      "noBookingAttached": "Aucune réservation liée à ce problème, seule l'option « conserver la référence » est donc disponible.",
+      "booking": "Réservation",
+      "correctedOdometer": "Kilométrage corrigé (km)",
+      "note": "Note",
+      "resolving": "Résolution en cours…",
+      "resolveIssue": "Résoudre le problème",
+      "resolveFailed": "Impossible de résoudre ce problème."
+    },
+    "bookingOverlap": {
+      "heading": "Résoudre le chevauchement de réservations",
+      "description": "Bloquez l'un des deux engagements qui se chevauchent. L'autre conserve son statut actuel.",
+      "columns": {
+        "booking": "Réservation",
+        "window": "Période",
+        "status": "Statut",
+        "blockThis": "Bloquer celle-ci"
+      },
+      "blockLabel": "Bloquer {{ref}}",
+      "note": "Note",
+      "resolving": "Résolution en cours…",
+      "blockButton": "Bloquer {{ref}}",
+      "blockButtonFallback": "Bloquer la réservation",
+      "resolveFailed": "Impossible de résoudre ce chevauchement."
+    },
+    "vehicleStatusConflict": {
+      "heading": "Résoudre le conflit de statut",
+      "description": "Une règle faisant autorité recommande un statut opérationnel corrigé pour ce véhicule.",
+      "currentStatus": "Statut actuel",
+      "calculateAndApply": "Calculer et appliquer le statut recommandé",
+      "confirmTitle": "Confirmer le changement de statut",
+      "confirmBody": "Appliquer le statut recommandé faisant autorité pour ce véhicule ?",
+      "applying": "Application en cours…",
+      "confirmYes": "Oui, appliquer",
+      "applied": "Appliqué {{status}} — {{reason}}",
+      "applyFailed": "Impossible d'appliquer un statut recommandé."
+    }
+  }
+}
diff --git a/frontend/src/i18n/locales/fr-BE/returns.json b/frontend/src/i18n/locales/fr-BE/returns.json
new file mode 100644
index 0000000..fe43257
--- /dev/null
+++ b/frontend/src/i18n/locales/fr-BE/returns.json
@@ -0,0 +1,73 @@
+{
+  "progress": {
+    "capture": "Saisie",
+    "review": "Vérification",
+    "result": "Résultat",
+    "ariaLabel": "Progression de l'enregistrement du retour"
+  },
+  "capture": {
+    "heading": "Enregistrer le retour du véhicule",
+    "description": "Enregistrez l'état à la restitution. L'étape suivante évalue les conséquences opérationnelles exactes avant toute validation.",
+    "endOdometer": "Kilométrage de retour (km)",
+    "fuelLevel": "Niveau de carburant (%)",
+    "conditionLegend": "État du véhicule",
+    "cleanlinessOk": "Propreté acceptable",
+    "damageReported": "Dommage signalé",
+    "technicalWarning": "Avertissement technique",
+    "notes": "Notes",
+    "evaluating": "Évaluation…",
+    "reviewReturn": "Vérifier le retour"
+  },
+  "review": {
+    "heading": "Vérifier l'impact du retour",
+    "description": "Ceci est l'évaluation faisant autorité du serveur sur ce que la validation entraînera — confirmez avant la mise à jour de l'état de la flotte et le déclenchement de l'automatisation.",
+    "odometer": "Kilométrage",
+    "fuel": "Carburant",
+    "cleanliness": "Propreté",
+    "cleanlinessAccepted": "Acceptée",
+    "cleanlinessFollowUp": "Suivi nécessaire",
+    "damage": "Dommage",
+    "damageReported": "Signalé",
+    "damageNone": "Aucun signalé",
+    "technicalWarning": "Avertissement technique",
+    "technicalWarningReported": "Signalé",
+    "technicalWarningNone": "Aucun signalé",
+    "expectedState": "État de flotte attendu :",
+    "odometerRegressionWarning": "Le kilométrage saisi ({{submitted}} km) est inférieur au relevé de référence ({{canonical}} km). Le kilométrage de référence ne changera pas et un problème de qualité des données sera ouvert.",
+    "nextBookingRisk": "La prochaine réservation {{ref}} débute {{when}} — peut être affectée par ce retour.",
+    "nextBookingLowRisk": "La prochaine réservation {{ref}} débute {{when}} — risque faible.",
+    "commitList": {
+      "inspection": "Créer une inspection de retour",
+      "updateAtomic": "Mettre à jour la réservation et le véhicule de façon atomique",
+      "queueAutomation": "Planifier l'automatisation après la validation locale"
+    },
+    "editDetails": "Modifier les détails",
+    "registering": "Enregistrement…",
+    "confirmReturn": "Confirmer le retour"
+  },
+  "result": {
+    "committedLocally": "Validé localement",
+    "heading": "Retour enregistré",
+    "inspection": "Inspection",
+    "resultingStatus": "Statut de véhicule résultant",
+    "qualityIssue": "Problème de qualité",
+    "noneCreated": "Aucun créé",
+    "automationEvent": "Tâche d'automatisation",
+    "queuedForDelivery": "En attente de traitement ({{ref}}) — validation locale réussie ; la livraison par automatisation est asynchrone et pas encore confirmée.",
+    "nextBookingRisk": "Risque prochaine réservation",
+    "nextBookingRiskValue": "{{ref}} {{status}}",
+    "atRisk": "— peut être affectée",
+    "lowRisk": "— risque faible",
+    "noUpcomingBooking": "Aucune réservation à venir pour ce véhicule",
+    "odometerRegressionNotice": "Le kilométrage saisi était inférieur au kilométrage de référence du véhicule. Il a été enregistré tel quel ; le kilométrage de référence n'a pas changé et un problème de qualité des données a été ouvert pour examen.",
+    "viewVehicle": "Voir le véhicule {{ref}}",
+    "viewAutomation": "Voir le statut d'automatisation",
+    "viewAudit": "Voir la piste d'audit",
+    "continueDemo": "Poursuivre la démo"
+  },
+  "scenario": {
+    "title": "Scénario de démo : anomalie de kilométrage",
+    "body": "Ce véhicule affiche actuellement {{odometer}} km. Le formulaire ci-dessous est pré-rempli avec un relevé de retour inférieur — signe d'une erreur de saisie ou d'un véhicule confondu. Confirmez le retour pour voir comment Fleet Ops détecte et traite cela.",
+    "preparing": "Préparation du scénario…"
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/accessibility.json b/frontend/src/i18n/locales/nl-BE/accessibility.json
new file mode 100644
index 0000000..63884bf
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/accessibility.json
@@ -0,0 +1,7 @@
+{
+  "openRow": "Openen: {{label}}",
+  "reducedMotion": "Beperkte beweging actief",
+  "closeDialog": "Dialoogvenster sluiten",
+  "expandSection": "Sectie uitklappen",
+  "collapseSection": "Sectie inklappen"
+}
diff --git a/frontend/src/i18n/locales/nl-BE/audit.json b/frontend/src/i18n/locales/nl-BE/audit.json
new file mode 100644
index 0000000..c5d7278
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/audit.json
@@ -0,0 +1,64 @@
+{
+  "eyebrow": "Bewaken / Onveranderlijke geschiedenis",
+  "title": "Audit trail",
+  "description": "Volg belangrijke statuswijzigingen, actoren en gekoppelde gebeurtenissen op.",
+  "actionFilterLabel": "Actie",
+  "actionFilterPlaceholder": "bv. demo-login",
+  "managerOnly": "De audit trail is enkel zichtbaar voor Operations Managers.",
+  "managerOnlyDetail": "Auditgeschiedenis is enkel zichtbaar voor Operations Managers.",
+  "loading": "Audit trail laden…",
+  "unavailable": "Audit trail is momenteel niet beschikbaar.",
+  "empty": "Geen auditgebeurtenissen gevonden",
+  "emptyDetail": "Pas het actiefilter aan.",
+  "relatedFilterActive": "Enkel gebeurtenissen gekoppeld aan deze actie ({{count}} gerelateerde gebeurtenissen).",
+  "clearFilter": "Filter wissen",
+  "count": "{{count}} gebeurtenissen",
+  "storedRendered": "UTC opgeslagen · Brussel weergegeven",
+  "columns": {
+    "when": "Wanneer",
+    "actor": "Actor",
+    "action": "Actie",
+    "entity": "Entiteit",
+    "change": "Wijziging",
+    "followUp": "Vervolg",
+    "details": "Details"
+  },
+  "viewRelatedEvents": "Gerelateerde gebeurtenissen bekijken",
+  "noChangeDetail": "Geen wijzigingsdetail geregistreerd.",
+  "noFieldChange": "Geen wijziging op veldniveau gedetecteerd.",
+  "reference": "Referentie",
+  "relatedEventsCount": "{{count}} gekoppelde gebeurtenis",
+  "relatedEventsCount_other": "{{count}} gekoppelde gebeurtenissen",
+  "showTechnicalEvents": "{{count}} technische gebeurtenis tonen",
+  "showTechnicalEvents_other": "{{count}} technische gebeurtenissen tonen",
+  "hideTechnicalEvents": "Technische gebeurtenissen verbergen",
+  "technicalDetails": "Technische details",
+  "fullReference": "Volledige referentie",
+  "correlationId": "Gekoppelde gebeurtenis-ID",
+  "diff": {
+    "setTo": "{{field}}: ingesteld op {{value}}",
+    "was": "{{field}}: was {{value}}",
+    "changed": "{{field}}: {{before}} → {{after}}"
+  },
+  "actions": {
+    "demo_login": "Ingelogd",
+    "demo_logout": "Uitgelogd",
+    "demo_reset": "Demogegevens hersteld",
+    "demo_data_seeded": "Demogegevens ingeladen",
+    "return_registered": "Voertuigretour geregistreerd",
+    "vehicle_status_changed": "Voertuigstatus gewijzigd",
+    "data_quality_issue_resolved": "Datakwaliteitsprobleem opgelost",
+    "data_quality_issue_deferred": "Datakwaliteitsprobleem uitgesteld",
+    "data_quality_issue_rejected": "Datakwaliteitsprobleem verworpen",
+    "data_quality_fields_provided": "Ontbrekende velden aangevuld",
+    "data_quality_odometer_corrected": "Kilometerstand gecorrigeerd",
+    "data_quality_odometer_retained": "Laatst bevestigde kilometerstand behouden",
+    "data_quality_status_applied": "Aanbevolen status toegepast",
+    "data_quality_booking_blocked": "Boeking geblokkeerd",
+    "data_quality_scan_run": "Kwaliteitscontrole uitgevoerd",
+    "customer_merged": "Klanten samengevoegd",
+    "workflow_retry": "Automatisering opnieuw geprobeerd",
+    "knowledge_question_asked": "Kennisvraag gesteld",
+    "mcp_tool_request": "MCP-tool aangeroepen"
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/auth.json b/frontend/src/i18n/locales/nl-BE/auth.json
new file mode 100644
index 0000000..dda3d67
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/auth.json
@@ -0,0 +1,23 @@
+{
+  "brandTagline": "Bedieningscentrum",
+  "orgLine": "Demo-organisatie: {{orgName}} (fictief)",
+  "headline1": "Elke overdracht.",
+  "headline2": "Eén helder overzicht.",
+  "defaultDescription": "Fleet Ops brengt voertuig-, boekings- en operationele gegevens samen, ondersteunt verhuurprocessen, detecteert datakwaliteitsproblemen en automatiseert gecontroleerde vervolgstappen.",
+  "footnote": "Synthetische demo · geen echte klant- of voertuiggegevens · op elk moment herstelbaar",
+  "accessEyebrow": "Demo-toegang",
+  "accessHeading": "Kies hoe je wil starten",
+  "accessIntro": "Geen wachtwoord nodig. Elke rol opent een afgebakende, synthetische omgeving — alle workflows en controles zijn echt geïmplementeerd.",
+  "startGuidedDemo": "Start begeleide demo",
+  "exploreAsOperationsManager": "Verken als Operations Manager",
+  "exploreAsOperationsManagerDetail": "Volledig overzicht, kwaliteitsoplossing en herpogingen",
+  "exploreAsRentalEmployee": "Verken als Rental Employee",
+  "exploreAsRentalEmployeeDetail": "Boekingen, retours, wagenpark en procedures",
+  "safeByDesignTitle": "Veilig ontworpen",
+  "safeByDesignDetail": "Elke actie wordt gelogd en is in deze demo herstelbaar.",
+  "loginFailed": "De demo-sessie kon niet gestart worden. De API is mogelijk niet bereikbaar.",
+  "roleOperationsManager": "Operations manager",
+  "roleRentalEmployee": "Rental employee",
+  "switchRole": "Wissel van rol",
+  "logout": "Uitloggen"
+}
diff --git a/frontend/src/i18n/locales/nl-BE/bookings.json b/frontend/src/i18n/locales/nl-BE/bookings.json
new file mode 100644
index 0000000..b305e33
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/bookings.json
@@ -0,0 +1,52 @@
+{
+  "list": {
+    "eyebrow": "Uitvoeren / Planning",
+    "title": "Boekingen",
+    "description": "Bekijk actieve verhuurperiodes en aankomende voertuigverbintenissen.",
+    "searchLabel": "Zoeken",
+    "searchPlaceholder": "Boeking, klant of voertuig",
+    "statusLabel": "Status",
+    "statusAll": "Alle statussen",
+    "loading": "Boekingsoverzicht laden…",
+    "empty": "Geen boekingen gevonden",
+    "emptyDetail": "Pas het statusfilter voor boekingen aan.",
+    "noMatch": "Geen overeenkomende boekingen",
+    "noMatchDetail": "Probeer een bredere zoekterm.",
+    "unavailable": "Boekingsoverzicht is momenteel niet beschikbaar.",
+    "count": "{{count}} boekingen",
+    "pageOf": "Pagina {{page}} van {{total}}",
+    "columns": {
+      "reference": "Referentie",
+      "customer": "Klant",
+      "vehicle": "Voertuig",
+      "window": "Periode",
+      "status": "Status"
+    },
+    "paginationLabel": "Boekingspagina's",
+    "previous": "Vorige",
+    "next": "Volgende",
+    "rangeOf": "{{from}}–{{to}} van {{total}}"
+  },
+  "statuses": {
+    "reserved": "gereserveerd",
+    "active": "actief",
+    "returned": "geretourneerd",
+    "cancelled": "geannuleerd",
+    "blocked": "geblokkeerd"
+  },
+  "detail": {
+    "backLink": "Boekingsoverzicht",
+    "eyebrow": "Boekingen / Huurrecord",
+    "notFound": "Deze boeking kon niet gevonden worden.",
+    "loading": "Boekingsrecord laden…",
+    "customer": "Klant",
+    "vehicle": "Voertuig",
+    "starts": "Start",
+    "ends": "Einde",
+    "startOdometer": "Startkilometerstand",
+    "endOdometer": "Eindkilometerstand",
+    "requirementsComplete": "Vereisten volledig",
+    "yes": "Ja",
+    "no": "Nee"
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/common.json b/frontend/src/i18n/locales/nl-BE/common.json
new file mode 100644
index 0000000..22c3df6
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/common.json
@@ -0,0 +1,44 @@
+{
+  "appName": "Fleet Ops",
+  "orgName": "Northstar Mobility",
+  "brandTagline": "Bedieningscentrum",
+  "actions": {
+    "save": "Opslaan",
+    "cancel": "Annuleren",
+    "confirm": "Bevestigen",
+    "close": "Sluiten",
+    "back": "Terug",
+    "next": "Volgende",
+    "retry": "Opnieuw proberen",
+    "reset": "Herstellen",
+    "yes": "Ja",
+    "no": "Nee",
+    "viewDetails": "Details bekijken",
+    "technicalDetails": "Technische details"
+  },
+  "status": {
+    "loading": "Laden…",
+    "saving": "Opslaan…",
+    "error": "Er ging iets mis",
+    "success": "Gelukt",
+    "noResults": "Geen resultaten"
+  },
+  "states": {
+    "loadingDefault": "Werkruimte wordt geladen…",
+    "errorTitle": "We konden deze werkruimte niet laden."
+  },
+  "timezone": "Europa/Brussel",
+  "language": {
+    "label": "Taal",
+    "nl-BE": "Nederlands",
+    "en-GB": "English",
+    "fr-BE": "Français"
+  },
+  "footer": {
+    "productLine": "Fleet Ops Demo",
+    "locale": "Europa/Brussel · Synthetische demogegevens"
+  },
+  "demo": {
+    "syntheticBadge": "Synthetische demo"
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/dashboard.json b/frontend/src/i18n/locales/nl-BE/dashboard.json
new file mode 100644
index 0000000..ce744ec
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/dashboard.json
@@ -0,0 +1,67 @@
+{
+  "eyebrow": "Uitvoeren / Live overzicht",
+  "title": "Goedemorgen. Hier is je wagenpark.",
+  "description": "Beschikbaarheid, uitzonderingen en overdrachten doorheen de huidige werking.",
+  "viewFleet": "Wagenpark bekijken",
+  "demoStart": {
+    "title": "Probeer een demonstratiescenario",
+    "readyCount": "{{ready}} van {{total}} scenario's klaar voor demo.",
+    "readyCountFallback": "Vijf afgebakende scenario's.",
+    "startGuide": "Start demo-gids",
+    "resumeGuide": "Verder met demo-gids ({{current}}/{{total}})",
+    "viewScenarios": "Bekijk scenario's"
+  },
+  "readiness": {
+    "title": "Wagenparkstatus",
+    "description": "Live vanuit persistente voertuigstatus",
+    "openFleet": "Wagenpark openen",
+    "available": "Beschikbaar",
+    "rented": "Verhuurd",
+    "cleaning": "Reiniging",
+    "maintenance": "Onderhoud",
+    "blocked": "Geblokkeerd"
+  },
+  "attention": {
+    "title": "Aandachtspunten",
+    "description": "{{openIssues}} open datakwaliteitsproblemen · {{workflowExceptions}} automatiseringsuitzonderingen",
+    "reviewQueue": "Wachtrij bekijken",
+    "filterPlaceholder": "Filter aandachtspunten…",
+    "filterAriaLabel": "Zoek in aandachtspunten",
+    "severityAll": "Alle ernst",
+    "severityHigh": "Kritiek",
+    "severityMedium": "Waarschuwing",
+    "severityLow": "Info",
+    "severityAriaLabel": "Ernst",
+    "empty": "Geen aandachtspunten voor dit filter.",
+    "openRecord": "Open {{title}}"
+  },
+  "movements": {
+    "title": "Bewegingen vandaag",
+    "description": "Vertrekken en retours in Europa/Brussel",
+    "allBookings": "Alle boekingen",
+    "empty": "Geen bewegingen gepland vandaag.",
+    "departure": "vertrek",
+    "return": "retour",
+    "openBooking": "Open boeking {{ref}}"
+  },
+  "integrationPulse": {
+    "title": "Integratiestatus",
+    "description": "Actuele evidentie van gekoppelde diensten",
+    "systemDetail": "Systeemdetail",
+    "n8nTitle": "n8n-aflevering",
+    "n8nSummary": "{{succeeded}} geslaagd · {{failed}} mislukt",
+    "n8nLatest": "Meest recente gebeurtenis {{ref}}",
+    "n8nNoEvidence": "Geen automatiseringsevidentie geregistreerd",
+    "knowledgeTitle": "Kennisassistent",
+    "knowledgeSummary": "{{count}} procedures geïndexeerd",
+    "knowledgeUnavailable": "Statuscontrole niet beschikbaar",
+    "mcpTitle": "MCP Hub",
+    "mcpEnabled": "Registratie ingeschakeld",
+    "mcpNotConnected": "Nog niet gekoppeld"
+  },
+  "recent": {
+    "title": "Recente activiteit",
+    "description": "Laatst geauditeerde workflowwijzigingen",
+    "empty": "Geen automatiseringsactiviteit geregistreerd."
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/demo.json b/frontend/src/i18n/locales/nl-BE/demo.json
new file mode 100644
index 0000000..1ca0527
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/demo.json
@@ -0,0 +1,189 @@
+{
+  "badge": {
+    "trigger": "Synthetische demo",
+    "dialogLabel": "Over deze demo-omgeving",
+    "close": "Sluiten",
+    "orgIntro": "<strong>{{orgName}}</strong> is een fictieve organisatie. Alle namen, voertuigen en boekingen zijn synthetisch.",
+    "orgIntroFallback": "Alle namen, voertuigen en boekingen in deze omgeving zijn synthetisch.",
+    "realWorkflows": "De workflows, controles en automatisering zijn echt geïmplementeerd — enkel de gegevens zijn verzonnen.",
+    "lastReset": "Laatste reset: <strong>{{when}}</strong> · deze omgeving is op elk moment herstelbaar.",
+    "aboutLink": "Over deze demo",
+    "unknown": "onbekend"
+  },
+  "guide": {
+    "dialogLabel": "Gegidste demo",
+    "trigger": "Demo-gids",
+    "kicker": "Gegidste demo · stap {{current}} van {{total}}",
+    "whatYouWillSee": "Wat je zal zien",
+    "whyItMatters": "Waarom dit relevant is",
+    "startAction": "Aan de slag",
+    "expectedOutcome": "Verwacht resultaat",
+    "goToStep": "Ga naar deze stap",
+    "next": "Volgende",
+    "close": "Sluiten",
+    "restart": "Demo opnieuw voorbereiden",
+    "restarting": "Bezig met herstellen…",
+    "restartFailed": "De demo kon niet hersteld worden.",
+    "allStepsLabel": "Alle stappen",
+    "progressChip": "Demo-gids · stap {{current}} van {{total}}",
+    "expand": "Demo-gids uitklappen",
+    "collapse": "Demo-gids inklappen",
+    "steps": {
+      "understand-state": {
+        "title": "1. Begrijp de operationele status",
+        "whatYouWillSee": "Het dashboard toont de wagenparkstatus, openstaande aandachtspunten en de bewegingen van vandaag.",
+        "whyItMatters": "Een Operations Manager start elke dag met dit overzicht om te bepalen waar ingrijpen nodig is.",
+        "startAction": "Open het dashboard en bekijk de aandachtslijst en de tijdlijn van vandaag.",
+        "expectedOutcome": "Je ziet welke boekingen, voertuigen of datakwaliteitsproblemen aandacht vragen."
+      },
+      "open-booking": {
+        "title": "2. Open een boeking die aandacht nodig heeft",
+        "whatYouWillSee": "De boeking BK-DEMO-RETURN, actief en klaar voor retour vandaag.",
+        "whyItMatters": "Retours zijn het moment waarop foute kilometerstanden of schade voor het eerst zichtbaar worden.",
+        "startAction": "Open de boeking vanuit het dashboard of de boekingenlijst.",
+        "expectedOutcome": "Je ziet de boekingsdetails en de knop om de retour te verwerken."
+      },
+      "process-return": {
+        "title": "3. Verwerk een retour met een afwijkende kilometerstand",
+        "whatYouWillSee": "Een retourformulier met een vooringevulde, verdachte kilometerstand lager dan de laatst gekende stand.",
+        "whyItMatters": "Een dalende kilometerstand wijst op een foutieve invoer of een verwisseld voertuig — dit moet vóór vrijgave worden opgemerkt.",
+        "startAction": "Vul de retour in met de voorgestelde waarde en bekijk de serverpreview vóór je bevestigt.",
+        "expectedOutcome": "De retour wordt verwerkt, het voertuig krijgt een passende status en er wordt automatisch een datakwaliteitsprobleem aangemaakt."
+      },
+      "handle-quality-issue": {
+        "title": "4. Bekijk en behandel het gecreëerde datakwaliteitsprobleem",
+        "whatYouWillSee": "Een nieuw issue van het type 'kilometerstand-afwijking' bovenaan de werklijst.",
+        "whyItMatters": "Elk gedetecteerd probleem heeft één afgebakende oplossingsstap — niets wordt automatisch stilzwijgend gecorrigeerd.",
+        "startAction": "Open het datakwaliteitsoverzicht en kies het nieuwste issue.",
+        "expectedOutcome": "Je ziet de aanbevolen actie, kiest een oplossing en het issue wordt opgelost met een audit-spoor."
+      },
+      "merge-duplicate": {
+        "title": "5. Beoordeel en behandel een mogelijke dubbele klant",
+        "whatYouWillSee": "Twee klantprofielen met hetzelfde e-mailadres en telefoonnummer, naast elkaar vergeleken.",
+        "whyItMatters": "Dubbele klanten leiden tot verspreide boekingsgeschiedenis en verwarrende communicatie.",
+        "startAction": "Vergelijk beide profielen en kies welk profiel behouden blijft.",
+        "expectedOutcome": "De profielen worden samengevoegd, boekingen worden herverbonden en het verliezende profiel wordt een tombstone."
+      },
+      "ask-knowledge": {
+        "title": "6. Stel een vraag aan de procedureassistent",
+        "whatYouWillSee": "Een antwoord met bronvermelding uit de afgebakende demokennisbank.",
+        "whyItMatters": "Medewerkers moeten snel een onderbouwd antwoord krijgen over procedures, zonder te gokken.",
+        "startAction": "Klik op één van de voorbeeldvragen, in de huidige interfacetaal.",
+        "expectedOutcome": "Je ziet het antwoord, de gebruikte procedure en de brontekst — of een eerlijk 'onvoldoende informatie' als dat niet aanwezig is."
+      },
+      "check-automation-audit": {
+        "title": "7. Controleer automatisering en audit trail",
+        "whatYouWillSee": "De status van de n8n-aflevering voor je retour, en de bijhorende audit-gebeurtenissen.",
+        "whyItMatters": "Elke belangrijke actie moet naspeurbaar zijn: wie deed wat, wanneer, en wat was het gevolg.",
+        "startAction": "Open Integraties om de afleverstatus te zien, en Audit trail voor het volledige spoor.",
+        "expectedOutcome": "Je ziet een geslaagde (of herstelbare) aflevering en een leesbaar audit-overzicht van je acties."
+      },
+      "review-real-vs-simulated": {
+        "title": "8. Bekijk wat echt is, gesimuleerd is, of nog niet gekoppeld",
+        "whatYouWillSee": "Een overzicht van wat in deze demo functioneel geïmplementeerd is, wat synthetisch is, en welke koppelingen nog niet live zijn.",
+        "whyItMatters": "Een demo is pas overtuigend als bezoekers zelf kunnen nagaan wat echt werkt en wat nog toekomstmuziek is.",
+        "startAction": "Lees de pagina 'Over deze demo'.",
+        "expectedOutcome": "Je kan zelf uitleggen wat Fleet Ops wel en niet is, zonder mondelinge toelichting."
+      }
+    }
+  },
+  "scenarios": {
+    "eyebrow": "Demonstratiescenario's",
+    "title": "Probeer een demonstratiescenario",
+    "description": "Vijf afgebakende scenario's die telkens dezelfde vaste boekingen, klanten en voertuigen gebruiken — na een reset zijn ze altijd opnieuw te vinden.",
+    "loading": "Scenario's laden…",
+    "ready": "Klaar voor demo",
+    "notReady": "Niet beschikbaar",
+    "duration": "Duur",
+    "durationValue": "± {{minutes}} min",
+    "role": "Rol",
+    "demonstrates": "Toont aan:",
+    "requiresRole": "Vereist rol: {{roles}}.",
+    "startScenario": "Start scenario",
+    "roleOr": "{{a}} of {{b}}",
+    "roles": {
+      "operations_manager": "Operations Manager",
+      "rental_employee": "Rental Employee"
+    },
+    "items": {
+      "return-anomaly": {
+        "title": "Retour met afwijkende kilometerstand",
+        "problem": "Een voertuig komt terug met een kilometerstand die lager ligt dan de laatst geregistreerde stand — een teken van een foutieve invoer of een verwisseld voertuig.",
+        "demonstrates": "Retourverwerking, automatische detectie van datakwaliteitsproblemen en de audit trail die daaruit ontstaat."
+      },
+      "duplicate-customer": {
+        "title": "Mogelijke dubbele klant samenvoegen",
+        "problem": "Twee klantprofielen delen hetzelfde e-mailadres en telefoonnummer — waarschijnlijk dezelfde persoon, twee keer geregistreerd.",
+        "demonstrates": "Samenvoegen van klanten met behoud van boekingsgeschiedenis en audit trail."
+      },
+      "booking-overlap": {
+        "title": "Overlappende boekingen herstellen",
+        "problem": "Eén voertuig staat dubbel gereserveerd voor overlappende periodes — een planningsfout die vóór vertrek moet worden opgelost.",
+        "demonstrates": "Detectie en gecontroleerde oplossing van planningsconflicten."
+      },
+      "automation-retry": {
+        "title": "Mislukte automatisering opnieuw proberen",
+        "problem": "Eén eerdere gebeurtenis kon niet worden afgeleverd aan de automatisering door een gesimuleerde verbindingsfout.",
+        "demonstrates": "Betrouwbare aflevering met begrensde herpogingen en zichtbare foutstatus."
+      },
+      "knowledge-question": {
+        "title": "Een procedurevraag stellen",
+        "problem": "Een medewerker weet niet zeker welke procedure van toepassing is bij een specifieke operationele situatie.",
+        "demonstrates": "Antwoorden met brongebaseerde onderbouwing uit een afgebakende demokennisbank."
+      }
+    },
+    "blockedReasons": {
+      "bookingNotFound": "Demoboeking BK-DEMO-RETURN niet gevonden. {{resetHint}}",
+      "bookingAlreadyProcessed": "Deze boeking is al verwerkt sinds de laatste reset. {{resetHint}}",
+      "duplicateIssueNotFound": "Demo-issue DQ-DEMO-DUPLICATE niet gevonden. {{resetHint}}",
+      "issueAlreadyResolved": "Dit issue is al opgelost sinds de laatste reset. {{resetHint}}",
+      "overlapIssueNotFound": "Demo-issue DQ-DEMO-OVERLAP niet gevonden. {{resetHint}}",
+      "failedEventNotFound": "Gesimuleerde mislukte gebeurtenis niet gevonden. {{resetHint}}",
+      "eventAlreadyRecovered": "Deze gebeurtenis is al hersteld sinds de laatste reset. {{resetHint}}",
+      "knowledgeUnavailable": "De demokennisbank is momenteel niet beschikbaar.",
+      "resetHint": "Reset de demogegevens om dit scenario opnieuw beschikbaar te maken."
+    }
+  },
+  "about": {
+    "eyebrow": "Over deze demo",
+    "title": "Wat Fleet Ops wel en niet is",
+    "description": "{{orgName}} is een fictieve verhuurorganisatie die dient om deze demo tastbaar te maken — geen bestaand bedrijf.",
+    "loading": "Demo-informatie laden…",
+    "ctaTitle": "Liever meteen aan de slag?",
+    "ctaBody": "De gegidste demo doorloopt alle acht stappen hierboven in de praktijk.",
+    "ctaButton": "Start begeleide demo",
+    "problemTitle": "Het fictieve probleem",
+    "problemBody": "{{orgName}} verhuurt zo'n 50 campers en bestelwagens vanuit één hoofdlocatie. Boekingen, retours, klantgegevens en onderhoud kwamen tot nu toe uit losse spreadsheets en mondelinge afspraken, waardoor fouten (dubbele klanten, foutieve kilometerstanden, dubbel geboekte voertuigen) laat aan het licht kwamen. Fleet Ops toont hoe één samenhangend systeem die problemen vroeg signaleert en gecontroleerd laat oplossen.",
+    "scopeTitle": "Voor wie en met welke scope",
+    "scopeBody": "Deze demo is bedoeld voor wie wil zien hoe Fleet Ops operationele problemen bij een kleine verhuurder aanpakt: Operations Managers en Rental Employees, en iedereen die de aanpak evalueert. De scope is bewust afgebakend tot één samenhangende proof of concept — geen boekhouding, geen betalingen, geen publieke reservaties, geen volledig CRM of ERP.",
+    "realTitle": "Wat écht werkt",
+    "realBody": "Alles hieronder is functionele code, niet alleen een mockup: rol-gebaseerde toegang en sessies, voertuig- en boekingsbeheer, retourverwerking met serverzijdige validatie, vijf datakwaliteitsregels met elk een eigen oplossingsstap, een volledige audit trail, geautomatiseerde aflevering naar n8n met begrensde herpogingen, Docker-gebaseerde deployment en een geautomatiseerde testsuite (backend en Playwright end-to-end).",
+    "syntheticTitle": "Wat synthetisch is",
+    "syntheticBody": "De organisatie, alle klanten, voertuigen, boekingen, onderhoudsgeschiedenis, procedures in de kennisbank en de vooraf ingerichte scenario's zijn volledig verzonnen. Geen enkel gegeven verwijst naar een bestaand persoon, voertuig of bedrijf; e-mailadressen gebruiken uitsluitend het testdomein {{testDomain}}.",
+    "architectureTitle": "Architectuur in het kort",
+    "architectureBody": "Een React/TypeScript-frontend praat met een FastAPI-backend (PostgreSQL via SQLAlchemy/Alembic-migraties); belangrijke bedrijfsregels leven in de backend, niet in n8n of in prompts. Retours en andere gebeurtenissen worden eerst lokaal gecommit en pas daarna asynchroon via een automatiseringsopdracht aan n8n afgeleverd, zodat een tijdelijke storing in de automatisering nooit een operationele actie blokkeert.",
+    "securityTitle": "Beveiliging en toegang",
+    "securityBody": "Toegang verloopt via ondertekende, HTTP-only sessiecookies per rol; elke rol gebonden aan een set toegestane routes, zowel serverzijdig afgedwongen als in de navigatie weerspiegeld. Belangrijke statuswijzigingen worden altijd gecontroleerd en gelogd — nooit stilzwijgend automatisch gecorrigeerd.",
+    "testingTitle": "Hoe dit getest is",
+    "testingBody": "Een geautomatiseerde backend-testsuite dekt bedrijfsregels en API-contracten; een volledige Playwright-eindtot-eind-suite dekt de gebruikersstromen, inclusief deze demo-ervaring zelf in drie talen. Elke wijziging wordt bovendien tegen een schone checkout (lege database, opnieuw opgebouwd vanaf de seed-data) gevalideerd voor deployment.",
+    "integrationsTitle": "Koppelingen — eerlijk gelabeld",
+    "integrationsDescription": "Wat operationeel is, wat demomodus is, en wat nog niet gekoppeld is.",
+    "resetTitle": "Demo-omgeving herstellen",
+    "resetBodyManager": "De omgeving is op elk moment terug te zetten naar de startsituatie. Laatste reset: <strong>{{when}}</strong>. Gebruik <strong>Demogegevens herstellen</strong> in de zijbalk om opnieuw te beginnen.",
+    "resetBodyEmployee": "De omgeving is op elk moment terug te zetten naar de startsituatie. Laatste reset: <strong>{{when}}</strong>. Een Operations Manager kan de demo-omgeving herstellen via de zijbalk.",
+    "limitationsTitle": "Beperkingen",
+    "limitationsBody": "Dit is een gerichte proof of concept, geen volledig ERP. RAGcore en de ITWorx MCP Hub zijn nog niet live gekoppeld; de kennisassistent gebruikt een lokale, afgebakende demokennisbank in plaats van een live RAGcore-omgeving.",
+    "unknown": "onbekend"
+  },
+  "integrationSummary": {
+    "titles": {
+      "n8n": "Automatisering (n8n)",
+      "ragcore": "Kennisassistent (RAGcore)",
+      "mcp_hub": "ITWorx MCP Hub"
+    },
+    "n8nDetail": "{{succeeded}} geslaagd · {{failed}} mislukt · {{pending}} in wachtrij.",
+    "ragcoreDetail": "{{count}} procedures geïndexeerd in {{collection}}.",
+    "mcpDetailEnabled": "Voorbereid voor toekomstige, gecontroleerde tool-aanroepen vanuit de Hub.",
+    "mcpDetailNotConnected": "Nog niet gekoppeld — voorbereid voor toekomstige, gecontroleerde tool-aanroepen vanuit de Hub."
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/errors.json b/frontend/src/i18n/locales/nl-BE/errors.json
new file mode 100644
index 0000000..011d938
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/errors.json
@@ -0,0 +1,8 @@
+{
+  "generic": "Er is een fout opgetreden. Probeer opnieuw.",
+  "workspaceLoadFailed": "We konden deze werkruimte niet laden.",
+  "unauthorized": "Je sessie is verlopen. Log opnieuw in.",
+  "forbidden": "Je hebt geen toegang tot dit onderdeel.",
+  "notFound": "Dit record kon niet gevonden worden.",
+  "networkUnavailable": "De verbinding met de server is momenteel niet beschikbaar."
+}
diff --git a/frontend/src/i18n/locales/nl-BE/fleet.json b/frontend/src/i18n/locales/nl-BE/fleet.json
new file mode 100644
index 0000000..70ebd95
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/fleet.json
@@ -0,0 +1,68 @@
+{
+  "list": {
+    "eyebrow": "Wagenpark / Register",
+    "title": "Wagenpark",
+    "description": "Live operationele status, locatie en onderhoudsgereedheid.",
+    "searchLabel": "Zoeken",
+    "searchPlaceholder": "Referentie, merk of locatie",
+    "statusLabel": "Status",
+    "statusAll": "Alle statussen",
+    "attentionOnly": "Enkel aandachtspunten",
+    "loading": "Wagenparkregister laden…",
+    "empty": "Geen voertuigen gevonden",
+    "emptyDetail": "Pas de huidige wagenparkfilters aan.",
+    "noMatch": "Geen overeenkomende voertuigen",
+    "noMatchDetail": "Probeer een bredere zoekterm.",
+    "unavailable": "Wagenparklijst is momenteel niet beschikbaar.",
+    "count": "{{count}} voertuigen",
+    "persisted": "Persistente wagenparkgegevens",
+    "columns": {
+      "reference": "Referentie",
+      "makeModel": "Merk / model",
+      "location": "Locatie",
+      "status": "Status",
+      "odometer": "Kilometerstand (km)",
+      "attention": "Aandacht"
+    },
+    "needsAttention": "Vraagt aandacht"
+  },
+  "statuses": {
+    "available": "beschikbaar",
+    "rented": "verhuurd",
+    "cleaning": "reiniging",
+    "maintenance": "onderhoud",
+    "blocked": "geblokkeerd"
+  },
+  "detail": {
+    "backLink": "Wagenparkregister",
+    "eyebrow": "Wagenpark / Voertuigrecord",
+    "notFound": "Dit voertuig kon niet gevonden worden.",
+    "loading": "Voertuigrecord laden…",
+    "needsAttention": "Vraagt aandacht",
+    "tabs": {
+      "overview": "Overzicht",
+      "bookings": "Boekingen",
+      "inspections": "Inspecties",
+      "maintenance": "Onderhoud",
+      "quality": "Kwaliteit"
+    },
+    "tabsAriaLabel": "Voertuigonderdelen",
+    "overview": {
+      "registration": "Kenteken",
+      "modelYear": "Bouwjaar",
+      "location": "Locatie",
+      "odometer": "Kilometerstand",
+      "nextService": "Volgende onderhoudsbeurt",
+      "active": "Actief"
+    },
+    "yes": "Ja",
+    "no": "Nee",
+    "noBookings": "Geen boekingen geregistreerd.",
+    "noInspections": "Geen inspecties geregistreerd.",
+    "noMaintenance": "Geen onderhoudsgegevens.",
+    "noQualityIssues": "Geen kwaliteitsproblemen geregistreerd.",
+    "fuel": "Brandstof {{percent}}%",
+    "damage": "Schade",
+    "technicalWarning": "Technische melding"
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/integrations.json b/frontend/src/i18n/locales/nl-BE/integrations.json
new file mode 100644
index 0000000..1d64153
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/integrations.json
@@ -0,0 +1,70 @@
+{
+  "eyebrow": "Bewaken / Integraties",
+  "title": "Integratiebeheer",
+  "description": "Bewaak afleverkwaliteit, beperkte beschikbaarheid en herprobeerbare workflowgebeurtenissen.",
+  "cards": {
+    "orchestrationKicker": "Orkestratie",
+    "n8nTitle": "n8n-aflevering",
+    "n8nSummary": "{{succeeded}} geslaagd · {{failed}} mislukt · {{pending}} in wachtrij · {{delivering}} bezig",
+    "n8nFallback": "Retourgebeurtenissen worden eerst lokaal verwerkt en pas daarna via de automatiseringsopdracht afgeleverd.",
+    "knowledgeKicker": "Kennis",
+    "knowledgeTitle": "Kennisassistent",
+    "knowledgeSummaryDemo": "Demokennisbank · {{count}} procedures geïndexeerd in {{collection}}.",
+    "knowledgeSummaryRagcore": "RAGcore · {{count}} procedures geïndexeerd in {{collection}}.",
+    "knowledgeUnavailable": "Statusevidentie momenteel niet beschikbaar.",
+    "gatewayKicker": "Tool-gateway",
+    "mcpTitle": "MCP Hub",
+    "mcpEnabled": "Registratie is ingeschakeld voor deze omgeving.",
+    "mcpNotConnected": "Nog niet gekoppeld — voorbereid voor toekomstige, gecontroleerde tool-aanroepen vanuit de Hub."
+  },
+  "statusLabels": {
+    "notConnected": "Niet gekoppeld",
+    "deliveryFailed": "Verwerking mislukt",
+    "retryAvailable": "Opnieuw proberen mogelijk",
+    "operational": "Operationeel",
+    "prepared": "Voorbereid",
+    "demoMode": "Demomodus",
+    "unavailable": "Niet beschikbaar"
+  },
+  "ledger": {
+    "title": "Automatiseringsopdrachten",
+    "description": "Vastgelegde automatiseringspogingen met de recentste foutevidentie.",
+    "filterLabel": "Weergave",
+    "filterNeedsAttention": "Vraagt aandacht",
+    "filterRecent": "Recent",
+    "filterSucceeded": "Geslaagd",
+    "filterAll": "Alle",
+    "statusFilterLabel": "Status",
+    "statusAll": "Alle statussen",
+    "statusPending": "In wachtrij",
+    "statusDelivering": "Bezig",
+    "statusSucceeded": "Geslaagd",
+    "statusFailed": "Mislukt",
+    "unavailable": "Automatiseringsopdrachten zijn momenteel niet beschikbaar.",
+    "managerOnly": "Automatisering is enkel zichtbaar voor Operations Managers.",
+    "loading": "Automatiseringsopdrachten laden…",
+    "empty": "Geen automatiseringsopdrachten voor dit filter.",
+    "count": "{{count}} workflowgebeurtenissen",
+    "boundedRetries": "Begrensde herpogingen",
+    "groupedSucceeded": "{{count}} geslaagde voertuigretourverwerkingen",
+    "showIndividually": "Individuele opdrachten tonen",
+    "hideIndividually": "Individuele opdrachten verbergen",
+    "columns": {
+      "event": "Opdracht",
+      "type": "Type",
+      "booking": "Boeking",
+      "status": "Status",
+      "attempts": "Pogingen",
+      "lastError": "Laatste fout",
+      "when": "Wanneer",
+      "action": "Actie"
+    },
+    "retry": "Opnieuw proberen",
+    "retrying": "Bezig met opnieuw proberen…",
+    "retryFailed": "Kon deze aflevering niet opnieuw proberen.",
+    "noAction": "—",
+    "eventTypes": {
+      "vehicle.returned.v1": "Voertuigretour verwerkt"
+    }
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/knowledge.json b/frontend/src/i18n/locales/nl-BE/knowledge.json
new file mode 100644
index 0000000..54f3da2
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/knowledge.json
@@ -0,0 +1,41 @@
+{
+  "eyebrow": "Bewaken / Onderbouwde kennis",
+  "title": "Procedurekennis",
+  "description": "Stel operationele vragen. Antwoorden verschijnen enkel wanneer {{provider}} voldoende onderbouwde evidentie teruggeeft.",
+  "providerDemo": "de demokennisbank",
+  "providerRagcore": "RAGcore",
+  "statusAvailable": "Beschikbaar",
+  "statusUnavailable": "Niet beschikbaar",
+  "proceduresIndexed": "{{count}} procedures geïndexeerd",
+  "providerNote": "Deze demo beantwoordt vanuit een kleine, vaste set geïndexeerde procedures — geen live RAGcore-koppeling. Een live RAGcore-backend zal later dezelfde interface overnemen, zonder dat deze pagina verandert.",
+  "askHeading": "Stel een procedurevraag",
+  "askSubheading": "Ophalen → evidentiecontrole → onderbouwd antwoord",
+  "questionLabel": "Vraag",
+  "questionPlaceholder": "bv. Wat moet ik doen wanneer een voertuig beschadigd terugkomt?",
+  "ask": "Vraag stellen",
+  "asking": "Bezig met vragen…",
+  "askFailed": "Kon de kennisdienst niet bereiken.",
+  "suggestedLabel": "Probeer:",
+  "suggestedQuestions": [
+    "Wat moet ik doen wanneer een voertuig terugkomt met schade?",
+    "Hoe registreer ik een voertuigretour?",
+    "Wanneer mag een voertuig opnieuw beschikbaar gezet worden?",
+    "Wie beoordeelt een ongewone kilometerstand?",
+    "Welke controles zijn verplicht vóór vertrek?"
+  ],
+  "emptyTitle": "Evidentie voor antwoorden",
+  "emptyDescription": "Vraag naar retours, schade, inspecties of een andere geïndexeerde procedure. Fleet Ops verzint geen antwoord wanneer evidentie ontbreekt.",
+  "retrievalFlow": {
+    "question": "Vraag",
+    "sources": "Bronnen",
+    "answer": "Antwoord"
+  },
+  "questionLabelExchange": "Vraag",
+  "evidenceStates": {
+    "grounded": "Onderbouwd met geciteerde procedures",
+    "insufficient": "Onvoldoende evidentie",
+    "unavailable": "Kennisdienst niet beschikbaar"
+  },
+  "unavailableBody": "De kennisdienst is momenteel niet bereikbaar. Operationele functies zijn hier niet door beïnvloed — probeer later opnieuw.",
+  "sourceVersion": "v{{version}}"
+}
diff --git a/frontend/src/i18n/locales/nl-BE/navigation.json b/frontend/src/i18n/locales/nl-BE/navigation.json
new file mode 100644
index 0000000..8ab013a
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/navigation.json
@@ -0,0 +1,39 @@
+{
+  "skipToContent": "Ga naar hoofdinhoud",
+  "groups": {
+    "operate": "Uitvoeren",
+    "assure": "Bewaken"
+  },
+  "items": {
+    "overview": "Overzicht",
+    "fleet": "Wagenpark",
+    "bookings": "Boekingen",
+    "quality": "Datakwaliteit",
+    "knowledge": "Kennis",
+    "integrations": "Integraties",
+    "audit": "Audit trail"
+  },
+  "primaryNavLabel": "Hoofdnavigatie",
+  "mobileNavLabel": "Mobiele navigatie",
+  "more": "Meer",
+  "openNavigation": "Navigatie openen",
+  "closeNavigation": "Navigatie sluiten",
+  "sidebarEnvironment": "Demo-omgeving",
+  "sidebarEnvironmentDetail": "Enkel synthetische gegevens",
+  "resetDemoData": "Demogegevens herstellen",
+  "resetConfirmTitle": "Demoreset bevestigen",
+  "resetConfirmBody": "Alle synthetische wijzigingen worden ongedaan gemaakt en de deterministische demogegevens worden hersteld. Je wordt uitgelogd.",
+  "resetting": "Bezig met herstellen…",
+  "resetConfirmYes": "Ja, herstellen",
+  "resetCancel": "Annuleren",
+  "resetFailed": "Demogegevens konden niet hersteld worden.",
+  "searchLabel": "Zoek in Fleet Ops",
+  "searchPlaceholder": "Zoek wagenpark, boeking of onderdeel…",
+  "searchShortcutHint": "Ctrl K",
+  "searchSearching": "Zoeken…",
+  "searchUnavailable": "Zoeken is momenteel niet beschikbaar.",
+  "searchNoResults": "Geen resultaten voor \"{{query}}\".",
+  "switchRole": "Wissel van rol",
+  "switchRoleTitle": "Wissel van demo-rol",
+  "languageSwitcherLabel": "Taal wijzigen"
+}
diff --git a/frontend/src/i18n/locales/nl-BE/quality.json b/frontend/src/i18n/locales/nl-BE/quality.json
new file mode 100644
index 0000000..6806bf8
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/quality.json
@@ -0,0 +1,192 @@
+{
+  "list": {
+    "eyebrow": "Bewaken / Werkbank",
+    "title": "Datakwaliteit",
+    "description": "Los evidentie-onderbouwde uitzonderingen op voor ze de werking verstoren.",
+    "runScan": "Kwaliteitscontrole uitvoeren",
+    "confirmScanTitle": "Kwaliteitscontrole bevestigen",
+    "confirmScanBody": "Nu de deterministische controle over alle vijf regeltypes uitvoeren?",
+    "scanning": "Bezig met controleren…",
+    "confirmScanYes": "Ja, uitvoeren",
+    "cancel": "Annuleren",
+    "scanComplete": "Controle voltooid: {{summary}}",
+    "scanNoNew": "geen nieuwe problemen gevonden (bestaande open problemen worden niet opnieuw aangemaakt).",
+    "scanFailed": "Kwaliteitscontrole kon niet uitgevoerd worden.",
+    "statusLabel": "Status",
+    "statusAll": "Alle statussen",
+    "statusOpen": "Open",
+    "statusDeferred": "Uitgesteld",
+    "statusResolved": "Opgelost",
+    "statusRejected": "Verworpen",
+    "ruleTypeLabel": "Regeltype",
+    "ruleTypeAll": "Alle regeltypes",
+    "demoScenariosOnly": "Enkel demoscenario's",
+    "loading": "Kwaliteitswerkbank laden…",
+    "queueClear": "Wachtrij is leeg",
+    "noIssuesMatch": "Geen problemen komen overeen met de huidige filters.",
+    "noDemoIssuesMatch": "Geen demoscenario-problemen komen overeen",
+    "noDemoIssuesMatchDetail": "Vink 'Enkel demoscenario's' uit om de volledige wachtrij te zien.",
+    "unavailable": "Datakwaliteitsproblemen zijn momenteel niet beschikbaar.",
+    "count": "{{count}} problemen",
+    "evidenceBacked": "Evidentie-onderbouwde detectie",
+    "columns": {
+      "reference": "Referentie",
+      "rule": "Regel",
+      "entity": "Entiteit",
+      "severity": "Ernst",
+      "status": "Status"
+    }
+  },
+  "ruleTypes": {
+    "possible_duplicate_customer": "Mogelijke dubbele klant",
+    "missing_required_field": "Ontbrekend verplicht veld",
+    "odometer_regression": "Afwijkende kilometerstand",
+    "booking_overlap": "Overlappende boeking",
+    "vehicle_status_conflict": "Statusconflict voertuig"
+  },
+  "severities": {
+    "high": "Kritiek",
+    "medium": "Waarschuwing",
+    "low": "Info"
+  },
+  "detail": {
+    "backLink": "Kwaliteitswerkbank",
+    "eyebrow": "Kwaliteit / {{rule}}",
+    "title": "Bekijk vastgelegde evidentie en registreer een geauditeerde oplossing.",
+    "notFound": "Dit probleem kon niet gevonden worden.",
+    "loading": "Probleemevidentie laden…",
+    "managerOnly": "De kwaliteitswerkbank is enkel zichtbaar voor Operations Managers.",
+    "managerOnlyDetail": "Datakwaliteitsevidentie en -oplossingen zijn enkel zichtbaar voor Operations Managers.",
+    "summary": {
+      "rule": "Regel",
+      "entity": "Entiteit",
+      "evidenceSummary": "Evidentiesamenvatting"
+    },
+    "resolved": {
+      "title": "Probleem {{ref}} opgelost",
+      "body": "De wijziging is doorgevoerd en vastgelegd in de audit trail.",
+      "viewAudit": "Audit trail bekijken",
+      "viewVehicle": "Voertuig bekijken",
+      "continueDemo": "Ga verder met de demo"
+    },
+    "deferOrReject": {
+      "heading": "Uitstellen of verwerpen",
+      "description": "Stel uit om later opnieuw te bekijken, of verwerp als dit geen echt probleem is.",
+      "defer": "Uitstellen",
+      "reject": "Verwerpen",
+      "deferFailed": "Kon dit probleem niet uitstellen.",
+      "rejectFailed": "Kon dit probleem niet verwerpen."
+    },
+    "explainer": {
+      "whatIsWrong": "Wat is er mis",
+      "whyItMatters": "Waarom dit belangrijk is",
+      "possible_duplicate_customer": {
+        "whatIsWrong": "Twee klantprofielen delen identificerende gegevens (e-mail, telefoon of een erg gelijkende naam) sterk genoeg om waarschijnlijk dezelfde persoon te zijn, twee keer geregistreerd.",
+        "whyItMatters": "Dubbele klanten verdelen de boekingsgeschiedenis over twee records, riskeren dubbele facturatie en verwarren klantcontacten."
+      },
+      "missing_required_field": {
+        "whatIsWrong": "Dit record mist gegevens die vereist zijn voor normale werking (bijvoorbeeld een klant zonder e-mail of telefoonnummer).",
+        "whyItMatters": "Zonder deze gegevens kan het bedrijf de klant niet bereiken, of het voertuig niet betrouwbaar identificeren voor compliance- en overdrachtscontroles."
+      },
+      "odometer_regression": {
+        "whatIsWrong": "Een ingevoerde kilometerstand ligt lager dan de laatst bevestigde (canonieke) stand van het voertuig.",
+        "whyItMatters": "Een dalende kilometerstand wijst meestal op een invoerfout of een verwisseld voertuig. Dit stilzwijgend doorlaten zou de onderhoudsplanning en de kilometerhistoriek bij wederverkoop verstoren."
+      },
+      "booking_overlap": {
+        "whatIsWrong": "Hetzelfde voertuig is toegewezen aan twee boekingen met overlappende periodes.",
+        "whyItMatters": "Slechts één van deze boekingen kan effectief worden nagekomen. Onopgelost zou een klant aankomen en merken dat zijn voertuig al bij iemand anders is."
+      },
+      "vehicle_status_conflict": {
+        "whatIsWrong": "De opgeslagen operationele status van dit voertuig komt niet overeen met wat de eigen boekings- en inspectiegeschiedenis impliceert.",
+        "whyItMatters": "Een foutieve status kan een niet-beschikbaar voertuig boekbaar laten lijken, of een beschikbaar voertuig verbergen voor het wagenpark."
+      }
+    },
+    "duplicateCustomer": {
+      "heading": "Vergelijken en samenvoegen",
+      "description": "Kies de klant die behouden blijft en bekijk elk afwijkend veld.",
+      "keepAsSurvivor": "Behouden als hoofdprofiel",
+      "differs": "Verschilt",
+      "match": "Gelijk",
+      "mergePreview": "{{loser}} wordt een tombstone gekoppeld aan {{survivor}}; de boekingen worden herverbonden.",
+      "mergeInto": "Samenvoegen met {{ref}}",
+      "confirmMergeTitle": "Samenvoegen bevestigen",
+      "confirmMergeBody": "{{loser}} samenvoegen met {{survivor}}? Dit kan niet ongedaan gemaakt worden.",
+      "merging": "Bezig met samenvoegen…",
+      "confirmMergeYes": "Ja, samenvoegen",
+      "mergeFailed": "Kon deze klanten niet samenvoegen.",
+      "bothMissing": "Beide klanten in deze vergelijking konden niet geladen worden.",
+      "fieldColumn": "Veld",
+      "fields": {
+        "first_name": "Voornaam",
+        "last_name": "Achternaam",
+        "email": "E-mail",
+        "phone": "Telefoon",
+        "postal_code": "Postcode",
+        "city": "Stad"
+      }
+    },
+    "missingField": {
+      "heading": "Ontbrekende velden invullen",
+      "description": "Vervolledig het record voor {{ref}}. Het probleem wordt automatisch opgelost zodra niets verplichts meer ontbreekt.",
+      "atLeastOne": "Minstens één van e-mail of telefoon is vereist.",
+      "saveAndRecheck": "Opslaan en herchecken",
+      "saving": "Opslaan…",
+      "saveFailed": "Kon deze velden niet opslaan.",
+      "fields": {
+        "first_name": "Voornaam",
+        "last_name": "Achternaam",
+        "email": "E-mail",
+        "phone": "Telefoon",
+        "registration_number": "Kenteken",
+        "make": "Merk",
+        "model": "Model",
+        "location": "Locatie"
+      }
+    },
+    "odometerRegression": {
+      "heading": "Kilometerafwijking oplossen",
+      "description": "De laatst bevestigde kilometerstand wordt nooit automatisch verlaagd — kies hoe dit te verwerken.",
+      "canonicalOdometer": "Laatst bevestigde kilometerstand",
+      "decisionLegend": "Beslissing",
+      "retainCanonical": "Laatst bevestigde stand behouden",
+      "retainCanonicalDetail": "Behandel de ingevoerde stand als foutief; er verandert niets aan het voertuigrecord.",
+      "correctReading": "Stand corrigeren",
+      "correctReadingDetail": "Werk zowel de boeking als de laatst bevestigde kilometerstand bij met de juiste waarde.",
+      "noBookingAttached": "Geen gekoppelde boeking bij dit probleem, dus enkel 'laatst bevestigde stand behouden' is beschikbaar.",
+      "booking": "Boeking",
+      "correctedOdometer": "Gecorrigeerde kilometerstand (km)",
+      "note": "Notitie",
+      "resolving": "Bezig met oplossen…",
+      "resolveIssue": "Probleem oplossen",
+      "resolveFailed": "Kon dit probleem niet oplossen."
+    },
+    "bookingOverlap": {
+      "heading": "Boekingsoverlap oplossen",
+      "description": "Blokkeer één van de twee overlappende verbintenissen. De andere behoudt zijn huidige status.",
+      "columns": {
+        "booking": "Boeking",
+        "window": "Periode",
+        "status": "Status",
+        "blockThis": "Deze blokkeren"
+      },
+      "blockLabel": "{{ref}} blokkeren",
+      "note": "Notitie",
+      "resolving": "Bezig met oplossen…",
+      "blockButton": "{{ref}} blokkeren",
+      "blockButtonFallback": "Boeking blokkeren",
+      "resolveFailed": "Kon deze overlap niet oplossen."
+    },
+    "vehicleStatusConflict": {
+      "heading": "Statusconflict oplossen",
+      "description": "Eén gezaghebbende regel beveelt een gecorrigeerde operationele status voor dit voertuig aan.",
+      "currentStatus": "Huidige status",
+      "calculateAndApply": "Aanbevolen status berekenen en toepassen",
+      "confirmTitle": "Statuswijziging bevestigen",
+      "confirmBody": "De gezaghebbende aanbevolen status voor dit voertuig toepassen?",
+      "applying": "Bezig met toepassen…",
+      "confirmYes": "Ja, toepassen",
+      "applied": "Toegepast {{status}} — {{reason}}",
+      "applyFailed": "Kon geen aanbevolen status toepassen."
+    }
+  }
+}
diff --git a/frontend/src/i18n/locales/nl-BE/returns.json b/frontend/src/i18n/locales/nl-BE/returns.json
new file mode 100644
index 0000000..d64d2cc
--- /dev/null
+++ b/frontend/src/i18n/locales/nl-BE/returns.json
@@ -0,0 +1,73 @@
+{
+  "progress": {
+    "capture": "Vastleggen",
+    "review": "Nakijken",
+    "result": "Resultaat",
+    "ariaLabel": "Voortgang retourregistratie"
+  },
+  "capture": {
+    "heading": "Voertuigretour registreren",
+    "description": "Leg de staat bij inlevering vast. De volgende stap evalueert de exacte operationele gevolgen voor er iets wordt bevestigd.",
+    "endOdometer": "Eindkilometerstand (km)",
+    "fuelLevel": "Brandstofniveau (%)",
+    "conditionLegend": "Voertuigstaat",
+    "cleanlinessOk": "Netheid aanvaardbaar",
+    "damageReported": "Schade gemeld",
+    "technicalWarning": "Technische melding",
+    "notes": "Notities",
+    "evaluating": "Evalueren…",
+    "reviewReturn": "Retour nakijken"
+  },
+  "review": {
+    "heading": "Retourimpact nakijken",
+    "description": "Dit is de gezaghebbende serverevaluatie van wat bevestigen zal doen — controleer dit voor het de wagenparkstatus bijwerkt en automatisering start.",
+    "odometer": "Kilometerstand",
+    "fuel": "Brandstof",
+    "cleanliness": "Netheid",
+    "cleanlinessAccepted": "Aanvaard",
+    "cleanlinessFollowUp": "Opvolging nodig",
+    "damage": "Schade",
+    "damageReported": "Gemeld",
+    "damageNone": "Niet gemeld",
+    "technicalWarning": "Technische melding",
+    "technicalWarningReported": "Gemeld",
+    "technicalWarningNone": "Niet gemeld",
+    "expectedState": "Verwachte wagenparkstatus:",
+    "odometerRegressionWarning": "De ingevoerde kilometerstand ({{submitted}} km) ligt onder de laatst bevestigde stand ({{canonical}} km). De laatst bevestigde kilometerstand wijzigt niet en er wordt een datakwaliteitsprobleem geopend.",
+    "nextBookingRisk": "Volgende boeking {{ref}} start {{when}} — mogelijk beïnvloed door deze retour.",
+    "nextBookingLowRisk": "Volgende boeking {{ref}} start {{when}} — laag risico.",
+    "commitList": {
+      "inspection": "Retourinspectie aanmaken",
+      "updateAtomic": "Boeking en voertuig atomair bijwerken",
+      "queueAutomation": "Automatisering inplannen na de lokale verwerking"
+    },
+    "editDetails": "Gegevens bewerken",
+    "registering": "Registreren…",
+    "confirmReturn": "Retour bevestigen"
+  },
+  "result": {
+    "committedLocally": "Lokaal verwerkt",
+    "heading": "Retour geregistreerd",
+    "inspection": "Inspectie",
+    "resultingStatus": "Resulterende wagenparkstatus",
+    "qualityIssue": "Datakwaliteitsprobleem",
+    "noneCreated": "Geen aangemaakt",
+    "automationEvent": "Automatiseringsopdracht",
+    "queuedForDelivery": "Klaargezet voor verwerking ({{ref}}) — lokale verwerking gelukt; aflevering via automatisering gebeurt asynchroon en is nog niet bevestigd.",
+    "nextBookingRisk": "Risico volgende boeking",
+    "nextBookingRiskValue": "{{ref}} {{status}}",
+    "atRisk": "— mogelijk beïnvloed",
+    "lowRisk": "— laag risico",
+    "noUpcomingBooking": "Geen aankomende boeking voor dit voertuig",
+    "odometerRegressionNotice": "De ingevoerde kilometerstand lag onder de laatst bevestigde stand van het voertuig. Ze werd zo geregistreerd; de laatst bevestigde kilometerstand is niet gewijzigd en er is een datakwaliteitsprobleem geopend ter controle.",
+    "viewVehicle": "Voertuig {{ref}} bekijken",
+    "viewAutomation": "Automatiseringsstatus bekijken",
+    "viewAudit": "Audit trail bekijken",
+    "continueDemo": "Ga verder met de demo"
+  },
+  "scenario": {
+    "title": "Demonstratiescenario: afwijkende kilometerstand",
+    "body": "Dit voertuig staat momenteel op {{odometer}} km. Het onderstaande formulier is vooraf ingevuld met een retourstand die daaronder ligt — een teken van een foutieve invoer of een verwisseld voertuig. Bevestig de retour om te zien hoe Fleet Ops dit detecteert en afhandelt.",
+    "preparing": "Scenario voorbereiden…"
+  }
+}
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
index c25e4e3..7dfac13 100644
--- a/frontend/src/main.tsx
+++ b/frontend/src/main.tsx
@@ -2,6 +2,7 @@ import React from "react";
 import ReactDOM from "react-dom/client";
 import { BrowserRouter } from "react-router-dom";
 import { App } from "./App";
+import "./i18n/config";
 import "./styles.css";
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
diff --git a/frontend/src/pages/AboutDemo.tsx b/frontend/src/pages/AboutDemo.tsx
new file mode 100644
index 0000000..4699ff2
--- /dev/null
+++ b/frontend/src/pages/AboutDemo.tsx
@@ -0,0 +1,135 @@
+import { Trans, useTranslation } from "react-i18next";
+import { useAuth } from "../context/AuthContext";
+import { useDemoGuide } from "../context/DemoGuideContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { useLocaleFormat } from "../i18n/format";
+import { Icon } from "../components/Icons";
+import { IntegrationMark, LoadingState, PageHeader, SectionHeading } from "../components/PageChrome";
+
+const INTEGRATION_ICON: Record<string, "n8n" | "rag" | "mcp"> = {
+  n8n: "n8n",
+  ragcore: "rag",
+  mcp_hub: "mcp",
+};
+
+const N8N_STATUS_LABEL_KEY: Record<string, string> = {
+  disabled: "notConnected",
+  unavailable: "deliveryFailed",
+  degraded: "retryAvailable",
+  operational: "operational",
+  no_evidence: "prepared",
+};
+
+export function AboutDemo() {
+  const { t } = useTranslation(["demo", "integrations"]);
+  const { formatDateTime } = useLocaleFormat();
+  const { manifest, loading } = useDemoManifest();
+  const { user } = useAuth();
+  const { openGuide } = useDemoGuide();
+
+  function statusLabelKey(key: string, statusCode: string): string {
+    if (key === "n8n") return N8N_STATUS_LABEL_KEY[statusCode] ?? statusCode;
+    return statusCode;
+  }
+
+  return (
+    <div className="page">
+      <PageHeader
+        eyebrow={t("about.eyebrow")}
+        title={t("about.title")}
+        description={manifest ? t("about.description", { orgName: manifest.organization_name }) : undefined}
+      />
+
+      {loading && <LoadingState label={t("about.loading")} />}
+
+      {manifest && (
+        <>
+          {user?.role === "operations_manager" && (
+            <section className="record-surface about-card about-cta">
+              <div>
+                <strong>{t("about.ctaTitle")}</strong>
+                <p>{t("about.ctaBody")}</p>
+              </div>
+              <button type="button" className="button button-primary" onClick={openGuide}>
+                <Icon name="spark" /> {t("about.ctaButton")}
+              </button>
+            </section>
+          )}
+
+          <section className="record-surface about-card">
+            <h2>{t("about.problemTitle")}</h2>
+            <p>{t("about.problemBody", { orgName: manifest.organization_name })}</p>
+          </section>
+
+          <section className="record-surface about-card">
+            <h2>{t("about.scopeTitle")}</h2>
+            <p>{t("about.scopeBody")}</p>
+          </section>
+
+          <section className="record-surface about-card">
+            <h2>{t("about.realTitle")}</h2>
+            <p>{t("about.realBody")}</p>
+          </section>
+
+          <section className="record-surface about-card">
+            <h2>{t("about.syntheticTitle")}</h2>
+            <p>{t("about.syntheticBody", { testDomain: ".test" })}</p>
+          </section>
+
+          <section className="record-surface about-card">
+            <h2>{t("about.architectureTitle")}</h2>
+            <p>{t("about.architectureBody")}</p>
+          </section>
+
+          <section className="record-surface about-card">
+            <h2>{t("about.securityTitle")}</h2>
+            <p>{t("about.securityBody")}</p>
+          </section>
+
+          <section className="record-surface about-card">
+            <h2>{t("about.testingTitle")}</h2>
+            <p>{t("about.testingBody")}</p>
+          </section>
+
+          <section aria-label={t("about.integrationsTitle")} className="record-surface">
+            <SectionHeading title={t("about.integrationsTitle")} description={t("about.integrationsDescription")} />
+            <div className="integration-cards">
+              {manifest.integrations.map((integration) => (
+                <article key={integration.key}>
+                  <IntegrationMark kind={INTEGRATION_ICON[integration.key]} />
+                  <div>
+                    <span className="integration-kicker">
+                      {t(`integrations:statusLabels.${statusLabelKey(integration.key, integration.status_code)}`)}
+                    </span>
+                    <h2>{t(`integrationSummary.titles.${integration.key}`, { ns: "demo" })}</h2>
+                    <p>{t(`integrationSummary.${integration.detail_code}`, { ns: "demo", ...integration.detail_params })}</p>
+                  </div>
+                </article>
+              ))}
+            </div>
+          </section>
+
+          <section className="record-surface about-card">
+            <h2>{t("about.resetTitle")}</h2>
+            <p>
+              <Trans
+                i18nKey={user?.role === "operations_manager" ? "about.resetBodyManager" : "about.resetBodyEmployee"}
+                t={t}
+                values={{ when: manifest.last_reset_at ? formatDateTime(manifest.last_reset_at) : t("about.unknown") }}
+                components={{ strong: <strong /> }}
+              />
+            </p>
+          </section>
+
+          <section className="access-note record-surface" aria-label={t("about.limitationsTitle")}>
+            <Icon name="shield" />
+            <p>
+              <strong>{t("about.limitationsTitle")}</strong>
+              <span>{t("about.limitationsBody")}</span>
+            </p>
+          </section>
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/pages/Audit.tsx b/frontend/src/pages/Audit.tsx
index 01e522c..a2c6aeb 100644
--- a/frontend/src/pages/Audit.tsx
+++ b/frontend/src/pages/Audit.tsx
@@ -1,30 +1,72 @@
-import { useEffect, useState } from "react";
-import { Link } from "react-router-dom";
+import { useEffect, useMemo, useState } from "react";
+import { Link, useSearchParams } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api } from "../api/client";
 import type { AuditEvent } from "../api/types";
 import { useAuth } from "../context/AuthContext";
+import { useLocaleFormat } from "../i18n/format";
 import { EmptyState, ErrorState, LoadingState, PageHeader } from "../components/PageChrome";
 
-function describeChanges(before: Record<string, unknown> | null, after: Record<string, unknown> | null): string {
-  if (!before && !after) return "No recorded change detail.";
+function humanizeField(field: string): string {
+  const spaced = field.replace(/_/g, " ");
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+function shortRef(id: string): string {
+  return `AUD-${id.slice(0, 8).toUpperCase()}`;
+}
+
+function actionLabel(t: (key: string, options?: Record<string, unknown>) => string, action: string): string {
+  return t(`actions.${action}`, { defaultValue: action.replace(/_/g, " ") });
+}
+
+function ChangeDiff({
+  before,
+  after,
+  t,
+}: {
+  before: Record<string, unknown> | null;
+  after: Record<string, unknown> | null;
+  t: (key: string, options?: Record<string, unknown>) => string;
+}) {
+  if (!before && !after) return <p className="table-subtext">{t("noChangeDetail")}</p>;
   const keys = new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})]);
-  const lines: string[] = [];
+  const lines: { field: string; text: string }[] = [];
   for (const key of keys) {
     const b = before?.[key];
     const a = after?.[key];
     if (JSON.stringify(b) === JSON.stringify(a)) continue;
-    if (b === undefined) lines.push(`${key}: set to ${JSON.stringify(a)}`);
-    else if (a === undefined) lines.push(`${key}: was ${JSON.stringify(b)}`);
-    else lines.push(`${key}: ${JSON.stringify(b)} → ${JSON.stringify(a)}`);
+    const field = humanizeField(key);
+    if (b === undefined) lines.push({ field, text: t("diff.setTo", { field, value: JSON.stringify(a) }) });
+    else if (a === undefined) lines.push({ field, text: t("diff.was", { field, value: JSON.stringify(b) }) });
+    else lines.push({ field, text: t("diff.changed", { field, before: JSON.stringify(b), after: JSON.stringify(a) }) });
   }
-  return lines.length > 0 ? lines.join("; ") : "No field-level change detected.";
+  if (lines.length === 0) return <p className="table-subtext">{t("noFieldChange")}</p>;
+  return (
+    <ul className="change-diff">
+      {lines.map((line) => (
+        <li key={line.field}>{line.text}</li>
+      ))}
+    </ul>
+  );
+}
+
+interface EventGroup {
+  correlationId: string;
+  primary: AuditEvent;
+  related: AuditEvent[];
 }
 
 export function Audit() {
+  const { t } = useTranslation("audit");
+  const { formatDateTime } = useLocaleFormat();
   const { user } = useAuth();
+  const [searchParams, setSearchParams] = useSearchParams();
   const [events, setEvents] = useState<AuditEvent[] | null>(null);
   const [error, setError] = useState<string | null>(null);
-  const [action, setAction] = useState("");
+  const [action, setAction] = useState(searchParams.get("action") ?? "");
+  const [expanded, setExpanded] = useState<Record<string, boolean>>({});
+  const correlationId = searchParams.get("correlation_id") ?? "";
 
   useEffect(() => {
     if (user?.role !== "operations_manager") return;
@@ -32,82 +74,155 @@ export function Audit() {
     setError(null);
     const params = new URLSearchParams();
     if (action) params.set("action", action);
+    if (correlationId) params.set("correlation_id", correlationId);
     api
       .get<AuditEvent[]>(`/api/v1/audit?${params.toString()}`)
       .then(setEvents)
-      .catch(() => setError("Audit trail is unavailable right now."));
-  }, [action, user]);
+      .catch(() => setError(t("unavailable")));
+  }, [action, correlationId, user]);
+
+  const groups = useMemo<EventGroup[]>(() => {
+    if (!events) return [];
+    const order: string[] = [];
+    const byCorrelation = new Map<string, AuditEvent[]>();
+    for (const event of events) {
+      if (!byCorrelation.has(event.correlation_id)) {
+        order.push(event.correlation_id);
+        byCorrelation.set(event.correlation_id, []);
+      }
+      byCorrelation.get(event.correlation_id)!.push(event);
+    }
+    return order.map((id) => {
+      const group = byCorrelation.get(id)!;
+      return { correlationId: id, primary: group[0], related: group.slice(1) };
+    });
+  }, [events]);
+
+  function showRelatedEvents(id: string) {
+    setSearchParams({ correlation_id: id });
+  }
+
+  function clearCorrelationFilter() {
+    setSearchParams(action ? { action } : {});
+  }
+
+  function toggleExpanded(id: string) {
+    setExpanded((prev) => ({ ...prev, [id]: !prev[id] }));
+  }
 
   if (user?.role !== "operations_manager") {
     return (
       <div className="page">
-        <PageHeader eyebrow="Assurance / Immutable history" title="Audit trail" description="The audit trail is visible to Operations Managers only." />
-        <p>Audit history is visible to Operations Managers only.</p>
+        <PageHeader eyebrow={t("eyebrow")} title={t("title")} description={t("managerOnly")} />
+        <p>{t("managerOnlyDetail")}</p>
       </div>
     );
   }
 
   return (
     <div className="page">
-      <PageHeader eyebrow="Assurance / Immutable history" title="Audit trail" description="Trace important state changes, actors and correlation references." />
+      <PageHeader eyebrow={t("eyebrow")} title={t("title")} description={t("description")} />
 
-      <form className="filters" aria-label="Filter audit events">
+      <form className="filters" aria-label={t("title")}>
         <label>
-          Action
+          {t("actionFilterLabel")}
           <input
             type="text"
             value={action}
             onChange={(e) => setAction(e.target.value)}
-            placeholder="e.g. demo_login"
+            placeholder={t("actionFilterPlaceholder")}
           />
         </label>
       </form>
 
-      {error && <ErrorState message={error} />}
-      {!error && !events && <LoadingState label="Loading audit trail…" />}
-      {events && events.length === 0 && <EmptyState icon="audit" title="No audit events found" detail="Adjust the action filter." />}
+      {correlationId && (
+        <p className="quiet-empty" role="status">
+          {t("relatedFilterActive", { count: events?.length ?? 0 })}{" "}
+          <button type="button" className="link-button" onClick={clearCorrelationFilter}>
+            {t("clearFilter")}
+          </button>
+        </p>
+      )}
 
-      {events && events.length > 0 && (
-        <div className="table-shell"><div className="table-meta"><span>{events.length} events</span><span>UTC stored · Brussels rendered</span></div><table className="data-table">
-          <caption className="visually-hidden">Audit events</caption>
-          <thead>
-            <tr>
-              <th scope="col">When</th>
-              <th scope="col">Actor</th>
-              <th scope="col">Action</th>
-              <th scope="col">Entity</th>
-              <th scope="col">Change</th>
-              <th scope="col">Details</th>
-            </tr>
-          </thead>
-          <tbody>
-            {events.map((e) => (
-              <tr key={e.id}>
-                <td data-label="When">
-                  <time dateTime={e.occurred_at}>
-                    {new Date(e.occurred_at).toLocaleString("en-GB", { timeZone: "Europe/Brussels" })}
-                  </time>
-                </td>
-                <td data-label="Actor"><strong>{e.actor_label}</strong><small className="table-subtext">{e.actor_type}</small></td>
-                <td data-label="Action">{e.action.replace(/_/g, " ")}</td>
-                <td data-label="Entity">
-                  {e.entity_link ? (
-                    <Link to={e.entity_link}>{e.entity_ref ?? e.entity_type}</Link>
-                  ) : (
-                    e.entity_ref ?? e.entity_type
-                  )}
-                </td>
-                <td data-label="Change">{describeChanges(e.before, e.after)}</td>
-                <td className="mono" data-label="Details">
-                  <details>
-                    <summary>{e.correlation_id.slice(0, 8)}</summary>
-                    <pre>{JSON.stringify({ before: e.before, after: e.after, metadata: e.metadata }, null, 2)}</pre>
+      {error && <ErrorState message={error} />}
+      {!error && !events && <LoadingState label={t("loading")} />}
+      {events && events.length === 0 && <EmptyState icon="audit" title={t("empty")} detail={t("emptyDetail")} />}
+
+      {groups.length > 0 && (
+        <div className="table-shell">
+          <div className="table-meta"><span>{t("count", { count: events!.length })}</span><span>{t("storedRendered")}</span></div>
+          <ul className="audit-group-list">
+            {groups.map((group) => {
+              const e = group.primary;
+              const isExpanded = expanded[group.correlationId] ?? false;
+              return (
+                <li key={group.correlationId} className="audit-group panel">
+                  <div className="audit-group-summary">
+                    <div className="audit-group-heading">
+                      <strong>{actionLabel(t, e.action)}</strong>
+                      <span className="table-subtext">{formatDateTime(e.occurred_at)}</span>
+                    </div>
+                    <div className="audit-group-meta">
+                      <span><strong>{e.actor_label}</strong> <small className="table-subtext">{e.actor_type}</small></span>
+                      {e.entity_link ? (
+                        <Link to={e.entity_link}>{e.entity_ref ?? e.entity_type}</Link>
+                      ) : (
+                        <span>{e.entity_ref ?? e.entity_type}</span>
+                      )}
+                    </div>
+                    <ChangeDiff before={e.before} after={e.after} t={t} />
+                    <div className="audit-group-actions">
+                      {group.related.length > 0 && (
+                        <button type="button" className="link-button" onClick={() => toggleExpanded(group.correlationId)}>
+                          {isExpanded
+                            ? t("hideTechnicalEvents")
+                            : t("showTechnicalEvents", { count: group.related.length })}
+                        </button>
+                      )}
+                      {!correlationId && (
+                        <button type="button" className="link-button" onClick={() => showRelatedEvents(group.correlationId)}>
+                          {t("viewRelatedEvents")}
+                        </button>
+                      )}
+                    </div>
+                  </div>
+
+                  <details className="evidence-disclosure">
+                    <summary>{t("technicalDetails")}</summary>
+                    <dl className="detail-grid audit-technical-grid">
+                      <div><dt>{t("reference")}</dt><dd>{shortRef(e.id)}</dd></div>
+                      <div><dt>{t("fullReference")}</dt><dd className="mono">{e.id}</dd></div>
+                      <div><dt>{t("correlationId")}</dt><dd className="mono">{e.correlation_id}</dd></div>
+                    </dl>
+                    <pre className="evidence-block">{JSON.stringify({ before: e.before, after: e.after, metadata: e.metadata }, null, 2)}</pre>
                   </details>
-                </td>
-              </tr>
-            ))}
-          </tbody>
-        </table></div>
+
+                  {isExpanded && group.related.length > 0 && (
+                    <ul className="audit-related-list">
+                      {group.related.map((related) => (
+                        <li key={related.id}>
+                          <div className="audit-group-heading">
+                            <strong>{actionLabel(t, related.action)}</strong>
+                            <span className="table-subtext">{formatDateTime(related.occurred_at)}</span>
+                          </div>
+                          <ChangeDiff before={related.before} after={related.after} t={t} />
+                          <details className="evidence-disclosure">
+                            <summary>{t("technicalDetails")}</summary>
+                            <dl className="detail-grid audit-technical-grid">
+                              <div><dt>{t("reference")}</dt><dd>{shortRef(related.id)}</dd></div>
+                              <div><dt>{t("fullReference")}</dt><dd className="mono">{related.id}</dd></div>
+                            </dl>
+                            <pre className="evidence-block">{JSON.stringify({ before: related.before, after: related.after, metadata: related.metadata }, null, 2)}</pre>
+                          </details>
+                        </li>
+                      ))}
+                    </ul>
+                  )}
+                </li>
+              );
+            })}
+          </ul>
+        </div>
       )}
     </div>
   );
diff --git a/frontend/src/pages/Automation.tsx b/frontend/src/pages/Automation.tsx
index d47727c..6f52886 100644
--- a/frontend/src/pages/Automation.tsx
+++ b/frontend/src/pages/Automation.tsx
@@ -1,23 +1,30 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
 import { api, ApiError } from "../api/client";
 import type { AutomationRun, IntegrationStatus, KnowledgeHealth } from "../api/types";
 import { StatusBadge } from "../components/Badge";
 import { useAuth } from "../context/AuthContext";
+import { useLocaleFormat } from "../i18n/format";
 import { ErrorState, IntegrationMark, LoadingState, PageHeader, SectionHeading } from "../components/PageChrome";
+import { N8N_STATE_META, MCP_STATE_META } from "../data/integrationLabels";
 
-const N8N_STATE_LABEL: Record<IntegrationStatus["n8n"]["state"], string> = {
-  disabled: "disabled",
-  unavailable: "unavailable",
-  degraded: "degraded",
-  operational: "available",
-  no_evidence: "no_events",
-};
+type ViewFilter = "attention" | "recent" | "succeeded" | "all";
+
+function deriveDisplayRef(run: AutomationRun): string {
+  const digits = run.aggregate_ref.match(/(\d+)$/)?.[1];
+  if (digits) return `AUT-RET-${digits}`;
+  return `AUT-${run.event_id.slice(0, 4).toUpperCase()}`;
+}
 
 export function Automation() {
+  const { t } = useTranslation(["integrations", "common"]);
+  const { formatDateTime } = useLocaleFormat();
   const { user } = useAuth();
   const [runs, setRuns] = useState<AutomationRun[] | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [status, setStatus] = useState("");
+  const [view, setView] = useState<ViewFilter>("attention");
+  const [expandSucceeded, setExpandSucceeded] = useState(false);
   const [retryError, setRetryError] = useState<string | null>(null);
   const [retrying, setRetrying] = useState<string | null>(null);
   const [knowledge, setKnowledge] = useState<KnowledgeHealth | null>(null);
@@ -32,13 +39,9 @@ export function Automation() {
       .get<AutomationRun[]>(`/api/v1/workflows?${params.toString()}`)
       .then(setRuns)
       .catch(() =>
-        setError(
-          user?.role === "operations_manager"
-            ? "Automation runs are unavailable right now."
-            : "Automation is only visible to Operations Managers.",
-        ),
+        setError(user?.role === "operations_manager" ? t("ledger.unavailable") : t("ledger.managerOnly")),
       );
-  }, [status, user]);
+  }, [status, user, t]);
 
   useEffect(() => {
     load();
@@ -67,123 +70,206 @@ export function Automation() {
       load();
       loadIntegrationStatus();
     } catch (err) {
-      setRetryError(err instanceof ApiError ? err.message : "Could not retry this delivery.");
+      setRetryError(err instanceof ApiError ? err.message : t("ledger.retryFailed"));
     } finally {
       setRetrying(null);
     }
   }
 
+  const visibleRuns = useMemo(() => {
+    if (!runs) return null;
+    switch (view) {
+      case "attention":
+        return runs.filter((r) => r.status === "failed" || r.status === "pending" || r.status === "delivering");
+      case "recent":
+        return runs.slice(0, 5);
+      case "succeeded":
+        return runs.filter((r) => r.status === "succeeded");
+      default:
+        return runs;
+    }
+  }, [runs, view]);
+
+  const succeededRuns = useMemo(() => (visibleRuns ?? []).filter((r) => r.status === "succeeded"), [visibleRuns]);
+  const otherRuns = useMemo(() => (visibleRuns ?? []).filter((r) => r.status !== "succeeded"), [visibleRuns]);
+  const groupSucceeded = view !== "succeeded" && succeededRuns.length > 3;
+
   if (user?.role !== "operations_manager") {
     return (
       <div className="page">
-        <PageHeader eyebrow="Assurance / Integrations" title="Integrations" description="Delivery evidence is visible to Operations Managers only." />
-        <p>Automation delivery status is visible to Operations Managers only.</p>
+        <PageHeader eyebrow={t("eyebrow")} title={t("title")} description={t("ledger.managerOnly")} />
+        <p>{t("ledger.managerOnly")}</p>
       </div>
     );
   }
 
+  function renderRow(r: AutomationRun) {
+    return (
+      <tr key={r.event_id}>
+        <td className="mono" data-label={t("ledger.columns.event")}>
+          <details>
+            <summary>{deriveDisplayRef(r)}</summary>
+            <span className="table-subtext">{r.event_id}</span>
+          </details>
+        </td>
+        <td data-label={t("ledger.columns.type")}>{t(`ledger.eventTypes.${r.event_type}`, { defaultValue: r.event_type })}</td>
+        <td data-label={t("ledger.columns.booking")}>{r.aggregate_ref}</td>
+        <td data-label={t("ledger.columns.status")}>
+          <StatusBadge status={r.status} label={t(`ledger.status${r.status.charAt(0).toUpperCase()}${r.status.slice(1)}`)} />
+        </td>
+        <td data-label={t("ledger.columns.attempts")}>{r.attempts}</td>
+        <td data-label={t("ledger.columns.lastError")}>{r.last_error ?? "—"}</td>
+        <td data-label={t("ledger.columns.when")}>
+          <time dateTime={r.occurred_at}>{formatDateTime(r.occurred_at)}</time>
+        </td>
+        <td data-label={t("ledger.columns.action")}>
+          {r.status === "failed" ? (
+            <button type="button" onClick={() => handleRetry(r.event_id)} disabled={retrying === r.event_id}>
+              {retrying === r.event_id ? t("ledger.retrying") : t("ledger.retry")}
+            </button>
+          ) : (
+            t("ledger.noAction")
+          )}
+        </td>
+      </tr>
+    );
+  }
+
   return (
     <div className="page">
-      <PageHeader eyebrow="Assurance / Integrations" title="Integration control" description="Monitor delivery health, graceful degradation and retryable workflow events." />
+      <PageHeader eyebrow={t("eyebrow")} title={t("title")} description={t("description")} />
 
-      <section className="integration-cards" aria-label="Integration health">
+      <section className="integration-cards" aria-label={t("title")}>
         <article>
           <IntegrationMark kind="n8n" />
           <div>
-            <span className="integration-kicker">Orchestration</span>
-            <h2>n8n delivery</h2>
+            <span className="integration-kicker">{t("cards.orchestrationKicker")}</span>
+            <h2>{t("cards.n8nTitle")}</h2>
             <p>
               {integrationStatus
-                ? `${integrationStatus.n8n.succeeded} succeeded · ${integrationStatus.n8n.failed} failed · ${integrationStatus.n8n.pending} pending · ${integrationStatus.n8n.delivering} delivering.`
-                : "Return events are committed locally first and then delivered through the outbox."}
+                ? t("cards.n8nSummary", {
+                    succeeded: integrationStatus.n8n.succeeded,
+                    failed: integrationStatus.n8n.failed,
+                    pending: integrationStatus.n8n.pending,
+                    delivering: integrationStatus.n8n.delivering,
+                  })
+                : t("cards.n8nFallback")}
             </p>
           </div>
-          <StatusBadge status={integrationStatus ? N8N_STATE_LABEL[integrationStatus.n8n.state] : (runs?.[0]?.status ?? "no_events")} />
+          {(() => {
+            const meta = integrationStatus ? N8N_STATE_META[integrationStatus.n8n.state] : null;
+            return (
+              <StatusBadge
+                status={meta?.statusClass ?? (runs?.[0]?.status ?? "no_events")}
+                label={meta ? t(`statusLabels.${meta.labelKey}`) : undefined}
+              />
+            );
+          })()}
+        </article>
+        <article>
+          <IntegrationMark kind="rag" />
+          <div>
+            <span className="integration-kicker">{t("cards.knowledgeKicker")}</span>
+            <h2>{t("cards.knowledgeTitle")}</h2>
+            <p>
+              {knowledge
+                ? t(knowledge.provider === "ragcore" ? "cards.knowledgeSummaryRagcore" : "cards.knowledgeSummaryDemo", {
+                    count: knowledge.document_count,
+                    collection: knowledge.collection,
+                  })
+                : t("cards.knowledgeUnavailable")}
+            </p>
+          </div>
+          <StatusBadge
+            status={knowledge?.available ? "available" : "unavailable"}
+            label={
+              knowledge?.available
+                ? t(`statusLabels.${knowledge.provider === "ragcore" ? "operational" : "demoMode"}`)
+                : t("statusLabels.unavailable")
+            }
+          />
         </article>
-        <article><IntegrationMark kind="rag" /><div><span className="integration-kicker">Knowledge</span><h2>RAGcore</h2><p>{knowledge ? `${knowledge.document_count} procedures indexed in ${knowledge.collection}.` : "Health evidence is currently unavailable."}</p></div><StatusBadge status={knowledge?.available ? "available" : "unavailable"} /></article>
         <article>
           <IntegrationMark kind="mcp" />
           <div>
-            <span className="integration-kicker">Tool gateway</span>
-            <h2>MCP Hub</h2>
-            <p>
-              {integrationStatus?.mcp_hub.registration_enabled
-                ? "Registration is enabled for this deployment."
-                : "No active MobilityOps adapter is configured in this proof of concept."}
-            </p>
+            <span className="integration-kicker">{t("cards.gatewayKicker")}</span>
+            <h2>{t("cards.mcpTitle")}</h2>
+            <p>{integrationStatus?.mcp_hub.registration_enabled ? t("cards.mcpEnabled") : t("cards.mcpNotConnected")}</p>
           </div>
-          <StatusBadge status={integrationStatus?.mcp_hub.state ?? "not_configured"} />
+          {(() => {
+            const meta = integrationStatus ? MCP_STATE_META[integrationStatus.mcp_hub.state] : null;
+            return <StatusBadge status={meta?.statusClass ?? "not_configured"} label={meta ? t(`statusLabels.${meta.labelKey}`) : undefined} />;
+          })()}
         </article>
       </section>
 
-      <SectionHeading title="Delivery ledger" description="Persisted outbox attempts with the latest failure evidence." />
+      <SectionHeading title={t("ledger.title")} description={t("ledger.description")} />
 
-      <form className="filters" aria-label="Filter automation runs">
+      <form className="filters" aria-label={t("ledger.title")}>
         <label>
-          Status
+          {t("ledger.filterLabel")}
+          <select value={view} onChange={(e) => setView(e.target.value as ViewFilter)}>
+            <option value="attention">{t("ledger.filterNeedsAttention")}</option>
+            <option value="recent">{t("ledger.filterRecent")}</option>
+            <option value="succeeded">{t("ledger.filterSucceeded")}</option>
+            <option value="all">{t("ledger.filterAll")}</option>
+          </select>
+        </label>
+        <label>
+          {t("ledger.statusFilterLabel")}
           <select value={status} onChange={(e) => setStatus(e.target.value)}>
-            <option value="">All statuses</option>
-            <option value="pending">Pending</option>
-            <option value="delivering">Delivering</option>
-            <option value="succeeded">Succeeded</option>
-            <option value="failed">Failed</option>
+            <option value="">{t("ledger.statusAll")}</option>
+            <option value="pending">{t("ledger.statusPending")}</option>
+            <option value="delivering">{t("ledger.statusDelivering")}</option>
+            <option value="succeeded">{t("ledger.statusSucceeded")}</option>
+            <option value="failed">{t("ledger.statusFailed")}</option>
           </select>
         </label>
       </form>
 
       {error && <ErrorState message={error} />}
       {retryError && <p className="error" role="alert">{retryError}</p>}
-      {!error && !runs && <LoadingState label="Loading workflow delivery ledger…" />}
-      {runs && runs.length === 0 && <p>No automation runs match this filter.</p>}
+      {!error && !runs && <LoadingState label={t("ledger.loading")} />}
+      {visibleRuns && visibleRuns.length === 0 && <p>{t("ledger.empty")}</p>}
 
-      {runs && runs.length > 0 && (
-        <div className="table-shell"><div className="table-meta"><span>{runs.length} workflow events</span><span>Bounded retries</span></div><table className="data-table">
-          <caption className="visually-hidden">Automation runs</caption>
-          <thead>
-            <tr>
-              <th scope="col">Event</th>
-              <th scope="col">Type</th>
-              <th scope="col">Booking</th>
-              <th scope="col">Status</th>
-              <th scope="col">Attempts</th>
-              <th scope="col">Last error</th>
-              <th scope="col">When</th>
-              <th scope="col">Action</th>
-            </tr>
-          </thead>
-          <tbody>
-            {runs.map((r) => (
-              <tr key={r.event_id}>
-                <td className="mono" data-label="Event">{r.event_id.slice(0, 8)}</td>
-                <td data-label="Type">{r.event_type}</td>
-                <td data-label="Booking">{r.aggregate_ref}</td>
-                <td data-label="Status">
-                  <StatusBadge status={r.status} />
-                </td>
-                <td data-label="Attempts">{r.attempts}</td>
-                <td data-label="Last error">{r.last_error ?? "—"}</td>
-                <td data-label="When">
-                  <time dateTime={r.occurred_at}>
-                    {new Date(r.occurred_at).toLocaleString("en-GB", { timeZone: "Europe/Brussels" })}
-                  </time>
-                </td>
-                <td data-label="Action">
-                  {r.status === "failed" ? (
-                    <button
-                      type="button"
-                      onClick={() => handleRetry(r.event_id)}
-                      disabled={retrying === r.event_id}
-                    >
-                      {retrying === r.event_id ? "Retrying…" : "Retry"}
-                    </button>
-                  ) : (
-                    "—"
-                  )}
-                </td>
+      {visibleRuns && visibleRuns.length > 0 && (
+        <div className="table-shell">
+          <div className="table-meta"><span>{t("ledger.count", { count: visibleRuns.length })}</span><span>{t("ledger.boundedRetries")}</span></div>
+          <table className="data-table">
+            <caption className="visually-hidden">{t("ledger.title")}</caption>
+            <thead>
+              <tr>
+                <th scope="col">{t("ledger.columns.event")}</th>
+                <th scope="col">{t("ledger.columns.type")}</th>
+                <th scope="col">{t("ledger.columns.booking")}</th>
+                <th scope="col">{t("ledger.columns.status")}</th>
+                <th scope="col">{t("ledger.columns.attempts")}</th>
+                <th scope="col">{t("ledger.columns.lastError")}</th>
+                <th scope="col">{t("ledger.columns.when")}</th>
+                <th scope="col">{t("ledger.columns.action")}</th>
               </tr>
-            ))}
-          </tbody>
-        </table></div>
+            </thead>
+            <tbody>
+              {otherRuns.map(renderRow)}
+              {groupSucceeded ? (
+                <>
+                  <tr>
+                    <td colSpan={8}>
+                      <button type="button" className="link-button" onClick={() => setExpandSucceeded((v) => !v)}>
+                        {expandSucceeded
+                          ? t("ledger.hideIndividually")
+                          : t("ledger.groupedSucceeded", { count: succeededRuns.length })}
+                      </button>
+                    </td>
+                  </tr>
+                  {expandSucceeded && succeededRuns.map(renderRow)}
+                </>
+              ) : (
+                succeededRuns.map(renderRow)
+              )}
+            </tbody>
+          </table>
+        </div>
       )}
     </div>
   );
diff --git a/frontend/src/pages/BookingDetail.tsx b/frontend/src/pages/BookingDetail.tsx
index 4303610..0096c87 100644
--- a/frontend/src/pages/BookingDetail.tsx
+++ b/frontend/src/pages/BookingDetail.tsx
@@ -1,24 +1,31 @@
 import { useCallback, useEffect, useState } from "react";
 import { Link, useParams } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api } from "../api/client";
-import type { Booking, RegisterReturnResult } from "../api/types";
+import type { Booking, RegisterReturnResult, VehicleDetail } from "../api/types";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { useLocaleFormat } from "../i18n/format";
 import { StatusBadge } from "../components/Badge";
 import { ReturnForm, ReturnResultPanel } from "../components/ReturnForm";
 import { Icon } from "../components/Icons";
 import { ErrorState, LoadingState, PageHeader } from "../components/PageChrome";
 
 export function BookingDetail() {
+  const { t } = useTranslation(["bookings", "returns"]);
+  const { formatDateTime, formatNumber } = useLocaleFormat();
   const { publicRef } = useParams<{ publicRef: string }>();
+  const { manifest } = useDemoManifest();
   const [booking, setBooking] = useState<Booking | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [returnResult, setReturnResult] = useState<RegisterReturnResult | null>(null);
+  const [canonicalOdometerKm, setCanonicalOdometerKm] = useState<number | null>(null);
 
   const load = useCallback(() => {
     if (!publicRef) return;
     api
       .get<Booking>(`/api/v1/bookings/${publicRef}`)
       .then(setBooking)
-      .catch(() => setError("This booking could not be found."));
+      .catch(() => setError(t("detail.notFound")));
   }, [publicRef]);
 
   useEffect(() => {
@@ -28,31 +35,67 @@ export function BookingDetail() {
     load();
   }, [load]);
 
+  // The odometer-regression demo scenario supplies its own suspicious reading (per the
+  // brief: never ask a demo visitor to invent one) -- only fetched for that one known
+  // scenario booking, not for every return.
+  const isReturnAnomalyScenario =
+    manifest?.scenarios.find((s) => s.id === "return-anomaly")?.start_path === `/bookings/${publicRef}`;
+
+  useEffect(() => {
+    setCanonicalOdometerKm(null);
+    if (!isReturnAnomalyScenario || !booking) return;
+    api
+      .get<VehicleDetail>(`/api/v1/vehicles/${booking.vehicle_ref}`)
+      .then((vehicle) => setCanonicalOdometerKm(vehicle.odometer_km))
+      .catch(() => setCanonicalOdometerKm(null));
+  }, [isReturnAnomalyScenario, booking]);
+
   function handleRegistered(result: RegisterReturnResult) {
     setReturnResult(result);
     load();
   }
 
   if (error) return <ErrorState message={error} />;
-  if (!booking) return <LoadingState label="Loading booking record…" />;
+  if (!booking) return <LoadingState label={t("detail.loading")} />;
 
   return (
     <div className="page">
-      <Link className="back-link" to="/bookings"><Icon name="arrow-left" /> Booking ledger</Link>
-      <PageHeader eyebrow="Bookings / Rental record" title={booking.public_ref} description={`${booking.customer_name} · ${booking.vehicle_ref}`} actions={<StatusBadge status={booking.status} />} />
-      <section className="record-surface" aria-label="Booking facts"><dl className="detail-grid">
-        <div><dt>Customer</dt><dd>{booking.customer_name} ({booking.customer_ref})</dd></div>
-        <div><dt>Vehicle</dt><dd><Link to={`/vehicles/${booking.vehicle_ref}`}>{booking.vehicle_ref}</Link></dd></div>
-        <div><dt>Starts</dt><dd>{new Date(booking.starts_at).toLocaleString("en-GB", { timeZone: "Europe/Brussels" })}</dd></div>
-        <div><dt>Ends</dt><dd>{new Date(booking.ends_at).toLocaleString("en-GB", { timeZone: "Europe/Brussels" })}</dd></div>
-        <div><dt>Start odometer</dt><dd>{booking.start_odometer_km ?? "—"} km</dd></div>
-        <div><dt>End odometer</dt><dd>{booking.end_odometer_km ?? "—"} km</dd></div>
-        <div><dt>Requirements complete</dt><dd>{booking.requirements_complete ? "Yes" : "No"}</dd></div>
+      <Link className="back-link" to="/bookings"><Icon name="arrow-left" /> {t("detail.backLink")}</Link>
+      <PageHeader eyebrow={t("detail.eyebrow")} title={booking.public_ref} description={`${booking.customer_name} · ${booking.vehicle_ref}`} actions={<StatusBadge status={booking.status} label={t(`statuses.${booking.status}`, { defaultValue: booking.status })} />} />
+      <section className="record-surface" aria-label={t("detail.eyebrow")}><dl className="detail-grid">
+        <div><dt>{t("detail.customer")}</dt><dd>{booking.customer_name} ({booking.customer_ref})</dd></div>
+        <div><dt>{t("detail.vehicle")}</dt><dd><Link to={`/vehicles/${booking.vehicle_ref}`}>{booking.vehicle_ref}</Link></dd></div>
+        <div><dt>{t("detail.starts")}</dt><dd>{formatDateTime(booking.starts_at)}</dd></div>
+        <div><dt>{t("detail.ends")}</dt><dd>{formatDateTime(booking.ends_at)}</dd></div>
+        <div><dt>{t("detail.startOdometer")}</dt><dd>{booking.start_odometer_km !== null ? `${formatNumber(booking.start_odometer_km)} km` : "—"}</dd></div>
+        <div><dt>{t("detail.endOdometer")}</dt><dd>{booking.end_odometer_km !== null ? `${formatNumber(booking.end_odometer_km)} km` : "—"}</dd></div>
+        <div><dt>{t("detail.requirementsComplete")}</dt><dd>{booking.requirements_complete ? t("detail.yes") : t("detail.no")}</dd></div>
       </dl></section>
 
+      {isReturnAnomalyScenario && !returnResult && canonicalOdometerKm !== null && (
+        <section className="record-surface scenario-callout" aria-label="Demo scenario">
+          <Icon name="spark" />
+          <div>
+            <strong>{t("returns:scenario.title")}</strong>
+            <p>{t("returns:scenario.body", { odometer: formatNumber(canonicalOdometerKm) })}</p>
+          </div>
+        </section>
+      )}
+
       {returnResult && <ReturnResultPanel result={returnResult} />}
-      {!returnResult && booking.status === "active" && (
-        <ReturnForm bookingRef={booking.public_ref} onRegistered={handleRegistered} />
+      {/* Wait for the scenario's canonical odometer before mounting the form at all when
+          this is the known demo scenario, so ReturnForm's suggestedOdometerKm is correct
+          from its very first render -- never updated asynchronously after mount, which
+          previously raced with anyone already typing into the field. */}
+      {!returnResult && booking.status === "active" && isReturnAnomalyScenario && canonicalOdometerKm === null && (
+        <LoadingState label={t("returns:scenario.preparing")} />
+      )}
+      {!returnResult && booking.status === "active" && (!isReturnAnomalyScenario || canonicalOdometerKm !== null) && (
+        <ReturnForm
+          bookingRef={booking.public_ref}
+          onRegistered={handleRegistered}
+          suggestedOdometerKm={isReturnAnomalyScenario && canonicalOdometerKm !== null ? Math.max(0, canonicalOdometerKm - 50) : undefined}
+        />
       )}
     </div>
   );
diff --git a/frontend/src/pages/Bookings.tsx b/frontend/src/pages/Bookings.tsx
index 8544bd1..c659044 100644
--- a/frontend/src/pages/Bookings.tsx
+++ b/frontend/src/pages/Bookings.tsx
@@ -1,13 +1,17 @@
 import { useEffect, useState } from "react";
 import { Link } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api } from "../api/client";
 import type { Booking } from "../api/types";
+import { useLocaleFormat } from "../i18n/format";
 import { StatusBadge } from "../components/Badge";
 import { EmptyState, ErrorState, LoadingState, PageHeader } from "../components/PageChrome";
 
 const STATUS_OPTIONS = ["reserved", "active", "returned", "cancelled", "blocked"];
 
 export function Bookings() {
+  const { t } = useTranslation("bookings");
+  const { formatShortDate } = useLocaleFormat();
   const [bookings, setBookings] = useState<Booking[] | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [status, setStatus] = useState("");
@@ -23,7 +27,7 @@ export function Bookings() {
     api
       .get<Booking[]>(`/api/v1/bookings?${params.toString()}`)
       .then(setBookings)
-      .catch(() => setError("Booking list is unavailable right now."));
+      .catch(() => setError(t("list.unavailable")));
   }, [status]);
 
   useEffect(() => {
@@ -37,20 +41,20 @@ export function Bookings() {
 
   return (
     <div className="page">
-      <PageHeader eyebrow="Operations / Schedule" title="Bookings" description="Review active rental windows and upcoming vehicle commitments." />
+      <PageHeader eyebrow={t("list.eyebrow")} title={t("list.title")} description={t("list.description")} />
 
-      <form className="filters" aria-label="Filter bookings">
+      <form className="filters" aria-label={t("list.title")}>
         <label>
-          Search
-          <input type="text" value={query} onChange={(e) => { setQuery(e.target.value); setPage(1); }} placeholder="Booking, customer or vehicle" />
+          {t("list.searchLabel")}
+          <input type="text" value={query} onChange={(e) => { setQuery(e.target.value); setPage(1); }} placeholder={t("list.searchPlaceholder")} />
         </label>
         <label>
-          Status
+          {t("list.statusLabel")}
           <select value={status} onChange={(e) => { setStatus(e.target.value); setPage(1); }}>
-            <option value="">All statuses</option>
+            <option value="">{t("list.statusAll")}</option>
             {STATUS_OPTIONS.map((s) => (
               <option key={s} value={s}>
-                {s}
+                {t(`statuses.${s}`)}
               </option>
             ))}
           </select>
@@ -58,44 +62,45 @@ export function Bookings() {
       </form>
 
       {error && <ErrorState message={error} />}
-      {!error && !bookings && <LoadingState label="Loading booking ledger…" />}
-      {bookings && bookings.length === 0 && <EmptyState icon="bookings" title="No bookings found" detail="Adjust the booking status filter." />}
+      {!error && !bookings && <LoadingState label={t("list.loading")} />}
+      {bookings && bookings.length === 0 && <EmptyState icon="bookings" title={t("list.empty")} detail={t("list.emptyDetail")} />}
 
       {bookings && bookings.length > 0 && (() => {
         const filtered = bookings.filter((b) => `${b.public_ref} ${b.customer_name} ${b.vehicle_ref}`.toLowerCase().includes(query.toLowerCase()));
         const totalPages = Math.max(1, Math.ceil(filtered.length / perPage));
         const visible = filtered.slice((page - 1) * perPage, page * perPage);
-        return filtered.length === 0 ? <EmptyState icon="search" title="No matching bookings" detail="Try a broader search term." /> : <div className="table-shell"><div className="table-meta"><span>{filtered.length} bookings</span><span>Page {page} of {totalPages}</span></div><table className="data-table">
-          <caption className="visually-hidden">Bookings</caption>
+        return filtered.length === 0 ? <EmptyState icon="search" title={t("list.noMatch")} detail={t("list.noMatchDetail")} /> : <div className="table-shell"><div className="table-meta"><span>{t("list.count", { count: filtered.length })}</span><span>{t("list.pageOf", { page, total: totalPages })}</span></div><table className="data-table">
+          <caption className="visually-hidden">{t("list.title")}</caption>
           <thead>
             <tr>
-              <th scope="col">Reference</th>
-              <th scope="col">Customer</th>
-              <th scope="col">Vehicle</th>
-              <th scope="col">Window</th>
-              <th scope="col">Status</th>
+              <th scope="col">{t("list.columns.reference")}</th>
+              <th scope="col">{t("list.columns.customer")}</th>
+              <th scope="col">{t("list.columns.vehicle")}</th>
+              <th scope="col">{t("list.columns.window")}</th>
+              <th scope="col">{t("list.columns.status")}</th>
             </tr>
           </thead>
           <tbody>
             {visible.map((b) => (
-              <tr key={b.public_ref}>
-                <th scope="row" data-label="Reference">
-                  <Link to={`/bookings/${b.public_ref}`}>{b.public_ref}</Link>
+              <tr key={b.public_ref} className="row-clickable">
+                <th scope="row" data-label={t("list.columns.reference")}>
+                  {b.public_ref}
+                  <Link className="row-link" to={`/bookings/${b.public_ref}`}><span className="visually-hidden">{b.public_ref}</span></Link>
                 </th>
-                <td data-label="Customer">{b.customer_name}</td>
-                <td data-label="Vehicle">
-                  <Link to={`/vehicles/${b.vehicle_ref}`}>{b.vehicle_ref}</Link>
+                <td data-label={t("list.columns.customer")}>{b.customer_name}</td>
+                <td data-label={t("list.columns.vehicle")}>
+                  <Link to={`/vehicles/${b.vehicle_ref}`} className="cell-link">{b.vehicle_ref}</Link>
                 </td>
-                <td data-label="Window">
-                  {new Date(b.starts_at).toLocaleDateString("en-GB")} → {new Date(b.ends_at).toLocaleDateString("en-GB")}
+                <td data-label={t("list.columns.window")}>
+                  {formatShortDate(b.starts_at)} → {formatShortDate(b.ends_at)}
                 </td>
-                <td data-label="Status">
-                  <StatusBadge status={b.status} />
+                <td data-label={t("list.columns.status")}>
+                  <StatusBadge status={b.status} label={t(`statuses.${b.status}`, { defaultValue: b.status })} />
                 </td>
               </tr>
             ))}
           </tbody>
-        </table><div className="pagination" aria-label="Booking pages"><button type="button" disabled={page === 1} onClick={() => setPage((p) => p - 1)}>Previous</button><span>{(page - 1) * perPage + 1}–{Math.min(page * perPage, filtered.length)} of {filtered.length}</span><button type="button" disabled={page === totalPages} onClick={() => setPage((p) => p + 1)}>Next</button></div></div>;
+        </table><div className="pagination" aria-label={t("list.paginationLabel")}><button type="button" disabled={page === 1} onClick={() => setPage((p) => p - 1)}>{t("list.previous")}</button><span>{t("list.rangeOf", { from: (page - 1) * perPage + 1, to: Math.min(page * perPage, filtered.length), total: filtered.length })}</span><button type="button" disabled={page === totalPages} onClick={() => setPage((p) => p + 1)}>{t("list.next")}</button></div></div>;
       })()}
     </div>
   );
diff --git a/frontend/src/pages/Dashboard.tsx b/frontend/src/pages/Dashboard.tsx
index 54751d7..e376dcc 100644
--- a/frontend/src/pages/Dashboard.tsx
+++ b/frontend/src/pages/Dashboard.tsx
@@ -1,33 +1,52 @@
 import { useEffect, useMemo, useState } from "react";
-import { Link } from "react-router-dom";
+import { Link, useSearchParams } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api } from "../api/client";
 import type { Dashboard as DashboardData, IntegrationStatus, KnowledgeHealth } from "../api/types";
 import { useAuth } from "../context/AuthContext";
+import { useDemoGuide } from "../context/DemoGuideContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { useLocaleFormat } from "../i18n/format";
 import { SeverityBadge, StatusBadge } from "../components/Badge";
 import { Icon } from "../components/Icons";
 import { ErrorState, IntegrationMark, LoadingState, PageHeader, SectionHeading } from "../components/PageChrome";
+import { N8N_STATE_META, MCP_STATE_META } from "../data/integrationLabels";
 
-const FLEET_METRICS: Array<{ key: keyof DashboardData["metrics"]; label: string; tone: string }> = [
-  { key: "available", label: "Available", tone: "ready" },
-  { key: "rented", label: "Rented", tone: "neutral" },
-  { key: "cleaning", label: "Cleaning", tone: "neutral" },
-  { key: "maintenance", label: "Maintenance", tone: "warning" },
-  { key: "blocked", label: "Blocked", tone: "critical" },
+const FLEET_METRIC_KEYS: Array<{ key: keyof DashboardData["metrics"]; labelKey: string; tone: string }> = [
+  { key: "available", labelKey: "readiness.available", tone: "ready" },
+  { key: "rented", labelKey: "readiness.rented", tone: "neutral" },
+  { key: "cleaning", labelKey: "readiness.cleaning", tone: "neutral" },
+  { key: "maintenance", labelKey: "readiness.maintenance", tone: "warning" },
+  { key: "blocked", labelKey: "readiness.blocked", tone: "critical" },
 ];
 
-function localTime(value: string, withDate = false) {
-  return new Date(value).toLocaleString("en-GB", {
-    ...(withDate ? { day: "2-digit", month: "short" } : {}),
-    hour: "2-digit",
-    minute: "2-digit",
-    timeZone: "Europe/Brussels",
-  });
+function attentionItemTitle(
+  t: (key: string, options?: Record<string, unknown>) => string,
+  item: { rule_type: string; link_ref: string },
+): string {
+  const ruleLabel = t(`quality:ruleTypes.${item.rule_type}`, { defaultValue: item.rule_type.replace(/_/g, " ") });
+  return `${ruleLabel} — ${item.link_ref}`;
 }
 
 export function Dashboard() {
+  const { t } = useTranslation(["dashboard", "common", "integrations"]);
+  const { formatTime, formatShortDate } = useLocaleFormat();
   const { user } = useAuth();
+  const { manifest } = useDemoManifest();
+  const { openGuide, restart, currentIndex, completed, totalSteps } = useDemoGuide();
+  const [searchParams, setSearchParams] = useSearchParams();
   const canSeeQuality = user?.role === "operations_manager";
   const canSeeAutomation = user?.role === "operations_manager";
+
+  useEffect(() => {
+    if (searchParams.get("guide") === "start") {
+      restart();
+      openGuide();
+      setSearchParams({}, { replace: true });
+    }
+    // Only ever react to the initial `?guide=start` marker set by the login screen's
+    // "Start begeleide demo" CTA, so this intentionally runs once on mount.
+  }, []);
   const [data, setData] = useState<DashboardData | null>(null);
   const [knowledge, setKnowledge] = useState<KnowledgeHealth | null>(null);
   const [integrationStatus, setIntegrationStatus] = useState<IntegrationStatus | null>(null);
@@ -36,7 +55,7 @@ export function Dashboard() {
   const [query, setQuery] = useState("");
 
   useEffect(() => {
-    api.get<DashboardData>("/api/v1/dashboard").then(setData).catch(() => setError("Dashboard data is unavailable right now."));
+    api.get<DashboardData>("/api/v1/dashboard").then(setData).catch(() => setError(t("common:status.error")));
     api.get<KnowledgeHealth>("/api/v1/knowledge/status").then(setKnowledge).catch(() => setKnowledge(null));
   }, []);
 
@@ -50,76 +69,104 @@ export function Dashboard() {
 
   const attention = useMemo(() => data?.attention_items.filter((item) => {
     const matchesSeverity = severity === "all" || item.severity === severity;
-    const haystack = `${item.title} ${item.detail} ${item.link_ref}`.toLowerCase();
+    const haystack = `${attentionItemTitle(t, item)} ${item.detail} ${item.link_ref}`.toLowerCase();
     return matchesSeverity && haystack.includes(query.toLowerCase());
-  }) ?? [], [data, query, severity]);
+  }) ?? [], [data, query, severity, t]);
 
   if (error) return <ErrorState message={error} />;
-  if (!data) return <LoadingState label="Loading operations overview…" />;
+  if (!data) return <LoadingState label={t("common:status.loading")} />;
 
   const latestRun = data.recent_automation[0];
-  const n8nState = !latestRun ? "No delivery yet" : latestRun.status === "failed" ? "Needs attention" : latestRun.status;
+  const readyCount = manifest?.scenarios.filter((s) => s.ready).length ?? 0;
 
   return (
     <div className="page dashboard-page">
-      <PageHeader eyebrow="Operations / Live overview" title="Good morning. Here’s the fleet." description="Readiness, exceptions and hand-offs across today’s operation." actions={<Link className="button button-secondary" to="/vehicles"><Icon name="fleet" /> View fleet</Link>} />
+      <PageHeader eyebrow={t("eyebrow")} title={t("title")} description={t("description")} actions={<Link className="button button-secondary" to="/vehicles"><Icon name="fleet" /> {t("viewFleet")}</Link>} />
+
+      <section className="demo-start-panel" aria-label={t("demoStart.title")}>
+        <div>
+          <Icon name="spark" />
+          <div>
+            <strong>{t("demoStart.title")}</strong>
+            <span>
+              {manifest ? t("demoStart.readyCount", { ready: readyCount, total: manifest.scenarios.length }) : t("demoStart.readyCountFallback")}
+            </span>
+          </div>
+        </div>
+        <div className="demo-start-actions">
+          {user?.role === "operations_manager" && (
+            <button type="button" className="button button-secondary" onClick={openGuide}>
+              <Icon name="spark" /> {completed.size > 0 ? t("demoStart.resumeGuide", { current: currentIndex + 1, total: totalSteps }) : t("demoStart.startGuide")}
+            </button>
+          )}
+          <Link className="button button-primary" to="/scenarios">{t("demoStart.viewScenarios")} <Icon name="chevron" /></Link>
+        </div>
+      </section>
 
       <section className="readiness-band" aria-labelledby="readiness-heading">
         <div className="readiness-label">
           <span className="live-indicator" />
-          <div><h2 id="readiness-heading">Fleet readiness</h2><p>Live from persisted vehicle state</p></div>
+          <div><h2 id="readiness-heading">{t("readiness.title")}</h2><p>{t("readiness.description")}</p></div>
         </div>
         <dl className="readiness-metrics">
-          {FLEET_METRICS.map((metric) => (
+          {FLEET_METRIC_KEYS.map((metric) => (
             <div key={metric.key} className={`metric-cell metric-${metric.tone}`}>
-              <dt>{metric.label}</dt><dd>{data.metrics[metric.key]}</dd>
+              <dt>{t(metric.labelKey)}</dt><dd>{data.metrics[metric.key]}</dd>
             </div>
           ))}
         </dl>
-        <Link className="inline-action" to="/vehicles">Open fleet <Icon name="chevron" /></Link>
+        <Link className="inline-action" to="/vehicles">{t("readiness.openFleet")} <Icon name="chevron" /></Link>
       </section>
 
       <div className="operations-grid">
         <section className="work-panel attention-panel" aria-labelledby="attention-heading">
-          <SectionHeading title="Attention queue" description={`${data.metrics.open_quality_issues} open quality issues · ${data.metrics.pending_or_failed_workflows} workflow exceptions`} action={canSeeQuality ? <Link to="/data-quality">Review queue <Icon name="chevron" /></Link> : undefined} />
+          <SectionHeading headingId="attention-heading" title={t("attention.title")} description={t("attention.description", { openIssues: data.metrics.open_quality_issues, workflowExceptions: data.metrics.pending_or_failed_workflows })} action={canSeeQuality ? <Link to="/data-quality">{t("attention.reviewQueue")} <Icon name="chevron" /></Link> : undefined} />
           <div className="queue-controls">
-            <label className="compact-search"><Icon name="search" /><span className="visually-hidden">Search attention queue</span><input value={query} onChange={(event) => setQuery(event.target.value)} placeholder="Filter issues…" /></label>
-            <label><span className="visually-hidden">Severity</span><select value={severity} onChange={(event) => setSeverity(event.target.value)}><option value="all">All severity</option><option value="high">Critical</option><option value="medium">Warning</option><option value="low">Info</option></select></label>
+            <label className="compact-search"><Icon name="search" /><span className="visually-hidden">{t("attention.filterAriaLabel")}</span><input value={query} onChange={(event) => setQuery(event.target.value)} placeholder={t("attention.filterPlaceholder")} /></label>
+            <label><span className="visually-hidden">{t("attention.severityAriaLabel")}</span><select value={severity} onChange={(event) => setSeverity(event.target.value)}><option value="all">{t("attention.severityAll")}</option><option value="high">{t("attention.severityHigh")}</option><option value="medium">{t("attention.severityMedium")}</option><option value="low">{t("attention.severityLow")}</option></select></label>
           </div>
-          {attention.length === 0 ? <p className="quiet-empty"><Icon name="check" /> No issues match this filter.</p> : (
+          {attention.length === 0 ? <p className="quiet-empty"><Icon name="check" /> {t("attention.empty")}</p> : (
             <ul className="attention-list">
-              {attention.slice(0, 6).map((item, index) => (
-                <li key={`${item.link_ref}-${index}`}>
-                  <SeverityBadge severity={item.severity} />
-                  <div className="queue-copy">
-                    <p className="attention-title">
-                      {item.issue_ref && canSeeQuality ? (
-                        <Link to={`/data-quality/${item.issue_ref}`}>{item.title}</Link>
-                      ) : item.link_type === "vehicle" ? (
-                        <Link to={`/vehicles/${item.link_ref}`}>{item.title}</Link>
-                      ) : (
-                        item.title
-                      )}
-                    </p>
-                    <p className="attention-detail">{item.detail}</p>
-                  </div>
-                  <span className="queue-ref">{item.link_ref}</span>
-                  <Icon name="chevron" className="row-chevron" />
-                </li>
-              ))}
+              {attention.slice(0, 6).map((item, index) => {
+                const href = item.issue_ref && canSeeQuality
+                  ? `/data-quality/${item.issue_ref}`
+                  : item.link_type === "vehicle"
+                    ? `/vehicles/${item.link_ref}`
+                    : null;
+                const title = attentionItemTitle(t, item);
+                return (
+                  <li key={`${item.link_ref}-${index}`} className={href ? "row-clickable" : ""}>
+                    <SeverityBadge severity={item.severity} />
+                    <div className="queue-copy">
+                      <p className="attention-title">{title}</p>
+                      <p className="attention-detail">{item.detail}</p>
+                    </div>
+                    <span className="queue-ref">{item.link_ref}</span>
+                    <Icon name="chevron" className="row-chevron" />
+                    {href && (
+                      <Link className="row-link" to={href} aria-label={t("attention.openRecord", { title })}>
+                        <span className="visually-hidden">{title}</span>
+                      </Link>
+                    )}
+                  </li>
+                );
+              })}
             </ul>
           )}
         </section>
 
         <section className="work-panel timeline-panel" aria-labelledby="today-heading">
-          <SectionHeading title="Today’s movements" description="Departures and returns in Europe/Brussels" action={<Link to="/bookings">All bookings <Icon name="chevron" /></Link>} />
-          {data.today.length === 0 ? <p className="quiet-empty"><Icon name="clock" /> No movements scheduled today.</p> : (
+          <SectionHeading headingId="today-heading" title={t("movements.title")} description={t("movements.description")} action={<Link to="/bookings">{t("movements.allBookings")} <Icon name="chevron" /></Link>} />
+          {data.today.length === 0 ? <p className="quiet-empty"><Icon name="clock" /> {t("movements.empty")}</p> : (
             <ol className="movement-timeline">
-              {data.today.slice(0, 6).map((item) => (
-                <li key={`${item.kind}-${item.booking_ref}`}>
-                  <time dateTime={item.scheduled_at}>{localTime(item.scheduled_at)}</time>
+              {data.today.map((item) => (
+                <li key={`${item.kind}-${item.booking_ref}`} className="row-clickable">
+                  <time dateTime={item.scheduled_at}>{formatTime(item.scheduled_at)}</time>
                   <span className={`timeline-node timeline-${item.kind}`}><Icon name={item.kind === "return" ? "arrow-left" : "chevron"} /></span>
-                  <div><span className="movement-kind">{item.kind}</span><Link to={`/bookings/${item.booking_ref}`}>{item.booking_ref}</Link><small>{item.vehicle_ref}</small></div>
+                  <div><span className="movement-kind">{item.kind === "return" ? t("movements.return") : t("movements.departure")}</span><span className="movement-ref">{item.booking_ref}</span><small>{item.vehicle_ref}</small></div>
+                  <Link className="row-link" to={`/bookings/${item.booking_ref}`} aria-label={t("movements.openBooking", { ref: item.booking_ref })}>
+                    <span className="visually-hidden">{item.booking_ref}</span>
+                  </Link>
                 </li>
               ))}
             </ol>
@@ -129,48 +176,65 @@ export function Dashboard() {
 
       <div className="secondary-grid">
         <section className="work-panel integration-panel" aria-labelledby="integration-heading">
-          <SectionHeading title="Integration pulse" description="Current evidence from connected services" action={canSeeAutomation ? <Link to="/automation">System detail <Icon name="chevron" /></Link> : undefined} />
+          <SectionHeading headingId="integration-heading" title={t("integrationPulse.title")} description={t("integrationPulse.description")} action={canSeeAutomation ? <Link to="/automation">{t("integrationPulse.systemDetail")} <Icon name="chevron" /></Link> : undefined} />
           <ul className="integration-list">
             <li>
               <IntegrationMark kind="n8n" />
               <div>
-                <strong>n8n delivery</strong>
+                <strong>{t("integrationPulse.n8nTitle")}</strong>
                 <span>
                   {integrationStatus
-                    ? `${integrationStatus.n8n.succeeded} succeeded · ${integrationStatus.n8n.failed} failed`
+                    ? t("integrationPulse.n8nSummary", { succeeded: integrationStatus.n8n.succeeded, failed: integrationStatus.n8n.failed })
                     : latestRun
-                      ? `Latest event ${latestRun.aggregate_ref}`
-                      : "No workflow evidence recorded"}
+                      ? t("integrationPulse.n8nLatest", { ref: latestRun.aggregate_ref })
+                      : t("integrationPulse.n8nNoEvidence")}
                 </span>
               </div>
+              {(() => {
+                const meta = integrationStatus ? N8N_STATE_META[integrationStatus.n8n.state] : null;
+                return (
+                  <StatusBadge
+                    status={meta?.statusClass ?? "no_events"}
+                    label={meta ? t(`integrations:statusLabels.${meta.labelKey}`) : undefined}
+                  />
+                );
+              })()}
+            </li>
+            <li>
+              <IntegrationMark kind="rag" />
+              <div>
+                <strong>{t("integrationPulse.knowledgeTitle")}</strong>
+                <span>{knowledge ? t("integrationPulse.knowledgeSummary", { count: knowledge.document_count }) : t("integrationPulse.knowledgeUnavailable")}</span>
+              </div>
               <StatusBadge
-                status={
-                  integrationStatus
-                    ? integrationStatus.n8n.state === "operational"
-                      ? "available"
-                      : integrationStatus.n8n.state
-                    : n8nState.toLowerCase().replace(/ /g, "_")
+                status={knowledge?.available ? "available" : "unavailable"}
+                label={
+                  knowledge?.available
+                    ? t(`integrations:statusLabels.${knowledge.provider === "ragcore" ? "operational" : "demoMode"}`)
+                    : t("integrations:statusLabels.unavailable")
                 }
               />
             </li>
-            <li><IntegrationMark kind="rag" /><div><strong>RAGcore knowledge</strong><span>{knowledge ? `${knowledge.document_count} procedures indexed` : "Health check unavailable"}</span></div><StatusBadge status={knowledge?.available ? "available" : "unavailable"} /></li>
             <li>
               <IntegrationMark kind="mcp" />
               <div>
-                <strong>MCP Hub</strong>
-                <span>{integrationStatus?.mcp_hub.registration_enabled ? "Registration enabled" : "No active adapter in this PoC"}</span>
+                <strong>{t("integrationPulse.mcpTitle")}</strong>
+                <span>{integrationStatus?.mcp_hub.registration_enabled ? t("integrationPulse.mcpEnabled") : t("integrationPulse.mcpNotConnected")}</span>
               </div>
-              <StatusBadge status={integrationStatus?.mcp_hub.state ?? "not_configured"} />
+              {(() => {
+                const meta = integrationStatus ? MCP_STATE_META[integrationStatus.mcp_hub.state] : null;
+                return <StatusBadge status={meta?.statusClass ?? "not_configured"} label={meta ? t(`integrations:statusLabels.${meta.labelKey}`) : undefined} />;
+              })()}
             </li>
           </ul>
         </section>
 
         <section className="work-panel recent-panel" aria-labelledby="recent-heading">
-          <SectionHeading title="Recent activity" description="Latest audited workflow changes" />
-          {data.recent_automation.length === 0 ? <p className="quiet-empty">No automation activity recorded.</p> : (
+          <SectionHeading headingId="recent-heading" title={t("recent.title")} description={t("recent.description")} />
+          {data.recent_automation.length === 0 ? <p className="quiet-empty">{t("recent.empty")}</p> : (
             <ul className="recent-list">
               {data.recent_automation.slice(0, 4).map((run) => (
-                <li key={run.event_id}><span className="activity-icon"><Icon name="activity" /></span><div><strong>{run.event_type.replace(/_/g, " ")}</strong><span>{run.aggregate_ref}</span></div><StatusBadge status={run.status} /><time dateTime={run.occurred_at}>{localTime(run.occurred_at, true)}</time></li>
+                <li key={run.event_id}><span className="activity-icon"><Icon name="activity" /></span><div><strong>{t(`integrations:ledger.eventTypes.${run.event_type}`, { defaultValue: run.event_type.replace(/_/g, " ") })}</strong><span>{run.aggregate_ref}</span></div><StatusBadge status={run.status} label={t(`integrations:ledger.status${run.status.charAt(0).toUpperCase()}${run.status.slice(1)}`, { defaultValue: run.status })} /><time dateTime={run.occurred_at}>{formatShortDate(run.occurred_at)}</time></li>
               ))}
             </ul>
           )}
diff --git a/frontend/src/pages/DataQuality.tsx b/frontend/src/pages/DataQuality.tsx
index d85c826..a7055c1 100644
--- a/frontend/src/pages/DataQuality.tsx
+++ b/frontend/src/pages/DataQuality.tsx
@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useState } from "react";
 import { Link } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api, ApiError } from "../api/client";
 import type { DataQualityIssue, ScanResult } from "../api/types";
 import { useAuth } from "../context/AuthContext";
@@ -15,6 +16,7 @@ const RULE_TYPES = [
 ];
 
 export function DataQuality() {
+  const { t } = useTranslation("quality");
   const { user } = useAuth();
   const [issues, setIssues] = useState<DataQualityIssue[] | null>(null);
   const [error, setError] = useState<string | null>(null);
@@ -24,6 +26,7 @@ export function DataQuality() {
   const [scanError, setScanError] = useState<string | null>(null);
   const [scanResult, setScanResult] = useState<ScanResult | null>(null);
   const [confirmingScan, setConfirmingScan] = useState(false);
+  const [demoScenariosOnly, setDemoScenariosOnly] = useState(false);
 
   const load = useCallback(() => {
     if (user?.role !== "operations_manager") return;
@@ -35,7 +38,7 @@ export function DataQuality() {
     api
       .get<DataQualityIssue[]>(`/api/v1/data-quality/issues?${params.toString()}`)
       .then(setIssues)
-      .catch(() => setError("Data-quality issues are unavailable right now."));
+      .catch(() => setError(t("list.unavailable")));
   }, [status, ruleType, user]);
 
   useEffect(() => {
@@ -51,7 +54,7 @@ export function DataQuality() {
       setConfirmingScan(false);
       load();
     } catch (err) {
-      setScanError(err instanceof ApiError ? err.message : "Could not run the quality scan.");
+      setScanError(err instanceof ApiError ? err.message : t("list.scanFailed"));
     } finally {
       setScanning(false);
     }
@@ -60,33 +63,38 @@ export function DataQuality() {
   if (user?.role !== "operations_manager") {
     return (
       <div className="page">
-        <PageHeader eyebrow="Assurance / Workbench" title="Data quality" description="The quality workbench is visible to Operations Managers only." />
-        <p>Data-quality evidence and resolutions are visible to Operations Managers only.</p>
+        <PageHeader eyebrow={t("list.eyebrow")} title={t("list.title")} description={t("detail.managerOnlyDetail")} />
+        <p>{t("detail.managerOnlyDetail")}</p>
       </div>
     );
   }
 
   const scanTotal = scanResult ? Object.values(scanResult.created).reduce((a, b) => a + b, 0) : 0;
+  const visibleIssues = issues
+    ? demoScenariosOnly
+      ? issues.filter((i) => i.public_ref.startsWith("DQ-DEMO-"))
+      : issues
+    : [];
 
   return (
     <div className="page">
       <PageHeader
-        eyebrow="Assurance / Workbench"
-        title="Data quality"
-        description="Resolve evidence-backed exceptions before they disrupt operations."
+        eyebrow={t("list.eyebrow")}
+        title={t("list.title")}
+        description={t("list.description")}
         actions={
           !confirmingScan ? (
             <button className="button button-secondary" type="button" onClick={() => setConfirmingScan(true)} disabled={scanning}>
-              Run quality scan
+              {t("list.runScan")}
             </button>
           ) : (
-            <div className="confirm-bar" role="alertdialog" aria-label="Confirm quality scan">
-              <p>Run the deterministic scan across all five rule types now?</p>
+            <div className="confirm-bar" role="alertdialog" aria-label={t("list.confirmScanTitle")}>
+              <p>{t("list.confirmScanBody")}</p>
               <button type="button" onClick={handleScan} disabled={scanning}>
-                {scanning ? "Scanning…" : "Yes, run scan"}
+                {scanning ? t("list.scanning") : t("list.confirmScanYes")}
               </button>
               <button type="button" onClick={() => setConfirmingScan(false)} disabled={scanning}>
-                Cancel
+                {t("list.cancel")}
               </button>
             </div>
           )
@@ -96,67 +104,81 @@ export function DataQuality() {
       {scanError && <p className="error" role="alert">{scanError}</p>}
       {scanResult && (
         <p className="quiet-empty" role="status">
-          Scan complete: {scanTotal === 0
-            ? "no new issues found (existing open issues are not recreated)."
-            : Object.entries(scanResult.created)
-                .map(([rule, count]) => `${count} new ${rule.replace(/_/g, " ")}`)
-                .join(", ")}
+          {t("list.scanComplete", {
+            summary: scanTotal === 0
+              ? t("list.scanNoNew")
+              : Object.entries(scanResult.created)
+                  .map(([rule, count]) => `${count} ${t(`ruleTypes.${rule}`, { defaultValue: rule.replace(/_/g, " ") })}`)
+                  .join(", "),
+          })}
         </p>
       )}
 
-      <form className="filters" aria-label="Filter data-quality issues">
+      <form className="filters" aria-label={t("list.title")}>
         <label>
-          Status
+          {t("list.statusLabel")}
           <select value={status} onChange={(e) => setStatus(e.target.value)}>
-            <option value="">All statuses</option>
-            <option value="open">Open</option>
-            <option value="deferred">Deferred</option>
-            <option value="resolved">Resolved</option>
-            <option value="rejected">Rejected</option>
+            <option value="">{t("list.statusAll")}</option>
+            <option value="open">{t("list.statusOpen")}</option>
+            <option value="deferred">{t("list.statusDeferred")}</option>
+            <option value="resolved">{t("list.statusResolved")}</option>
+            <option value="rejected">{t("list.statusRejected")}</option>
           </select>
         </label>
         <label>
-          Rule type
+          {t("list.ruleTypeLabel")}
           <select value={ruleType} onChange={(e) => setRuleType(e.target.value)}>
-            <option value="">All rule types</option>
+            <option value="">{t("list.ruleTypeAll")}</option>
             {RULE_TYPES.map((r) => (
               <option key={r} value={r}>
-                {r.replace(/_/g, " ")}
+                {t(`ruleTypes.${r}`)}
               </option>
             ))}
           </select>
         </label>
+        <label className="checkbox-label">
+          <input
+            type="checkbox"
+            checked={demoScenariosOnly}
+            onChange={(e) => setDemoScenariosOnly(e.target.checked)}
+          />
+          {t("list.demoScenariosOnly")}
+        </label>
       </form>
 
       {error && <ErrorState message={error} />}
-      {!error && !issues && <LoadingState label="Loading quality workbench…" />}
-      {issues && issues.length === 0 && <EmptyState icon="check" title="Queue is clear" detail="No issues match the current filters." />}
+      {!error && !issues && <LoadingState label={t("list.loading")} />}
+      {issues && issues.length === 0 && <EmptyState icon="check" title={t("list.queueClear")} detail={t("list.noIssuesMatch")} />}
+      {issues && issues.length > 0 && visibleIssues.length === 0 && (
+        <EmptyState icon="check" title={t("list.noDemoIssuesMatch")} detail={t("list.noDemoIssuesMatchDetail")} />
+      )}
 
-      {issues && issues.length > 0 && (
-        <div className="table-shell"><div className="table-meta"><span>{issues.length} issues</span><span>Evidence-backed detection</span></div><table className="data-table">
-          <caption className="visually-hidden">Data-quality issues</caption>
+      {visibleIssues.length > 0 && (
+        <div className="table-shell"><div className="table-meta"><span>{t("list.count", { count: visibleIssues.length })}</span><span>{t("list.evidenceBacked")}</span></div><table className="data-table">
+          <caption className="visually-hidden">{t("list.title")}</caption>
           <thead>
             <tr>
-              <th scope="col">Reference</th>
-              <th scope="col">Rule</th>
-              <th scope="col">Entity</th>
-              <th scope="col">Severity</th>
-              <th scope="col">Status</th>
+              <th scope="col">{t("list.columns.reference")}</th>
+              <th scope="col">{t("list.columns.rule")}</th>
+              <th scope="col">{t("list.columns.entity")}</th>
+              <th scope="col">{t("list.columns.severity")}</th>
+              <th scope="col">{t("list.columns.status")}</th>
             </tr>
           </thead>
           <tbody>
-            {issues.map((i) => (
-              <tr key={i.public_ref}>
-                <th scope="row" data-label="Reference">
-                  <Link to={`/data-quality/${i.public_ref}`}>{i.public_ref}</Link>
+            {visibleIssues.map((i) => (
+              <tr key={i.public_ref} className="row-clickable">
+                <th scope="row" data-label={t("list.columns.reference")}>
+                  {i.public_ref}
+                  <Link className="row-link" to={`/data-quality/${i.public_ref}`}><span className="visually-hidden">{i.public_ref}</span></Link>
                 </th>
-                <td data-label="Rule">{i.rule_type.replace(/_/g, " ")}</td>
-                <td data-label="Entity">{i.entity_ref}</td>
-                <td data-label="Severity">
+                <td data-label={t("list.columns.rule")}>{t(`ruleTypes.${i.rule_type}`, { defaultValue: i.rule_type.replace(/_/g, " ") })}</td>
+                <td data-label={t("list.columns.entity")}>{i.entity_ref}</td>
+                <td data-label={t("list.columns.severity")}>
                   <SeverityBadge severity={i.severity} />
                 </td>
-                <td data-label="Status">
-                  <StatusBadge status={i.status} />
+                <td data-label={t("list.columns.status")}>
+                  <StatusBadge status={i.status} label={t(`list.status${i.status.charAt(0).toUpperCase()}${i.status.slice(1)}`, { defaultValue: i.status })} />
                 </td>
               </tr>
             ))}
diff --git a/frontend/src/pages/DataQualityIssueDetail.tsx b/frontend/src/pages/DataQualityIssueDetail.tsx
index 5d017d6..ef57e45 100644
--- a/frontend/src/pages/DataQualityIssueDetail.tsx
+++ b/frontend/src/pages/DataQualityIssueDetail.tsx
@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useState, type FormEvent } from "react";
-import { Link, useParams } from "react-router-dom";
+import { Link, useNavigate, useParams } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api, ApiError } from "../api/client";
 import type {
   ApplyRecommendedStatusResult,
@@ -8,21 +9,44 @@ import type {
 } from "../api/types";
 import { SeverityBadge, StatusBadge } from "../components/Badge";
 import { useAuth } from "../context/AuthContext";
+import { useDemoGuide } from "../context/DemoGuideContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { useLocaleFormat } from "../i18n/format";
+import { DEMO_GUIDE_STEPS } from "../data/demoGuideSteps";
 import { Icon } from "../components/Icons";
 import { ErrorState, LoadingState, PageHeader, SectionHeading } from "../components/PageChrome";
 
 const MERGE_FIELDS = ["first_name", "last_name", "email", "phone", "postal_code", "city"];
 
+function RuleExplainer({ ruleType }: { ruleType: string }) {
+  const { t } = useTranslation("quality");
+  if (!t(`detail.explainer.${ruleType}.whatIsWrong`, { defaultValue: "" })) return null;
+  return (
+    <section className="rule-explainer" aria-label={t("detail.explainer.whyItMatters")}>
+      <div>
+        <strong>{t("detail.explainer.whatIsWrong")}</strong>
+        <p>{t(`detail.explainer.${ruleType}.whatIsWrong`)}</p>
+      </div>
+      <div>
+        <strong>{t("detail.explainer.whyItMatters")}</strong>
+        <p>{t(`detail.explainer.${ruleType}.whyItMatters`)}</p>
+      </div>
+    </section>
+  );
+}
+
 function EvidenceDisclosure({ issue }: { issue: IssueDetail }) {
+  const { t } = useTranslation("common");
   return (
     <details className="evidence-disclosure">
-      <summary>Technical evidence</summary>
+      <summary>{t("actions.technicalDetails")}</summary>
       <pre className="evidence-block">{JSON.stringify(issue.evidence, null, 2)}</pre>
     </details>
   );
 }
 
 function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onResolved: () => void }) {
+  const { t } = useTranslation("quality");
   const { user } = useAuth();
   const [survivorRef, setSurvivorRef] = useState(issue.entity_snapshot?.public_ref ?? "");
   const [fieldChoices, setFieldChoices] = useState<Record<string, "a" | "b">>({});
@@ -31,7 +55,7 @@ function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onR
   const [confirming, setConfirming] = useState(false);
 
   if (!issue.entity_snapshot || !issue.related_snapshots[0]) {
-    return <p className="error">Both customers in this comparison could not be loaded.</p>;
+    return <p className="error">{t("detail.duplicateCustomer.bothMissing")}</p>;
   }
   const a: EntitySnapshot = issue.entity_snapshot;
   const b: EntitySnapshot = issue.related_snapshots[0];
@@ -57,7 +81,7 @@ function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onR
       });
       onResolved();
     } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Could not merge these customers.");
+      setError(err instanceof ApiError ? err.message : t("detail.duplicateCustomer.mergeFailed"));
       setConfirming(false);
     } finally {
       setSubmitting(false);
@@ -66,44 +90,41 @@ function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onR
 
   if (user?.role !== "operations_manager") {
     return (
-      <p className="panel">
-        Merging duplicate customers requires the Operations Manager role. Switch role to resolve
-        this issue.
-      </p>
+      <p className="panel">{t("detail.managerOnlyDetail")}</p>
     );
   }
 
   return (
     <section className="panel duplicate-compare" aria-labelledby="compare-heading">
-      <SectionHeading title="Compare and merge" description="Choose the canonical customer and review each conflicting field." />
+      <SectionHeading headingId="compare-heading" title={t("detail.duplicateCustomer.heading")} description={t("detail.duplicateCustomer.description")} />
       {error && <p className="error" role="alert">{error}</p>}
 
-      <fieldset>
-        <legend>Keep as survivor</legend>
-        <label className="checkbox-label">
+      <fieldset className="choice-fieldset">
+        <legend>{t("detail.duplicateCustomer.keepAsSurvivor")}</legend>
+        <label className={`choice-card ${survivorRef === a.public_ref ? "is-selected" : ""}`}>
           <input
             type="radio"
             name="survivor"
             checked={survivorRef === a.public_ref}
             onChange={() => setSurvivorRef(a.public_ref)}
           />
-          {a.public_ref}
+          <span className="choice-card-title">{a.public_ref}</span>
         </label>
-        <label className="checkbox-label">
+        <label className={`choice-card ${survivorRef === b.public_ref ? "is-selected" : ""}`}>
           <input
             type="radio"
             name="survivor"
             checked={survivorRef === b.public_ref}
             onChange={() => setSurvivorRef(b.public_ref)}
           />
-          {b.public_ref}
+          <span className="choice-card-title">{b.public_ref}</span>
         </label>
       </fieldset>
 
       <table className="data-table compare-table">
         <thead>
           <tr>
-            <th scope="col">Field</th>
+            <th scope="col">{t("detail.duplicateCustomer.fieldColumn")}</th>
             <th scope="col">{a.public_ref}</th>
             <th scope="col">{b.public_ref}</th>
           </tr>
@@ -115,7 +136,7 @@ function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onR
             const differ = valueA !== valueB;
             return (
               <tr key={field}>
-                <th scope="row" data-label="Field">{field.replace(/_/g, " ")}{differ ? <span className="difference-mark">Differs</span> : <span className="match-mark">Match</span>}</th>
+                <th scope="row" data-label="Field">{t(`detail.duplicateCustomer.fields.${field}`)}{differ ? <span className="difference-mark">{t("detail.duplicateCustomer.differs")}</span> : <span className="match-mark">{t("detail.duplicateCustomer.match")}</span>}</th>
                 <td data-label={a.public_ref}>
                   {differ ? (
                     <label className="checkbox-label">
@@ -153,25 +174,22 @@ function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onR
       </table>
 
       <p className="merge-preview">
-        <strong>{loser.public_ref}</strong> will become a tombstone linked to{" "}
-        <strong>{survivor.public_ref}</strong>; its bookings will be rewired to the survivor.
+        {t("detail.duplicateCustomer.mergePreview", { loser: loser.public_ref, survivor: survivor.public_ref })}
       </p>
 
       {!confirming && (
-        <button type="button" onClick={() => setConfirming(true)}>
-          Merge into {survivor.public_ref}
+        <button type="button" className="button button-primary" onClick={() => setConfirming(true)}>
+          {t("detail.duplicateCustomer.mergeInto", { ref: survivor.public_ref })}
         </button>
       )}
       {confirming && (
-        <div className="confirm-bar" role="alertdialog" aria-label="Confirm merge">
-          <p>
-            Merge {loser.public_ref} into {survivor.public_ref}? This cannot be undone.
-          </p>
-          <button type="button" onClick={handleMerge} disabled={submitting}>
-            {submitting ? "Merging…" : "Yes, merge"}
+        <div className="confirm-bar" role="alertdialog" aria-label={t("detail.duplicateCustomer.confirmMergeTitle")}>
+          <p>{t("detail.duplicateCustomer.confirmMergeBody", { loser: loser.public_ref, survivor: survivor.public_ref })}</p>
+          <button type="button" className="button button-primary" onClick={handleMerge} disabled={submitting}>
+            {submitting ? t("detail.duplicateCustomer.merging") : t("detail.duplicateCustomer.confirmMergeYes")}
           </button>
-          <button type="button" onClick={() => setConfirming(false)} disabled={submitting}>
-            Cancel
+          <button type="button" className="button button-secondary" onClick={() => setConfirming(false)} disabled={submitting}>
+            {t("list.cancel")}
           </button>
         </div>
       )}
@@ -179,26 +197,16 @@ function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onR
   );
 }
 
-const CUSTOMER_FIELD_LABELS: Record<string, string> = {
-  first_name: "First name",
-  last_name: "Last name",
-  email: "Email",
-  phone: "Phone",
-};
-const VEHICLE_FIELD_LABELS: Record<string, string> = {
-  registration_number: "Registration number",
-  make: "Make",
-  model: "Model",
-  location: "Location",
-};
-
 function MissingFieldPanel({ issue, onResolved }: { issue: IssueDetail; onResolved: () => void }) {
+  const { t } = useTranslation("quality");
   const isCustomer = issue.entity_type === "customer";
-  const labels = isCustomer ? CUSTOMER_FIELD_LABELS : VEHICLE_FIELD_LABELS;
+  const fieldKeys = isCustomer
+    ? ["first_name", "last_name", "email", "phone"]
+    : ["registration_number", "make", "model", "location"];
   const snapshot = issue.entity_snapshot;
   const [values, setValues] = useState<Record<string, string>>(() => {
     const initial: Record<string, string> = {};
-    for (const key of Object.keys(labels)) {
+    for (const key of fieldKeys) {
       initial[key] = snapshot && snapshot[key] ? String(snapshot[key]) : "";
     }
     return initial;
@@ -217,7 +225,7 @@ function MissingFieldPanel({ issue, onResolved }: { issue: IssueDetail; onResolv
       await api.post(`/api/v1/data-quality/issues/${issue.public_ref}/provide-fields`, { fields });
       onResolved();
     } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Could not save these fields.");
+      setError(err instanceof ApiError ? err.message : t("detail.missingField.saveFailed"));
     } finally {
       setSubmitting(false);
     }
@@ -226,14 +234,15 @@ function MissingFieldPanel({ issue, onResolved }: { issue: IssueDetail; onResolv
   return (
     <form className="panel" onSubmit={handleSubmit} aria-labelledby="missing-field-heading">
       <SectionHeading
-        title="Provide the missing fields"
-        description={`Complete the record for ${snapshot?.public_ref ?? issue.entity_ref}. The issue resolves automatically once nothing required is missing.`}
+        headingId="missing-field-heading"
+        title={t("detail.missingField.heading")}
+        description={t("detail.missingField.description", { ref: snapshot?.public_ref ?? issue.entity_ref })}
       />
       {error && <p className="error" role="alert">{error}</p>}
       <div className="form-grid">
-        {Object.entries(labels).map(([field, label]) => (
+        {fieldKeys.map((field) => (
           <label key={field}>
-            {label}
+            {t(`detail.missingField.fields.${field}`)}
             <input
               type="text"
               value={values[field] ?? ""}
@@ -243,11 +252,11 @@ function MissingFieldPanel({ issue, onResolved }: { issue: IssueDetail; onResolv
         ))}
       </div>
       {isCustomer && (
-        <p className="table-subtext">At least one of email or phone is required.</p>
+        <p className="table-subtext">{t("detail.missingField.atLeastOne")}</p>
       )}
       <div className="form-actions">
         <button className="button button-primary" type="submit" disabled={submitting}>
-          {submitting ? "Saving…" : "Save and re-check"}
+          {submitting ? t("detail.missingField.saving") : t("detail.missingField.saveAndRecheck")}
         </button>
       </div>
     </form>
@@ -255,6 +264,8 @@ function MissingFieldPanel({ issue, onResolved }: { issue: IssueDetail; onResolv
 }
 
 function OdometerRegressionPanel({ issue, onResolved }: { issue: IssueDetail; onResolved: () => void }) {
+  const { t } = useTranslation("quality");
+  const { formatNumber } = useLocaleFormat();
   const bookingSnapshots = issue.related_snapshots.filter((s) => s.entity_type === "booking");
   const [decision, setDecision] = useState<"retain_canonical" | "correct_reading">("retain_canonical");
   const [bookingRef, setBookingRef] = useState(bookingSnapshots[0]?.public_ref ?? "");
@@ -277,7 +288,7 @@ function OdometerRegressionPanel({ issue, onResolved }: { issue: IssueDetail; on
       });
       onResolved();
     } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Could not resolve this issue.");
+      setError(err instanceof ApiError ? err.message : t("detail.odometerRegression.resolveFailed"));
     } finally {
       setSubmitting(false);
     }
@@ -286,25 +297,29 @@ function OdometerRegressionPanel({ issue, onResolved }: { issue: IssueDetail; on
   return (
     <form className="panel" onSubmit={handleSubmit} aria-labelledby="odometer-heading">
       <SectionHeading
-        title="Resolve the odometer regression"
-        description="The canonical odometer is never lowered automatically -- choose how to reconcile it."
+        headingId="odometer-heading"
+        title={t("detail.odometerRegression.heading")}
+        description={t("detail.odometerRegression.description")}
       />
       {error && <p className="error" role="alert">{error}</p>}
       <dl className="detail-grid">
-        <div><dt>Canonical odometer</dt><dd>{Number(issue.entity_snapshot?.odometer_km ?? 0).toLocaleString("en-GB")} km</dd></div>
+        <div><dt>{t("detail.odometerRegression.canonicalOdometer")}</dt><dd>{formatNumber(Number(issue.entity_snapshot?.odometer_km ?? 0))} km</dd></div>
       </dl>
-      <fieldset>
-        <legend>Decision</legend>
-        <label className="checkbox-label check-card">
+      <fieldset className="choice-fieldset">
+        <legend>{t("detail.odometerRegression.decisionLegend")}</legend>
+        <label className={`choice-card ${decision === "retain_canonical" ? "is-selected" : ""}`}>
           <input
             type="radio"
             name="decision"
             checked={decision === "retain_canonical"}
             onChange={() => setDecision("retain_canonical")}
           />
-          Retain canonical -- treat the submitted reading as erroneous
+          <span className="choice-card-body">
+            <span className="choice-card-title">{t("detail.odometerRegression.retainCanonical")}</span>
+            <span className="choice-card-detail">{t("detail.odometerRegression.retainCanonicalDetail")}</span>
+          </span>
         </label>
-        <label className="checkbox-label check-card">
+        <label className={`choice-card ${decision === "correct_reading" ? "is-selected" : ""} ${bookingSnapshots.length === 0 ? "is-disabled" : ""}`}>
           <input
             type="radio"
             name="decision"
@@ -312,26 +327,29 @@ function OdometerRegressionPanel({ issue, onResolved }: { issue: IssueDetail; on
             onChange={() => setDecision("correct_reading")}
             disabled={bookingSnapshots.length === 0}
           />
-          Correct the reading -- update the booking and canonical odometer
+          <span className="choice-card-body">
+            <span className="choice-card-title">{t("detail.odometerRegression.correctReading")}</span>
+            <span className="choice-card-detail">{t("detail.odometerRegression.correctReadingDetail")}</span>
+          </span>
         </label>
         {bookingSnapshots.length === 0 && (
-          <p className="table-subtext">No related booking is attached to this issue, so only "retain canonical" is available.</p>
+          <p className="table-subtext">{t("detail.odometerRegression.noBookingAttached")}</p>
         )}
       </fieldset>
       {decision === "correct_reading" && (
         <div className="form-grid">
           <label>
-            Booking
+            {t("detail.odometerRegression.booking")}
             <select value={bookingRef} onChange={(e) => setBookingRef(e.target.value)}>
               {bookingSnapshots.map((snap) => (
                 <option key={snap.public_ref} value={snap.public_ref}>
-                  {snap.public_ref} ({typeof snap.end_odometer_km === "number" ? snap.end_odometer_km.toLocaleString("en-GB") : "—"} km)
+                  {snap.public_ref} ({typeof snap.end_odometer_km === "number" ? formatNumber(snap.end_odometer_km) : "—"} km)
                 </option>
               ))}
             </select>
           </label>
           <label>
-            Corrected odometer (km)
+            {t("detail.odometerRegression.correctedOdometer")}
             <input
               type="number"
               min={0}
@@ -343,12 +361,12 @@ function OdometerRegressionPanel({ issue, onResolved }: { issue: IssueDetail; on
         </div>
       )}
       <label>
-        Note
+        {t("detail.odometerRegression.note")}
         <textarea value={note} onChange={(e) => setNote(e.target.value)} maxLength={500} rows={2} />
       </label>
       <div className="form-actions">
         <button className="button button-primary" type="submit" disabled={submitting}>
-          {submitting ? "Resolving…" : "Resolve issue"}
+          {submitting ? t("detail.odometerRegression.resolving") : t("detail.odometerRegression.resolveIssue")}
         </button>
       </div>
     </form>
@@ -356,6 +374,8 @@ function OdometerRegressionPanel({ issue, onResolved }: { issue: IssueDetail; on
 }
 
 function BookingOverlapPanel({ issue, onResolved }: { issue: IssueDetail; onResolved: () => void }) {
+  const { t } = useTranslation("quality");
+  const { formatShortDate } = useLocaleFormat();
   const bookings = issue.related_snapshots.filter((s) => s.entity_type === "booking");
   const [bookingRef, setBookingRef] = useState(bookings[0]?.public_ref ?? "");
   const [note, setNote] = useState("");
@@ -373,7 +393,7 @@ function BookingOverlapPanel({ issue, onResolved }: { issue: IssueDetail; onReso
       });
       onResolved();
     } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Could not resolve this overlap.");
+      setError(err instanceof ApiError ? err.message : t("detail.bookingOverlap.resolveFailed"));
     } finally {
       setSubmitting(false);
     }
@@ -382,50 +402,41 @@ function BookingOverlapPanel({ issue, onResolved }: { issue: IssueDetail; onReso
   return (
     <form className="panel" onSubmit={handleSubmit} aria-labelledby="overlap-heading">
       <SectionHeading
-        title="Resolve the booking overlap"
-        description="Block one of the two overlapping commitments. The other keeps its current status."
+        headingId="overlap-heading"
+        title={t("detail.bookingOverlap.heading")}
+        description={t("detail.bookingOverlap.description")}
       />
       {error && <p className="error" role="alert">{error}</p>}
-      <table className="data-table compare-table">
-        <thead>
-          <tr>
-            <th scope="col">Booking</th>
-            <th scope="col">Window</th>
-            <th scope="col">Status</th>
-            <th scope="col">Block this one</th>
-          </tr>
-        </thead>
-        <tbody>
-          {bookings.map((b) => (
-            <tr key={b.public_ref}>
-              <th scope="row">{b.public_ref}</th>
-              <td>
-                {b.starts_at ? new Date(String(b.starts_at)).toLocaleDateString("en-GB") : "—"} →{" "}
-                {b.ends_at ? new Date(String(b.ends_at)).toLocaleDateString("en-GB") : "—"}
-              </td>
-              <td><StatusBadge status={String(b.status)} /></td>
-              <td>
-                <label className="checkbox-label">
-                  <input
-                    type="radio"
-                    name="overlap-booking"
-                    checked={bookingRef === b.public_ref}
-                    onChange={() => setBookingRef(b.public_ref)}
-                  />
-                  <span className="visually-hidden">Block {b.public_ref}</span>
-                </label>
-              </td>
-            </tr>
-          ))}
-        </tbody>
-      </table>
+      <fieldset className="choice-fieldset choice-fieldset-grid">
+        <legend className="visually-hidden">{t("detail.bookingOverlap.columns.blockThis")}</legend>
+        {bookings.map((b) => (
+          <label key={b.public_ref} className={`choice-card ${bookingRef === b.public_ref ? "is-selected" : ""}`}>
+            <input
+              type="radio"
+              name="overlap-booking"
+              checked={bookingRef === b.public_ref}
+              onChange={() => setBookingRef(b.public_ref)}
+              aria-label={`${t("detail.bookingOverlap.blockLabel", { ref: b.public_ref })}, ${
+                b.starts_at ? formatShortDate(String(b.starts_at)) : "—"
+              } → ${b.ends_at ? formatShortDate(String(b.ends_at)) : "—"}, ${b.status}`}
+            />
+            <span className="choice-card-body">
+              <span className="choice-card-title">{b.public_ref}</span>
+              <span className="choice-card-detail">
+                {b.starts_at ? formatShortDate(String(b.starts_at)) : "—"} → {b.ends_at ? formatShortDate(String(b.ends_at)) : "—"}
+              </span>
+              <StatusBadge status={String(b.status)} label={t(`bookings:statuses.${b.status}`, { defaultValue: String(b.status) })} />
+            </span>
+          </label>
+        ))}
+      </fieldset>
       <label>
-        Note
+        {t("detail.bookingOverlap.note")}
         <textarea value={note} onChange={(e) => setNote(e.target.value)} maxLength={500} rows={2} />
       </label>
       <div className="form-actions">
         <button className="button button-primary" type="submit" disabled={submitting || !bookingRef}>
-          {submitting ? "Resolving…" : `Block ${bookingRef || "booking"}`}
+          {submitting ? t("detail.bookingOverlap.resolving") : t("detail.bookingOverlap.blockButton", { ref: bookingRef || t("detail.bookingOverlap.blockButtonFallback") })}
         </button>
       </div>
     </form>
@@ -433,11 +444,21 @@ function BookingOverlapPanel({ issue, onResolved }: { issue: IssueDetail; onReso
 }
 
 function VehicleStatusConflictPanel({ issue, onResolved }: { issue: IssueDetail; onResolved: () => void }) {
+  const { t } = useTranslation("quality");
+  const navigate = useNavigate();
+  const { manifest } = useDemoManifest();
+  const { open: guideOpen, currentIndex, completeAndAdvance } = useDemoGuide();
   const [error, setError] = useState<string | null>(null);
   const [result, setResult] = useState<ApplyRecommendedStatusResult | null>(null);
   const [submitting, setSubmitting] = useState(false);
   const [confirming, setConfirming] = useState(false);
 
+  function continueDemo() {
+    completeAndAdvance();
+    const nextIndex = Math.min(currentIndex + 1, DEMO_GUIDE_STEPS.length - 1);
+    navigate(DEMO_GUIDE_STEPS[nextIndex].route(manifest));
+  }
+
   // Once resolved through this panel, keep showing the "Applied" confirmation even
   // after the parent's issue.status flips away from "open" -- reloading on success
   // updates the page's own status badge immediately, but this panel controls its own
@@ -454,7 +475,7 @@ function VehicleStatusConflictPanel({ issue, onResolved }: { issue: IssueDetail;
       setResult(applied);
       onResolved();
     } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Could not apply a recommended status.");
+      setError(err instanceof ApiError ? err.message : t("detail.vehicleStatusConflict.applyFailed"));
       setConfirming(false);
     } finally {
       setSubmitting(false);
@@ -464,29 +485,41 @@ function VehicleStatusConflictPanel({ issue, onResolved }: { issue: IssueDetail;
   return (
     <section className="panel" aria-labelledby="status-conflict-heading">
       <SectionHeading
-        title="Resolve the status conflict"
-        description="One authoritative rule recommends a corrected operational status for this vehicle."
+        headingId="status-conflict-heading"
+        title={t("detail.vehicleStatusConflict.heading")}
+        description={t("detail.vehicleStatusConflict.description")}
       />
       {error && <p className="error" role="alert">{error}</p>}
       <dl className="detail-grid">
-        <div><dt>Current status</dt><dd><StatusBadge status={String(issue.entity_snapshot?.operational_status ?? "")} /></dd></div>
+        <div><dt>{t("detail.vehicleStatusConflict.currentStatus")}</dt><dd><StatusBadge status={String(issue.entity_snapshot?.operational_status ?? "")} label={t(`fleet:statuses.${issue.entity_snapshot?.operational_status}`, { defaultValue: String(issue.entity_snapshot?.operational_status ?? "") })} /></dd></div>
       </dl>
       {result ? (
-        <p className="quiet-empty">
-          <Icon name="check" /> Applied <StatusBadge status={result.applied_status} /> — {result.reason}
-        </p>
+        <>
+          <p className="quiet-empty">
+            <Icon name="check" /> {t("detail.vehicleStatusConflict.applied", { status: result.applied_status, reason: result.reason })}
+          </p>
+          <div className="result-links">
+            <Link className="button button-secondary" to="/audit">{t("detail.resolved.viewAudit")}<Icon name="chevron" /></Link>
+            <Link className="button button-secondary" to={`/vehicles/${issue.entity_ref}`}>{t("detail.resolved.viewVehicle")}<Icon name="chevron" /></Link>
+            {guideOpen && (
+              <button type="button" className="button button-primary" onClick={continueDemo}>
+                {t("detail.resolved.continueDemo")} <Icon name="chevron" />
+              </button>
+            )}
+          </div>
+        </>
       ) : !confirming ? (
-        <button type="button" onClick={() => setConfirming(true)}>
-          Calculate and apply recommended status
+        <button type="button" className="button button-primary" onClick={() => setConfirming(true)}>
+          {t("detail.vehicleStatusConflict.calculateAndApply")}
         </button>
       ) : (
-        <div className="confirm-bar" role="alertdialog" aria-label="Confirm status change">
-          <p>Apply the authoritative recommended status for this vehicle?</p>
-          <button type="button" onClick={handleApply} disabled={submitting}>
-            {submitting ? "Applying…" : "Yes, apply"}
+        <div className="confirm-bar" role="alertdialog" aria-label={t("detail.vehicleStatusConflict.confirmTitle")}>
+          <p>{t("detail.vehicleStatusConflict.confirmBody")}</p>
+          <button type="button" className="button button-primary" onClick={handleApply} disabled={submitting}>
+            {submitting ? t("detail.vehicleStatusConflict.applying") : t("detail.vehicleStatusConflict.confirmYes")}
           </button>
-          <button type="button" onClick={() => setConfirming(false)} disabled={submitting}>
-            Cancel
+          <button type="button" className="button button-secondary" onClick={() => setConfirming(false)} disabled={submitting}>
+            {t("list.cancel")}
           </button>
         </div>
       )}
@@ -495,27 +528,44 @@ function VehicleStatusConflictPanel({ issue, onResolved }: { issue: IssueDetail;
 }
 
 export function DataQualityIssueDetail() {
+  const { t } = useTranslation("quality");
   const { user } = useAuth();
+  const navigate = useNavigate();
+  const { manifest } = useDemoManifest();
+  const { open: guideOpen, currentIndex, completeAndAdvance } = useDemoGuide();
   const { publicRef } = useParams<{ publicRef: string }>();
   const [issue, setIssue] = useState<IssueDetail | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [actionError, setActionError] = useState<string | null>(null);
+  const [justResolved, setJustResolved] = useState(false);
 
   const load = useCallback(() => {
     if (!publicRef) return;
     api
       .get<IssueDetail>(`/api/v1/data-quality/issues/${publicRef}`)
       .then(setIssue)
-      .catch(() => setError("This issue could not be found."));
+      .catch(() => setError(t("detail.notFound")));
   }, [publicRef]);
 
   useEffect(() => {
     if (user?.role !== "operations_manager") return;
     setIssue(null);
     setError(null);
+    setJustResolved(false);
     load();
   }, [load, user]);
 
+  function handleResolved() {
+    setJustResolved(true);
+    load();
+  }
+
+  function continueDemo() {
+    completeAndAdvance();
+    const nextIndex = Math.min(currentIndex + 1, DEMO_GUIDE_STEPS.length - 1);
+    navigate(DEMO_GUIDE_STEPS[nextIndex].route(manifest));
+  }
+
   async function handleAction(action: "defer" | "reject") {
     if (!issue) return;
     setActionError(null);
@@ -523,61 +573,81 @@ export function DataQualityIssueDetail() {
       await api.post(`/api/v1/data-quality/issues/${issue.public_ref}/${action}`);
       load();
     } catch (err) {
-      setActionError(err instanceof ApiError ? err.message : `Could not ${action} this issue.`);
+      setActionError(err instanceof ApiError ? err.message : t(`detail.deferOrReject.${action}Failed`));
     }
   }
 
   if (user?.role !== "operations_manager") {
     return (
       <div className="page">
-        <PageHeader eyebrow="Assurance / Workbench" title="Data quality issue" description="The quality workbench is visible to Operations Managers only." />
-        <p>Data-quality evidence and resolutions are visible to Operations Managers only.</p>
+        <PageHeader eyebrow={t("list.eyebrow")} title={t("list.title")} description={t("detail.managerOnly")} />
+        <p>{t("detail.managerOnlyDetail")}</p>
       </div>
     );
   }
 
   if (error) return <ErrorState message={error} />;
-  if (!issue) return <LoadingState label="Loading issue evidence…" />;
+  if (!issue) return <LoadingState label={t("detail.loading")} />;
 
   return (
     <div className="page">
-      <Link className="back-link" to="/data-quality"><Icon name="arrow-left" /> Quality workbench</Link>
-      <PageHeader eyebrow={`Quality / ${issue.rule_type.replace(/_/g, " ")}`} title={issue.public_ref} description="Review persisted evidence and record an audited resolution." actions={<div className="status-stack"><SeverityBadge severity={issue.severity} /><StatusBadge status={issue.status} /></div>} />
-      <section className="record-surface" aria-label="Issue summary"><dl className="detail-grid">
-        <div><dt>Rule</dt><dd>{issue.rule_type.replace(/_/g, " ")}</dd></div>
-        <div><dt>Entity</dt><dd>{issue.entity_type === "vehicle" ? <Link to={`/vehicles/${issue.entity_ref}`}>{issue.entity_ref}</Link> : issue.entity_ref}</dd></div>
-        <div><dt>Evidence summary</dt><dd>{String(issue.evidence.summary ?? "")}</dd></div>
+      <Link className="back-link" to="/data-quality"><Icon name="arrow-left" /> {t("detail.backLink")}</Link>
+      <PageHeader eyebrow={t("detail.eyebrow", { rule: t(`ruleTypes.${issue.rule_type}`, { defaultValue: issue.rule_type.replace(/_/g, " ") }) })} title={issue.public_ref} description={t("detail.title")} actions={<div className="status-stack"><SeverityBadge severity={issue.severity} /><StatusBadge status={issue.status} label={t(`list.status${issue.status.charAt(0).toUpperCase()}${issue.status.slice(1)}`, { defaultValue: issue.status })} /></div>} />
+      <section className="record-surface" aria-label={t("detail.summary.rule")}><dl className="detail-grid">
+        <div><dt>{t("detail.summary.rule")}</dt><dd>{t(`ruleTypes.${issue.rule_type}`, { defaultValue: issue.rule_type.replace(/_/g, " ") })}</dd></div>
+        <div><dt>{t("detail.summary.entity")}</dt><dd>{issue.entity_type === "vehicle" ? <Link to={`/vehicles/${issue.entity_ref}`}>{issue.entity_ref}</Link> : issue.entity_ref}</dd></div>
+        <div><dt>{t("detail.summary.evidenceSummary")}</dt><dd>{String(issue.evidence.summary ?? "")}</dd></div>
       </dl>
       <EvidenceDisclosure issue={issue} /></section>
 
+      <RuleExplainer ruleType={issue.rule_type} />
+
       {actionError && <p className="error" role="alert">{actionError}</p>}
 
+      {justResolved && issue.status !== "open" && issue.rule_type !== "vehicle_status_conflict" && (
+        <section className="panel success-panel" aria-live="polite">
+          <div className="result-heading"><span><Icon name="check" /></span><div><p className="page-eyebrow">{t("list.statusResolved")}</p><h2>{t("detail.resolved.title", { ref: issue.public_ref })}</h2></div></div>
+          <p>{t("detail.resolved.body")}</p>
+          <div className="result-links">
+            <Link className="button button-secondary" to="/audit">{t("detail.resolved.viewAudit")}<Icon name="chevron" /></Link>
+            {issue.entity_type === "vehicle" && (
+              <Link className="button button-secondary" to={`/vehicles/${issue.entity_ref}`}>{t("detail.resolved.viewVehicle")}<Icon name="chevron" /></Link>
+            )}
+            {guideOpen && (
+              <button type="button" className="button button-primary" onClick={continueDemo}>
+                {t("detail.resolved.continueDemo")} <Icon name="chevron" />
+              </button>
+            )}
+          </div>
+        </section>
+      )}
+
       {issue.status === "open" && issue.rule_type === "possible_duplicate_customer" && (
-        <DuplicateCustomerPanel issue={issue} onResolved={load} />
+        <DuplicateCustomerPanel issue={issue} onResolved={handleResolved} />
       )}
       {issue.status === "open" && issue.rule_type === "missing_required_field" && (
-        <MissingFieldPanel issue={issue} onResolved={load} />
+        <MissingFieldPanel issue={issue} onResolved={handleResolved} />
       )}
       {issue.status === "open" && issue.rule_type === "odometer_regression" && (
-        <OdometerRegressionPanel issue={issue} onResolved={load} />
+        <OdometerRegressionPanel issue={issue} onResolved={handleResolved} />
       )}
       {issue.status === "open" && issue.rule_type === "booking_overlap" && (
-        <BookingOverlapPanel issue={issue} onResolved={load} />
+        <BookingOverlapPanel issue={issue} onResolved={handleResolved} />
       )}
       {issue.rule_type === "vehicle_status_conflict" && (
-        <VehicleStatusConflictPanel issue={issue} onResolved={load} />
+        <VehicleStatusConflictPanel issue={issue} onResolved={handleResolved} />
       )}
 
       {issue.status === "open" && (
-        <section className="panel" aria-labelledby="resolution-heading">
-          <h2 id="resolution-heading">Defer or reject</h2>
-          <p>Defer to review later, or reject if this is not a real issue.</p>
+        <section className="panel defer-reject-panel" aria-labelledby="resolution-heading">
+          <h2 id="resolution-heading">{t("detail.deferOrReject.heading")}</h2>
+          <p>{t("detail.deferOrReject.description")}</p>
           <div className="resolution-actions">
-            <button type="button" onClick={() => handleAction("defer")}>
-              Defer
+            <button type="button" className="button-tertiary" onClick={() => handleAction("defer")}>
+              {t("detail.deferOrReject.defer")}
             </button>
-            <button type="button" onClick={() => handleAction("reject")}>
-              Reject
+            <button type="button" className="button-tertiary button-tertiary-destructive" onClick={() => handleAction("reject")}>
+              {t("detail.deferOrReject.reject")}
             </button>
           </div>
         </section>
diff --git a/frontend/src/pages/Knowledge.tsx b/frontend/src/pages/Knowledge.tsx
index e3dcfc3..8da4b30 100644
--- a/frontend/src/pages/Knowledge.tsx
+++ b/frontend/src/pages/Knowledge.tsx
@@ -1,4 +1,5 @@
 import { useEffect, useState, type FormEvent } from "react";
+import { useTranslation } from "react-i18next";
 import { api, ApiError } from "../api/client";
 import type { GroundedAnswer, KnowledgeHealth } from "../api/types";
 import { Icon } from "../components/Icons";
@@ -9,53 +10,85 @@ interface Exchange {
   answer: GroundedAnswer;
 }
 
-const EVIDENCE_LABEL: Record<GroundedAnswer["evidence_state"], string> = {
-  grounded: "Grounded in cited procedures",
-  insufficient: "Insufficient evidence",
-  unavailable: "Knowledge service unavailable",
-};
-
 export function Knowledge() {
+  const { t, i18n } = useTranslation(["knowledge", "errors"]);
   const [status, setStatus] = useState<KnowledgeHealth | null>(null);
   const [question, setQuestion] = useState("");
   const [submitting, setSubmitting] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [exchanges, setExchanges] = useState<Exchange[]>([]);
 
+  const language = i18n.language as "nl-BE" | "en-GB" | "fr-BE";
+
   useEffect(() => {
     api
-      .get<KnowledgeHealth>("/api/v1/knowledge/status")
+      .get<KnowledgeHealth>(`/api/v1/knowledge/status?language=${language}`)
       .then(setStatus)
       .catch(() => setStatus(null));
-  }, []);
+  }, [language]);
 
-  async function handleSubmit(e: FormEvent) {
-    e.preventDefault();
-    if (!question.trim()) return;
+  async function ask(questionText: string) {
     setError(null);
     setSubmitting(true);
     try {
-      const answer = await api.post<GroundedAnswer>("/api/v1/knowledge/questions", { question });
-      setExchanges((prev) => [{ question, answer }, ...prev]);
+      const answer = await api.post<GroundedAnswer>("/api/v1/knowledge/questions", {
+        question: questionText,
+        language,
+      });
+      setExchanges((prev) => [{ question: questionText, answer }, ...prev]);
       setQuestion("");
     } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Could not reach the knowledge service.");
+      setError(err instanceof ApiError ? err.message : t("askFailed"));
     } finally {
       setSubmitting(false);
     }
   }
 
+  async function handleSubmit(e: FormEvent) {
+    e.preventDefault();
+    if (!question.trim()) return;
+    await ask(question);
+  }
+
+  const providerLabel = status?.provider === "ragcore" ? t("providerRagcore") : t("providerDemo");
+  const suggestedQuestions = t("suggestedQuestions", { returnObjects: true, defaultValue: [] }) as string[];
+
   return (
     <div className="page">
-      <PageHeader eyebrow="Assurance / Grounded knowledge" title="Procedure knowledge" description="Ask operational questions. Answers are shown only when RAGcore returns sufficient cited evidence." />
+      <PageHeader
+        eyebrow={t("eyebrow")}
+        title={t("title")}
+        description={t("description", { provider: providerLabel.toLowerCase() })}
+      />
       {status && (
-        <div className="knowledge-status"><span className={`health-orb ${status.available ? "is-healthy" : "is-down"}`} /><div><strong>{status.provider}</strong><span>{status.available ? "Available" : "Unavailable"} · {status.document_count} procedures indexed</span></div><small>{status.collection}</small></div>
+        <div className="knowledge-status">
+          <span className={`health-orb ${status.available ? "is-healthy" : "is-down"}`} />
+          <div>
+            <strong>{providerLabel}</strong>
+            <span>
+              {status.available ? t("statusAvailable") : t("statusUnavailable")} ·{" "}
+              {t("proceduresIndexed", { count: status.document_count })}
+            </span>
+          </div>
+          <small>{status.collection}</small>
+        </div>
+      )}
+      {status?.provider !== "ragcore" && (
+        <p className="knowledge-provider-note">
+          <Icon name="shield" /> {t("providerNote")}
+        </p>
       )}
 
       <form className="panel knowledge-form" onSubmit={handleSubmit} aria-labelledby="ask-heading">
-        <div className="ask-heading"><span><Icon name="spark" /></span><div><h2 id="ask-heading">Ask a procedure question</h2><p>Retrieval → evidence check → grounded answer</p></div></div>
+        <div className="ask-heading">
+          <span><Icon name="spark" /></span>
+          <div>
+            <h2 id="ask-heading">{t("askHeading")}</h2>
+            <p>{t("askSubheading")}</p>
+          </div>
+        </div>
         <label htmlFor="knowledge-question" className="visually-hidden">
-          Question
+          {t("questionLabel")}
         </label>
         <div className="knowledge-input-row">
           <input
@@ -63,38 +96,53 @@ export function Knowledge() {
             type="text"
             value={question}
             onChange={(e) => setQuestion(e.target.value)}
-            placeholder="e.g. What must I do when a vehicle returns with damage?"
+            placeholder={t("questionPlaceholder")}
             minLength={3}
             maxLength={1000}
             required
           />
           <button className="button button-primary" type="submit" disabled={submitting}>
-            {submitting ? "Asking…" : "Ask"}
+            {submitting ? t("asking") : t("ask")}
             {!submitting && <Icon name="chevron" />}
           </button>
         </div>
         {error && <p className="error" role="alert">{error}</p>}
+        <div className="knowledge-suggestions">
+          <span>{t("suggestedLabel")}</span>
+          {suggestedQuestions.map((q) => (
+            <button key={q} type="button" className="suggestion-chip" onClick={() => ask(q)} disabled={submitting}>
+              {q}
+            </button>
+          ))}
+        </div>
       </form>
 
       {exchanges.length === 0 && !error && (
-        <div className="knowledge-empty"><span><Icon name="knowledge" /></span><h2>Evidence before answers</h2><p>Ask about returns, damage, inspections or another indexed procedure. MobilityOps will not invent an answer when evidence is missing.</p><div className="retrieval-flow" aria-hidden="true"><span>Question</span><i /><span>RAGcore</span><i /><span>Sources</span><i /><span>Answer</span></div></div>
+        <div className="knowledge-empty">
+          <span><Icon name="knowledge" /></span>
+          <h2>{t("emptyTitle")}</h2>
+          <p>{t("emptyDescription")}</p>
+          <div className="retrieval-flow" aria-hidden="true">
+            <span>{t("retrievalFlow.question")}</span><i />
+            <span>{providerLabel}</span><i />
+            <span>{t("retrievalFlow.sources")}</span><i />
+            <span>{t("retrievalFlow.answer")}</span>
+          </div>
+        </div>
       )}
 
       <ul className="exchange-list">
         {exchanges.map((exchange, index) => (
           <li key={index} className="panel exchange">
             <p className="exchange-question">
-              <strong>Question</strong> {exchange.question}
+              <strong>{t("questionLabelExchange")}</strong> {exchange.question}
             </p>
             <p className={`evidence-state evidence-${exchange.answer.evidence_state}`}>
-              {EVIDENCE_LABEL[exchange.answer.evidence_state]}
+              {t(`evidenceStates.${exchange.answer.evidence_state}`)}
             </p>
 
             {exchange.answer.evidence_state === "unavailable" ? (
-              <p>
-                The knowledge service is currently unreachable. Operational features are
-                unaffected — try again later.
-              </p>
+              <p>{t("unavailableBody")}</p>
             ) : (
               <p>{exchange.answer.answer}</p>
             )}
@@ -104,7 +152,7 @@ export function Knowledge() {
                 {exchange.answer.sources.map((source) => (
                   <li key={`${source.document_id}-${source.section}`} className="source-card">
                     <p className="source-title">
-                      {source.title} <span className="source-version">v{source.version}</span>
+                      {source.title} <span className="source-version">{t("sourceVersion", { version: source.version })}</span>
                     </p>
                     <p className="source-section">{source.section}</p>
                     <p className="source-excerpt">{source.excerpt}</p>
diff --git a/frontend/src/pages/Login.tsx b/frontend/src/pages/Login.tsx
index a62355f..b1efa4e 100644
--- a/frontend/src/pages/Login.tsx
+++ b/frontend/src/pages/Login.tsx
@@ -1,32 +1,43 @@
 import { useState } from "react";
 import { useNavigate } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { useAuth } from "../context/AuthContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { LanguageSwitcher } from "../components/LanguageSwitcher";
 import type { Role } from "../api/types";
 import { BrandMark, Icon } from "../components/Icons";
 
 export function Login() {
+  const { t } = useTranslation(["auth", "common"]);
   const { loginAs, loading } = useAuth();
+  const { manifest } = useDemoManifest();
   const navigate = useNavigate();
   const [error, setError] = useState<string | null>(null);
 
-  async function handleLogin(role: Role) {
+  async function handleLogin(role: Role, guided = false) {
     setError(null);
     try {
       await loginAs(role);
-      navigate("/dashboard");
+      navigate(guided ? "/dashboard?guide=start" : "/dashboard");
     } catch {
-      setError("Could not start a demo session. The API may be unavailable.");
+      setError(t("loginFailed"));
     }
   }
 
+  const orgName = manifest?.organization_name ?? t("common:orgName");
+  const description = t("defaultDescription");
+
   return (
     <main className="login-shell">
       <section className="login-story" aria-labelledby="product-name">
-        <div className="brand-lockup login-brand"><BrandMark className="brand-mark" /><div><strong>MobilityOps</strong><span>Control centre</span></div></div>
+        <div className="brand-lockup login-brand">
+          <BrandMark className="brand-mark" />
+          <div><strong>{t("common:appName")}</strong><span>{t("brandTagline")}</span></div>
+        </div>
         <div className="login-message">
-          <p className="eyebrow">Connected mobility operations</p>
-          <h1 id="product-name">Every hand-off.<br />One clear view.</h1>
-          <p>Turn fleet state, rental returns, data quality and automation into one calm operational rhythm.</p>
+          <p className="eyebrow">{t("orgLine", { orgName })}</p>
+          <h1 id="product-name">{t("headline1")}<br />{t("headline2")}</h1>
+          <p>{description}</p>
         </div>
         <div className="control-illustration" aria-hidden="true">
           <div className="illustration-orbit orbit-one"><span /></div>
@@ -36,28 +47,42 @@ export function Login() {
           <span className="illustration-node node-two"><Icon name="bookings" /></span>
           <span className="illustration-node node-three"><Icon name="quality" /></span>
         </div>
-        <p className="login-footnote"><Icon name="shield" /> Synthetic proof of concept · no real customer data</p>
+        <p className="login-footnote"><Icon name="shield" /> {t("footnote")}</p>
       </section>
 
       <section className="login-access" aria-labelledby="login-heading">
         <div className="login-panel">
-          <p className="page-eyebrow">Demo access</p>
-          <h2 id="login-heading">Choose your workspace</h2>
-          <p className="login-intro">No password is required. Each role opens a scoped synthetic environment.</p>
+          <div className="login-panel-top">
+            <p className="page-eyebrow">{t("accessEyebrow")}</p>
+            <LanguageSwitcher />
+          </div>
+          <h2 id="login-heading">{t("accessHeading")}</h2>
+          <p className="login-intro">{t("accessIntro")}</p>
           {error && <p className="error" role="alert">{error}</p>}
+
+          <button
+            type="button"
+            className="button button-primary login-guide-cta"
+            disabled={loading}
+            onClick={() => handleLogin("operations_manager", true)}
+          >
+            <Icon name="spark" />
+            {t("startGuidedDemo")}
+          </button>
+
           <div className="login-options">
-            <button type="button" aria-label="Open as Operations Manager" disabled={loading} onClick={() => handleLogin("operations_manager")}>
+            <button type="button" aria-label={t("exploreAsOperationsManager")} disabled={loading} onClick={() => handleLogin("operations_manager")}>
               <span className="role-icon"><Icon name="activity" /></span>
-              <span><strong>Operations Manager</strong><small>Full overview, quality resolution and retries</small></span>
+              <span><strong>{t("exploreAsOperationsManager")}</strong><small>{t("exploreAsOperationsManagerDetail")}</small></span>
               <Icon name="chevron" />
             </button>
-            <button type="button" aria-label="Open as Rental Employee" disabled={loading} onClick={() => handleLogin("rental_employee")}>
+            <button type="button" aria-label={t("exploreAsRentalEmployee")} disabled={loading} onClick={() => handleLogin("rental_employee")}>
               <span className="role-icon"><Icon name="user" /></span>
-              <span><strong>Rental Employee</strong><small>Bookings, returns, fleet and procedures</small></span>
+              <span><strong>{t("exploreAsRentalEmployee")}</strong><small>{t("exploreAsRentalEmployeeDetail")}</small></span>
               <Icon name="chevron" />
             </button>
           </div>
-          <div className="access-note"><Icon name="shield" /><p><strong>Safe by design</strong><span>All actions are audited and resettable in this demo.</span></p></div>
+          <div className="access-note"><Icon name="shield" /><p><strong>{t("safeByDesignTitle")}</strong><span>{t("safeByDesignDetail")}</span></p></div>
         </div>
       </section>
     </main>
diff --git a/frontend/src/pages/Scenarios.tsx b/frontend/src/pages/Scenarios.tsx
new file mode 100644
index 0000000..a7b0c0a
--- /dev/null
+++ b/frontend/src/pages/Scenarios.tsx
@@ -0,0 +1,75 @@
+import { Link } from "react-router-dom";
+import { useTranslation } from "react-i18next";
+import { useAuth } from "../context/AuthContext";
+import { useDemoManifest } from "../context/DemoManifestContext";
+import { Icon } from "../components/Icons";
+import { LoadingState, PageHeader } from "../components/PageChrome";
+
+export function Scenarios() {
+  const { t } = useTranslation("demo");
+  const { manifest, loading } = useDemoManifest();
+  const { user } = useAuth();
+
+  function roleLabel(roles: string[]): string {
+    const labels = roles.map((r) => t(`scenarios.roles.${r}`, { defaultValue: r }));
+    return labels.length > 1 ? t("scenarios.roleOr", { a: labels[0], b: labels[1] }) : labels[0];
+  }
+
+  return (
+    <div className="page">
+      <PageHeader
+        eyebrow={t("scenarios.eyebrow")}
+        title={t("scenarios.title")}
+        description={t("scenarios.description")}
+      />
+
+      {loading && <LoadingState label={t("scenarios.loading")} />}
+
+      {manifest && (
+        <div className="scenario-grid">
+          {manifest.scenarios.map((scenario) => {
+            const canRun = !user || scenario.required_roles.includes(user.role);
+            const blockedText = scenario.blocked_reason_code
+              ? t(`scenarios.blockedReasons.${scenario.blocked_reason_code}`, {
+                  resetHint: t("scenarios.blockedReasons.resetHint"),
+                  ...scenario.blocked_reason_params,
+                })
+              : null;
+            return (
+              <article key={scenario.id} className="scenario-card">
+                <header>
+                  <h2>{t(`scenarios.items.${scenario.id}.title`)}</h2>
+                  <span className={`badge ${scenario.ready ? "status-available" : "status-unavailable"}`}>
+                    {scenario.ready ? t("scenarios.ready") : t("scenarios.notReady")}
+                  </span>
+                </header>
+                <p className="scenario-problem">{t(`scenarios.items.${scenario.id}.problem`)}</p>
+                <dl className="scenario-meta">
+                  <div><dt>{t("scenarios.duration")}</dt><dd>{t("scenarios.durationValue", { minutes: scenario.estimated_minutes })}</dd></div>
+                  <div><dt>{t("scenarios.role")}</dt><dd>{roleLabel(scenario.required_roles)}</dd></div>
+                </dl>
+                <p className="scenario-demonstrates"><strong>{t("scenarios.demonstrates")}</strong> {t(`scenarios.items.${scenario.id}.demonstrates`)}</p>
+                {!scenario.ready && blockedText && (
+                  <p className="scenario-blocked"><Icon name="alert" /> {blockedText}</p>
+                )}
+                {!canRun && (
+                  <p className="scenario-blocked"><Icon name="alert" /> {t("scenarios.requiresRole", { roles: roleLabel(scenario.required_roles) })}</p>
+                )}
+                <Link
+                  className={`button ${scenario.ready && canRun ? "button-primary" : "button-secondary"}`}
+                  to={scenario.start_path}
+                  aria-disabled={!scenario.ready || !canRun}
+                  onClick={(event) => {
+                    if (!scenario.ready || !canRun) event.preventDefault();
+                  }}
+                >
+                  {t("scenarios.startScenario")} <Icon name="chevron" />
+                </Link>
+              </article>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/pages/VehicleDetail.tsx b/frontend/src/pages/VehicleDetail.tsx
index fe6f3fd..82ff1e3 100644
--- a/frontend/src/pages/VehicleDetail.tsx
+++ b/frontend/src/pages/VehicleDetail.tsx
@@ -1,7 +1,9 @@
 import { useEffect, useState } from "react";
 import { Link, useParams } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api } from "../api/client";
 import type { VehicleDetail as VehicleDetailData } from "../api/types";
+import { useLocaleFormat } from "../i18n/format";
 import { SeverityBadge, StatusBadge } from "../components/Badge";
 import { Icon } from "../components/Icons";
 import { ErrorState, LoadingState, PageHeader } from "../components/PageChrome";
@@ -10,6 +12,8 @@ const TABS = ["overview", "bookings", "inspections", "maintenance", "quality"] a
 type Tab = (typeof TABS)[number];
 
 export function VehicleDetail() {
+  const { t } = useTranslation(["fleet", "bookings", "quality"]);
+  const { formatNumber, formatShortDate } = useLocaleFormat();
   const { publicRef } = useParams<{ publicRef: string }>();
   const [vehicle, setVehicle] = useState<VehicleDetailData | null>(null);
   const [error, setError] = useState<string | null>(null);
@@ -22,52 +26,52 @@ export function VehicleDetail() {
     api
       .get<VehicleDetailData>(`/api/v1/vehicles/${publicRef}`)
       .then(setVehicle)
-      .catch(() => setError("This vehicle could not be found."));
+      .catch(() => setError(t("detail.notFound")));
   }, [publicRef]);
 
   if (error) return <ErrorState message={error} />;
-  if (!vehicle) return <LoadingState label="Loading vehicle record…" />;
+  if (!vehicle) return <LoadingState label={t("detail.loading")} />;
 
   return (
     <div className="page">
-      <Link className="back-link" to="/vehicles"><Icon name="arrow-left" /> Fleet registry</Link>
-      <PageHeader eyebrow="Fleet / Vehicle record" title={`${vehicle.public_ref} · ${vehicle.make} ${vehicle.model}`} description={`${vehicle.registration_number} · ${vehicle.location}`} actions={<div className="status-stack"><StatusBadge status={vehicle.operational_status} />{vehicle.attention && <span className="badge severity-high">Needs attention</span>}</div>} />
+      <Link className="back-link" to="/vehicles"><Icon name="arrow-left" /> {t("detail.backLink")}</Link>
+      <PageHeader eyebrow={t("detail.eyebrow")} title={`${vehicle.public_ref} · ${vehicle.make} ${vehicle.model}`} description={`${vehicle.registration_number} · ${vehicle.location}`} actions={<div className="status-stack"><StatusBadge status={vehicle.operational_status} label={t(`statuses.${vehicle.operational_status}`, { defaultValue: vehicle.operational_status })} />{vehicle.attention && <span className="badge severity-high">{t("detail.needsAttention")}</span>}</div>} />
 
-      <div role="tablist" aria-label="Vehicle sections" className="tabs" aria-orientation="horizontal">
-        {TABS.map((t) => (
+      <div role="tablist" aria-label={t("detail.tabsAriaLabel")} className="tabs" aria-orientation="horizontal">
+        {TABS.map((tb) => (
           <button
-            key={t}
+            key={tb}
             role="tab"
             type="button"
-            aria-selected={tab === t}
-            className={tab === t ? "active" : ""}
-            onClick={() => setTab(t)}
+            aria-selected={tab === tb}
+            className={tab === tb ? "active" : ""}
+            onClick={() => setTab(tb)}
           >
-            {t.charAt(0).toUpperCase() + t.slice(1)}
+            {t(`detail.tabs.${tb}`)}
           </button>
         ))}
       </div>
 
       {tab === "overview" && (
-        <section className="record-surface" aria-label="Vehicle overview"><dl className="detail-grid">
-          <div><dt>Registration</dt><dd>{vehicle.registration_number}</dd></div>
-          <div><dt>Model year</dt><dd>{vehicle.model_year}</dd></div>
-          <div><dt>Location</dt><dd>{vehicle.location}</dd></div>
-          <div><dt>Odometer</dt><dd>{vehicle.odometer_km.toLocaleString("en-GB")} km</dd></div>
-          <div><dt>Next service</dt><dd>{vehicle.next_service_km.toLocaleString("en-GB")} km</dd></div>
-          <div><dt>Active</dt><dd>{vehicle.active ? "Yes" : "No"}</dd></div>
+        <section className="record-surface" aria-label={t("detail.tabs.overview")}><dl className="detail-grid">
+          <div><dt>{t("detail.overview.registration")}</dt><dd>{vehicle.registration_number}</dd></div>
+          <div><dt>{t("detail.overview.modelYear")}</dt><dd>{vehicle.model_year}</dd></div>
+          <div><dt>{t("detail.overview.location")}</dt><dd>{vehicle.location}</dd></div>
+          <div><dt>{t("detail.overview.odometer")}</dt><dd>{formatNumber(vehicle.odometer_km)} km</dd></div>
+          <div><dt>{t("detail.overview.nextService")}</dt><dd>{formatNumber(vehicle.next_service_km)} km</dd></div>
+          <div><dt>{t("detail.overview.active")}</dt><dd>{vehicle.active ? t("detail.yes") : t("detail.no")}</dd></div>
         </dl></section>
       )}
 
       {tab === "bookings" && (
         <ul className="record-list">
-          {vehicle.bookings.length === 0 && <li>No bookings recorded.</li>}
+          {vehicle.bookings.length === 0 && <li>{t("detail.noBookings")}</li>}
           {vehicle.bookings.map((b) => (
             <li key={b.public_ref}>
               <Link to={`/bookings/${b.public_ref}`}>{b.public_ref}</Link>
-              <StatusBadge status={b.status} />
+              <StatusBadge status={b.status} label={t(`bookings:statuses.${b.status}`, { defaultValue: b.status })} />
               <span>
-                {new Date(b.starts_at).toLocaleDateString("en-GB")} → {new Date(b.ends_at).toLocaleDateString("en-GB")}
+                {formatShortDate(b.starts_at)} → {formatShortDate(b.ends_at)}
               </span>
             </li>
           ))}
@@ -76,15 +80,15 @@ export function VehicleDetail() {
 
       {tab === "inspections" && (
         <ul className="record-list">
-          {vehicle.inspections.length === 0 && <li>No inspections recorded.</li>}
+          {vehicle.inspections.length === 0 && <li>{t("detail.noInspections")}</li>}
           {vehicle.inspections.map((i) => (
             <li key={i.public_ref}>
               <span>{i.type}</span>
-              <span>{i.odometer_km.toLocaleString("en-GB")} km</span>
-              <span>Fuel {i.fuel_level_percent}%</span>
-              {i.damage_reported && <span className="badge severity-high">Damage</span>}
-              {i.technical_warning && <span className="badge severity-high">Technical warning</span>}
-              <time dateTime={i.completed_at}>{new Date(i.completed_at).toLocaleDateString("en-GB")}</time>
+              <span>{formatNumber(i.odometer_km)} km</span>
+              <span>{t("detail.fuel", { percent: i.fuel_level_percent })}</span>
+              {i.damage_reported && <span className="badge severity-high">{t("detail.damage")}</span>}
+              {i.technical_warning && <span className="badge severity-high">{t("detail.technicalWarning")}</span>}
+              <time dateTime={i.completed_at}>{formatShortDate(i.completed_at)}</time>
             </li>
           ))}
         </ul>
@@ -92,12 +96,12 @@ export function VehicleDetail() {
 
       {tab === "maintenance" && (
         <ul className="record-list">
-          {vehicle.maintenance.length === 0 && <li>No maintenance records.</li>}
+          {vehicle.maintenance.length === 0 && <li>{t("detail.noMaintenance")}</li>}
           {vehicle.maintenance.map((m) => (
             <li key={m.public_ref}>
               <span>{m.category}</span>
               <span>{m.summary}</span>
-              <time dateTime={m.occurred_at}>{new Date(m.occurred_at).toLocaleDateString("en-GB")}</time>
+              <time dateTime={m.occurred_at}>{formatShortDate(m.occurred_at)}</time>
             </li>
           ))}
         </ul>
@@ -105,13 +109,13 @@ export function VehicleDetail() {
 
       {tab === "quality" && (
         <ul className="record-list">
-          {vehicle.quality_issues.length === 0 && <li>No quality issues recorded.</li>}
+          {vehicle.quality_issues.length === 0 && <li>{t("detail.noQualityIssues")}</li>}
           {vehicle.quality_issues.map((q) => (
             <li key={q.public_ref}>
               <Link to={`/data-quality/${q.public_ref}`}>{q.public_ref}</Link>
               <SeverityBadge severity={q.severity} />
-              <span>{q.rule_type.replace(/_/g, " ")}</span>
-              <StatusBadge status={q.status} />
+              <span>{t(`quality:ruleTypes.${q.rule_type}`, { defaultValue: q.rule_type.replace(/_/g, " ") })}</span>
+              <StatusBadge status={q.status} label={t(`quality:list.status${q.status.charAt(0).toUpperCase()}${q.status.slice(1)}`, { defaultValue: q.status })} />
             </li>
           ))}
         </ul>
diff --git a/frontend/src/pages/Vehicles.tsx b/frontend/src/pages/Vehicles.tsx
index 7a83896..6a297d4 100644
--- a/frontend/src/pages/Vehicles.tsx
+++ b/frontend/src/pages/Vehicles.tsx
@@ -1,13 +1,17 @@
 import { useEffect, useState } from "react";
 import { Link } from "react-router-dom";
+import { useTranslation } from "react-i18next";
 import { api } from "../api/client";
 import type { Vehicle } from "../api/types";
+import { useLocaleFormat } from "../i18n/format";
 import { StatusBadge } from "../components/Badge";
 import { EmptyState, ErrorState, LoadingState, PageHeader } from "../components/PageChrome";
 
 const STATUS_OPTIONS = ["available", "rented", "cleaning", "maintenance", "blocked"];
 
 export function Vehicles() {
+  const { t } = useTranslation("fleet");
+  const { formatNumber } = useLocaleFormat();
   const [vehicles, setVehicles] = useState<Vehicle[] | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [status, setStatus] = useState("");
@@ -23,25 +27,25 @@ export function Vehicles() {
     api
       .get<Vehicle[]>(`/api/v1/vehicles?${params.toString()}`)
       .then(setVehicles)
-      .catch(() => setError("Vehicle list is unavailable right now."));
+      .catch(() => setError(t("list.unavailable")));
   }, [status, attentionOnly]);
 
   return (
     <div className="page">
-      <PageHeader eyebrow="Fleet / Registry" title="Vehicle fleet" description="Live operational state, location and service readiness." />
+      <PageHeader eyebrow={t("list.eyebrow")} title={t("list.title")} description={t("list.description")} />
 
-      <form className="filters" aria-label="Filter vehicles">
+      <form className="filters" aria-label={t("list.title")}>
         <label>
-          Search
-          <input type="text" value={query} onChange={(e) => setQuery(e.target.value)} placeholder="Reference, make or location" />
+          {t("list.searchLabel")}
+          <input type="text" value={query} onChange={(e) => setQuery(e.target.value)} placeholder={t("list.searchPlaceholder")} />
         </label>
         <label>
-          Status
+          {t("list.statusLabel")}
           <select value={status} onChange={(e) => setStatus(e.target.value)}>
-            <option value="">All statuses</option>
+            <option value="">{t("list.statusAll")}</option>
             {STATUS_OPTIONS.map((s) => (
               <option key={s} value={s}>
-                {s}
+                {t(`statuses.${s}`)}
               </option>
             ))}
           </select>
@@ -52,43 +56,44 @@ export function Vehicles() {
             checked={attentionOnly}
             onChange={(e) => setAttentionOnly(e.target.checked)}
           />
-          Attention only
+          {t("list.attentionOnly")}
         </label>
       </form>
 
       {error && <ErrorState message={error} />}
-      {!error && !vehicles && <LoadingState label="Loading fleet registry…" />}
-      {vehicles && vehicles.length === 0 && <EmptyState icon="fleet" title="No vehicles found" detail="Adjust the current fleet filters." />}
+      {!error && !vehicles && <LoadingState label={t("list.loading")} />}
+      {vehicles && vehicles.length === 0 && <EmptyState icon="fleet" title={t("list.empty")} detail={t("list.emptyDetail")} />}
 
       {vehicles && vehicles.length > 0 && (() => {
         const filtered = vehicles.filter((v) => `${v.public_ref} ${v.make} ${v.model} ${v.location}`.toLowerCase().includes(query.toLowerCase()));
-        return filtered.length === 0 ? <EmptyState icon="search" title="No matching vehicles" detail="Try a broader search term." /> : <div className="table-shell"><div className="table-meta"><span>{filtered.length} vehicles</span><span>Persisted fleet data</span></div><table className="data-table">
-          <caption className="visually-hidden">Vehicle fleet</caption>
+        return filtered.length === 0 ? <EmptyState icon="search" title={t("list.noMatch")} detail={t("list.noMatchDetail")} /> : <div className="table-shell"><div className="table-meta"><span>{t("list.count", { count: filtered.length })}</span><span>{t("list.persisted")}</span></div><table className="data-table">
+          <caption className="visually-hidden">{t("list.title")}</caption>
           <thead>
             <tr>
-              <th scope="col">Reference</th>
-              <th scope="col">Make / model</th>
-              <th scope="col">Location</th>
-              <th scope="col">Status</th>
-              <th scope="col">Odometer (km)</th>
-              <th scope="col">Attention</th>
+              <th scope="col">{t("list.columns.reference")}</th>
+              <th scope="col">{t("list.columns.makeModel")}</th>
+              <th scope="col">{t("list.columns.location")}</th>
+              <th scope="col">{t("list.columns.status")}</th>
+              <th scope="col">{t("list.columns.odometer")}</th>
+              <th scope="col">{t("list.columns.attention")}</th>
             </tr>
           </thead>
           <tbody>
             {filtered.map((v) => (
-              <tr key={v.public_ref} className={v.attention ? "row-attention" : ""}>
-                <th scope="row" data-label="Reference">
-                  <Link to={`/vehicles/${v.public_ref}`}>{v.public_ref}</Link>
+              <tr key={v.public_ref} className={`row-clickable ${v.attention ? "row-attention" : ""}`}>
+                <th scope="row" data-label={t("list.columns.reference")}>
+                  {v.public_ref}
+                  <Link className="row-link" to={`/vehicles/${v.public_ref}`}><span className="visually-hidden">{v.public_ref}</span></Link>
                 </th>
-                <td data-label="Make / model">
+                <td data-label={t("list.columns.makeModel")}>
                   {v.make} {v.model} ({v.model_year})
                 </td>
-                <td data-label="Location">{v.location}</td>
-                <td data-label="Status">
-                  <StatusBadge status={v.operational_status} />
+                <td data-label={t("list.columns.location")}>{v.location}</td>
+                <td data-label={t("list.columns.status")}>
+                  <StatusBadge status={v.operational_status} label={t(`statuses.${v.operational_status}`, { defaultValue: v.operational_status })} />
                 </td>
-                <td data-label="Odometer">{v.odometer_km.toLocaleString("en-GB")}</td>
-                <td data-label="Attention">{v.attention ? <span className="attention-flag">Needs attention</span> : "—"}</td>
+                <td data-label={t("list.columns.odometer")}>{formatNumber(v.odometer_km)}</td>
+                <td data-label={t("list.columns.attention")}>{v.attention ? <span className="attention-flag">{t("list.needsAttention")}</span> : "—"}</td>
               </tr>
             ))}
           </tbody>
diff --git a/frontend/src/styles.css b/frontend/src/styles.css
index a38409a..ee64c2f 100644
--- a/frontend/src/styles.css
+++ b/frontend/src/styles.css
@@ -103,8 +103,22 @@ a:hover { color: var(--teal); }
 .icon-button:hover { background: var(--surface-subtle); border-color: var(--line); }
 .icon-button svg { width: 18px; height: 18px; }
 .mobile-menu { display: none; }
-.demo-banner { min-height: 32px; margin: 0; display: flex; align-items: center; justify-content: center; gap: 7px; padding: 6px 20px; color: #48566a; background: #eaf0f5; border-bottom: 1px solid #d7e0e8; font-size: .68rem; font-weight: 600; letter-spacing: .02em; }
-.demo-banner svg { width: 14px; height: 14px; }
+.language-switcher select { height: 32px; padding: 0 8px; color: var(--ink-soft); background: white; border: 1px solid var(--line-strong); border-radius: var(--radius); font-size: .68rem; font-weight: 600; cursor: pointer; }
+.language-switcher-compact select { height: 28px; font-size: .64rem; }
+.sidebar-language { display: none; padding: 0 20px 14px; }
+.login-panel-top { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+.login-panel-top .page-eyebrow { margin: 0; }
+.demo-badge { position: relative; }
+.demo-badge-trigger { display: flex; align-items: center; gap: 6px; height: 32px; padding: 0 12px; color: #48566a; background: #eaf0f5; border: 1px solid #d7e0e8; border-radius: 999px; font-size: .68rem; font-weight: 700; letter-spacing: .02em; cursor: pointer; }
+.demo-badge-trigger:hover { background: #dfe8ef; }
+.demo-badge-trigger svg { width: 13px; height: 13px; }
+.demo-badge-popover { position: absolute; z-index: 30; top: calc(100% + 8px); right: 0; width: min(320px, 84vw); padding: 16px; display: grid; gap: 10px; background: var(--surface); border: 1px solid var(--line); border-radius: var(--radius); box-shadow: var(--shadow-float); }
+.demo-badge-popover p { margin: 0; color: var(--ink-soft); font-size: .74rem; line-height: 1.55; }
+.demo-badge-reset { color: var(--muted) !important; font-size: .68rem !important; }
+.demo-badge-popover a { display: inline-flex; align-items: center; gap: 4px; color: var(--teal-dark); text-decoration: none; font-size: .74rem; font-weight: 700; }
+.demo-badge-popover a svg { width: 13px; }
+.demo-badge-close { position: absolute; top: 8px; right: 8px; width: 28px; height: 28px; }
+.demo-badge-close svg { width: 14px; height: 14px; }
 #main-content { width: min(1320px, calc(100% - 56px)); margin: 0 auto; padding: 38px 0 64px; flex: 1; }
 .app-footer { min-height: 52px; display: flex; justify-content: space-between; align-items: center; gap: 16px; padding: 0 28px; color: var(--muted); border-top: 1px solid var(--line); font-size: .68rem; }
 .mobile-nav, .nav-scrim { display: none; }
@@ -174,7 +188,13 @@ a:hover { color: var(--teal); }
 .timeline-departure { color: var(--info); border-color: #6a98b3; }
 .movement-timeline li > div { min-width: 0; display: grid; grid-template-columns: auto 1fr; gap: 2px 8px; align-items: baseline; }
 .movement-kind { color: var(--muted); font-size: .59rem; font-weight: 700; text-transform: uppercase; letter-spacing: .08em; }
-.movement-timeline a { color: var(--ink); font-size: .75rem; font-weight: 700; text-decoration: none; }.movement-timeline small { grid-column: 2; color: var(--muted); font-size: .66rem; }
+.movement-timeline .movement-ref { color: var(--ink); font-size: .75rem; font-weight: 700; }.movement-timeline small { grid-column: 2; color: var(--muted); font-size: .66rem; }
+.row-clickable { position: relative; cursor: pointer; }
+.row-link { position: absolute; inset: 0; z-index: 1; border-radius: inherit; }
+.row-link:focus-visible { outline: 2px solid var(--focus); outline-offset: -2px; }
+.attention-list li.row-clickable:hover .attention-title, .movement-timeline li.row-clickable:hover .movement-ref { color: var(--teal-dark); }
+.data-table tr.row-clickable:hover { background: var(--surface-subtle); }
+.data-table tr.row-clickable .cell-link { position: relative; z-index: 2; }
 
 .integration-list li, .recent-list li { min-height: 60px; display: flex; align-items: center; gap: 11px; padding: 10px 18px; border-bottom: 1px solid #e8edf2; }
 .integration-list li:last-child, .recent-list li:last-child { border-bottom: 0; }.integration-list li > div, .recent-list li > div { flex: 1; display: grid; gap: 3px; }
@@ -219,6 +239,12 @@ details summary { cursor: pointer; color: var(--teal-dark); }.data-table details
 .tabs button { position: relative; min-height: 44px; padding: 8px 13px; border: 0; background: transparent; color: var(--muted); font-size: .72rem; font-weight: 700; text-transform: capitalize; cursor: pointer; }
 .tabs button.active { color: var(--teal-dark); }.tabs button.active::after { content: ""; position: absolute; inset: auto 7px -1px; height: 2px; background: var(--teal); }
 .record-surface { padding: 18px; margin-bottom: 18px; }
+.about-card h2 { margin: 0 0 8px; color: var(--ink); font-size: 1rem; letter-spacing: -.015em; }
+.about-card p { margin: 0; color: var(--muted); font-size: .82rem; line-height: 1.62; }
+.about-card p code { padding: 1px 5px; background: var(--surface-subtle); border-radius: 4px; font-size: .78rem; }
+.about-cta { display: flex; align-items: center; justify-content: space-between; gap: 16px; flex-wrap: wrap; background: var(--teal-pale); border-color: #bfe6df; }
+.about-cta strong { display: block; color: var(--ink); font-size: .85rem; }
+.about-cta p { margin: 2px 0 0; }
 .detail-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 1px; margin: 0; background: var(--line); border: 1px solid var(--line); }
 .detail-grid div { min-height: 76px; padding: 13px 14px; background: white; }
 .detail-grid dt { margin: 0; color: var(--muted); font-size: .63rem; font-weight: 700; text-transform: uppercase; letter-spacing: .065em; }.detail-grid dd { margin: 7px 0 0; color: var(--ink); font-size: .82rem; font-weight: 700; }
@@ -236,15 +262,70 @@ details summary { cursor: pointer; color: var(--teal-dark); }.data-table details
 .impact-preview { display: flex; align-items: flex-start; gap: 11px; padding: 15px; border: 1px solid; border-radius: var(--radius); }.impact-preview > svg { width: 20px; flex: 0 0 auto; }.impact-preview strong { font-size: .76rem; }.impact-preview p { margin: 4px 0 0; font-size: .72rem; line-height: 1.45; }.impact-ready { color: #185d41; background: var(--success-pale); border-color: #bfe3d0; }.impact-warning { color: #844909; background: var(--warning-pale); border-color: #eed4aa; }
 .commit-list { list-style: none; display: grid; gap: 7px; margin: 16px 0 0; padding: 0; color: var(--muted); font-size: .7rem; }.commit-list li { display: flex; gap: 7px; }.commit-list svg { width: 14px; color: var(--teal-dark); }
 .success-panel { padding: 22px; }.result-heading { display: flex; align-items: center; gap: 12px; margin-bottom: 18px; }.result-heading > span { width: 40px; height: 40px; display: grid; place-items: center; color: white; background: var(--success); border-radius: 50%; }.result-heading svg { width: 20px; }.result-heading h2 { margin: 0; font-size: 1.2rem; }
+.result-links { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 16px; }
+.link-button { padding: 0; color: var(--teal-dark); background: transparent; border: 0; font-size: inherit; font-weight: 700; text-decoration: underline; cursor: pointer; }
+.link-button:hover { color: var(--teal); }
+.rule-explainer { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 14px; margin-bottom: 18px; padding: 16px 18px; background: var(--info-pale); border: 1px solid #cfe3ee; border-radius: var(--radius); }
+.rule-explainer strong { display: block; margin-bottom: 4px; color: var(--ink); font-size: .72rem; font-weight: 700; text-transform: uppercase; letter-spacing: .05em; }
+.rule-explainer p { margin: 0; color: var(--ink-soft); font-size: .78rem; line-height: 1.55; }
+.scenario-callout { display: flex; align-items: flex-start; gap: 12px; margin-bottom: 18px; padding: 16px 18px; background: var(--teal-pale); border: 1px solid #bfe6df; }
+.scenario-callout svg { width: 18px; height: 18px; color: var(--teal-dark); flex-shrink: 0; margin-top: 2px; }
+.scenario-callout strong { display: block; margin-bottom: 4px; color: var(--ink); font-size: .82rem; }
+.scenario-callout p { margin: 0; color: var(--ink-soft); font-size: .78rem; line-height: 1.55; }
 
 .duplicate-compare { margin-top: 18px; }.duplicate-compare fieldset { margin: 15px 0; padding: 13px; border: 1px solid var(--line); }.duplicate-compare legend { padding: 0 5px; color: var(--ink-soft); font-size: .69rem; font-weight: 700; }.duplicate-compare fieldset label { display: inline-flex !important; margin-right: 18px; }
 .compare-table th, .compare-table td { vertical-align: top; }.compare-table label { display: inline-flex; flex-direction: row; align-items: center; gap: 6px; }.difference-mark, .match-mark { display: block; width: max-content; margin-top: 4px; padding: 2px 5px; font-size: .52rem; border-radius: 2px; }.difference-mark { color: var(--warning); background: var(--warning-pale); }.match-mark { color: var(--success); background: var(--success-pale); }
 .merge-preview { padding: 13px; color: var(--ink-soft); background: var(--surface-subtle); border-left: 3px solid var(--teal); font-size: .75rem; }.duplicate-compare > button { color: white; background: var(--teal-dark); border-color: var(--teal-dark); }
 .confirm-bar { margin-top: 13px; padding: 15px; background: var(--warning-pale); border: 1px solid #eed4aa; }.confirm-bar p { margin: 0 0 11px; color: #75420c; font-size: .75rem; font-weight: 700; }.confirm-bar button:first-of-type { color: white; background: var(--critical); border-color: var(--critical); }
 .resolution-actions { display: flex; gap: 9px; }.evidence-block { max-width: 100%; padding: 13px; overflow: auto; color: #324054; background: var(--surface-subtle); border: 1px solid var(--line); font-size: .68rem; }
+.evidence-disclosure { margin-top: 14px; }.evidence-disclosure summary { font-size: .68rem; font-weight: 700; text-transform: uppercase; letter-spacing: .05em; }.evidence-disclosure .evidence-block { margin-top: 8px; }
+
+.choice-fieldset { display: grid; gap: 9px; margin: 0 0 17px; padding: 0; border: 0; }.choice-fieldset legend { margin-bottom: 2px; padding: 0; color: var(--ink-soft); font-size: .67rem; font-weight: 700; }.choice-fieldset-grid { grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); }
+.choice-card { display: flex !important; flex-direction: row; align-items: flex-start; gap: 11px; padding: 13px 15px; background: var(--surface); border: 1.5px solid var(--line-strong); border-radius: var(--radius); cursor: pointer; transition: border-color .15s ease, background .15s ease; }
+.choice-card:hover { border-color: var(--teal); }
+.choice-card:has(input:checked), .choice-card.is-selected { border-color: var(--teal-dark); background: var(--teal-pale); }
+.choice-card:has(input:disabled), .choice-card.is-disabled { cursor: not-allowed; opacity: .55; }
+.choice-card input[type="radio"] { flex: 0 0 auto; margin-top: 2px; }
+.choice-card-body { display: grid; gap: 3px; }
+.choice-card-title { color: var(--ink); font-size: .82rem; font-weight: 700; }
+.choice-card-detail { color: var(--muted); font-size: .72rem; line-height: 1.5; }
+
+.defer-reject-panel { padding: 16px 18px; background: var(--surface-subtle); }
+.defer-reject-panel h2 { margin: 0 0 4px; color: var(--ink-soft); font-size: .78rem; font-weight: 700; }
+.defer-reject-panel > p { margin: 0 0 12px; color: var(--muted); font-size: .72rem; }
+
+.audit-group-list { list-style: none; display: grid; gap: 12px; margin: 0; padding: 16px; }
+.audit-group { padding: 16px 18px; }
+.audit-group-heading { display: flex; flex-wrap: wrap; align-items: baseline; gap: 8px; }
+.audit-group-heading strong { color: var(--ink); font-size: .85rem; }
+.audit-group-meta { display: flex; flex-wrap: wrap; align-items: center; gap: 14px; margin-top: 6px; font-size: .76rem; }
+.change-diff { list-style: none; display: grid; gap: 4px; margin: 10px 0 0; padding: 0; color: var(--ink-soft); font-size: .74rem; }
+.change-diff li { padding: 6px 10px; background: var(--surface-subtle); border-radius: 4px; }
+.audit-group-actions { display: flex; flex-wrap: wrap; gap: 14px; margin-top: 10px; }
+.audit-related-list { list-style: none; display: grid; gap: 10px; margin: 12px 0 0; padding: 12px; background: var(--surface-subtle); border: 1px solid var(--line); border-radius: var(--radius); }
+.audit-related-list > li { padding: 10px 12px; background: white; border: 1px solid var(--line); border-radius: var(--radius); }
+.audit-technical-grid { margin-top: 8px; }
+.resolution-actions .button-tertiary, .resolution-actions .button-tertiary-destructive { min-height: 36px; padding: 7px 12px; color: var(--muted); background: transparent; border: 1px solid transparent; border-radius: var(--radius); font-size: .7rem; font-weight: 700; cursor: pointer; }
+.resolution-actions .button-tertiary:hover { color: var(--ink); background: var(--surface); border-color: var(--line); }
+.resolution-actions .button-tertiary-destructive:hover { color: var(--critical); background: var(--surface); border-color: var(--line); }
 
 .integration-cards { display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px; margin-bottom: 28px; }.integration-cards article { min-height: 170px; display: grid; grid-template-columns: auto 1fr; gap: 12px; padding: 18px; background: white; border: 1px solid var(--line); border-radius: var(--radius); }.integration-cards .badge { grid-column: 1 / -1; width: max-content; align-self: end; }.integration-cards h2 { margin: 3px 0 7px; font-size: .95rem; }.integration-cards p { margin: 0; color: var(--muted); font-size: .7rem; line-height: 1.48; }.integration-kicker { color: var(--muted); font-size: .56rem; font-weight: 700; text-transform: uppercase; letter-spacing: .09em; }
 
+.scenario-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 14px; }
+.scenario-card { display: flex; flex-direction: column; gap: 10px; padding: 18px; background: var(--surface); border: 1px solid var(--line); border-radius: var(--radius); }
+.scenario-card header { display: flex; align-items: flex-start; justify-content: space-between; gap: 10px; }
+.scenario-card h2 { margin: 0; font-size: 1rem; letter-spacing: -.015em; }
+.scenario-problem, .scenario-demonstrates { margin: 0; color: var(--muted); font-size: .78rem; line-height: 1.55; }
+.scenario-demonstrates strong { color: var(--ink-soft); }
+.scenario-meta { display: flex; gap: 20px; margin: 0; }
+.scenario-meta div { display: grid; gap: 2px; }
+.scenario-meta dt { color: var(--muted); font-size: .58rem; font-weight: 700; text-transform: uppercase; letter-spacing: .07em; }
+.scenario-meta dd { margin: 0; color: var(--ink-soft); font-size: .76rem; font-weight: 600; }
+.scenario-blocked { display: flex; align-items: flex-start; gap: 6px; margin: 0; padding: 8px 10px; color: #8a5a12; background: #fdf3e2; border: 1px solid #f2ddb0; border-radius: 8px; font-size: .68rem; line-height: 1.45; }
+.scenario-blocked svg { width: 14px; flex-shrink: 0; margin-top: 1px; }
+.scenario-card > .button { align-self: flex-start; margin-top: auto; }
+.scenario-card > .button[aria-disabled="true"] { opacity: .55; cursor: not-allowed; pointer-events: none; }
+
 .knowledge-status { min-height: 58px; display: flex; align-items: center; gap: 11px; margin-bottom: 14px; padding: 10px 16px; background: white; border: 1px solid var(--line); border-radius: var(--radius); }.knowledge-status div { flex: 1; display: grid; gap: 3px; }.knowledge-status strong { font-size: .74rem; }.knowledge-status span:not(.health-orb), .knowledge-status small { color: var(--muted); font-size: .65rem; }.health-orb { width: 9px; height: 9px; border-radius: 50%; }.health-orb.is-healthy { background: var(--success); box-shadow: 0 0 0 4px var(--success-pale); }.health-orb.is-down { background: var(--critical); box-shadow: 0 0 0 4px var(--critical-pale); }
 .knowledge-form { margin-bottom: 18px; }.ask-heading { display: flex; gap: 11px; align-items: center; margin-bottom: 15px; }.ask-heading > span { width: 36px; height: 36px; display: grid; place-items: center; color: var(--teal-dark); background: var(--teal-pale); border-radius: var(--radius); }.ask-heading svg { width: 18px; }.ask-heading h2 { margin: 0; font-size: .95rem; }.ask-heading p { margin: 3px 0 0; color: var(--muted); font-size: .65rem; }
 .knowledge-input-row { display: flex; gap: 8px; }.knowledge-input-row input { min-width: 0; flex: 1; }.knowledge-empty { min-height: 290px; display: flex; flex-direction: column; align-items: center; justify-content: center; text-align: center; padding: 30px; color: var(--muted); background: white; border: 1px dashed var(--line-strong); border-radius: var(--radius); }.knowledge-empty > span { width: 50px; height: 50px; display: grid; place-items: center; color: var(--teal-dark); background: var(--teal-pale); border-radius: 50%; }.knowledge-empty svg { width: 22px; }.knowledge-empty h2 { margin: 15px 0 7px; color: var(--ink); font-size: 1rem; }.knowledge-empty p { max-width: 540px; margin: 0; font-size: .75rem; line-height: 1.5; }
@@ -260,23 +341,92 @@ details summary { cursor: pointer; color: var(--teal-dark); }.data-table details
 .login-brand { height: auto; padding: 0; border: 0; }.login-brand .brand-mark { width: 36px; height: 36px; }.login-brand strong { font-size: 1.05rem; }.login-message { position: relative; z-index: 2; max-width: 620px; margin: auto 0 22px; }.login-message .eyebrow { color: #5eead4; }.login-message h1 { margin: 0; color: white; font-size: clamp(2.8rem, 5.5vw, 5.4rem); line-height: .98; letter-spacing: -.06em; }.login-message > p:last-child { max-width: 520px; margin: 23px 0 0; color: #a9b7c8; font-size: .98rem; line-height: 1.65; }
 .control-illustration { position: absolute; width: min(35vw, 500px); aspect-ratio: 1; right: -80px; top: 7vh; opacity: .88; }.illustration-orbit { position: absolute; inset: 10%; border: 1px solid #29435a; border-radius: 50%; }.orbit-two { inset: 28%; border-style: dashed; transform: rotate(35deg); }.illustration-orbit::before, .illustration-orbit::after { content: ""; position: absolute; background: #2dd4bf; border-radius: 50%; }.illustration-orbit::before { width: 7px; height: 7px; top: 13%; left: 16%; }.illustration-orbit::after { width: 5px; height: 5px; right: 2%; bottom: 33%; }.illustration-core { position: absolute; inset: 40%; display: grid; place-items: center; color: white; background: #172a3e; border: 1px solid #2c465e; border-radius: 50%; }.illustration-core svg { width: 45px; }.illustration-node { position: absolute; width: 42px; height: 42px; display: grid; place-items: center; color: #5eead4; background: #152b3f; border: 1px solid #2c465e; border-radius: 50%; }.illustration-node svg { width: 18px; }.node-one { top: 13%; left: 20%; }.node-two { right: 5%; bottom: 27%; }.node-three { left: 15%; bottom: 12%; }
 .login-footnote { position: relative; z-index: 2; display: flex; align-items: center; gap: 7px; margin: auto 0 0; color: #7f90a4; font-size: .68rem; }.login-footnote svg { width: 14px; }
-.login-access { display: grid; place-items: center; padding: 46px max(38px, 7vw); background: #f8fafb; }.login-panel { width: min(470px, 100%); }.login-panel h2 { margin: 0; color: var(--ink); font-size: 1.7rem; letter-spacing: -.04em; }.login-intro { margin: 9px 0 26px; color: var(--muted); font-size: .8rem; line-height: 1.55; }.login-options { display: grid; gap: 10px; }.login-options button { min-height: 76px; display: grid; grid-template-columns: 40px 1fr 18px; align-items: center; gap: 12px; padding: 13px; text-align: left; color: var(--ink); background: white; border: 1px solid var(--line-strong); border-radius: var(--radius); box-shadow: 0 7px 20px rgba(15,23,42,.04); cursor: pointer; transition: border .16s ease, transform .16s ease, box-shadow .16s ease; }.login-options button:hover { transform: translateY(-2px); border-color: var(--teal); box-shadow: var(--shadow-float); }.login-options button > svg { width: 17px; color: var(--teal-dark); }.login-options button > span:nth-child(2) { display: grid; gap: 5px; }.login-options strong { font-size: .8rem; }.login-options small { color: var(--muted); font-size: .66rem; }.role-icon { width: 40px; height: 40px; display: grid !important; place-items: center; color: var(--teal-dark); background: var(--teal-pale); border-radius: var(--radius); }.role-icon svg { width: 18px; }.access-note { display: flex; gap: 10px; margin-top: 22px; padding-top: 20px; color: var(--muted); border-top: 1px solid var(--line); }.access-note > svg { width: 18px; color: var(--teal-dark); }.access-note p { display: grid; gap: 3px; margin: 0; }.access-note strong { color: var(--ink-soft); font-size: .69rem; }.access-note span { font-size: .64rem; }
+.login-access { display: grid; place-items: center; padding: 46px max(38px, 7vw); background: #f8fafb; }.login-panel { width: min(470px, 100%); }.login-panel h2 { margin: 0; color: var(--ink); font-size: 1.7rem; letter-spacing: -.04em; }.login-intro { margin: 9px 0 26px; color: var(--muted); font-size: .8rem; line-height: 1.55; }.login-guide-cta { width: 100%; min-height: 48px; margin-bottom: 18px; font-size: .85rem; }.login-options { display: grid; gap: 10px; }.login-options button { min-height: 76px; display: grid; grid-template-columns: 40px 1fr 18px; align-items: center; gap: 12px; padding: 13px; text-align: left; color: var(--ink); background: white; border: 1px solid var(--line-strong); border-radius: var(--radius); box-shadow: 0 7px 20px rgba(15,23,42,.04); cursor: pointer; transition: border .16s ease, transform .16s ease, box-shadow .16s ease; }.login-options button:hover { transform: translateY(-2px); border-color: var(--teal); box-shadow: var(--shadow-float); }.login-options button > svg { width: 17px; color: var(--teal-dark); }.login-options button > span:nth-child(2) { display: grid; gap: 5px; }.login-options strong { font-size: .8rem; }.login-options small { color: var(--muted); font-size: .66rem; }.role-icon { width: 40px; height: 40px; display: grid !important; place-items: center; color: var(--teal-dark); background: var(--teal-pale); border-radius: var(--radius); }.role-icon svg { width: 18px; }.access-note { display: flex; gap: 10px; margin-top: 22px; padding-top: 20px; color: var(--muted); border-top: 1px solid var(--line); }.access-note > svg { width: 18px; color: var(--teal-dark); }.access-note p { display: grid; gap: 3px; margin: 0; }.access-note strong { color: var(--ink-soft); font-size: .69rem; }.access-note span { font-size: .64rem; }
 
 @media (max-width: 1120px) {
   .app-shell { grid-template-columns: 190px minmax(0, 1fr); }.sidebar { width: 190px; }.brand-lockup { padding-inline: 14px; }.readiness-band { grid-template-columns: 160px 1fr; }.readiness-band .inline-action { display: none; }.operations-grid { grid-template-columns: 1fr 1fr; }.timezone { display: none; }.review-facts { grid-template-columns: repeat(3, 1fr); }
 }
 
+.knowledge-provider-note { display: flex; align-items: flex-start; gap: 8px; margin: -6px 0 18px; padding: 10px 14px; color: var(--ink-soft); background: var(--info-pale); border: 1px solid #cfe3ee; border-radius: var(--radius); font-size: .72rem; line-height: 1.5; }
+.knowledge-provider-note svg { width: 15px; flex-shrink: 0; margin-top: 1px; color: var(--info); }
+.knowledge-suggestions { display: flex; flex-wrap: wrap; align-items: center; gap: 7px; margin-top: 12px; }
+.knowledge-suggestions > span { color: var(--muted); font-size: .68rem; font-weight: 700; }
+.suggestion-chip { padding: 6px 11px; color: var(--teal-dark); background: var(--teal-pale); border: 1px solid #bfe6df; border-radius: 999px; font-size: .68rem; font-weight: 600; cursor: pointer; }
+.suggestion-chip:hover { background: #d9f0ea; }
+.suggestion-chip:disabled { opacity: .6; cursor: not-allowed; }
+
+.demo-start-panel { display: flex; align-items: center; justify-content: space-between; gap: 16px; flex-wrap: wrap; margin-bottom: 22px; padding: 16px 20px; background: var(--teal-pale); border: 1px solid #bfe6df; border-radius: var(--radius); }
+.demo-start-panel > div:first-child { display: flex; align-items: center; gap: 12px; }
+.demo-start-panel > div:first-child > svg { width: 22px; height: 22px; color: var(--teal-dark); flex-shrink: 0; }
+.demo-start-panel strong { display: block; color: var(--ink); font-size: .85rem; }
+.demo-start-panel span { display: block; margin-top: 2px; color: var(--muted); font-size: .72rem; }
+.demo-start-actions { display: flex; gap: 8px; flex-wrap: wrap; }
+
+.demo-guide-trigger { display: flex; align-items: center; gap: 6px; height: 32px; padding: 0 12px; color: var(--teal-dark); background: var(--teal-pale); border: 1px solid #bfe6df; border-radius: 999px; font-size: .68rem; font-weight: 700; cursor: pointer; }
+.demo-guide-trigger:hover { background: #d9f0ea; }
+.demo-guide-trigger svg { width: 13px; height: 13px; }
+.demo-guide-progress-pill { padding: 1px 6px; color: var(--teal-dark); background: white; border-radius: 999px; font-size: .6rem; }
+
+.demo-guide-panel { position: fixed; z-index: 40; top: 0; right: 0; width: min(400px, 92vw); height: 100vh; display: flex; flex-direction: column; gap: 14px; padding: 20px; background: var(--surface); border-left: 1px solid var(--line); box-shadow: var(--shadow-float); overflow-y: auto; }
+@media (min-width: 701px) {
+  /* The guide panel is a fixed right-side overlay at this width -- push page content
+     aside while it's open so it never sits underneath and blocks actionable buttons. */
+  .app-workspace.guide-open { padding-right: min(400px, 92vw); transition: padding-right .2s ease; }
+  .app-workspace.guide-open.guide-collapsed { padding-right: 0; }
+}
+/* Extra-wide desktop (>=1440px, see useViewportTier): a docked rail rather than a
+   floating overlay -- guaranteed minimum width, no shadow (it reads as part of the
+   layout, not something hovering above it), and it never auto-collapses to a chip. */
+.demo-guide-panel.is-wide { width: 420px; min-width: 420px; box-shadow: none; }
+
+.demo-guide-chip { position: fixed; z-index: 40; right: 20px; bottom: 20px; display: flex; align-items: stretch; height: 44px; background: white; border: 1px solid #bfe6df; border-radius: 999px; box-shadow: var(--shadow-float); overflow: hidden; }
+.demo-guide-chip-expand { display: flex; align-items: center; gap: 8px; padding: 0 14px; color: var(--teal-dark); background: transparent; border: 0; font-size: .72rem; font-weight: 700; cursor: pointer; }
+.demo-guide-chip-expand:hover { background: var(--teal-pale); }
+.demo-guide-chip-expand svg { width: 14px; }
+.demo-guide-chip-close { display: flex; align-items: center; padding: 0 12px; color: var(--muted); background: transparent; border: 0; border-left: 1px solid var(--line); cursor: pointer; }
+.demo-guide-chip-close:hover { color: var(--ink); background: var(--surface-subtle); }
+.demo-guide-chip-close svg { width: 12px; }
+
+.demo-guide-highlight { animation: demo-guide-pulse 2.2s ease; outline: 3px solid var(--teal); outline-offset: 3px; border-radius: var(--radius); }
+@keyframes demo-guide-pulse {
+  0% { outline-color: var(--teal-dark); }
+  70% { outline-color: var(--teal-dark); }
+  100% { outline-color: transparent; }
+}
+@media (prefers-reduced-motion: reduce) {
+  .demo-guide-highlight { animation: none; }
+}
+.demo-guide-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 10px; }
+.demo-guide-kicker { margin: 0 0 4px; color: var(--teal-dark); font-size: .64rem; font-weight: 700; text-transform: uppercase; letter-spacing: .08em; }
+.demo-guide-header h2 { margin: 0; font-size: 1.05rem; letter-spacing: -.015em; }
+.demo-guide-progress-bar { display: flex; gap: 4px; }
+.demo-guide-progress-bar span { flex: 1; height: 4px; background: var(--line); border-radius: 2px; }
+.demo-guide-progress-bar span.is-done { background: var(--teal); }
+.demo-guide-progress-bar span.is-current { background: var(--teal-dark); }
+.demo-guide-body { display: grid; gap: 12px; }
+.demo-guide-body p { margin: 0; color: var(--ink-soft); font-size: .78rem; line-height: 1.55; }
+.demo-guide-body p strong { color: var(--muted); font-size: .64rem; font-weight: 700; text-transform: uppercase; letter-spacing: .06em; }
+.demo-guide-steps { display: grid; gap: 3px; padding-top: 12px; border-top: 1px solid var(--line); }
+.demo-guide-steps button { display: flex; align-items: center; gap: 7px; padding: 7px 8px; text-align: left; color: var(--muted); background: transparent; border: 0; border-radius: var(--radius); font-size: .68rem; cursor: pointer; }
+.demo-guide-steps button svg { width: 12px; color: var(--teal); flex-shrink: 0; }
+.demo-guide-steps button:hover { background: var(--surface-subtle); }
+.demo-guide-steps button.is-current { color: var(--ink); background: var(--teal-pale); font-weight: 700; }
+.demo-guide-footer { display: flex; flex-wrap: wrap; gap: 8px; margin-top: auto; padding-top: 12px; border-top: 1px solid var(--line); }
+.demo-guide-restart { width: 100%; padding: 8px; color: var(--muted); background: transparent; border: 1px dashed var(--line-strong); border-radius: var(--radius); font-size: .68rem; font-weight: 600; cursor: pointer; }
+.demo-guide-restart:hover { color: var(--ink-soft); border-color: var(--muted-light); }
+.demo-guide-restart:disabled { opacity: .6; cursor: not-allowed; }
+
 @media (max-width: 960px) {
-  .app-shell { display: block; }.app-workspace { min-height: 100vh; }.sidebar { width: min(286px, 86vw); transform: translateX(-102%); transition: transform .22s ease; box-shadow: var(--shadow-float); }.sidebar.is-open { transform: none; }.nav-scrim { display: block; position: fixed; inset: 0; z-index: 25; width: 100%; height: 100%; padding: 0; background: rgba(5, 12, 22, .48); border: 0; }.mobile-menu { display: grid; }.topbar { padding: 0 20px; }.operator > span:last-child, .global-search kbd { display: none; }.global-search { width: min(460px, 55vw); }.mobile-nav { position: fixed; inset: auto 0 0; z-index: 22; height: 65px; display: grid; grid-template-columns: repeat(6, 1fr); padding-bottom: env(safe-area-inset-bottom); background: rgba(255,255,255,.98); border-top: 1px solid var(--line); }.mobile-nav a, .mobile-nav button { min-width: 0; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 4px; color: var(--muted); background: transparent; border: 0; text-decoration: none; font-size: .55rem; font-weight: 700; cursor: pointer; }.mobile-nav svg { width: 18px; height: 18px; }.mobile-nav a.active { color: var(--teal-dark); }.mobile-nav a.active::before { content: ""; position: absolute; top: 0; width: 28px; height: 2px; background: var(--teal); }.app-footer { padding-bottom: 65px; }.operations-grid, .secondary-grid { grid-template-columns: 1fr; }.integration-cards { grid-template-columns: 1fr; }.login-shell { grid-template-columns: 1fr; }.login-story { min-height: 44vh; padding: 28px 8vw; }.login-message { margin: auto 0; }.login-message h1 { font-size: clamp(2.5rem, 9vw, 4rem); }.login-message > p:last-child { margin-top: 15px; }.control-illustration { width: 55vw; opacity: .45; right: -10vw; top: -5vw; }.login-footnote { margin-top: 20px; }.login-access { min-height: 56vh; padding: 42px 8vw 60px; }
+  .app-shell { display: block; }.app-workspace { min-height: 100vh; }.sidebar { width: min(286px, 86vw); transform: translateX(-102%); transition: transform .22s ease; box-shadow: var(--shadow-float); }.sidebar.is-open { transform: none; }.nav-scrim { display: block; position: fixed; inset: 0; z-index: 25; width: 100%; height: 100%; padding: 0; background: rgba(5, 12, 22, .48); border: 0; }.mobile-menu { display: grid; }.topbar { padding: 0 20px; }.operator > span:last-child, .global-search kbd { display: none; }.topbar-meta > .language-switcher-compact { display: none; }.sidebar-language { display: block; }.global-search { width: min(460px, 55vw); }.mobile-nav { position: fixed; inset: auto 0 0; z-index: 22; height: 65px; display: grid; grid-template-columns: repeat(6, 1fr); padding-bottom: env(safe-area-inset-bottom); background: rgba(255,255,255,.98); border-top: 1px solid var(--line); }.mobile-nav a, .mobile-nav button { min-width: 0; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 4px; color: var(--muted); background: transparent; border: 0; text-decoration: none; font-size: .55rem; font-weight: 700; cursor: pointer; }.mobile-nav svg { width: 18px; height: 18px; }.mobile-nav a.active { color: var(--teal-dark); }.mobile-nav a.active::before { content: ""; position: absolute; top: 0; width: 28px; height: 2px; background: var(--teal); }.app-footer { padding-bottom: 65px; }.operations-grid, .secondary-grid { grid-template-columns: 1fr; }.integration-cards { grid-template-columns: 1fr; }.login-shell { grid-template-columns: 1fr; }.login-story { min-height: 44vh; padding: 28px 8vw; }.login-message { margin: auto 0; }.login-message h1 { font-size: clamp(2.5rem, 9vw, 4rem); }.login-message > p:last-child { margin-top: 15px; }.control-illustration { width: 55vw; opacity: .45; right: -10vw; top: -5vw; }.login-footnote { margin-top: 20px; }.login-access { min-height: 56vh; padding: 42px 8vw 60px; }
 }
 
 @media (max-width: 700px) {
-  #main-content { width: min(100% - 28px, 620px); padding: 24px 0 90px; }.topbar { height: 58px; padding: 0 14px; gap: 8px; }.global-search { flex: 1; width: auto; }.topbar-meta { gap: 3px; }.operator { padding-left: 7px; border: 0; }.demo-banner { min-height: 28px; padding-inline: 10px; font-size: .59rem; }.page-header { align-items: flex-start; margin-bottom: 20px; }.page-header h1 { font-size: 1.65rem; }.page-actions { display: none; }.page-description { font-size: .78rem; }.readiness-band { display: block; }.readiness-label { min-height: 62px; border-right: 0; border-bottom: 1px solid var(--line); }.readiness-metrics { grid-template-columns: repeat(5, minmax(66px, 1fr)); overflow-x: auto; }.metric-cell { min-width: 68px; padding: 12px 9px; }.metric-cell dd { font-size: 1.18rem; }.metric-cell dt { font-size: .53rem; }.section-heading { padding: 14px; }.section-heading > a { display: none; }.queue-controls { padding: 9px 14px; }.attention-list li { grid-template-columns: auto minmax(0,1fr) 14px; padding-inline: 14px; }.queue-ref { display: none; }.attention-detail { white-space: normal; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; }.movement-timeline { padding-inline: 14px; }.integration-list li, .recent-list li { padding-inline: 14px; }.recent-list time { display: none; }
+  #main-content { width: min(100% - 28px, 620px); padding: 24px 0 90px; }.topbar { height: 58px; padding: 0 14px; gap: 8px; }.global-search { flex: 1; width: auto; }.topbar-meta { gap: 3px; }.operator { padding-left: 7px; border: 0; }.demo-badge-trigger { height: 28px; padding: 0 9px; font-size: .6rem; }.demo-guide-trigger span:not(.demo-guide-progress-pill) { display: none; }.demo-guide-panel { top: auto; right: 0; bottom: 65px; left: 0; width: 100%; height: min(78vh, 640px); border-left: 0; border-top: 1px solid var(--line); border-radius: 14px 14px 0 0; transition: height .2s ease; }.demo-guide-panel.sheet-full { height: min(78vh, 640px); }.demo-guide-panel.sheet-half { height: min(42vh, 340px); }.demo-guide-panel.sheet-collapsed { height: auto; gap: 4px; padding-bottom: 12px; }.demo-guide-sheet-handle { width: 100%; display: flex; justify-content: center; padding: 4px 0 2px; background: transparent; border: 0; cursor: pointer; }.demo-guide-sheet-handle span { width: 36px; height: 4px; background: var(--line-strong); border-radius: 999px; }@media (prefers-reduced-motion: reduce) { .demo-guide-panel { transition: none; } }.demo-start-panel { flex-direction: column; align-items: flex-start; padding: 14px; }.demo-start-actions { width: 100%; }.demo-start-actions .button { flex: 1; min-width: 0; white-space: normal; text-align: center; }.page-header { align-items: flex-start; margin-bottom: 20px; }.page-header h1 { font-size: 1.65rem; }.page-actions { display: none; }.page-description { font-size: .78rem; }.readiness-band { display: block; }.readiness-label { min-height: 62px; border-right: 0; border-bottom: 1px solid var(--line); }.readiness-metrics { grid-template-columns: repeat(5, minmax(66px, 1fr)); overflow-x: auto; }.metric-cell { min-width: 68px; padding: 12px 9px; }.metric-cell dd { font-size: 1.18rem; }.metric-cell dt { font-size: .53rem; }.section-heading { padding: 14px; }.section-heading > a { display: none; }.queue-controls { padding: 9px 14px; }.attention-list li { grid-template-columns: auto minmax(0,1fr) 14px; padding-inline: 14px; }.queue-ref { display: none; }.attention-detail { white-space: normal; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; }.movement-timeline { padding-inline: 14px; }.integration-list li, .recent-list li { padding-inline: 14px; }.recent-list time { display: none; }
   .filters { display: grid; grid-template-columns: 1fr 1fr; padding: 12px; }.filters label:first-child { grid-column: 1 / -1; }.filters input[type="text"], .filters select { min-width: 0; width: 100%; }.checkbox-label { align-self: center; }
   .table-shell { overflow: visible; border: 0; background: transparent; }.table-meta { border: 1px solid var(--line); border-radius: var(--radius); margin-bottom: 9px; }.data-table, .data-table tbody { display: block; }.data-table thead { display: none; }.data-table tr { display: block; margin-bottom: 9px; padding: 7px 0; background: white; border: 1px solid var(--line); border-radius: var(--radius); }.data-table th, .data-table td { min-height: 34px; height: auto; display: grid; grid-template-columns: minmax(90px, .8fr) minmax(0, 1.3fr); align-items: center; gap: 10px; padding: 7px 12px; border: 0; text-align: right; font-size: .71rem; }.data-table th[scope="row"] { text-align: right; }.data-table th::before, .data-table td::before { content: attr(data-label); color: var(--muted); font-size: .57rem; font-weight: 700; text-align: left; text-transform: uppercase; letter-spacing: .06em; }.compare-table th, .compare-table td { text-align: left; }.pagination { justify-content: space-between; padding-inline: 0; border: 0; }
   .tabs { margin-inline: -2px; }.record-surface { padding: 10px; }.detail-grid { grid-template-columns: 1fr 1fr; }.detail-grid div { min-height: 70px; padding: 11px; }.return-progress { padding-inline: 12px; gap: 6px; }.return-progress b { width: 20px; }.return-progress span { font-size: .58rem; }.return-form > .section-heading { padding: 16px; }.return-capture, .return-review { padding: 16px; }.form-grid, .condition-fieldset, .review-facts { grid-template-columns: 1fr; }.condition-fieldset { display: grid; }.review-facts div { display: flex; justify-content: space-between; align-items: center; }.review-facts dd { margin: 0; }.form-actions { padding: 12px 16px; }.form-actions .button { flex: 1; }.duplicate-compare { padding: 14px; }.duplicate-compare fieldset label { display: flex !important; margin-bottom: 8px; }.integration-cards article { min-height: 140px; }.knowledge-input-row { align-items: stretch; }.knowledge-input-row .button { min-width: 72px; padding-inline: 10px; }.knowledge-empty { min-height: 250px; padding: 22px 16px; }.retrieval-flow { width: 100%; gap: 4px; }.retrieval-flow span { padding: 5px; font-size: .52rem; }.retrieval-flow i { flex: 1; min-width: 5px; }.login-story { min-height: 38vh; }.login-message > p:last-child { font-size: .8rem; }.control-illustration { display: none; }.login-access { min-height: 62vh; padding: 34px 20px 50px; }.login-options button { min-height: 72px; }.app-footer { display: none; }
 }
 
-@media (max-width: 420px) {
-  .global-search input::placeholder { color: transparent; }.global-search { max-width: 118px; }.topbar-meta { margin-left: auto; }.avatar { width: 29px; height: 29px; }.mobile-nav a span, .mobile-nav button span { max-width: 56px; overflow: hidden; text-overflow: ellipsis; }.filters { grid-template-columns: 1fr; }.filters label:first-child { grid-column: auto; }.detail-grid { grid-template-columns: 1fr; }.readiness-metrics { margin-right: -1px; }.badge { font-size: .55rem; }.page-header h1 { font-size: 1.5rem; }.login-message h1 { font-size: 2.6rem; }
+@media (max-width: 440px) {
+  .global-search input::placeholder { color: transparent; }.global-search { max-width: 118px; }.topbar-meta { margin-left: auto; }.demo-guide-trigger { display: none; }.avatar { width: 29px; height: 29px; }.mobile-nav a span, .mobile-nav button span { max-width: 56px; overflow: hidden; text-overflow: ellipsis; }.filters { grid-template-columns: 1fr; }.filters label:first-child { grid-column: auto; }.detail-grid { grid-template-columns: 1fr; }.readiness-metrics { margin-right: -1px; }.badge { font-size: .55rem; }.page-header h1 { font-size: 1.5rem; }.login-message h1 { font-size: 2.6rem; }
 }
diff --git a/knowledge/procedures/01-vehicle-checkout.md b/knowledge/procedures/en-GB/01-vehicle-checkout.md
similarity index 100%
rename from knowledge/procedures/01-vehicle-checkout.md
rename to knowledge/procedures/en-GB/01-vehicle-checkout.md
diff --git a/knowledge/procedures/02-vehicle-return.md b/knowledge/procedures/en-GB/02-vehicle-return.md
similarity index 100%
rename from knowledge/procedures/02-vehicle-return.md
rename to knowledge/procedures/en-GB/02-vehicle-return.md
diff --git a/knowledge/procedures/03-damage-handling.md b/knowledge/procedures/en-GB/03-damage-handling.md
similarity index 100%
rename from knowledge/procedures/03-damage-handling.md
rename to knowledge/procedures/en-GB/03-damage-handling.md
diff --git a/knowledge/procedures/04-odometer-anomalies.md b/knowledge/procedures/en-GB/04-odometer-anomalies.md
similarity index 100%
rename from knowledge/procedures/04-odometer-anomalies.md
rename to knowledge/procedures/en-GB/04-odometer-anomalies.md
diff --git a/knowledge/procedures/05-cleaning-checklist.md b/knowledge/procedures/en-GB/05-cleaning-checklist.md
similarity index 100%
rename from knowledge/procedures/05-cleaning-checklist.md
rename to knowledge/procedures/en-GB/05-cleaning-checklist.md
diff --git a/knowledge/procedures/06-maintenance-escalation.md b/knowledge/procedures/en-GB/06-maintenance-escalation.md
similarity index 100%
rename from knowledge/procedures/06-maintenance-escalation.md
rename to knowledge/procedures/en-GB/06-maintenance-escalation.md
diff --git a/knowledge/procedures/07-customer-documents.md b/knowledge/procedures/en-GB/07-customer-documents.md
similarity index 100%
rename from knowledge/procedures/07-customer-documents.md
rename to knowledge/procedures/en-GB/07-customer-documents.md
diff --git a/knowledge/procedures/08-privacy.md b/knowledge/procedures/en-GB/08-privacy.md
similarity index 100%
rename from knowledge/procedures/08-privacy.md
rename to knowledge/procedures/en-GB/08-privacy.md
diff --git a/knowledge/procedures/09-booking-conflicts.md b/knowledge/procedures/en-GB/09-booking-conflicts.md
similarity index 100%
rename from knowledge/procedures/09-booking-conflicts.md
rename to knowledge/procedures/en-GB/09-booking-conflicts.md
diff --git a/knowledge/procedures/10-roles-and-escalation.md b/knowledge/procedures/en-GB/10-roles-and-escalation.md
similarity index 100%
rename from knowledge/procedures/10-roles-and-escalation.md
rename to knowledge/procedures/en-GB/10-roles-and-escalation.md
diff --git a/knowledge/procedures/en-GB/11-vehicle-availability.md b/knowledge/procedures/en-GB/11-vehicle-availability.md
new file mode 100644
index 0000000..5b0c93c
--- /dev/null
+++ b/knowledge/procedures/en-GB/11-vehicle-availability.md
@@ -0,0 +1,21 @@
+---
+document_id: vehicle-availability-procedure
+title: Vehicle availability procedure
+version: "1.0"
+effective_date: 2026-07-01
+department: Rental Operations
+status: active
+---
+# Vehicle availability procedure
+
+## 1. Conditions
+
+A vehicle may be set to available only when no blocking condition remains: no open damage, no unresolved technical warning, no pending maintenance block and no open critical data-quality issue against the vehicle.
+
+## 2. Cleaning is not sufficient
+
+Completing the cleaning checklist alone does not make a vehicle available. Availability is derived from the combined state of cleaning, maintenance and data-quality checks, not from any single step.
+
+## 3. Confirmation
+
+An authorised employee confirms the final check and the vehicle status changes to available. The change is recorded in the audit trail with the checks that were confirmed clear.
diff --git a/knowledge/procedures/fr-BE/01-vehicle-checkout.md b/knowledge/procedures/fr-BE/01-vehicle-checkout.md
new file mode 100644
index 0000000..0935f6f
--- /dev/null
+++ b/knowledge/procedures/fr-BE/01-vehicle-checkout.md
@@ -0,0 +1,21 @@
+---
+document_id: vehicle-checkout-procedure
+title: Procédure de départ du véhicule
+version: "1.2"
+effective_date: 2026-06-01
+department: Opérations de location
+status: active
+---
+# Procédure de départ du véhicule
+
+## 1. Contrôles obligatoires
+
+Avant qu'un véhicule ne quitte le site, l'employé de location doit confirmer la réservation active, l'identité du client, le permis de conduire et les documents signés requis. Le kilométrage de départ enregistré ne peut pas être inférieur au kilométrage canonique actuel du véhicule.
+
+## 2. État du véhicule
+
+Effectuez l'inspection de départ, enregistrez le niveau de carburant et les dommages préexistants visibles, et confirmez qu'aucun problème bloquant d'entretien ou de qualité des données n'est ouvert.
+
+## 3. Mise à disposition
+
+Seul un véhicule ayant fait l'objet d'une inspection de départ approuvée peut être mis en location. En cas d'écart critique, le véhicule reste bloqué et le cas est transmis aux Opérations.
diff --git a/knowledge/procedures/fr-BE/02-vehicle-return.md b/knowledge/procedures/fr-BE/02-vehicle-return.md
new file mode 100644
index 0000000..e1731df
--- /dev/null
+++ b/knowledge/procedures/fr-BE/02-vehicle-return.md
@@ -0,0 +1,25 @@
+---
+document_id: vehicle-return-procedure
+title: Procédure de retour du véhicule
+version: "2.0"
+effective_date: 2026-07-01
+department: Opérations de location
+status: active
+---
+# Procédure de retour du véhicule
+
+## 1. Enregistrer le retour
+
+Ouvrez la réservation active et enregistrez le kilométrage final, le niveau de carburant, la propreté, les dommages visibles, les avertissements techniques et les notes pertinentes.
+
+## 2. Valider le relevé
+
+Un relevé de kilométrage inférieur au relevé canonique précédent ne doit jamais remplacer la valeur canonique. Enregistrez l'inspection, créez un problème de qualité des données et demandez une revue humaine.
+
+## 3. Déterminer l'état suivant
+
+Un dommage ou un avertissement technique impose un état bloqué. Un seuil d'entretien atteint impose un entretien. Sinon, le véhicule passe au nettoyage avant de pouvoir devenir disponible.
+
+## 4. Suivi
+
+L'automatisation du retour peut créer un suivi de nettoyage ou d'entretien, mais Fleet Ops reste la source de vérité pour l'état du véhicule.
diff --git a/knowledge/procedures/fr-BE/03-damage-handling.md b/knowledge/procedures/fr-BE/03-damage-handling.md
new file mode 100644
index 0000000..a524244
--- /dev/null
+++ b/knowledge/procedures/fr-BE/03-damage-handling.md
@@ -0,0 +1,21 @@
+---
+document_id: damage-procedure
+title: Procédure de gestion des dommages
+version: "1.3"
+effective_date: 2026-06-15
+department: Opérations
+status: active
+---
+# Procédure de gestion des dommages
+
+## 1. Actions immédiates
+
+Lorsqu'un véhicule revient avec des dommages visibles ou signalés, marquez le dommage dans l'inspection de retour, ajoutez une description factuelle concise et gardez le véhicule bloqué. Ne promettez pas au client un coût de réparation ou une décision de responsabilité.
+
+## 2. Preuves
+
+Enregistrez au moins quatre photographies dans le système d'inspection source : côté affecté en entier, gros plan, contexte plus large et plaque d'immatriculation. Fleet Ops ne peut stocker que la référence à cette preuve dans ce PoC.
+
+## 3. Escalade
+
+Créez une revue Opérations avant toute nouvelle location. Un véhicule avec un dommage non résolu ne peut pas être marqué disponible, même en présence d'une réservation future.
diff --git a/knowledge/procedures/fr-BE/04-odometer-anomalies.md b/knowledge/procedures/fr-BE/04-odometer-anomalies.md
new file mode 100644
index 0000000..d250d3d
--- /dev/null
+++ b/knowledge/procedures/fr-BE/04-odometer-anomalies.md
@@ -0,0 +1,21 @@
+---
+document_id: odometer-anomaly-guideline
+title: Directive sur les anomalies de kilométrage
+version: "1.1"
+effective_date: 2026-05-20
+department: Opérations
+status: active
+---
+# Directive sur les anomalies de kilométrage
+
+## 1. Relevé inférieur
+
+Si un nouveau relevé est inférieur au kilométrage canonique, conservez le relevé soumis comme preuve mais n'abaissez pas la valeur canonique. Vérifiez une inversion de chiffres, une sélection erronée du véhicule ou une erreur d'importation du système source.
+
+## 2. Résolution
+
+Un Operations Manager peut résoudre le problème après vérification de l'inspection d'origine. Ne corrigez que l'inspection erronée ou le mappage source ; ne réécrivez pas les relevés historiques valides.
+
+## 3. Seuil d'escalade
+
+Toute diminution inexpliquée ou une hausse unique de plus de 2 500 kilomètres au cours d'une même location nécessite une revue.
diff --git a/knowledge/procedures/fr-BE/05-cleaning-checklist.md b/knowledge/procedures/fr-BE/05-cleaning-checklist.md
new file mode 100644
index 0000000..fd390be
--- /dev/null
+++ b/knowledge/procedures/fr-BE/05-cleaning-checklist.md
@@ -0,0 +1,21 @@
+---
+document_id: cleaning-checklist
+title: Liste de contrôle de nettoyage du véhicule
+version: "1.4"
+effective_date: 2026-06-10
+department: Préparation de flotte
+status: active
+---
+# Liste de contrôle de nettoyage du véhicule
+
+## 1. Intérieur
+
+Retirez les déchets, inspectez les sellerie, nettoyez les surfaces de cuisine et sanitaires, et confirmez que la liste d'inventaire est complète.
+
+## 2. Extérieur
+
+Inspectez les vitres, les feux, les pneus et la carrosserie pendant le nettoyage. Signalez tout nouveau dommage constaté plutôt que de terminer la tâche silencieusement.
+
+## 3. Achèvement
+
+L'achèvement du nettoyage seul ne rend pas disponible un véhicule bloqué ou en entretien. Fleet Ops déduit la disponibilité de toutes les restrictions actives.
diff --git a/knowledge/procedures/fr-BE/06-maintenance-escalation.md b/knowledge/procedures/fr-BE/06-maintenance-escalation.md
new file mode 100644
index 0000000..205b5c6
--- /dev/null
+++ b/knowledge/procedures/fr-BE/06-maintenance-escalation.md
@@ -0,0 +1,21 @@
+---
+document_id: maintenance-escalation
+title: Procédure d'escalade d'entretien
+version: "1.1"
+effective_date: 2026-04-01
+department: Atelier
+status: active
+---
+# Procédure d'escalade d'entretien
+
+## 1. Déclencheurs
+
+Escaladez lorsqu'un avertissement technique est signalé, le seuil d'entretien est atteint, un défaut lié à la sécurité est observé ou un blocage d'entretien existant reste non résolu.
+
+## 2. État
+
+Définissez ou conservez l'état d'entretien. Une réservation future ne remplace pas une restriction d'entretien.
+
+## 3. Levée du blocage
+
+Seuls un enregistrement autorisé d'entretien terminé et l'absence d'autres problèmes bloquants permettent au véhicule de passer au nettoyage ou à la disponibilité.
diff --git a/knowledge/procedures/fr-BE/07-customer-documents.md b/knowledge/procedures/fr-BE/07-customer-documents.md
new file mode 100644
index 0000000..dfda656
--- /dev/null
+++ b/knowledge/procedures/fr-BE/07-customer-documents.md
@@ -0,0 +1,21 @@
+---
+document_id: customer-document-requirements
+title: Documents client requis
+version: "1.0"
+effective_date: 2026-07-01
+department: Opérations de location
+status: active
+---
+# Documents client requis
+
+## 1. Exigences au départ
+
+L'identité du client et un permis de conduire valide doivent être vérifiés dans le processus source avant le départ. Les documents contractuels requis doivent être signés.
+
+## 2. Minimisation des données
+
+Fleet Ops n'enregistre dans ce PoC que le statut d'achèvement et les références sources. Aucune image de document d'identité n'est stockée.
+
+## 3. Informations manquantes
+
+Une réservation dont les documents requis sont incomplets n'est pas prête pour le départ et doit apparaître comme point d'attention.
diff --git a/knowledge/procedures/fr-BE/08-privacy.md b/knowledge/procedures/fr-BE/08-privacy.md
new file mode 100644
index 0000000..0e17bc9
--- /dev/null
+++ b/knowledge/procedures/fr-BE/08-privacy.md
@@ -0,0 +1,21 @@
+---
+document_id: privacy-guideline
+title: Directive de confidentialité opérationnelle
+version: "1.0"
+effective_date: 2026-03-01
+department: Direction
+status: active
+---
+# Directive de confidentialité opérationnelle
+
+## 1. Accès minimal
+
+Les employés ne peuvent accéder qu'aux informations client et de réservation nécessaires à leur rôle. Les outils d'IA externes ne reçoivent aucun jeu de données client non restreint.
+
+## 2. Plateforme de connaissances
+
+N'intégrez pas de données personnelles de clients, de notes de réservation ou de documents d'identité dans la collection de connaissances des procédures. La collection se limite aux directives internes approuvées.
+
+## 3. Journalisation
+
+Consignez les métadonnées d'action et les références sources, mais évitez de copier des données personnelles inutiles dans les journaux techniques.
diff --git a/knowledge/procedures/fr-BE/09-booking-conflicts.md b/knowledge/procedures/fr-BE/09-booking-conflicts.md
new file mode 100644
index 0000000..8c6cffb
--- /dev/null
+++ b/knowledge/procedures/fr-BE/09-booking-conflicts.md
@@ -0,0 +1,21 @@
+---
+document_id: booking-conflict-procedure
+title: Procédure de conflit de réservation
+version: "1.2"
+effective_date: 2026-06-20
+department: Opérations
+status: active
+---
+# Procédure de conflit de réservation
+
+## 1. Détection
+
+Deux réservations réservées ou actives pour le même véhicule ne peuvent pas se chevaucher. Les conflits hérités importés doivent être signalés comme problème de qualité des données.
+
+## 2. Résolution
+
+Les Opérations examinent les deux réservations, confirment la propriété dans le système source et réattribuent ou annulent une réservation dans le système de réservation faisant autorité. Fleet Ops enregistre le résultat de la revue.
+
+## 3. Sécurité
+
+N'annulez jamais automatiquement une réservation client sur la seule base d'un conflit déduit.
diff --git a/knowledge/procedures/fr-BE/10-roles-and-escalation.md b/knowledge/procedures/fr-BE/10-roles-and-escalation.md
new file mode 100644
index 0000000..feb79e7
--- /dev/null
+++ b/knowledge/procedures/fr-BE/10-roles-and-escalation.md
@@ -0,0 +1,21 @@
+---
+document_id: roles-and-escalation
+title: Matrice des rôles et de l'escalade
+version: "1.0"
+effective_date: 2026-06-01
+department: Direction
+status: active
+---
+# Matrice des rôles et de l'escalade
+
+## Employé de location
+
+Peut consulter les enregistrements opérationnels assignés, réaliser les inspections de départ et de retour, et consulter les procédures. Ne peut pas fusionner des fiches client ni réinitialiser l'environnement de démonstration.
+
+## Operations Manager
+
+Peut examiner tous les points d'attention et problèmes de qualité des données, fusionner des clients en double confirmés, relancer la livraison d'automatisation et réinitialiser la démo synthétique.
+
+## Intégrations de service
+
+n8n, RAGcore et ITWorx MCP Hub utilisent des identités distinctes à portée limitée. Les identités de service n'héritent pas d'un rôle utilisateur interactif.
diff --git a/knowledge/procedures/fr-BE/11-vehicle-availability.md b/knowledge/procedures/fr-BE/11-vehicle-availability.md
new file mode 100644
index 0000000..59c001b
--- /dev/null
+++ b/knowledge/procedures/fr-BE/11-vehicle-availability.md
@@ -0,0 +1,21 @@
+---
+document_id: vehicle-availability-procedure
+title: Procédure de disponibilité du véhicule
+version: "1.0"
+effective_date: 2026-07-01
+department: Opérations de location
+status: active
+---
+# Procédure de disponibilité du véhicule
+
+## 1. Conditions
+
+Un véhicule ne peut être mis en disponible que si aucune condition bloquante ne subsiste : aucun dommage ouvert, aucun avertissement technique non résolu, aucun blocage d'entretien en cours et aucun problème critique de qualité des données ouvert sur le véhicule.
+
+## 2. Le nettoyage seul ne suffit pas
+
+L'achèvement de la liste de contrôle de nettoyage seul ne rend pas un véhicule disponible. La disponibilité est déduite de l'état combiné du nettoyage, de l'entretien et des contrôles de qualité des données, et non d'une seule étape.
+
+## 3. Confirmation
+
+Un employé autorisé confirme le contrôle final et le statut du véhicule passe à disponible. Le changement est enregistré dans la piste d'audit avec les contrôles confirmés comme conformes.
diff --git a/knowledge/procedures/nl-BE/01-vehicle-checkout.md b/knowledge/procedures/nl-BE/01-vehicle-checkout.md
new file mode 100644
index 0000000..1ae3051
--- /dev/null
+++ b/knowledge/procedures/nl-BE/01-vehicle-checkout.md
@@ -0,0 +1,21 @@
+---
+document_id: vehicle-checkout-procedure
+title: Procedure voertuigvertrek
+version: "1.2"
+effective_date: 2026-06-01
+department: Verhuuroperaties
+status: active
+---
+# Procedure voertuigvertrek
+
+## 1. Verplichte controles
+
+Voordat een voertuig de site verlaat, moet de verhuurmedewerker de actieve boeking, de identiteit van de klant, het rijbewijs en de vereiste ondertekende documenten bevestigen. De geregistreerde startkilometerstand mag niet lager zijn dan de huidige laatst bevestigde kilometerstand van het voertuig.
+
+## 2. Staat van het voertuig
+
+Voer de vertrekinspectie uit, registreer het brandstofniveau en zichtbare bestaande schade, en bevestig dat er geen blokkerend onderhouds- of datakwaliteitsprobleem openstaat.
+
+## 3. Vrijgave
+
+Alleen een voertuig met een goedgekeurde vertrekinspectie mag op verhuurd gezet worden. Bij een kritieke afwijking blijft het voertuig geblokkeerd en wordt dit geëscaleerd naar Operations.
diff --git a/knowledge/procedures/nl-BE/02-vehicle-return.md b/knowledge/procedures/nl-BE/02-vehicle-return.md
new file mode 100644
index 0000000..ea5da8b
--- /dev/null
+++ b/knowledge/procedures/nl-BE/02-vehicle-return.md
@@ -0,0 +1,25 @@
+---
+document_id: vehicle-return-procedure
+title: Procedure voertuigretour
+version: "2.0"
+effective_date: 2026-07-01
+department: Verhuuroperaties
+status: active
+---
+# Procedure voertuigretour
+
+## 1. Retour registreren
+
+Open de actieve boeking en registreer de eindkilometerstand, het brandstofniveau, de netheid, zichtbare schade, technische waarschuwingen en relevante notities.
+
+## 2. Meting valideren
+
+Een ingevoerde kilometerstand die lager is dan de vorige laatst bevestigde stand mag nooit de laatst bevestigde waarde vervangen. Registreer de inspectie, maak een datakwaliteitsprobleem aan en vraag een menselijke beoordeling.
+
+## 3. Volgende status bepalen
+
+Schade of een technische waarschuwing vereist een geblokkeerde status. Een bereikte onderhoudsdrempel vereist onderhoud. Anders gaat het voertuig naar reiniging voordat het beschikbaar kan worden.
+
+## 4. Opvolging
+
+De retourautomatisering kan een reinigings- of onderhoudsopvolging aanmaken, maar Fleet Ops blijft de bron van waarheid voor de voertuigstatus.
diff --git a/knowledge/procedures/nl-BE/03-damage-handling.md b/knowledge/procedures/nl-BE/03-damage-handling.md
new file mode 100644
index 0000000..6e5e87c
--- /dev/null
+++ b/knowledge/procedures/nl-BE/03-damage-handling.md
@@ -0,0 +1,21 @@
+---
+document_id: damage-procedure
+title: Procedure schadeafhandeling
+version: "1.3"
+effective_date: 2026-06-15
+department: Operations
+status: active
+---
+# Procedure schadeafhandeling
+
+## 1. Directe acties
+
+Wanneer een voertuig terugkomt met zichtbare of gemelde schade, markeer de schade in de retourinspectie, voeg een beknopte feitelijke beschrijving toe en houd het voertuig geblokkeerd. Beloof de klant geen herstelkost of aansprakelijkheidsbeslissing.
+
+## 2. Bewijs
+
+Registreer minstens vier foto's in het bron-inspectiesysteem: volledige aangetaste zijde, close-up, ruimere context en kentekenplaat. Fleet Ops mag in deze PoC enkel de verwijzing naar dat bewijs opslaan.
+
+## 3. Escalatie
+
+Maak een Operations-beoordeling aan vóór elke nieuwe verhuur. Een voertuig met onopgeloste schade mag niet als beschikbaar gemarkeerd worden, zelfs niet bij een toekomstige boeking.
diff --git a/knowledge/procedures/nl-BE/04-odometer-anomalies.md b/knowledge/procedures/nl-BE/04-odometer-anomalies.md
new file mode 100644
index 0000000..10a0da7
--- /dev/null
+++ b/knowledge/procedures/nl-BE/04-odometer-anomalies.md
@@ -0,0 +1,21 @@
+---
+document_id: odometer-anomaly-guideline
+title: Richtlijn kilometerstandafwijkingen
+version: "1.1"
+effective_date: 2026-05-20
+department: Operations
+status: active
+---
+# Richtlijn kilometerstandafwijkingen
+
+## 1. Lagere meting
+
+Als een nieuwe meting lager is dan de laatst bevestigde kilometerstand, bewaar de ingevoerde meting als bewijs maar verlaag de laatst bevestigde waarde niet. Controleer op cijferverwisseling, verkeerde voertuigselectie of een importfout uit het bronsysteem.
+
+## 2. Oplossing
+
+Een Operations Manager mag het probleem oplossen na controle van de oorspronkelijke inspectie. Corrigeer enkel de foutieve inspectie of bronkoppeling; herschrijf geen geldige historische metingen.
+
+## 3. Escalatiedrempel
+
+Elke onverklaarde daling of een enkele stijging van meer dan 2.500 kilometer tijdens één verhuur vereist beoordeling.
diff --git a/knowledge/procedures/nl-BE/05-cleaning-checklist.md b/knowledge/procedures/nl-BE/05-cleaning-checklist.md
new file mode 100644
index 0000000..0dd4330
--- /dev/null
+++ b/knowledge/procedures/nl-BE/05-cleaning-checklist.md
@@ -0,0 +1,21 @@
+---
+document_id: cleaning-checklist
+title: Reinigingschecklist voertuig
+version: "1.4"
+effective_date: 2026-06-10
+department: Wagenparkvoorbereiding
+status: active
+---
+# Reinigingschecklist voertuig
+
+## 1. Interieur
+
+Verwijder afval, inspecteer de bekleding, reinig keuken- en sanitaire oppervlakken en bevestig dat de inventarischecklist volledig is.
+
+## 2. Exterieur
+
+Inspecteer ramen, verlichting, banden en carrosserie tijdens het reinigen. Meld nieuw vastgestelde schade in plaats van de taak stilzwijgend af te ronden.
+
+## 3. Afronding
+
+Het voltooien van de reiniging alleen maakt een geblokkeerd of onderhoudsvoertuig niet beschikbaar. Fleet Ops leidt de beschikbaarheid af uit alle actieve beperkingen.
diff --git a/knowledge/procedures/nl-BE/06-maintenance-escalation.md b/knowledge/procedures/nl-BE/06-maintenance-escalation.md
new file mode 100644
index 0000000..4fb8e44
--- /dev/null
+++ b/knowledge/procedures/nl-BE/06-maintenance-escalation.md
@@ -0,0 +1,21 @@
+---
+document_id: maintenance-escalation
+title: Procedure onderhoudsescalatie
+version: "1.1"
+effective_date: 2026-04-01
+department: Werkplaats
+status: active
+---
+# Procedure onderhoudsescalatie
+
+## 1. Aanleidingen
+
+Escaleer wanneer een technische waarschuwing gemeld wordt, de onderhoudsdrempel bereikt is, een veiligheidsgerelateerd gebrek wordt vastgesteld of een bestaande onderhoudsblokkering onopgelost blijft.
+
+## 2. Status
+
+Stel de onderhoudsstatus in of behoud deze. Een toekomstige boeking overschrijft een onderhoudsbeperking niet.
+
+## 3. Vrijgave
+
+Enkel een geautoriseerde registratie van voltooid onderhoud en de afwezigheid van andere blokkerende problemen laten het voertuig toe tot reiniging of beschikbaarheid.
diff --git a/knowledge/procedures/nl-BE/07-customer-documents.md b/knowledge/procedures/nl-BE/07-customer-documents.md
new file mode 100644
index 0000000..ffc2865
--- /dev/null
+++ b/knowledge/procedures/nl-BE/07-customer-documents.md
@@ -0,0 +1,21 @@
+---
+document_id: customer-document-requirements
+title: Vereiste klantdocumenten
+version: "1.0"
+effective_date: 2026-07-01
+department: Verhuuroperaties
+status: active
+---
+# Vereiste klantdocumenten
+
+## 1. Vereisten bij vertrek
+
+De identiteit van de klant en een geldig rijbewijs moeten geverifieerd zijn in het bronproces vóór vertrek. Vereiste contractuele documenten moeten ondertekend zijn.
+
+## 2. Dataminimalisatie
+
+Fleet Ops registreert in deze PoC enkel de afhandelingsstatus en bronverwijzingen. Er worden geen afbeeldingen van identiteitsdocumenten opgeslagen.
+
+## 3. Ontbrekende informatie
+
+Een boeking met onvolledige verplichte documenten is niet klaar voor vertrek en moet als aandachtspunt verschijnen.
diff --git a/knowledge/procedures/nl-BE/08-privacy.md b/knowledge/procedures/nl-BE/08-privacy.md
new file mode 100644
index 0000000..fb82ee7
--- /dev/null
+++ b/knowledge/procedures/nl-BE/08-privacy.md
@@ -0,0 +1,21 @@
+---
+document_id: privacy-guideline
+title: Operationele privacyrichtlijn
+version: "1.0"
+effective_date: 2026-03-01
+department: Management
+status: active
+---
+# Operationele privacyrichtlijn
+
+## 1. Minimale toegang
+
+Medewerkers mogen enkel de klant- en boekingsinformatie raadplegen die nodig is voor hun rol. Externe AI-tools krijgen geen ongelimiteerde klantdataset.
+
+## 2. Kennisplatform
+
+Voeg geen persoonsgegevens van klanten, boekingsnotities of identiteitsdocumenten toe aan de kennisverzameling van procedures. De verzameling is beperkt tot goedgekeurde interne richtlijnen.
+
+## 3. Logging
+
+Registreer actiemetadata en bronverwijzingen, maar vermijd onnodige persoonsgegevens te kopiëren naar technische logs.
diff --git a/knowledge/procedures/nl-BE/09-booking-conflicts.md b/knowledge/procedures/nl-BE/09-booking-conflicts.md
new file mode 100644
index 0000000..c98b116
--- /dev/null
+++ b/knowledge/procedures/nl-BE/09-booking-conflicts.md
@@ -0,0 +1,21 @@
+---
+document_id: booking-conflict-procedure
+title: Procedure boekingsconflicten
+version: "1.2"
+effective_date: 2026-06-20
+department: Operations
+status: active
+---
+# Procedure boekingsconflicten
+
+## 1. Detectie
+
+Twee gereserveerde of actieve boekingen voor hetzelfde voertuig mogen niet overlappen. Geïmporteerde historische conflicten moeten gemarkeerd worden als datakwaliteitsprobleem.
+
+## 2. Oplossing
+
+Operations beoordeelt beide boekingen, bevestigt het eigenaarschap in het bronsysteem en wijst één boeking opnieuw toe of annuleert deze in het gezaghebbende boekingssysteem. Fleet Ops registreert het beoordeelde resultaat.
+
+## 3. Veiligheid
+
+Annuleer een klantboeking nooit automatisch enkel op basis van een afgeleid conflict.
diff --git a/knowledge/procedures/nl-BE/10-roles-and-escalation.md b/knowledge/procedures/nl-BE/10-roles-and-escalation.md
new file mode 100644
index 0000000..b73715f
--- /dev/null
+++ b/knowledge/procedures/nl-BE/10-roles-and-escalation.md
@@ -0,0 +1,21 @@
+---
+document_id: roles-and-escalation
+title: Rollen- en escalatiematrix
+version: "1.0"
+effective_date: 2026-06-01
+department: Management
+status: active
+---
+# Rollen- en escalatiematrix
+
+## Verhuurmedewerker
+
+Mag toegewezen operationele records bekijken, vertrek- en retourinspecties uitvoeren en procedures raadplegen. Mag geen klantrecords samenvoegen of de demo-omgeving herstellen.
+
+## Operations Manager
+
+Mag alle aandachtspunten en datakwaliteitsproblemen beoordelen, bevestigde dubbele klanten samenvoegen, aflevering van automatisering opnieuw proberen en de synthetische demo herstellen.
+
+## Service-integraties
+
+n8n, RAGcore en ITWorx MCP Hub gebruiken afzonderlijke, beperkte identiteiten. Service-identiteiten erven geen interactieve gebruikersrol.
diff --git a/knowledge/procedures/nl-BE/11-vehicle-availability.md b/knowledge/procedures/nl-BE/11-vehicle-availability.md
new file mode 100644
index 0000000..68f442c
--- /dev/null
+++ b/knowledge/procedures/nl-BE/11-vehicle-availability.md
@@ -0,0 +1,21 @@
+---
+document_id: vehicle-availability-procedure
+title: Procedure voertuigbeschikbaarheid
+version: "1.0"
+effective_date: 2026-07-01
+department: Verhuuroperaties
+status: active
+---
+# Procedure voertuigbeschikbaarheid
+
+## 1. Voorwaarden
+
+Een voertuig mag enkel op beschikbaar gezet worden als er geen blokkerende voorwaarde meer geldt: geen openstaande schade, geen onopgeloste technische waarschuwing, geen lopende onderhoudsblokkering en geen open kritiek datakwaliteitsprobleem voor het voertuig.
+
+## 2. Reiniging alleen is niet voldoende
+
+Het voltooien van de reinigingschecklist alleen maakt een voertuig niet beschikbaar. Beschikbaarheid wordt afgeleid uit de gecombineerde status van reiniging, onderhoud en datakwaliteitscontroles, niet uit één enkele stap.
+
+## 3. Bevestiging
+
+Een geautoriseerde medewerker bevestigt de laatste controle en de voertuigstatus verandert naar beschikbaar. De wijziging wordt geregistreerd in het audittraject samen met de controles die als correct bevestigd zijn.