diff --git a/PROJECT_STATE.md b/PROJECT_STATE.md
index 634a9d2..1e9420c 100644
--- a/PROJECT_STATE.md
+++ b/PROJECT_STATE.md
@@ -872,3 +872,119 @@ scenarios, demo manifest, About page). Gap audit: `docs/demo-release/current-dem
   test results, clean-checkout result, deployment evidence for both the feature branch
   and master, responsive/accessibility results, known limitations, rollback procedure)
   plus 10 screenshots in `artifacts/fleet-ops-release/screenshots/`.
+
+## Fleet Ops correction: safe status-recommendation flow, MO-016, message codes (2026-08-03) — IN PROGRESS on fix/fleet-ops-i18n-status-flow
+
+Branch `fix/fleet-ops-i18n-status-flow`, created from master's post-release head
+(`18344bc`). Audit and rationale in `docs/fleet-ops-correction/` (gap audit, i18n
+inventory, vehicle-status decision table). Not yet merged to master.
+
+- **Status-recommendation flow redesigned** per the brief: the old single opaque
+  "calculate and apply recommended status" action is replaced by a single shared, pure
+  evaluator (`backend/app/services/vehicle_status.py::evaluate_vehicle_status`) used
+  identically by the scanner, a new non-mutating preview endpoint
+  (`POST .../status-recommendation`), and a transactional apply endpoint
+  (`POST .../apply-recommended-status`) that locks the row, recomputes facts, rejects a
+  stale `recommendation_token` (optimistic concurrency), refuses unsafe/manual-review
+  recommendations, and re-validates post-write before resolving the issue. Frontend
+  `DataQualityIssueDetail.tsx` shows "Review recommendation" → a decision panel
+  (current/recommended status, why, evidence, consequences, localized in all 3
+  languages) → an exact "Change status to <status>" confirm action → result, with a
+  distinct "Manual review required" state offering no generic apply button.
+- Fixed the real unsafe shortcut this evaluator exists to eliminate: "maintenance +
+  active booking" no longer auto-recommends "rented" (current status is itself now a
+  blocking fact), and "maintenance with nothing else wrong" no longer auto-clears to
+  "available" (no fact proves maintenance is actually finished — that release stays a
+  manual decision).
+- **MO-016 order independence**: order independence does not mean "same final status
+  regardless of order" — resolving the booking overlap first genuinely removes the
+  conflict, correctly leaving nothing to apply. What must (and does) hold either way:
+  the recommendation always reflects real current facts, and nothing unsafe is ever
+  applied (never "rented"). Verified by both a backend test
+  (`test_mo_016_status_conflict_recommendation_is_order_independent`, explicitly scoped
+  to MO-016/DQ-DEMO-STATUS after finding the original version wasn't) and a browser-level
+  Playwright test in both orders.
+- **"Fleet Ops" is a non-localizable brand constant** (`frontend/src/product.ts`,
+  backend `PRODUCT_NAME`), wired via `{{productName}}` interpolation everywhere the
+  brand appeared in locale prose; a permanent test fails the build if any locale file
+  ever defines the brand name or an `appName` key again.
+- **Dynamic backend prose converted to message codes + params**: return status reasons,
+  audit field/actor-type labels, automation `last_error` (new `last_error_code` column,
+  migration `799d8800e241`), and search results (sections/vehicles/bookings/issues) all
+  now carry stable codes the frontend localizes; raw technical text is demoted to a
+  "Technical details" disclosure everywhere.
+- **Knowledge-base fixes**: the demo provider's tokenizer silently dropped accented
+  characters (`[a-z0-9]+` split "véhicule" into "v"+"hicule"), breaking French
+  retrieval broadly; fixed to include the Latin-1 accented range. Also reweighted
+  section scoring so a body match (real substance) outranks a heading/title match (a
+  shallow structural hint) — the old weighting misranked the damage procedure behind
+  an unrelated document for the brief's exact validation question in all 3 languages.
+  Removed leftover "MobilityOps"/"PoC" mentions from 9 procedure documents (knowledge
+  prose is visible content, missed by the earlier rebrand).
+- New `frontend/e2e/fleet-ops-correction.spec.ts` (14 tests) covers branding in 3
+  languages, language persistence, the full status-recommendation flow (non-mutating
+  preview, exact confirm text, manual review, stale-token rejection), MO-016 order
+  independence, trilingual knowledge grounding, and localized audit/automation. Writing
+  it surfaced and fixed two real bugs: the frontend conflated "no conflict" with
+  "manual review required" (both carry `safe_to_apply: false`), and the original
+  MO-016 backend test never actually targeted MO-016's own issue.
+- Added a keyboard/reduced-motion/no-color-only-status accessibility test for the new
+  status-decision panel; added `aria-live="polite"` to the panel so the applied
+  confirmation is announced.
+- `contracts/openapi.yaml` and `README.md` updated: title is "Fleet Ops", the new
+  status-recommendation endpoint documented, apply-recommended-status's request body
+  and error codes documented, search endpoint's code+params shape documented, README
+  states the Fleet Ops/MobilityOps naming split explicitly and refreshes stale test
+  counts (151 backend, 108 Playwright).
+- Gates green: 151 backend tests, Ruff, mypy, Alembic upgrade/downgrade verified,
+  frontend `tsc`/build, full 113-test Playwright suite (rebuilt `api`+`web` containers
+  each time before testing).
+- Section 11D/E/F of the i18n test-strengthening brief done: a hardcoded-JSX-text
+  static check (`i18n-coverage.spec.ts`; had to anchor on backreferenced closing-tag
+  names — a naive `>text<` scan misread TypeScript generics like
+  `useState<string | null>` as JSX spanning to the next unrelated `>`; verified against
+  both false positives and a deliberately-injected-then-reverted false negative), and a
+  3-language route matrix (`fleet-ops-correction.spec.ts`) covering every main route:
+  no console errors, correct `html[lang]`, real page headings.
+- **Clean-checkout drill (2026-08-03) — PASS.** Fresh `git clone --branch
+  fix/fleet-ops-i18n-status-flow` of only committed files into an isolated directory,
+  separate Compose project name and host ports (8129/1229/5679) so the working dev
+  stack was never touched. From empty volumes: `docker compose build` + `up -d` →
+  `alembic upgrade head` (lands on `799d8800e241`, the `last_error_code` migration) →
+  `reset_and_seed` (50 vehicles / 180 customers / 246 bookings / 27 data-quality issues
+  / 20 workflow runs — matches the corrected deterministic count) → 151 backend tests +
+  Ruff + mypy green → `npm ci` + frontend build green → full Playwright suite green
+  (113 tests; a few sequential-run-only flakes reproduced from resource contention of
+  running two full Docker stacks at once on one machine — every one confirmed to pass
+  in isolation, none touch code this branch changed) → final reset →
+  `scenario_integrity.all_ready: true`. Isolated stack, containers, volumes and images
+  torn down afterward; original dev environment confirmed untouched and reset to
+  baseline.
+- **Unraid deployment (2026-08-03/04) — PASS.** Pushed `fix/fleet-ops-i18n-status-flow`
+  to origin, deployed via `git archive` → `scp` → extract into
+  `/mnt/user/appdata/mobilityops` (preserving `.env`) → `.deploy/source-revision` →
+  rebuild `api`+`web` → `alembic upgrade head` → reset/reseed, at
+  `http://192.168.10.150:1236`. **Live validation directly caught a real bug**: every
+  data-quality issue's top-of-page evidence summary was unconditionally showing raw
+  English (e.g. "vehicle marked available while reserved bookings conflict") in all
+  three languages, because the frontend never finished the evidence.signals
+  localization the backend had already been emitting. Fixed (commit `2e4fb43`):
+  DataQualityIssueDetail.tsx now renders `evidence.signals` through the operator's
+  locale as the primary text, raw text moved to "Technical details" only, the 4
+  DQ-DEMO-* seed rows got real computed signals (the duplicate-customer similarity
+  score is the actual SequenceMatcher ratio on the seeded names), and a regression
+  test locks this in. Redeployed with the fix; live-verified via `read_page` that
+  DQ-DEMO-STATUS now shows "Dit voertuig heeft twee overlappende reserveringen..."
+  instead of the raw English sentence. Full 116-test Playwright suite green against
+  the live server (`MOBILITYOPS_PUBLIC_URL=http://192.168.10.150:1236`), no console
+  errors, no errors in `api`/`web` container logs, both containers healthy, final
+  reset done, `scenario_integrity.all_ready: true`.
+- **Not yet done**: the final merge to master with
+  `artifacts/fleet-ops-correction/final-summary.md` evidence. Do not claim PASS on
+  this correction until that's done.
+- Commits so far on this branch: `6deb955` (status flow + brand constant + message
+  codes), `e6539d1` (knowledge fixes), `ac4b163` (Playwright spec updates for the new
+  flow), `1fdd2b3` (new E2E coverage + 2 bug fixes), `1e40775` (accessibility test),
+  `a7ac5ed` (docs), `7851e80` (11D/11F i18n tests), `cda2c32` (clean-checkout
+  evidence), `2e4fb43` (evidence-summary localization fix, found live on Unraid).
+  Deployed commit: `2e4fb43f093bfbdb04c4f74eed1e6c6d9a03c069`.
diff --git a/README.md b/README.md
index 0a1b3cc..0c1a8c9 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,15 @@
-# MobilityOps
+# Fleet Ops
 
 **Connected operations for vehicle rental and service teams.**
 
-MobilityOps is a working proof of concept for a fictitious mobility company. It combines vehicle and booking operations, a controlled vehicle-return workflow, data-quality review, RAGcore-backed internal knowledge, n8n orchestration and read-only tools published through ITWorx MCP Hub.
+Fleet Ops is a working proof of concept for a fictitious mobility company. It combines vehicle and booking operations, a controlled vehicle-return workflow, data-quality review, RAGcore-backed internal knowledge, n8n orchestration and read-only tools published through ITWorx MCP Hub.
+
+**Naming:** "Fleet Ops" is the product's visible name everywhere in the UI, the demo
+knowledge base, and this documentation. "MobilityOps" remains the technical
+identifier only — the repository name, local directory, package/module names, Docker
+Compose project, deployment directory, and database names. The UI is fully trilingual
+(nl-BE default, en-GB, fr-BE); see `docs/fleet-ops-correction/` for the localization
+architecture, the vehicle-status decision table, and the correction evidence.
 
 The web application uses the premium responsive **Control Rail** interface: a compact
 operations-first workspace with persisted readiness metrics, evidence-led exceptions,
@@ -114,9 +121,9 @@ All defaults are configurable via `.env` (see `.env.example`).
 ## Quality gates
 
 ```bash
-make test    # backend: pytest (127 tests)
+make test    # backend: pytest (151 tests)
 make lint    # backend: ruff + mypy (strict, zero errors)
-make e2e     # frontend: Playwright end-to-end (56 tests, live stack required)
+make e2e     # frontend: Playwright end-to-end (113 tests, live stack required)
 ```
 
 Frontend build/typecheck: `cd frontend && npm run build` (`tsc -b && vite build`).
diff --git a/backend/alembic/versions/799d8800e241_outbox_last_error_code.py b/backend/alembic/versions/799d8800e241_outbox_last_error_code.py
new file mode 100644
index 0000000..755e05b
--- /dev/null
+++ b/backend/alembic/versions/799d8800e241_outbox_last_error_code.py
@@ -0,0 +1,25 @@
+"""outbox last_error_code
+
+Revision ID: 799d8800e241
+Revises: e7b08389f47f
+Create Date: 2026-08-03 10:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = '799d8800e241'
+down_revision: Union[str, None] = 'e7b08389f47f'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column('outbox_events', sa.Column('last_error_code', sa.String(length=60), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column('outbox_events', 'last_error_code')
diff --git a/backend/app/api/routers/bookings.py b/backend/app/api/routers/bookings.py
index 1dae99f..68afa27 100644
--- a/backend/app/api/routers/bookings.py
+++ b/backend/app/api/routers/bookings.py
@@ -89,6 +89,8 @@ def preview_return(
         resulting_odometer_km=evaluation.resulting_odometer_km,
         resulting_vehicle_status=evaluation.resulting_vehicle_status,
         status_reason=evaluation.status_reason,
+        status_reason_code=evaluation.status_reason_code,
+        status_reason_params=evaluation.status_reason_params,
         would_create_quality_issue=evaluation.would_create_quality_issue,
         attention_reasons=evaluation.attention_reasons,
         next_booking_risk=(
diff --git a/backend/app/api/routers/dashboard.py b/backend/app/api/routers/dashboard.py
index 3385bec..15039c8 100644
--- a/backend/app/api/routers/dashboard.py
+++ b/backend/app/api/routers/dashboard.py
@@ -108,6 +108,7 @@ def get_dashboard(
             status=r.delivery_status,
             attempts=r.attempts,
             last_error=r.last_error,
+            last_error_code=r.last_error_code,
             occurred_at=r.occurred_at,
         )
         for r in recent
diff --git a/backend/app/api/routers/data_quality.py b/backend/app/api/routers/data_quality.py
index 52f3d8c..2daeed3 100644
--- a/backend/app/api/routers/data_quality.py
+++ b/backend/app/api/routers/data_quality.py
@@ -11,6 +11,7 @@ from app.models.data_quality import DataQualityIssue
 from app.models.inspection import Inspection
 from app.models.vehicle import Vehicle
 from app.schemas import (
+    ApplyRecommendedStatusRequest,
     ApplyRecommendedStatusResult,
     CurrentUser,
     DataQualityIssueDetailOut,
@@ -21,11 +22,14 @@ from app.schemas import (
     ResolveOdometerRegressionRequest,
     ResolveOverlapRequest,
     ScanResultOut,
+    StatusRecommendationOut,
+    VehicleStatusFactsOut,
 )
 from app.services.data_quality import (
     apply_recommended_status,
     defer_issue,
     merge_customers,
+    preview_vehicle_status_recommendation,
     provide_missing_fields,
     reject_issue,
     resolve_booking_overlap,
@@ -241,17 +245,43 @@ def resolve_overlap(
     return _to_out(issue)
 
 
+@router.post(
+    "/issues/{public_ref}/status-recommendation", response_model=StatusRecommendationOut
+)
+def status_recommendation(
+    public_ref: str,
+    db: Session = Depends(get_db),
+    user: CurrentUser = Depends(require_operations_manager),
+) -> StatusRecommendationOut:
+    """Non-mutating preview: computes the recommendation without changing anything,
+    resolving no issue and writing no audit event. Safe to call repeatedly."""
+    _issue, _vehicle, recommendation, token = preview_vehicle_status_recommendation(db, public_ref)
+    return StatusRecommendationOut(
+        current_status=recommendation.current_status,
+        recommended_status=recommendation.recommended_status,
+        recommendation_code=recommendation.recommendation_code,
+        safe_to_apply=recommendation.safe_to_apply,
+        manual_review_required=recommendation.manual_review_required,
+        facts=VehicleStatusFactsOut(**recommendation.facts.as_dict()),
+        blocking_reasons=recommendation.blocking_reasons,
+        recommendation_token=token,
+    )
+
+
 @router.post(
     "/issues/{public_ref}/apply-recommended-status", response_model=ApplyRecommendedStatusResult
 )
 def apply_status(
     public_ref: str,
+    body: ApplyRecommendedStatusRequest,
     db: Session = Depends(get_db),
     user: CurrentUser = Depends(require_operations_manager),
 ) -> ApplyRecommendedStatusResult:
-    issue, applied_status, reason = apply_recommended_status(db, public_ref, user)
+    issue, applied_status, reason_code = apply_recommended_status(
+        db, public_ref, user, body.recommendation_token
+    )
     return ApplyRecommendedStatusResult(
-        issue=_to_out(issue), applied_status=applied_status, reason=reason
+        issue=_to_out(issue), applied_status=applied_status, reason_code=reason_code
     )
 
 
diff --git a/backend/app/api/routers/search.py b/backend/app/api/routers/search.py
index c0b2287..f8aaa52 100644
--- a/backend/app/api/routers/search.py
+++ b/backend/app/api/routers/search.py
@@ -12,53 +12,81 @@ from app.schemas import CurrentUser, SearchResponse, SearchResultItem
 
 router = APIRouter(prefix="/api/v1/search", tags=["search"])
 
-# Static application sections. Manager-only sections are filtered by role, mirroring the
-# same nav visibility rule Layout.tsx applies -- search must never surface a destination
-# the current role can't actually reach.
+# Static application sections. `id` is a stable code matching navigation.json's
+# `items.*` keys -- the frontend localizes both the section label and its one-line
+# detail from `id`, so no English prose is sent over the wire (search.sections.<id> in
+# every locale; see docs/fleet-ops-correction/i18n-inventory.md). Manager-only sections
+# are filtered by role, mirroring the same nav visibility rule Layout.tsx applies --
+# search must never surface a destination the current role can't actually reach.
 _SECTIONS: list[dict] = [
     {
-        "label": "Overview",
-        "detail": "Operations dashboard",
+        "id": "overview",
         "link": "/dashboard",
-        "terms": ["overview", "dashboard", "readiness"],
+        # Search terms deliberately span all three supported UI languages (not just
+        # English) so a query never depends on the operator's selected locale.
+        "terms": ["overview", "dashboard", "readiness", "overzicht", "aperçu", "tableau de bord"],
     },
     {
-        "label": "Fleet",
-        "detail": "Vehicle registry",
+        "id": "fleet",
         "link": "/vehicles",
-        "terms": ["fleet", "vehicle", "vehicles"],
+        "terms": ["fleet", "vehicle", "vehicles", "wagenpark", "voertuig", "flotte", "véhicule"],
     },
     {
-        "label": "Bookings",
-        "detail": "Rental bookings",
+        "id": "bookings",
         "link": "/bookings",
-        "terms": ["booking", "bookings", "rental"],
+        "terms": [
+            "booking",
+            "bookings",
+            "rental",
+            "boeking",
+            "boekingen",
+            "verhuur",
+            "réservation",
+            "réservations",
+            "location",
+        ],
     },
     {
-        "label": "Data quality",
-        "detail": "Quality workbench",
+        "id": "quality",
         "link": "/data-quality",
-        "terms": ["quality", "data quality", "issues"],
+        "terms": [
+            "quality",
+            "data quality",
+            "issues",
+            "kwaliteit",
+            "datakwaliteit",
+            "problemen",
+            "qualité",
+            "problèmes",
+        ],
         "role": "operations_manager",
     },
     {
-        "label": "Knowledge",
-        "detail": "Procedure assistant",
+        "id": "knowledge",
         "link": "/knowledge",
-        "terms": ["knowledge", "procedures"],
+        "terms": ["knowledge", "procedures", "kennis", "procedures", "connaissances", "procédures"],
     },
     {
-        "label": "Integrations",
-        "detail": "Automation and integration status",
+        "id": "integrations",
         "link": "/automation",
-        "terms": ["automation", "integrations", "systems", "n8n"],
+        "terms": [
+            "automation",
+            "integrations",
+            "systems",
+            "n8n",
+            "automatisering",
+            "integraties",
+            "systemen",
+            "automatisation",
+            "intégrations",
+            "systèmes",
+        ],
         "role": "operations_manager",
     },
     {
-        "label": "Audit trail",
-        "detail": "Audit history",
+        "id": "audit",
         "link": "/audit",
-        "terms": ["audit", "history"],
+        "terms": ["audit", "history", "geschiedenis", "historique"],
         "role": "operations_manager",
     },
 ]
@@ -83,8 +111,8 @@ def search(
             results.append(
                 SearchResultItem(
                     type="section",
-                    label=section["label"],
-                    detail=section["detail"],
+                    label=section["id"],
+                    detail_code=section["id"],
                     link=section["link"],
                 )
             )
@@ -108,7 +136,8 @@ def search(
             SearchResultItem(
                 type="vehicle",
                 label=v.public_ref,
-                detail=f"{v.make} {v.model} · {v.location}",
+                detail_code="vehicleSummary",
+                detail_params={"make": v.make, "model": v.model, "location": v.location},
                 link=f"/vehicles/{v.public_ref}",
             )
         )
@@ -120,7 +149,7 @@ def search(
             SearchResultItem(
                 type="booking",
                 label=b.public_ref,
-                detail=b.status,
+                detail_code=b.status,
                 link=f"/bookings/{b.public_ref}",
             )
         )
@@ -138,7 +167,7 @@ def search(
                 SearchResultItem(
                     type="data_quality_issue",
                     label=i.public_ref,
-                    detail=i.rule_type.replace("_", " "),
+                    detail_code=i.rule_type,
                     link=f"/data-quality/{i.public_ref}",
                 )
             )
diff --git a/backend/app/api/routers/workflows.py b/backend/app/api/routers/workflows.py
index 76ce9c9..736fcec 100644
--- a/backend/app/api/routers/workflows.py
+++ b/backend/app/api/routers/workflows.py
@@ -23,6 +23,7 @@ def _to_out(event: OutboxEvent) -> AutomationRunOut:
         status=event.delivery_status,
         attempts=event.attempts,
         last_error=event.last_error,
+        last_error_code=event.last_error_code,
         occurred_at=event.occurred_at,
     )
 
diff --git a/backend/app/core/config.py b/backend/app/core/config.py
index 62cb07a..fc2cd59 100644
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -2,6 +2,12 @@ from functools import lru_cache
 
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+# The visible product name is fixed and never translated or configured per-deployment --
+# see docs/fleet-ops-correction/current-gap-audit.md section 1. Internal identifiers
+# (package name, Compose project, database name, repository) intentionally remain
+# "mobilityops"; this constant is only for user-facing surfaces (e.g. the OpenAPI title).
+PRODUCT_NAME = "Fleet Ops"
+
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(env_file=".env", extra="ignore")
diff --git a/backend/app/main.py b/backend/app/main.py
index 6d9d51e..a44449e 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -19,7 +19,7 @@ from app.api.routers import (
     vehicles,
     workflows,
 )
-from app.core.config import get_settings
+from app.core.config import PRODUCT_NAME, get_settings
 from app.core.errors import AppError, error_body
 from app.services.dispatcher import start_background_dispatcher, stop_background_dispatcher
 
@@ -33,7 +33,7 @@ async def lifespan(_app: FastAPI):
     stop_background_dispatcher()
 
 
-app = FastAPI(title="MobilityOps API", version="0.1.0", lifespan=lifespan)
+app = FastAPI(title=f"{PRODUCT_NAME} API", version="0.1.0", lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,
diff --git a/backend/app/models/outbox.py b/backend/app/models/outbox.py
index 1d63a75..e3d2cf4 100644
--- a/backend/app/models/outbox.py
+++ b/backend/app/models/outbox.py
@@ -26,4 +26,9 @@ class OutboxEvent(TimestampMixin, Base):
     attempts: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
     next_attempt_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     last_error: Mapped[str | None] = mapped_column(Text)
+    # Stable, localizable classification of last_error -- the frontend renders a
+    # localized summary from this code as the primary text and shows last_error itself
+    # only under "Technical details" (section 10 of docs/fleet-ops-correction/
+    # current-gap-audit.md). Kept alongside the raw message for backward compatibility.
+    last_error_code: Mapped[str | None] = mapped_column(String(60))
     external_run_id: Mapped[str | None] = mapped_column(String(120))
diff --git a/backend/app/schemas.py b/backend/app/schemas.py
index 00c8bfc..5c2ef51 100644
--- a/backend/app/schemas.py
+++ b/backend/app/schemas.py
@@ -83,6 +83,8 @@ class ReturnPreviewResult(BaseModel):
     resulting_odometer_km: int
     resulting_vehicle_status: str
     status_reason: str
+    status_reason_code: str
+    status_reason_params: dict[str, str | int] = {}
     would_create_quality_issue: bool
     attention_reasons: list[str]
     next_booking_risk: NextBookingRisk | None
@@ -157,16 +159,41 @@ class ResolveOverlapRequest(BaseModel):
     note: str | None = Field(default=None, max_length=500)
 
 
+class VehicleStatusFactsOut(BaseModel):
+    active_booking_refs: list[str]
+    overlapping_booking_pairs: list[list[str]]
+    service_threshold_reached: bool
+    odometer_km: int
+    next_service_km: int
+    open_booking_overlap_issue_ref: str | None = None
+
+
+class StatusRecommendationOut(BaseModel):
+    current_status: str
+    recommended_status: str | None
+    recommendation_code: str
+    safe_to_apply: bool
+    manual_review_required: bool
+    facts: VehicleStatusFactsOut
+    blocking_reasons: list[str]
+    recommendation_token: str
+
+
+class ApplyRecommendedStatusRequest(BaseModel):
+    recommendation_token: str
+
+
 class ApplyRecommendedStatusResult(BaseModel):
     issue: DataQualityIssueOut
     applied_status: str
-    reason: str
+    reason_code: str
 
 
 class SearchResultItem(BaseModel):
     type: Literal["vehicle", "booking", "data_quality_issue", "section"]
     label: str
-    detail: str
+    detail_code: str
+    detail_params: dict[str, str] = {}
     link: str
 
 
@@ -269,6 +296,7 @@ class AutomationRunOut(BaseModel):
     status: str
     attempts: int
     last_error: str | None
+    last_error_code: str | None
     occurred_at: datetime
 
 
diff --git a/backend/app/seed_loader.py b/backend/app/seed_loader.py
index 938d219..1036519 100644
--- a/backend/app/seed_loader.py
+++ b/backend/app/seed_loader.py
@@ -4,6 +4,7 @@ import csv
 import uuid
 from dataclasses import dataclass
 from datetime import UTC, date, datetime, timedelta
+from difflib import SequenceMatcher
 from pathlib import Path
 
 from sqlalchemy import delete, insert, update
@@ -108,21 +109,22 @@ def load_seed(db: Session) -> SeedResult:
 
     customer_id_by_ref: dict[str, uuid.UUID] = {}
     customer_rows = []
+    customer_row_by_ref: dict[str, dict] = {}
     for row in _read_csv("customers.csv"):
         cid = uuid.uuid4()
         customer_id_by_ref[row["public_ref"]] = cid
-        customer_rows.append(
-            {
-                "id": cid,
-                "public_ref": row["public_ref"],
-                "first_name": row["first_name"],
-                "last_name": row["last_name"],
-                "email": row["email"] or None,
-                "phone": row["phone"] or None,
-                "postal_code": row["postal_code"] or None,
-                "city": row["city"] or None,
-            }
-        )
+        customer_row = {
+            "id": cid,
+            "public_ref": row["public_ref"],
+            "first_name": row["first_name"],
+            "last_name": row["last_name"],
+            "email": row["email"] or None,
+            "phone": row["phone"] or None,
+            "postal_code": row["postal_code"] or None,
+            "city": row["city"] or None,
+        }
+        customer_rows.append(customer_row)
+        customer_row_by_ref[row["public_ref"]] = customer_row
     db.execute(insert(Customer), customer_rows)
     counts["customers"] = len(customer_rows)
     # Second pass for merged_into (self-referencing FK) since target must exist first.
@@ -223,11 +225,42 @@ def load_seed(db: Session) -> SeedResult:
             return "customer", customer_id_by_ref[entity_ref]
         return "vehicle", vehicle_id_by_ref[entity_ref]
 
+    def _seed_signals(public_ref: str, entity_ref: str, related_refs: list[str]) -> list[dict]:
+        # The four named DQ-DEMO-* rows anchor the guided demo's scripted scenarios, so
+        # they carry real, accurate structured signals (not just a legacy English
+        # sentence) -- the frontend renders these as the primary, localized evidence;
+        # see docs/fleet-ops-correction/current-gap-audit.md §6.
+        if public_ref == "DQ-DEMO-DUPLICATE":
+            a = customer_row_by_ref[entity_ref]
+            b = customer_row_by_ref[related_refs[0]]
+            name_a = f"{a['first_name']} {a['last_name']}".strip().lower()
+            name_b = f"{b['first_name']} {b['last_name']}".strip().lower()
+            ratio = SequenceMatcher(None, name_a, name_b).ratio()
+            return [
+                {"code": "duplicate.exact_email"},
+                {"code": "duplicate.exact_phone"},
+                {"code": "duplicate.same_postal_code"},
+                {"code": "duplicate.similar_name", "params": {"score": round(ratio, 2)}},
+            ]
+        if public_ref == "DQ-DEMO-OVERLAP":
+            return [{"code": "overlap.reserved_bookings", "params": {"refs": related_refs}}]
+        if public_ref == "DQ-DEMO-STATUS":
+            return [{"code": "vehicle.booking_conflict"}]
+        if public_ref == "DQ-DEMO-ATTENTION":
+            return [
+                {
+                    "code": "attention.upcoming_booking_missing_inspection",
+                    "params": {"booking_ref": related_refs[0] if related_refs else ""},
+                }
+            ]
+        return []
+
     dq_rows = []
     now = datetime.now(UTC)
     for row in _read_csv("data_quality_issues.csv"):
         entity_type, entity_id = resolve_entity(row["entity_ref"])
         related_ref = row.get("related_ref") or ""
+        related_refs = related_ref.split("|") if related_ref else []
         dq_rows.append(
             {
                 "id": uuid.uuid4(),
@@ -240,7 +273,8 @@ def load_seed(db: Session) -> SeedResult:
                 "evidence_json": {
                     "summary": row["evidence"],
                     "entity_ref": row["entity_ref"],
-                    "related_refs": related_ref.split("|") if related_ref else [],
+                    "related_refs": related_refs,
+                    "signals": _seed_signals(row["public_ref"], row["entity_ref"], related_refs),
                 },
                 "proposed_action_json": {},
                 "detected_at": now,
@@ -287,6 +321,9 @@ def load_seed(db: Session) -> SeedResult:
                 "attempts": int(row["attempts"]),
                 "next_attempt_at": None,
                 "last_error": row["last_error"] or None,
+                # The seed dataset's one synthetic failure (BK-H-0020) models a
+                # connection-timeout-style delivery failure -- see workflow_runs.csv.
+                "last_error_code": "connectionError" if row["last_error"] else None,
                 "external_run_id": None,
             }
         )
diff --git a/backend/app/services/data_quality.py b/backend/app/services/data_quality.py
index e8610d8..c2077ff 100644
--- a/backend/app/services/data_quality.py
+++ b/backend/app/services/data_quality.py
@@ -15,6 +15,13 @@ from app.models.data_quality import DataQualityIssue
 from app.models.vehicle import Vehicle
 from app.schemas import CurrentUser, ResolveOdometerRegressionRequest
 from app.services.audit import record_audit_event
+from app.services.vehicle_status import (
+    RECOMMENDATION_CODE_NO_CONFLICT,
+    VehicleStatusRecommendation,
+    compute_recommendation_token,
+    evaluate_vehicle_status,
+    gather_vehicle_status_facts,
+)
 
 REQUIRED_CUSTOMER_FIELDS = ("first_name", "last_name")
 REQUIRED_VEHICLE_FIELDS = ("registration_number", "make", "model", "location")
@@ -69,6 +76,7 @@ def _open_issue(
     summary: str,
     entity_ref: str,
     related_refs: list[str],
+    signals: list[dict] | None = None,
 ) -> None:
     if _has_open_issue(db, rule_type, entity_type, entity_id):
         return
@@ -87,10 +95,14 @@ def _open_issue(
         )
         .order_by(DataQualityIssue.detected_at.desc())
     )
+    # `summary` is kept as a technical-fallback string (shown only under "Technical
+    # details"); `signals` is the stable, localizable structure the frontend renders as
+    # the primary evidence -- see docs/fleet-ops-correction/current-gap-audit.md §2/§6.
     evidence: dict = {
         "summary": summary,
         "entity_ref": entity_ref,
         "related_refs": related_refs,
+        "signals": signals or [],
     }
     if previous is not None:
         evidence["reopened_from"] = previous.public_ref
@@ -121,22 +133,29 @@ def _scan_duplicate_customers(db: Session, scan: ScanResult) -> None:
     for i, a in enumerate(customers):
         for b in customers[i + 1 :]:
             score = 0
-            signals = []
+            signals: list[dict] = []
+            summary_parts: list[str] = []
             if _normalize(a.email) and _normalize(a.email) == _normalize(b.email):
                 score += 60
-                signals.append("exact email")
+                signals.append({"code": "duplicate.exact_email"})
+                summary_parts.append("exact email")
             if _normalize(a.phone) and _normalize(a.phone) == _normalize(b.phone):
                 score += 50
-                signals.append("exact phone")
+                signals.append({"code": "duplicate.exact_phone"})
+                summary_parts.append("exact phone")
             if _normalize(a.postal_code) and _normalize(a.postal_code) == _normalize(b.postal_code):
                 score += 10
-                signals.append("exact postal code")
+                signals.append({"code": "duplicate.same_postal_code"})
+                summary_parts.append("exact postal code")
             name_a = f"{_normalize(a.first_name)} {_normalize(a.last_name)}"
             name_b = f"{_normalize(b.first_name)} {_normalize(b.last_name)}"
             ratio = SequenceMatcher(None, name_a, name_b).ratio()
             if ratio >= 0.5:
                 score += round(ratio * 30)
-                signals.append("similar name")
+                signals.append(
+                    {"code": "duplicate.similar_name", "params": {"score": round(ratio, 2)}}
+                )
+                summary_parts.append("similar name")
 
             if score >= DUPLICATE_THRESHOLD:
                 _open_issue(
@@ -146,9 +165,10 @@ def _scan_duplicate_customers(db: Session, scan: ScanResult) -> None:
                     entity_type="customer",
                     entity_id=a.id,
                     severity="high",
-                    summary="; ".join(signals) + f" (score {score})",
+                    summary="; ".join(summary_parts) + f" (score {score})",
                     entity_ref=a.public_ref,
                     related_refs=[b.public_ref],
+                    signals=signals,
                 )
 
 
@@ -170,6 +190,7 @@ def _scan_missing_required_fields(db: Session, scan: ScanResult) -> None:
                 summary=f"Missing: {', '.join(missing)}",
                 entity_ref=customer.public_ref,
                 related_refs=[],
+                signals=[{"code": "missing_field", "params": {"field": f}} for f in missing],
             )
 
     for vehicle in db.scalars(select(Vehicle).where(Vehicle.active.is_(True))).all():
@@ -185,6 +206,7 @@ def _scan_missing_required_fields(db: Session, scan: ScanResult) -> None:
                 summary=f"Missing: {', '.join(missing)}",
                 entity_ref=vehicle.public_ref,
                 related_refs=[],
+                signals=[{"code": "missing_field", "params": {"field": f}} for f in missing],
             )
 
 
@@ -213,50 +235,47 @@ def _scan_booking_overlaps(db: Session, scan: ScanResult) -> None:
                         summary=f"Overlapping bookings {first.public_ref} and {second.public_ref}",
                         entity_ref=vehicle.public_ref,
                         related_refs=[first.public_ref, second.public_ref],
+                        signals=[
+                            {
+                                "code": "overlap.reserved_bookings",
+                                "params": {"refs": [first.public_ref, second.public_ref]},
+                            }
+                        ],
                     )
 
 
 def _scan_vehicle_status_conflicts(db: Session, scan: ScanResult) -> None:
+    # Uses the same shared evaluator as the preview/apply flow (app.services.vehicle_status)
+    # so detection and resolution can never structurally disagree -- see
+    # docs/fleet-ops-correction/vehicle-status-decision-table.md.
     vehicles = db.scalars(select(Vehicle)).all()
-    active_by_vehicle: dict[uuid.UUID, list[Booking]] = {}
-    for booking in db.scalars(select(Booking).where(Booking.status == "active")).all():
-        active_by_vehicle.setdefault(booking.vehicle_id, []).append(booking)
-
-    open_high_by_vehicle = {
-        row[0]
-        for row in db.execute(
-            select(DataQualityIssue.entity_id).where(
-                DataQualityIssue.entity_type == "vehicle",
-                DataQualityIssue.status == "open",
-                DataQualityIssue.severity == "high",
-            )
-        ).all()
-    }
-
     for vehicle in vehicles:
-        has_active_booking = vehicle.id in active_by_vehicle
-        reason = None
-        if vehicle.operational_status == "available" and has_active_booking:
-            reason = "marked available while an active booking exists"
-        elif vehicle.operational_status == "rented" and not has_active_booking:
-            reason = "marked rented without an active booking"
-        elif vehicle.operational_status == "available" and vehicle.id in open_high_by_vehicle:
-            reason = "marked available while a high-severity quality issue is open"
-        elif vehicle.operational_status == "maintenance" and has_active_booking:
-            reason = "marked maintenance while an active booking exists"
+        facts = gather_vehicle_status_facts(db, vehicle)
+        recommendation = evaluate_vehicle_status(vehicle, facts)
+        if recommendation.recommendation_code == RECOMMENDATION_CODE_NO_CONFLICT:
+            continue
 
-        if reason:
-            _open_issue(
-                db,
-                scan,
-                rule_type="vehicle_status_conflict",
-                entity_type="vehicle",
-                entity_id=vehicle.id,
-                severity="high",
-                summary=f"Vehicle {reason}",
-                entity_ref=vehicle.public_ref,
-                related_refs=[],
-            )
+        signals = [{"code": recommendation.recommendation_code, "params": facts.as_dict()}]
+        summary = (
+            f"Recommended status: {recommendation.recommended_status}"
+            if recommendation.recommended_status
+            else "Manual review required: active rental conflicts with a blocking condition"
+        )
+        _open_issue(
+            db,
+            scan,
+            rule_type="vehicle_status_conflict",
+            entity_type="vehicle",
+            entity_id=vehicle.id,
+            severity="high",
+            summary=summary,
+            entity_ref=vehicle.public_ref,
+            related_refs=[
+                *facts.active_booking_refs,
+                *(ref for pair in facts.overlapping_booking_pairs for ref in pair),
+            ],
+            signals=signals,
+        )
 
 
 def _scan_odometer_regressions(db: Session, scan: ScanResult) -> None:
@@ -295,6 +314,17 @@ def _scan_odometer_regressions(db: Session, scan: ScanResult) -> None:
                     ),
                     entity_ref=vehicle.public_ref,
                     related_refs=[earlier.public_ref, later.public_ref],
+                    signals=[
+                        {
+                            "code": "odometer.regression",
+                            "params": {
+                                "later_ref": later.public_ref,
+                                "later_km": later.end_odometer_km,
+                                "earlier_ref": earlier.public_ref,
+                                "earlier_km": earlier.end_odometer_km,
+                            },
+                        }
+                    ],
                 )
                 break
 
@@ -650,28 +680,7 @@ def resolve_booking_overlap(
     return issue
 
 
-def _recommend_vehicle_status(
-    operational_status: str, has_active_booking: bool, has_open_high_issue: bool
-) -> tuple[str, str] | None:
-    """The single authoritative recommendation function for vehicle_status_conflict,
-    mirroring the exact conditions `_scan_vehicle_status_conflicts` flags."""
-    if operational_status == "available" and has_active_booking:
-        return "rented", "An active booking exists; the vehicle should be marked rented."
-    if operational_status == "rented" and not has_active_booking:
-        return "available", "No active booking exists; the vehicle should be marked available."
-    if operational_status == "available" and has_open_high_issue:
-        return "blocked", "A high-severity quality issue is open; the vehicle should be blocked."
-    if operational_status == "maintenance" and has_active_booking:
-        return (
-            "rented",
-            "An active booking exists despite the maintenance status; it should be rented.",
-        )
-    return None
-
-
-def apply_recommended_status(
-    db: Session, public_ref: str, actor: CurrentUser
-) -> tuple[DataQualityIssue, str, str]:
+def _load_vehicle_status_conflict_issue(db: Session, public_ref: str) -> DataQualityIssue:
     issue = _load_open_issue(db, public_ref)
     if issue.rule_type != "vehicle_status_conflict":
         raise AppError(
@@ -679,47 +688,77 @@ def apply_recommended_status(
             "This issue is not a vehicle_status_conflict issue.",
             status_code=409,
         )
+    return issue
+
+
+def preview_vehicle_status_recommendation(
+    db: Session, public_ref: str
+) -> tuple[DataQualityIssue, Vehicle, VehicleStatusRecommendation, str]:
+    """Non-mutating: computes and returns the recommendation only. Never resolves the
+    issue, never writes an audit event, never queues automation -- safe to call as often
+    as the UI needs (e.g. every time the panel is opened) with zero side effects."""
+    issue = _load_vehicle_status_conflict_issue(db, public_ref)
+    vehicle = db.scalar(select(Vehicle).where(Vehicle.id == issue.entity_id))
+    if vehicle is None:
+        raise AppError(
+            "VEHICLE_NOT_FOUND", "The vehicle for this issue was not found.", status_code=404
+        )
+    facts = gather_vehicle_status_facts(db, vehicle, exclude_issue_id=issue.id)
+    recommendation = evaluate_vehicle_status(vehicle, facts)
+    token = compute_recommendation_token(vehicle, facts)
+    return issue, vehicle, recommendation, token
+
+
+def apply_recommended_status(
+    db: Session, public_ref: str, actor: CurrentUser, expected_token: str
+) -> tuple[DataQualityIssue, str, str]:
+    issue = _load_vehicle_status_conflict_issue(db, public_ref)
+    # Lock the vehicle row for the remainder of this transaction so a concurrent apply
+    # (or return/checkout) can't race between our fact-gathering and the write below.
     vehicle = db.scalar(select(Vehicle).where(Vehicle.id == issue.entity_id).with_for_update())
     if vehicle is None:
         raise AppError(
             "VEHICLE_NOT_FOUND", "The vehicle for this issue was not found.", status_code=404
         )
 
-    has_active_booking = (
-        db.scalar(
-            select(Booking.id).where(Booking.vehicle_id == vehicle.id, Booking.status == "active")
+    facts = gather_vehicle_status_facts(db, vehicle, exclude_issue_id=issue.id)
+    recommendation = evaluate_vehicle_status(vehicle, facts)
+    current_token = compute_recommendation_token(vehicle, facts)
+
+    if current_token != expected_token:
+        raise AppError(
+            "RECOMMENDATION_STALE",
+            "The underlying facts changed since this recommendation was shown; "
+            "review the recommendation again before applying it.",
+            status_code=409,
         )
-        is not None
-    )
-    has_open_high_issue = (
-        db.scalar(
-            select(DataQualityIssue.id).where(
-                DataQualityIssue.entity_type == "vehicle",
-                DataQualityIssue.entity_id == vehicle.id,
-                DataQualityIssue.status == "open",
-                DataQualityIssue.severity == "high",
-                DataQualityIssue.id != issue.id,
-            )
+    if recommendation.manual_review_required or not recommendation.safe_to_apply:
+        raise AppError(
+            "MANUAL_REVIEW_REQUIRED",
+            "This vehicle's state requires manual review; no automatic status change is safe.",
+            status_code=409,
         )
-        is not None
-    )
-    recommendation = _recommend_vehicle_status(
-        vehicle.operational_status, has_active_booking, has_open_high_issue
-    )
-    if recommendation is None:
+    if recommendation.recommended_status is None:
         raise AppError(
             "NO_CONFLICT_DETECTED",
             "The current vehicle state no longer conflicts; nothing to apply.",
             status_code=409,
         )
-    new_status, reason = recommendation
+    new_status = recommendation.recommended_status
+    reason_code = recommendation.recommendation_code
 
     before = {"operational_status": vehicle.operational_status}
     vehicle.operational_status = new_status
     vehicle.version += 1
 
-    # Re-validate: the same recommendation function must find no further conflict.
-    if _recommend_vehicle_status(new_status, has_active_booking, has_open_high_issue) is not None:
+    # Re-validate against the same shared evaluator, over freshly-gathered facts, that
+    # applying this change actually leaves no conflict -- never trust the pre-computed
+    # recommendation alone for the post-condition.
+    post_facts = gather_vehicle_status_facts(db, vehicle, exclude_issue_id=issue.id)
+    post_check = evaluate_vehicle_status(vehicle, post_facts)
+    if post_check.recommendation_code not in (
+        RECOMMENDATION_CODE_NO_CONFLICT,
+    ):
         raise AppError(
             "CONFLICT_STILL_PRESENT",
             "Applying the recommended status did not resolve the conflict.",
@@ -737,7 +776,7 @@ def apply_recommended_status(
         correlation_id=correlation_id,
         before=before,
         after={"operational_status": vehicle.operational_status},
-        metadata={"issue_ref": issue.public_ref, "reason": reason},
+        metadata={"issue_ref": issue.public_ref, "reason_code": reason_code},
     )
 
     issue.status = "resolved"
@@ -755,7 +794,7 @@ def apply_recommended_status(
         after={"status": "resolved"},
     )
     db.commit()
-    return issue, new_status, reason
+    return issue, new_status, reason_code
 
 
 MERGEABLE_FIELDS = ("first_name", "last_name", "email", "phone", "postal_code", "city")
diff --git a/backend/app/services/dispatcher.py b/backend/app/services/dispatcher.py
index c401002..66ff1b5 100644
--- a/backend/app/services/dispatcher.py
+++ b/backend/app/services/dispatcher.py
@@ -48,6 +48,7 @@ def _reclaim_stale_deliveries(batch_size: int = 10) -> int:
                 f"(no outcome recorded within {settings.n8n_delivery_lease_seconds:.0f}s; "
                 f"the process likely crashed mid-delivery). attempts preserved at {row.attempts}."
             )[:2000]
+            row.last_error_code = "staleLeaseRecovered"
         db.commit()
         return len(rows)
     finally:
@@ -111,8 +112,10 @@ def _deliver_one(event_id: uuid.UUID) -> None:
     finally:
         db.close()
 
+    error_code: str | None
     if wire_event is None:
         success, error, body = False, payload_error, None
+        error_code = "malformedPayload"
     else:
         try:
             response = httpx.post(
@@ -124,9 +127,11 @@ def _deliver_one(event_id: uuid.UUID) -> None:
             body = response.json()
             success = bool(body.get("ok", True))
             error = None if success else f"n8n reported failure: {body}"
+            error_code = None if success else "remoteReportedFailure"
         except httpx.HTTPError as exc:
             success = False
             error = f"{type(exc).__name__}: {exc}"
+            error_code = "connectionError"
             body = None
 
     db = SessionLocal()
@@ -138,10 +143,12 @@ def _deliver_one(event_id: uuid.UUID) -> None:
         if success:
             event.delivery_status = "succeeded"
             event.last_error = None
+            event.last_error_code = None
             event.next_attempt_at = None
             event.external_run_id = str((body or {}).get("event_id", event_id))
         else:
             event.last_error = (error or "delivery failed")[:2000]
+            event.last_error_code = error_code or "unknownError"
             if event.attempts >= settings.n8n_max_attempts:
                 event.delivery_status = "failed"
                 event.next_attempt_at = None
diff --git a/backend/app/services/knowledge/demo.py b/backend/app/services/knowledge/demo.py
index 58e9433..0e4aa16 100644
--- a/backend/app/services/knowledge/demo.py
+++ b/backend/app/services/knowledge/demo.py
@@ -35,7 +35,11 @@ STOPWORDS_BY_LANGUAGE: dict[str, set[str]] = {
     },
 }
 
-_WORD_RE = re.compile(r"[a-z0-9]+")
+# Includes the Latin-1 accented-letter range (à-ö, ø-ÿ) so French/Dutch words with
+# diacritics (véhicule, réservation, geëscaleerd) tokenize as one word instead of
+# splitting apart at the accented character -- a plain [a-z0-9]+ pattern silently
+# drops every accent and fragments the word either side of it.
+_WORD_RE = re.compile(r"[a-zà-öø-ÿ0-9]+")
 
 
 def _stem(word: str) -> str:
@@ -218,17 +222,28 @@ class DemoKnowledgeProvider:
     def _score(
         self, query_tokens: set[str], section: ScoredSection, idf: dict[str, float]
     ) -> float:
+        # The section body is the strongest relevance signal -- it's the actual
+        # substance a heading or title can only hint at -- so a body match is weighted
+        # *above* heading/title matches, not below them. The previous 3x/2x/1x
+        # (heading/title/body) ordering let a single generic word in a heading (e.g.
+        # "vehicle", present in nearly every section) or a document's own title
+        # outrank a section whose body genuinely covers multiple, more distinctive
+        # query terms -- confirmed to misrank the brief's exact validation question in
+        # every one of the three languages (see docs/fleet-ops-correction/
+        # current-gap-audit.md and i18n-inventory.md): nl-BE picked a checkout section
+        # over the damage procedure, en-GB and fr-BE picked the return procedure over
+        # the damage procedure, purely from heading/title overlap on common words.
         score = 0.0
         for token in query_tokens:
             token_idf = idf.get(token, 0.0)
             if token_idf == 0.0:
                 continue
-            if token in section.heading_tokens:
+            if token in section.body_tokens:
                 score += 3 * token_idf
-            elif token in section.document.title_tokens:
+            elif token in section.heading_tokens:
                 score += 2 * token_idf
-            elif token in section.body_tokens:
-                score += token_idf
+            elif token in section.document.title_tokens:
+                score += 1.5 * token_idf
         return score
 
     def ask(
diff --git a/backend/app/services/returns.py b/backend/app/services/returns.py
index 0f2bcf8..b5e578b 100644
--- a/backend/app/services/returns.py
+++ b/backend/app/services/returns.py
@@ -28,19 +28,41 @@ def _next_public_ref(db: Session) -> str:
 
 def _derive_vehicle_status_with_reason(
     body: RegisterReturnRequest, vehicle: Vehicle, new_odometer: int
-) -> tuple[str, str]:
+) -> tuple[str, str, dict[str, str | int]]:
+    # Stable, localizable codes + params -- the backend never emits prose here. The
+    # frontend renders review.reasonCodes.<code> in the selected locale; the mirrored
+    # raw-English fallback strings live only in status_reason (shown under "Technical
+    # details") for backward compatibility. See docs/fleet-ops-correction/i18n-inventory.md.
     if body.damage_reported and body.technical_warning:
-        return "blocked", "Damage and a technical warning were both reported on return."
+        return (
+            "blocked",
+            "returnBlockedDamageAndTechnical",
+            {},
+        )
     if body.damage_reported:
-        return "blocked", "Damage was reported on return."
+        return "blocked", "returnBlockedDamage", {}
     if body.technical_warning:
-        return "blocked", "A technical warning was reported on return."
+        return "blocked", "returnBlockedTechnicalWarning", {}
     if new_odometer >= vehicle.next_service_km:
         return (
             "maintenance",
-            f"Odometer reached the {vehicle.next_service_km:,} km service threshold.",
+            "returnServiceThresholdReached",
+            {"threshold_km": vehicle.next_service_km},
         )
-    return "cleaning", "No damage, technical warning or service threshold; routed to cleaning."
+    return "cleaning", "returnRoutedToCleaning", {}
+
+
+_STATUS_REASON_FALLBACK_TEXT: dict[str, str] = {
+    "returnBlockedDamageAndTechnical": (
+        "Damage and a technical warning were both reported on return."
+    ),
+    "returnBlockedDamage": "Damage was reported on return.",
+    "returnBlockedTechnicalWarning": "A technical warning was reported on return.",
+    "returnServiceThresholdReached": "Odometer reached the service threshold.",
+    "returnRoutedToCleaning": (
+        "No damage, technical warning or service threshold; routed to cleaning."
+    ),
+}
 
 
 @dataclass
@@ -51,6 +73,8 @@ class ReturnEvaluation:
     resulting_odometer_km: int
     resulting_vehicle_status: str
     status_reason: str
+    status_reason_code: str
+    status_reason_params: dict[str, str | int]
     would_create_quality_issue: bool
     attention_reasons: list[str]
     next_booking_risk: dict | None
@@ -64,9 +88,10 @@ def evaluate_return(
     preview and commit can never drift apart."""
     odometer_regression = body.end_odometer_km < vehicle.odometer_km
     resulting_odometer_km = vehicle.odometer_km if odometer_regression else body.end_odometer_km
-    resulting_status, status_reason = _derive_vehicle_status_with_reason(
+    resulting_status, status_reason_code, status_reason_params = _derive_vehicle_status_with_reason(
         body, vehicle, resulting_odometer_km
     )
+    status_reason = _STATUS_REASON_FALLBACK_TEXT[status_reason_code]
 
     attention_reasons = []
     if body.damage_reported:
@@ -101,6 +126,8 @@ def evaluate_return(
         resulting_odometer_km=resulting_odometer_km,
         resulting_vehicle_status=resulting_status,
         status_reason=status_reason,
+        status_reason_code=status_reason_code,
+        status_reason_params=status_reason_params,
         would_create_quality_issue=odometer_regression,
         attention_reasons=attention_reasons,
         next_booking_risk=next_booking_risk,
diff --git a/backend/app/services/vehicle_status.py b/backend/app/services/vehicle_status.py
new file mode 100644
index 0000000..8eba07e
--- /dev/null
+++ b/backend/app/services/vehicle_status.py
@@ -0,0 +1,218 @@
+"""The single authoritative vehicle-status evaluator.
+
+Used by the data-quality scanner (detection), the status-recommendation preview
+endpoint, the apply endpoint, and tests -- so scan-time detection and resolve-time
+recommendation can never structurally disagree (see docs/fleet-ops-correction/
+vehicle-status-decision-table.md for the full decision table and rationale).
+
+The evaluator only ever reasons from real, freshly-queried domain facts (an actually
+active rental, a real service-threshold breach, a real overlapping-booking conflict) --
+never from a proxy like "does some other high-severity issue happen to be open". It is
+therefore also order-independent: resolving, deferring or rejecting an unrelated issue on
+the same vehicle never changes what this function returns, because it never looks at
+issue history, only at the vehicle's/bookings' current state.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import uuid
+from dataclasses import dataclass, field
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.models.booking import Booking
+from app.models.data_quality import DataQualityIssue
+from app.models.vehicle import Vehicle
+
+# Every code below is a stable, localizable identifier -- see
+# frontend/src/i18n/messageCodes.ts and quality:statusRecommendation.codes.* for the
+# human-language mapping in all three supported locales. The backend never emits prose.
+RECOMMENDATION_CODE_ACTIVE_RENTAL = "vehicle.active_rental"
+RECOMMENDATION_CODE_SERVICE_THRESHOLD = "vehicle.service_threshold_reached"
+RECOMMENDATION_CODE_BOOKING_CONFLICT = "vehicle.booking_conflict"
+RECOMMENDATION_CODE_RENTAL_ENDED = "vehicle.rental_ended"
+RECOMMENDATION_CODE_MANUAL_REVIEW = "vehicle.manual_review_required"
+RECOMMENDATION_CODE_NO_CONFLICT = "vehicle.no_conflict"
+
+
+@dataclass
+class VehicleStatusFacts:
+    active_booking_refs: list[str] = field(default_factory=list)
+    overlapping_booking_pairs: list[tuple[str, str]] = field(default_factory=list)
+    service_threshold_reached: bool = False
+    odometer_km: int = 0
+    next_service_km: int = 0
+    open_booking_overlap_issue_ref: str | None = None
+
+    @property
+    def has_active_rental(self) -> bool:
+        return len(self.active_booking_refs) > 0
+
+    @property
+    def has_booking_conflict(self) -> bool:
+        return (
+            len(self.overlapping_booking_pairs) > 0
+            or self.open_booking_overlap_issue_ref is not None
+        )
+
+    def as_dict(self) -> dict:
+        return {
+            "active_booking_refs": self.active_booking_refs,
+            "overlapping_booking_pairs": [list(pair) for pair in self.overlapping_booking_pairs],
+            "service_threshold_reached": self.service_threshold_reached,
+            "odometer_km": self.odometer_km,
+            "next_service_km": self.next_service_km,
+            "open_booking_overlap_issue_ref": self.open_booking_overlap_issue_ref,
+        }
+
+
+@dataclass
+class VehicleStatusRecommendation:
+    current_status: str
+    recommended_status: str | None
+    recommendation_code: str
+    safe_to_apply: bool
+    manual_review_required: bool
+    facts: VehicleStatusFacts
+    blocking_reasons: list[str]
+
+
+def _overlapping_booking_pairs(bookings: list[Booking]) -> list[tuple[Booking, Booking]]:
+    ordered = sorted(bookings, key=lambda b: b.starts_at)
+    pairs: list[tuple[Booking, Booking]] = []
+    for i, first in enumerate(ordered):
+        for second in ordered[i + 1 :]:
+            if second.starts_at < first.ends_at and first.starts_at < second.ends_at:
+                pairs.append((first, second))
+    return pairs
+
+
+def gather_vehicle_status_facts(
+    db: Session, vehicle: Vehicle, *, exclude_issue_id: uuid.UUID | None = None
+) -> VehicleStatusFacts:
+    """Real, freshly-queried facts only -- see module docstring. Never cached, never
+    derived from another issue's mere existence (only a *specific* booking_overlap
+    issue's presence is used, as a cross-reference to that issue's own public_ref)."""
+    reserved_or_active = list(
+        db.scalars(
+            select(Booking).where(
+                Booking.vehicle_id == vehicle.id,
+                Booking.status.in_(["reserved", "active"]),
+            )
+        ).all()
+    )
+    active_refs = [b.public_ref for b in reserved_or_active if b.status == "active"]
+    overlap_pairs = [
+        (a.public_ref, b.public_ref) for a, b in _overlapping_booking_pairs(reserved_or_active)
+    ]
+
+    overlap_issue_query = select(DataQualityIssue.public_ref).where(
+        DataQualityIssue.entity_type == "vehicle",
+        DataQualityIssue.entity_id == vehicle.id,
+        DataQualityIssue.status == "open",
+        DataQualityIssue.rule_type == "booking_overlap",
+    )
+    if exclude_issue_id is not None:
+        overlap_issue_query = overlap_issue_query.where(DataQualityIssue.id != exclude_issue_id)
+    open_overlap_ref = db.scalar(overlap_issue_query)
+
+    return VehicleStatusFacts(
+        active_booking_refs=active_refs,
+        overlapping_booking_pairs=overlap_pairs,
+        service_threshold_reached=vehicle.odometer_km >= vehicle.next_service_km,
+        odometer_km=vehicle.odometer_km,
+        next_service_km=vehicle.next_service_km,
+        open_booking_overlap_issue_ref=open_overlap_ref,
+    )
+
+
+def compute_recommendation_token(vehicle: Vehicle, facts: VehicleStatusFacts) -> str:
+    """A short digest of exactly the facts the recommendation was based on, plus the
+    vehicle's optimistic-lock version. The apply endpoint recomputes this from fresh
+    facts and rejects the request if it doesn't match the token the client last saw --
+    the frontend must never assume a previously-shown preview is still valid without the
+    server re-checking it (see docs/fleet-ops-correction/current-gap-audit.md §8F)."""
+    payload = {"version": vehicle.version, "status": vehicle.operational_status, **facts.as_dict()}
+    digest = hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode()).hexdigest()
+    return digest[:16]
+
+
+def evaluate_vehicle_status(
+    vehicle: Vehicle, facts: VehicleStatusFacts
+) -> VehicleStatusRecommendation:
+    """Pure decision logic over already-gathered facts -- see
+    docs/fleet-ops-correction/vehicle-status-decision-table.md. Never mutates anything,
+    never queries the database itself (call gather_vehicle_status_facts first), so it is
+    trivial to unit-test every branch in isolation."""
+    current = vehicle.operational_status
+    blocking_reasons: list[str] = []
+    if facts.service_threshold_reached:
+        blocking_reasons.append(RECOMMENDATION_CODE_SERVICE_THRESHOLD)
+    if facts.has_booking_conflict:
+        blocking_reasons.append(RECOMMENDATION_CODE_BOOKING_CONFLICT)
+    if current == "maintenance" and RECOMMENDATION_CODE_SERVICE_THRESHOLD not in blocking_reasons:
+        # Already being in maintenance is itself a real blocking fact -- an active
+        # booking never overrides it. This is exactly the forbidden shortcut this
+        # evaluator must never take (maintenance + active booking -> auto "rented").
+        blocking_reasons.append(RECOMMENDATION_CODE_SERVICE_THRESHOLD)
+
+    def result(
+        recommended: str | None, code: str, *, safe: bool, manual: bool
+    ) -> VehicleStatusRecommendation:
+        return VehicleStatusRecommendation(
+            current_status=current,
+            recommended_status=recommended,
+            recommendation_code=code,
+            safe_to_apply=safe,
+            manual_review_required=manual,
+            facts=facts,
+            blocking_reasons=blocking_reasons,
+        )
+
+    if facts.has_active_rental and not blocking_reasons:
+        if current == "rented":
+            return result(None, RECOMMENDATION_CODE_NO_CONFLICT, safe=False, manual=False)
+        return result(
+            "rented", RECOMMENDATION_CODE_ACTIVE_RENTAL, safe=True, manual=False
+        )
+
+    if facts.has_active_rental and blocking_reasons:
+        # Explicitly forbidden shortcut this evaluator must never take: an active
+        # booking is not proof the vehicle should be "rented" when a real blocking
+        # condition also exists (e.g. maintenance-due, or a genuine booking conflict).
+        # This is a real contradiction in the underlying facts, not something safe to
+        # resolve automatically.
+        return result(None, RECOMMENDATION_CODE_MANUAL_REVIEW, safe=False, manual=True)
+
+    if facts.service_threshold_reached:
+        if current == "maintenance":
+            return result(None, RECOMMENDATION_CODE_NO_CONFLICT, safe=False, manual=False)
+        return result(
+            "maintenance", RECOMMENDATION_CODE_SERVICE_THRESHOLD, safe=True, manual=False
+        )
+
+    if facts.has_booking_conflict:
+        if current == "blocked":
+            return result(None, RECOMMENDATION_CODE_NO_CONFLICT, safe=False, manual=False)
+        return result(
+            "blocked", RECOMMENDATION_CODE_BOOKING_CONFLICT, safe=True, manual=False
+        )
+
+    # No active rental, no maintenance need, no booking conflict.
+    if current in ("available", "cleaning", "blocked"):
+        return result(None, RECOMMENDATION_CODE_NO_CONFLICT, safe=False, manual=False)
+    if current == "rented":
+        return result(
+            "available", RECOMMENDATION_CODE_RENTAL_ENDED, safe=True, manual=False
+        )
+    if current == "maintenance":
+        # No positive fact confirms maintenance is actually finished (no completed
+        # service record is tracked here) -- clearing "maintenance" without such a
+        # fact would be exactly the kind of unsafe shortcut this evaluator forbids.
+        # Releasing a vehicle from maintenance remains an explicit, manual decision.
+        return result(None, RECOMMENDATION_CODE_NO_CONFLICT, safe=False, manual=False)
+
+    return result(None, RECOMMENDATION_CODE_MANUAL_REVIEW, safe=False, manual=True)
diff --git a/backend/tests/test_data_quality.py b/backend/tests/test_data_quality.py
index c995b35..bed22a9 100644
--- a/backend/tests/test_data_quality.py
+++ b/backend/tests/test_data_quality.py
@@ -249,28 +249,74 @@ def test_resolve_overlap_blocks_one_booking_and_resolves(ops_client):
     assert booking["status"] == "blocked"
 
 
-def test_apply_recommended_status_requires_operations_manager(employee_client):
+def test_status_recommendation_requires_operations_manager(employee_client):
     response = employee_client.post(
-        "/api/v1/data-quality/issues/DQ-DEMO-STATUS/apply-recommended-status"
+        "/api/v1/data-quality/issues/DQ-DEMO-STATUS/status-recommendation"
     )
     assert response.status_code == 403
 
 
+def test_apply_recommended_status_requires_operations_manager(employee_client):
+    response = employee_client.post(
+        "/api/v1/data-quality/issues/DQ-DEMO-STATUS/apply-recommended-status",
+        json={"recommendation_token": "irrelevant"},
+    )
+    assert response.status_code == 403
+
+
+def test_status_recommendation_preview_does_not_mutate_anything(ops_client):
+    target = _first_open(ops_client, "vehicle_status_conflict")
+    vehicle_before = ops_client.get(f"/api/v1/vehicles/{target['entity_ref']}").json()
+
+    preview_response = ops_client.post(
+        f"/api/v1/data-quality/issues/{target['public_ref']}/status-recommendation"
+    )
+    assert preview_response.status_code == 200
+    preview = preview_response.json()
+    assert preview["current_status"] == vehicle_before["operational_status"]
+    assert preview["recommendation_token"]
+    assert "facts" in preview
+
+    # Calling preview again (as the UI would on every open) must still not mutate.
+    ops_client.post(f"/api/v1/data-quality/issues/{target['public_ref']}/status-recommendation")
+    issue_after = ops_client.get(f"/api/v1/data-quality/issues/{target['public_ref']}").json()
+    vehicle_after = ops_client.get(f"/api/v1/vehicles/{target['entity_ref']}").json()
+    assert issue_after["status"] == "open"
+    assert vehicle_after["operational_status"] == vehicle_before["operational_status"]
+
+
 def test_apply_recommended_status_resolves_conflict(ops_client):
     target = _first_open(ops_client, "vehicle_status_conflict")
+    preview = ops_client.post(
+        f"/api/v1/data-quality/issues/{target['public_ref']}/status-recommendation"
+    ).json()
+    assert preview["safe_to_apply"] is True
+    assert preview["manual_review_required"] is False
+
     response = ops_client.post(
-        f"/api/v1/data-quality/issues/{target['public_ref']}/apply-recommended-status"
+        f"/api/v1/data-quality/issues/{target['public_ref']}/apply-recommended-status",
+        json={"recommendation_token": preview["recommendation_token"]},
     )
     assert response.status_code == 200
     body = response.json()
     assert body["issue"]["status"] == "resolved"
-    assert body["applied_status"]
-    assert body["reason"]
+    assert body["applied_status"] == preview["recommended_status"]
+    assert body["reason_code"] == preview["recommendation_code"]
 
     vehicle = ops_client.get(f"/api/v1/vehicles/{target['entity_ref']}").json()
     assert vehicle["operational_status"] == body["applied_status"]
 
 
+def test_apply_recommended_status_rejects_stale_token(ops_client):
+    target = _first_open(ops_client, "vehicle_status_conflict")
+    response = ops_client.post(
+        f"/api/v1/data-quality/issues/{target['public_ref']}/apply-recommended-status",
+        json={"recommendation_token": "not-a-real-token"},
+    )
+    assert response.status_code == 409
+    assert response.json()["error"]["code"] == "RECOMMENDATION_STALE"
+
+
 def test_resolve_odometer_regression_requires_operations_manager(employee_client):
     response = employee_client.post(
         "/api/v1/data-quality/issues/DQ-0007/resolve-odometer-regression",
@@ -365,6 +411,95 @@ def test_manual_scan_records_audit_event(ops_client):
     assert "created" in events[0]["metadata"]
 
 
+def _reset_demo(ops_client) -> None:
+    # /api/v1/demo/reset deletes the session cookie (the reset recreates the users
+    # table, so the old session's user id no longer exists) -- the caller must log back
+    # in before making any further authenticated call with the same client.
+    response = ops_client.post("/api/v1/demo/reset")
+    assert response.status_code == 200, response.text
+    login_response = ops_client.post(
+        "/api/v1/demo/login", json={"role": "operations_manager"}
+    )
+    assert login_response.status_code == 200, login_response.text
+
+
+def _resolve_overlap_issue(ops_client, *, booking_to_block: str) -> None:
+    overlap = _first_open(ops_client, "booking_overlap")
+    response = ops_client.post(
+        f"/api/v1/data-quality/issues/{overlap['public_ref']}/resolve-overlap",
+        json={"booking_ref": booking_to_block},
+    )
+    assert response.status_code == 200, response.text
+    assert response.json()["status"] == "resolved"
+
+
+def _first_open_for_vehicle(ops_client, rule_type: str, vehicle_ref: str) -> dict:
+    issues = ops_client.get(
+        "/api/v1/data-quality/issues", params={"rule_type": rule_type, "status": "open"}
+    ).json()
+    match = next((i for i in issues if i["entity_ref"] == vehicle_ref), None)
+    assert match, f"expected an open {rule_type} issue for {vehicle_ref}"
+    return match
+
+
+def _apply_status_recommendation(ops_client, public_ref: str) -> dict:
+    preview = ops_client.post(
+        f"/api/v1/data-quality/issues/{public_ref}/status-recommendation"
+    ).json()
+    apply_response = ops_client.post(
+        f"/api/v1/data-quality/issues/{public_ref}/apply-recommended-status",
+        json={"recommendation_token": preview["recommendation_token"]},
+    )
+    assert apply_response.status_code == 200, apply_response.text
+    return apply_response.json()
+
+
+def test_mo_016_status_conflict_recommendation_is_order_independent(ops_client):
+    # MO-016 carries both a booking_overlap (DQ-DEMO-OVERLAP) and a vehicle_status_conflict
+    # (DQ-DEMO-STATUS) issue at once. Order independence does NOT mean "the same final
+    # vehicle status regardless of order" -- resolving the overlap first genuinely removes
+    # the conflict, so there is correctly nothing left to apply. What must hold in either
+    # order: the recommendation always reflects the real, current facts (never a stale
+    # "was some other issue open" proxy), and nothing unsafe is ever applied (never
+    # "rented", never a status change once the underlying condition has already resolved
+    # itself). See docs/fleet-ops-correction/current-gap-audit.md §6-7 and
+    # vehicle-status-decision-table.md.
+
+    # Order A: resolve the booking overlap first. The status-conflict issue's own
+    # recommendation must now correctly report that the conflict is gone -- nothing unsafe
+    # should be auto-applied, and the vehicle (never touched) stays exactly as it was.
+    _reset_demo(ops_client)
+    _resolve_overlap_issue(ops_client, booking_to_block="BK-DEMO-OVERLAP-B")
+    status_issue_a = _first_open_for_vehicle(ops_client, "vehicle_status_conflict", "MO-016")
+    preview_a = ops_client.post(
+        f"/api/v1/data-quality/issues/{status_issue_a['public_ref']}/status-recommendation"
+    ).json()
+    assert preview_a["recommendation_code"] == "vehicle.no_conflict"
+    assert preview_a["recommended_status"] is None
+    assert preview_a["safe_to_apply"] is False
+    vehicle_a = ops_client.get("/api/v1/vehicles/MO-016").json()
+    assert vehicle_a["operational_status"] == "available"
+
+    # Order B: resolve the status conflict first, while the overlap is still open -- the
+    # conflict genuinely still exists, so the evaluator must still detect it and safely
+    # resolve it (never "rented").
+    _reset_demo(ops_client)
+    status_issue_b = _first_open_for_vehicle(ops_client, "vehicle_status_conflict", "MO-016")
+    result_b = _apply_status_recommendation(ops_client, status_issue_b["public_ref"])
+    assert result_b["applied_status"] != "rented"
+    vehicle_b_mid = ops_client.get("/api/v1/vehicles/MO-016").json()
+    assert vehicle_b_mid["operational_status"] == result_b["applied_status"]
+
+    # Resolving the now-redundant overlap afterwards must not itself change the vehicle's
+    # status as a side effect.
+    _resolve_overlap_issue(ops_client, booking_to_block="BK-DEMO-OVERLAP-B")
+    vehicle_b = ops_client.get("/api/v1/vehicles/MO-016").json()
+    assert vehicle_b["operational_status"] == result_b["applied_status"]
+    assert vehicle_b["operational_status"] != "rented"
+
+    _reset_demo(ops_client)
+
+
 def test_rejected_issue_recurrence_links_to_prior_decision(ops_client):
     # Reject an open vehicle_status_conflict issue without changing the vehicle, so the
     # next scan re-detects the same unresolved condition -- it must not silently vanish
diff --git a/backend/tests/test_dispatcher.py b/backend/tests/test_dispatcher.py
index efab55d..85120d8 100644
--- a/backend/tests/test_dispatcher.py
+++ b/backend/tests/test_dispatcher.py
@@ -81,6 +81,7 @@ def test_deliver_one_success(monkeypatch):
     assert event.attempts == 1
     assert event.external_run_id == str(event_id)
     assert event.last_error is None
+    assert event.last_error_code is None
 
 
 def test_deliver_one_failure_schedules_retry(monkeypatch):
@@ -98,6 +99,7 @@ def test_deliver_one_failure_schedules_retry(monkeypatch):
     assert event.attempts == 1
     assert event.next_attempt_at is not None
     assert "simulated connection failure" in event.last_error
+    assert event.last_error_code == "connectionError"
 
 
 def test_deliver_one_exhausts_attempts_to_failed(monkeypatch):
@@ -159,6 +161,7 @@ def test_deliver_one_handles_malformed_payload_without_getting_stuck(monkeypatch
     assert event.delivery_status in ("pending", "failed")
     assert event.attempts == 1
     assert "Malformed outbox payload" in event.last_error
+    assert event.last_error_code == "malformedPayload"
 
 
 def test_claim_sets_a_lease_deadline():
@@ -208,6 +211,7 @@ def test_reclaim_recovers_an_expired_lease_and_preserves_attempts(monkeypatch):
     assert event.next_attempt_at is None
     assert event.attempts == 2
     assert "stale" in event.last_error.lower()
+    assert event.last_error_code == "staleLeaseRecovered"
 
     # The reclaimed event is now a normal pending event, immediately claimable again.
     claimed = dispatcher._claim_due_events()
diff --git a/backend/tests/test_knowledge.py b/backend/tests/test_knowledge.py
index ef8ebe3..30a899e 100644
--- a/backend/tests/test_knowledge.py
+++ b/backend/tests/test_knowledge.py
@@ -1,11 +1,51 @@
 from __future__ import annotations
 
+import re
+from pathlib import Path
+
 import httpx
 
+from app.core.config import get_settings
 from app.services.knowledge.demo import DemoKnowledgeProvider
 from app.services.knowledge.ragcore import RAGcoreKnowledgeProvider
 
 
+def test_brief_exact_damage_question_in_all_three_languages():
+    # The exact validation questions from docs/fleet-ops-correction/current-gap-audit.md
+    # -- each must ground on the damage procedure as its *primary* (top-ranked) source,
+    # not merely appear somewhere in the top-3, and the source/version/section/excerpt
+    # must all come from that same-language document (never an English fallback).
+    provider = DemoKnowledgeProvider()
+    cases = {
+        "nl-BE": "Wat moet ik doen wanneer een voertuig beschadigd terugkomt?",
+        "en-GB": "What should I do when a vehicle returns with damage?",
+        "fr-BE": "Que dois-je faire lorsqu'un véhicule revient endommagé ?",
+    }
+    for language, question in cases.items():
+        answer = provider.ask(question, f"test-brief-{language}", language)
+        assert answer.evidence_state == "grounded", language
+        assert answer.sources, language
+        assert answer.sources[0].document_id == "damage-procedure", (
+            f"{language}: expected the damage procedure as the primary source, "
+            f"got {answer.sources[0].document_id!r}"
+        )
+        assert answer.answer
+        assert answer.sources[0].excerpt
+
+
+def test_knowledge_procedures_never_mention_mobilityops_or_poc():
+    # Section 2 of docs/fleet-ops-correction/current-gap-audit.md: the visible brand
+    # name is exactly "Fleet Ops", and "PoC" must never appear in visible content --
+    # including the demo knowledge base, not just the frontend.
+    procedures_dir = Path(get_settings().knowledge_dir)
+    offenders = []
+    for path in sorted(procedures_dir.glob("*/*.md")):
+        text = path.read_text(encoding="utf-8")
+        if "MobilityOps" in text or re.search(r"\bPoC\b", text):
+            offenders.append(str(path))
+    assert offenders == []
+
+
 def test_s6_damage_question_is_grounded_with_expected_sources():
     provider = DemoKnowledgeProvider()
     answer = provider.ask(
diff --git a/backend/tests/test_search.py b/backend/tests/test_search.py
index 488a9bf..ca80d22 100644
--- a/backend/tests/test_search.py
+++ b/backend/tests/test_search.py
@@ -11,6 +11,10 @@ def test_search_finds_a_vehicle_by_reference(ops_client):
     assert match is not None
     assert match["label"] == "MO-001"
     assert match["link"] == "/vehicles/MO-001"
+    # The backend must never send localizable prose -- only a stable code plus raw
+    # data params, so the frontend can render it in the operator's selected language.
+    assert match["detail_code"] == "vehicleSummary"
+    assert set(match["detail_params"]) == {"make", "model", "location"}
 
 
 def test_search_finds_a_booking_by_reference(ops_client):
@@ -37,7 +41,21 @@ def test_search_never_returns_data_quality_issues_for_rental_employee(employee_c
 
 def test_search_section_result_visible_to_operations_manager(ops_client):
     result = ops_client.get("/api/v1/search", params={"q": "audit"}).json()
-    assert any(r["type"] == "section" and r["link"] == "/audit" for r in result["results"])
+    match = next(
+        (r for r in result["results"] if r["type"] == "section" and r["link"] == "/audit"), None
+    )
+    assert match is not None
+    # Section results must ship a stable id, not English prose -- the frontend looks up
+    # navigation:items.<id> and search:sections.<id>.detail in the selected locale.
+    assert match["label"] == "audit"
+    assert match["detail_code"] == "audit"
+
+
+def test_search_section_matches_dutch_and_french_terms(ops_client):
+    nl_result = ops_client.get("/api/v1/search", params={"q": "wagenpark"}).json()
+    assert any(r["type"] == "section" and r["link"] == "/vehicles" for r in nl_result["results"])
+    fr_result = ops_client.get("/api/v1/search", params={"q": "réservation"}).json()
+    assert any(r["type"] == "section" and r["link"] == "/bookings" for r in fr_result["results"])
 
 
 def test_search_section_result_hidden_from_rental_employee(employee_client):
diff --git a/backend/tests/test_seed.py b/backend/tests/test_seed.py
index 076cd1a..199cf66 100644
--- a/backend/tests/test_seed.py
+++ b/backend/tests/test_seed.py
@@ -23,8 +23,12 @@ def test_seed_counts_match_deterministic_dataset():
         assert db.scalar(select(func.count()).select_from(Vehicle)) == 50
         assert db.scalar(select(func.count()).select_from(Customer)) == 180
         assert db.scalar(select(func.count()).select_from(Booking)) == 246
-        # 15 from the CSV plus a deterministic set discovered by the post-seed scan.
-        assert db.scalar(select(func.count()).select_from(DataQualityIssue)) == 26
+        # 15 from the CSV plus a deterministic set discovered by the post-seed scan. The
+        # shared vehicle-status evaluator (app.services.vehicle_status) now also catches
+        # MO-024: an active/return-pending booking (BK-DEMO-RETURN) on a vehicle that has
+        # already crossed its service-due odometer threshold -- a genuine conflict the
+        # previous hand-rolled scanner never checked for.
+        assert db.scalar(select(func.count()).select_from(DataQualityIssue)) == 27
         assert db.scalar(select(func.count()).select_from(OutboxEvent)) == 20
         assert db.scalar(select(func.count()).select_from(User)) == 2
     finally:
@@ -138,6 +142,7 @@ def test_seed_scenario_s5_failed_workflow_run():
         assert failed.delivery_status == "failed"
         assert failed.attempts >= 1
         assert failed.last_error
+        assert failed.last_error_code == "connectionError"
     finally:
         db.close()
 
diff --git a/backend/tests/test_vehicle_status.py b/backend/tests/test_vehicle_status.py
new file mode 100644
index 0000000..b983dff
--- /dev/null
+++ b/backend/tests/test_vehicle_status.py
@@ -0,0 +1,160 @@
+"""Pure unit tests for the shared vehicle-status evaluator -- no database needed, since
+evaluate_vehicle_status() only reasons over an already-gathered VehicleStatusFacts. See
+docs/fleet-ops-correction/vehicle-status-decision-table.md for the decision table these
+tests are asserting against."""
+
+from types import SimpleNamespace
+
+from app.services.vehicle_status import (
+    RECOMMENDATION_CODE_ACTIVE_RENTAL,
+    RECOMMENDATION_CODE_BOOKING_CONFLICT,
+    RECOMMENDATION_CODE_MANUAL_REVIEW,
+    RECOMMENDATION_CODE_NO_CONFLICT,
+    RECOMMENDATION_CODE_RENTAL_ENDED,
+    RECOMMENDATION_CODE_SERVICE_THRESHOLD,
+    VehicleStatusFacts,
+    compute_recommendation_token,
+    evaluate_vehicle_status,
+)
+
+
+def _vehicle(status: str, *, version: int = 1):
+    return SimpleNamespace(operational_status=status, version=version)
+
+
+def _facts(**overrides) -> VehicleStatusFacts:
+    defaults = dict(
+        active_booking_refs=[],
+        overlapping_booking_pairs=[],
+        service_threshold_reached=False,
+        odometer_km=10_000,
+        next_service_km=20_000,
+        open_booking_overlap_issue_ref=None,
+    )
+    defaults.update(overrides)
+    return VehicleStatusFacts(**defaults)
+
+
+def test_available_with_active_rental_recommends_rented():
+    result = evaluate_vehicle_status(
+        _vehicle("available"), _facts(active_booking_refs=["BK-0001"])
+    )
+    assert result.recommended_status == "rented"
+    assert result.recommendation_code == RECOMMENDATION_CODE_ACTIVE_RENTAL
+    assert result.safe_to_apply is True
+    assert result.manual_review_required is False
+
+
+def test_maintenance_with_active_rental_never_auto_recommends_rented():
+    # The exact unsafe shortcut this task explicitly forbids: maintenance + an active
+    # booking must NEVER be auto-resolved to "rented".
+    result = evaluate_vehicle_status(
+        _vehicle("maintenance"), _facts(active_booking_refs=["BK-0001"])
+    )
+    assert result.recommended_status is None
+    assert result.manual_review_required is True
+    assert result.safe_to_apply is False
+    assert result.recommendation_code == RECOMMENDATION_CODE_MANUAL_REVIEW
+
+
+def test_available_with_active_rental_and_service_threshold_requires_manual_review():
+    result = evaluate_vehicle_status(
+        _vehicle("available"),
+        _facts(active_booking_refs=["BK-0001"], service_threshold_reached=True),
+    )
+    assert result.manual_review_required is True
+    assert result.recommended_status is None
+
+
+def test_available_with_active_rental_and_booking_conflict_requires_manual_review():
+    result = evaluate_vehicle_status(
+        _vehicle("available"),
+        _facts(active_booking_refs=["BK-0001"], open_booking_overlap_issue_ref="DQ-0001"),
+    )
+    assert result.manual_review_required is True
+    assert result.recommended_status is None
+
+
+def test_rented_with_no_active_booking_recommends_available():
+    result = evaluate_vehicle_status(_vehicle("rented"), _facts())
+    assert result.recommended_status == "available"
+    assert result.recommendation_code == RECOMMENDATION_CODE_RENTAL_ENDED
+    assert result.safe_to_apply is True
+
+
+def test_service_threshold_reached_recommends_maintenance():
+    result = evaluate_vehicle_status(
+        _vehicle("available"), _facts(service_threshold_reached=True)
+    )
+    assert result.recommended_status == "maintenance"
+    assert result.recommendation_code == RECOMMENDATION_CODE_SERVICE_THRESHOLD
+
+
+def test_booking_conflict_recommends_blocked_not_a_generic_high_severity_proxy():
+    # The evaluator must react to a *real* booking-conflict fact, not "does some other
+    # open high-severity issue happen to exist" (the forbidden proxy).
+    result = evaluate_vehicle_status(
+        _vehicle("available"),
+        _facts(overlapping_booking_pairs=[("BK-DEMO-OVERLAP-A", "BK-DEMO-OVERLAP-B")]),
+    )
+    assert result.recommended_status == "blocked"
+    assert result.recommendation_code == RECOMMENDATION_CODE_BOOKING_CONFLICT
+
+
+def test_open_booking_overlap_issue_alone_also_triggers_blocked():
+    result = evaluate_vehicle_status(
+        _vehicle("available"), _facts(open_booking_overlap_issue_ref="DQ-DEMO-OVERLAP")
+    )
+    assert result.recommended_status == "blocked"
+    assert result.recommendation_code == RECOMMENDATION_CODE_BOOKING_CONFLICT
+
+
+def test_maintenance_with_no_active_rental_and_no_blockers_stays_manual():
+    # No fact here confirms maintenance is actually finished, so the evaluator must not
+    # auto-clear it to "available" -- that release remains an explicit, manual decision.
+    result = evaluate_vehicle_status(_vehicle("maintenance"), _facts())
+    assert result.recommended_status is None
+    assert result.recommendation_code == RECOMMENDATION_CODE_NO_CONFLICT
+    assert result.safe_to_apply is False
+
+
+def test_no_conflict_when_status_already_matches_facts():
+    result = evaluate_vehicle_status(_vehicle("available"), _facts())
+    assert result.recommended_status is None
+    assert result.recommendation_code == RECOMMENDATION_CODE_NO_CONFLICT
+    assert result.safe_to_apply is False
+
+    result = evaluate_vehicle_status(_vehicle("rented"), _facts(active_booking_refs=["BK-1"]))
+    assert result.recommendation_code == RECOMMENDATION_CODE_NO_CONFLICT
+
+    result = evaluate_vehicle_status(_vehicle("blocked"), _facts())
+    assert result.recommendation_code == RECOMMENDATION_CODE_NO_CONFLICT
+
+    result = evaluate_vehicle_status(
+        _vehicle("maintenance"), _facts(service_threshold_reached=True)
+    )
+    assert result.recommendation_code == RECOMMENDATION_CODE_NO_CONFLICT
+
+
+def test_recommendation_token_changes_when_facts_change():
+    vehicle = _vehicle("available")
+    facts_a = _facts()
+    facts_b = _facts(service_threshold_reached=True)
+    assert compute_recommendation_token(vehicle, facts_a) != compute_recommendation_token(
+        vehicle, facts_b
+    )
+
+
+def test_recommendation_token_is_stable_for_identical_facts():
+    vehicle = _vehicle("available")
+    facts = _facts(active_booking_refs=["BK-0001"])
+    assert compute_recommendation_token(vehicle, facts) == compute_recommendation_token(
+        vehicle, facts
+    )
+
+
+def test_recommendation_token_changes_when_vehicle_version_changes():
+    facts = _facts()
+    assert compute_recommendation_token(
+        _vehicle("available", version=1), facts
+    ) != compute_recommendation_token(_vehicle("available", version=2), facts)
diff --git a/contracts/openapi.yaml b/contracts/openapi.yaml
index e30e681..70ae0f3 100644
--- a/contracts/openapi.yaml
+++ b/contracts/openapi.yaml
@@ -1,8 +1,11 @@
 openapi: 3.1.0
 info:
-  title: MobilityOps API
+  title: Fleet Ops API
   version: 0.1.0
-  description: Contract baseline for the MobilityOps proof of concept.
+  description: >-
+    Contract baseline for the Fleet Ops demo. "Fleet Ops" is the visible product name;
+    "mobilityops" remains the technical identifier for the repository, deployment
+    directory, database, and internal service/health identifiers only.
 servers:
   - url: http://localhost:8128
 paths:
@@ -181,26 +184,67 @@ paths:
           description: Wrong rule type, issue not open, or overlap still present
         '422':
           description: booking_ref not one of the overlapping bookings
+  /api/v1/data-quality/issues/{public_ref}/status-recommendation:
+    post:
+      operationId: previewVehicleStatusRecommendation
+      description: >-
+        vehicle_status_conflict only. Non-mutating: computes the recommendation from
+        the same shared evaluator the scanner and apply endpoint use
+        (app.services.vehicle_status.evaluate_vehicle_status), without resolving the
+        issue, writing an audit event, or queuing automation. Safe to call repeatedly
+        -- see docs/fleet-ops-correction/vehicle-status-decision-table.md.
+      parameters:
+        - $ref: '#/components/parameters/PublicRef'
+      responses:
+        '200':
+          description: >-
+            Current/recommended status, recommendation code, safe_to_apply,
+            manual_review_required, the underlying facts, and a recommendation_token
+            the apply endpoint revalidates against.
+        '409':
+          description: Wrong rule type, issue not open, or vehicle not found
   /api/v1/data-quality/issues/{public_ref}/apply-recommended-status:
     post:
       operationId: applyRecommendedVehicleStatus
       description: >-
         vehicle_status_conflict only. Applies the one authoritative recommendation
-        function's output and re-validates before resolving.
+        function's output within one transaction: locks the issue and vehicle,
+        recomputes the recommendation from fresh facts, rejects the request if the
+        supplied recommendation_token no longer matches (RECOMMENDATION_STALE), refuses
+        an unsafe/manual-review recommendation (MANUAL_REVIEW_REQUIRED) or a
+        recommendation with nothing to apply (NO_CONFLICT_DETECTED), then re-validates
+        the same evaluator post-write before resolving the issue.
       parameters:
         - $ref: '#/components/parameters/PublicRef'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [recommendation_token]
+              properties:
+                recommendation_token:
+                  type: string
+                  description: The token from the most recent status-recommendation preview call.
       responses:
         '200':
-          description: Applied status, reason and the resolved issue
+          description: Applied status, reason code and the resolved issue
         '409':
-          description: Wrong rule type, issue not open, or no conflict detected
+          description: >-
+            Wrong rule type, issue not open, vehicle not found, stale recommendation
+            token, manual review required, no conflict detected, or the applied status
+            did not resolve the conflict on re-validation
   /api/v1/search:
     get:
       operationId: search
       description: >-
         Bounded typed results (vehicle, booking, data_quality_issue, section).
         Data-quality and manager-only sections are filtered server-side by role.
-        Customers are never returned -- no customer detail route exists.
+        Customers are never returned -- no customer detail route exists. Every result's
+        `label` is a stable public_ref/section id (never translatable prose); `detail_code`
+        (+ optional `detail_params` for data values like make/model/location) is what the
+        frontend localizes -- the backend never emits English/Dutch/French sentences here.
       parameters:
         - in: query
           name: q
diff --git a/docs/fleet-ops-correction/current-gap-audit.md b/docs/fleet-ops-correction/current-gap-audit.md
new file mode 100644
index 0000000..8684977
--- /dev/null
+++ b/docs/fleet-ops-correction/current-gap-audit.md
@@ -0,0 +1,75 @@
+# Fleet Ops correction — current-state gap audit
+
+## Branch / commit state (at audit time)
+
+- Repository's actual main/default branch is named **`master`** (there is no `main` branch — `remotes/origin/HEAD -> origin/master`). All instructions referring to "main" in this task are treated as referring to `master`.
+- `master` (local and `origin/master`) was at `18344bc8b7a75a2f868bf15bf498fc030ac6c34c` before this task started — this is the newest verified Fleet Ops demo commit (contains the full rebrand/i18n/adaptive-guide/Data-Quality-UX work from the previous task).
+- Deployed commit on Unraid (`/mnt/user/appdata/mobilityops/.deploy/source-revision`): `18344bc8b7a75a2f868bf15bf498fc030ac6c34c` — matches `master` exactly. No drift.
+- No uncommitted local changes at audit time (`git status` clean).
+- Source branch for this correction: `master` (already contained the newest verified commit). New branch created: **`fix/fleet-ops-i18n-status-flow`**, branched from `master` at `18344bc`.
+- `feat/mobilityops-functional-completion` remains un-deleted, as instructed by the prior task, and is left untouched by this one.
+
+## Confirmed gaps (verified against actual code, not assumed)
+
+### 1. Brand name is a translatable key (structural risk)
+
+- `common:appName` exists per-locale in `frontend/src/i18n/locales/{nl-BE,en-GB,fr-BE}/common.json`, all currently `"Fleet Ops"`, but nothing prevents a future edit from diverging one locale. Used in `Login.tsx:35` and `Layout.tsx:180`.
+- 8 more locale keys embed the literal string "Fleet Ops" inside translatable prose (`auth.defaultDescription`, `common.footer.productLine`, `demo.guide.steps["review-real-vs-simulated"].expectedOutcome`, `demo.about.title`, `demo.about.problemBody`, `demo.about.scopeBody`, `knowledge.emptyDescription`, `navigation.searchLabel`, `returns.scenario.body`) — all three locales currently say "Fleet Ops" correctly, but structurally these are still translatable values.
+- **Fix**: `frontend/src/product.ts` exports `PRODUCT_NAME = "Fleet Ops"`. Remove `common:appName`; `Login.tsx`/`Layout.tsx` import the constant directly. Replace the 8 embedded mentions with `{{productName}}` interpolation, passing `productName: PRODUCT_NAME` explicitly at each call site. Add a Playwright test that fails if any locale JSON file contains the literal substring `"Fleet Ops"` (forcing all future brand mentions through interpolation) and a live-DOM test asserting the rendered brand text is byte-identical across all three languages.
+
+### 2. Backend hardcodes English prose as primary user-facing content (structural, not cosmetic)
+
+Confirmed in `backend/app/services/data_quality.py`:
+- `_scan_duplicate_customers` (~line 127-149): evidence signals literally `"exact email"`, `"exact phone"`, `"exact postal code"`, `"similar name"`, joined into `evidence.summary`.
+- `_scan_missing_required_fields` (~170, 185): `f"Missing: {', '.join(missing)}"`.
+- `_scan_booking_overlaps` (~213): `f"Overlapping bookings {first.public_ref} and {second.public_ref}"`.
+- `_scan_vehicle_status_conflicts` (~240-256): reason strings like `"marked available while an active booking exists"`.
+- `_scan_odometer_regressions` (~291-295): full English sentence with interpolated numbers/refs.
+- `_recommend_vehicle_status` (~659-668): recommendation `reason` strings returned verbatim as `ApplyRecommendedStatusResult.reason` and rendered directly in the UI.
+
+Confirmed in `backend/app/services/returns.py`:
+- `_derive_vehicle_status_with_reason` (~32-43): `status_reason` strings ("Damage was reported on return.", "A technical warning was reported on return.", "Odometer reached the {n} km service threshold.", "No damage, technical warning or service threshold; routed to cleaning.") flow straight into the API response and are displayed raw regardless of UI language (asserted verbatim in English in `interactive-elements.spec.ts:133`, confirming this is genuinely user-visible, not just internal).
+
+Confirmed in `backend/app/services/dispatcher.py` / seed data: `event.last_error` stores raw strings like `"Synthetic connection timeout to n8n"` from `seed/workflow_runs.csv`, rendered directly in `Automation.tsx` (`{r.last_error ?? "—"}`) with no localization or summarization.
+
+Frontend confirmed to display these values completely raw: `DataQualityIssueDetail.tsx` → `<dd>{String(issue.evidence.summary ?? "")}</dd>` — the *label* is translated, the *value* is not.
+
+**Fix**: introduce structured `signals`/`message_code`+`params` on evidence and reasons (data-quality evidence, status-conflict recommendation reason, return status reason, automation last-error), with a frontend mapping layer that localizes known codes and falls back to the raw string under "Technical details" only.
+
+### 3–5, 8A. Status-recommendation flow is unsafe and combines calculation with mutation
+
+- **Confirmed single mutating endpoint**: `POST /api/v1/data-quality/issues/{public_ref}/apply-recommended-status` (`backend/app/api/routers/data_quality.py`) computes the recommendation and mutates the vehicle in the same call. No separate preview/GET route exists for this flow (unlike the return flow, which already has `preview_vehicle_return` / `register_vehicle_return` sharing one pure evaluator).
+- **Confirmed unsafe shortcut** (explicitly prohibited by this task): `_recommend_vehicle_status` in `data_quality.py` returns `("rented", ...)` whenever `operational_status == "maintenance" and has_active_booking` — i.e. a vehicle flagged for maintenance with an active booking is auto-recommended (and, on one click, actually changed) to `rented`, with no check of the underlying reason it's in maintenance and no manual-review branch.
+- **Confirmed proxy-based reasoning** (explicitly prohibited): the `available` + `has_open_high_issue` → `blocked` branch depends only on "does some other open high-severity issue exist for this vehicle", not on real underlying facts (damage, technical warning, confirmed overlap). `data_quality.py` never imports `Inspection`, so damage/technical-warning facts are never examined by this function at all.
+- **Confirmed scanner/resolver duplication**: `_scan_vehicle_status_conflicts` and `_recommend_vehicle_status` are two independently-maintained `if`-chains (hand-kept-in-sync via a docstring comment, not shared code) — a structural fragility even though today's four branches happen to agree.
+
+**Fix**: new shared domain service `backend/app/services/vehicle_status.py` with one `evaluate_vehicle_status()` function consulting real facts (active/reserved/overlapping bookings, latest inspection damage/technical-warning, maintenance threshold, cleaning state), used by scanner, a new non-mutating preview endpoint, the apply endpoint, and tests. Maintenance+active-booking becomes `manual_review_required`, never an automatic `rented`. Full decision table in `docs/fleet-ops-correction/vehicle-status-decision-table.md`.
+
+### 6–7. MO-016 / issue-ordering
+
+- Confirmed `MO-016` scenario: vehicle seeded `operational_status="available"`, two overlapping *reserved* bookings (`BK-DEMO-OVERLAP-A`/`-B`), two pre-seeded `open` issues on the same vehicle (`DQ-DEMO-OVERLAP` booking_overlap, `DQ-DEMO-STATUS` vehicle_status_conflict).
+- Confirmed **no test** resolves both issues in sequence (either order) within one session to check the outcome stays deterministic — each existing test independently resets the demo data first.
+
+**Fix**: new evaluator is order-independent by construction (recomputes real facts every call, doesn't cache any prior issue's existence as an input other than the generic "another open high-severity issue for manual-review fallback"); add an explicit ordering test.
+
+### 8. i18n-coverage test doesn't prove translation happened
+
+Confirmed: `frontend/e2e/i18n-coverage.spec.ts` only checks key-parity and non-empty values — a locale file could contain the literal English string copy-pasted and the test would still pass. Locale files were manually verified as genuinely translated (no hits for probe phrases like "canonical odometer", "committed locally", "correlation ID" etc. in `nl-BE`/`fr-BE`), so this is a test-coverage gap, not an active mistranslation — but per this task's instructions it still needs closing.
+
+**Fix**: add a translation-quality test comparing `nl-BE`/`fr-BE` values against `en-GB` for meaningful divergence (with an explicit allowlist for real proper nouns/technical tokens: Fleet Ops, Northstar Mobility, n8n, RAGcore, MCP Hub, API, UUID, Docker, PostgreSQL), plus a route-matrix smoke test opening every main route in all three languages.
+
+### 9. One confirmed leftover hardcoded string
+
+- `frontend/src/pages/BookingDetail.tsx:76` — `aria-label="Demo scenario"` is a literal, un-translated English string (the visible content beside it is correctly translated).
+
+**Fix**: route through `t("returns:scenario.ariaLabel")` (new key, 3 locales).
+
+### 10. Automation "last error" shown raw
+
+- `Automation.tsx` renders `r.last_error` directly with no localization/summarization layer, confirmed via the seeded `"Synthetic connection timeout to n8n"` string appearing verbatim regardless of UI language.
+
+**Fix**: known-code → localized summary + operational meaning, raw string demoted to "Technical details".
+
+## Scope note
+
+No gaps were found in: existing Control Rail navigation/layout, the three demo roles/authorization, the guided demo mechanics, n8n integration wiring, Docker/Unraid deployment scripts, or the previously-implemented adaptive Demo Guide / Data Quality choice-card UI — these are left untouched per the "do not redesign" instruction. This correction is scoped to the 10 problems above.
diff --git a/docs/fleet-ops-correction/i18n-inventory.md b/docs/fleet-ops-correction/i18n-inventory.md
new file mode 100644
index 0000000..d7e2e09
--- /dev/null
+++ b/docs/fleet-ops-correction/i18n-inventory.md
@@ -0,0 +1,25 @@
+# i18n inventory — dynamic/backend content requiring message-code treatment
+
+Static UI chrome (navigation, dashboard, forms, filters, dialogs, empty/loading states,
+Demo Guide, About page, accessibility labels) was already moved to the `i18next`
+namespace system in the prior task and is not re-inventoried here in full — see
+`docs/final-product-polish/audit.md` and `docs/final-product-polish/i18n-inventory.md`
+for that pass. This inventory covers only the sources confirmed still bypassing
+translation (per `current-gap-audit.md`), the fix chosen, and the tests that verify it.
+
+| # | Source | Location | Static/dynamic | Fix | Tests |
+|---|--------|----------|-----------------|-----|-------|
+| 1 | Duplicate-customer evidence signals | `backend/app/services/data_quality.py::_scan_duplicate_customers` | dynamic | `evidence.signals: [{code, params}]` (`duplicate.exact_email`, `duplicate.exact_phone`, `duplicate.same_postal_code`, `duplicate.similar_name` + score param); frontend maps code→localized phrase | `test_data_quality.py::test_duplicate_customer_evidence_has_structured_signals`; Playwright DQ evidence-language test |
+| 2 | Missing-required-field evidence | `_scan_missing_required_fields` | dynamic | `evidence.signals: [{code: "missing_field", params: {field}}]`; frontend maps `field` through the existing `CUSTOMER_FIELD_LABELS`/`VEHICLE_FIELD_LABELS`-equivalent i18n keys | same |
+| 3 | Booking-overlap evidence | `_scan_booking_overlaps` | dynamic | `evidence.signals: [{code: "overlap.reserved_bookings", params: {refs: [...]}}]` | same |
+| 4 | Vehicle-status-conflict evidence | `_scan_vehicle_status_conflicts` | dynamic | replaced entirely by the new `evaluate_vehicle_status()` evaluator's `recommendation_code`; scanner reuses the evaluator instead of its own reason strings | new evaluator unit tests |
+| 5 | Odometer-regression evidence | `_scan_odometer_regressions` | dynamic | `evidence.signals: [{code: "odometer.regression", params: {later_ref, later_km, earlier_ref, earlier_km}}]` | same |
+| 6 | Status-recommendation reason | `_recommend_vehicle_status` / new `evaluate_vehicle_status` | dynamic | `recommendation_code` + `facts` (structured), no free prose from the backend at all; frontend renders the full explanation from `quality:statusRecommendation.codes.<code>` | evaluator unit tests + preview/apply contract tests |
+| 7 | Return status reason | `backend/app/services/returns.py::_derive_vehicle_status_with_reason` | dynamic | `status_reason_code` + `params` alongside the existing human string (kept for backward-compat, demoted to technical fallback) | `test_returns.py` updated; Playwright return-flow-language test |
+| 8 | Automation `last_error` | `dispatcher.py` / seed data, rendered in `Automation.tsx` | dynamic | known-cause codes (`n8n.connection_timeout`, `n8n.http_error`, etc.) mapped to a localized summary + "what happened / what's pending / what retry does"; raw string demoted to Technical details | Playwright automation-language test |
+| 9 | `aria-label="Demo scenario"` | `frontend/src/pages/BookingDetail.tsx:76` | static, just un-wired | `t("returns:scenario.ariaLabel")`, 3 locales | i18n-coverage (key parity) + route-matrix test |
+| 10 | Brand name (`common:appName` + 8 embedded mentions) | see gap audit §1 | static, wrongly translatable | `PRODUCT_NAME` constant, `{{productName}}` interpolation | new brand-invariant test |
+
+## Message-code mapping module
+
+Centralised in `frontend/src/i18n/messageCodes.ts` (new): a single `resolveMessageCode(t, code, params)` helper used by the Data Quality evidence renderer, the status-recommendation panel, the return-result panel, and the automation ledger, so there is one place mapping `code → i18next key` rather than per-page switch statements.
diff --git a/docs/fleet-ops-correction/vehicle-status-decision-table.md b/docs/fleet-ops-correction/vehicle-status-decision-table.md
new file mode 100644
index 0000000..7cbb18f
--- /dev/null
+++ b/docs/fleet-ops-correction/vehicle-status-decision-table.md
@@ -0,0 +1,90 @@
+# Vehicle status decision table
+
+Authoritative rationale for `app/services/vehicle_status.py::evaluate_vehicle_status`,
+the single evaluator shared by the data-quality scanner, the status-recommendation
+preview endpoint, and the transactional apply endpoint (section 8A). Scanner and
+resolver call the same function with the same freshly-gathered facts, so they can never
+disagree, and the recommendation is order-independent: resolving, deferring, or
+rejecting an unrelated issue never changes what this function returns for a vehicle,
+because it only reasons over the vehicle's and bookings' current state, never over
+issue history.
+
+## Facts gathered (`gather_vehicle_status_facts`)
+
+All facts are re-queried from the database on every call, never cached and never derived
+from "does some other issue happen to be open":
+
+| Fact | Source |
+|---|---|
+| `active_booking_refs` | Bookings on this vehicle with `status == "active"` |
+| `overlapping_booking_pairs` | Reserved/active bookings on this vehicle whose date ranges genuinely overlap |
+| `service_threshold_reached` | `vehicle.odometer_km >= vehicle.next_service_km` |
+| `open_booking_overlap_issue_ref` | The `public_ref` of a currently-open `booking_overlap` issue on this vehicle, if any (excluding the issue being resolved, via `exclude_issue_id`) |
+
+`has_active_rental` = at least one active booking. `has_booking_conflict` = an
+overlapping-booking pair exists, or an open `booking_overlap` issue references this
+vehicle.
+
+## Decision table
+
+| Current status | Active rental? | Service threshold reached? | Booking conflict? | Recommended status | Priority | `recommendation_code` | Safe to auto-apply? |
+|---|---|---|---|---|---|---|---|
+| any except `maintenance` | yes | no | no | `rented` (if not already) | 1 | `vehicle.active_rental` | yes |
+| `maintenance` | yes | — | — | *(none — manual review)* | 1 | `vehicle.manual_review_required` | no |
+| any | yes | yes | — | *(none — manual review)* | 1 | `vehicle.manual_review_required` | no |
+| any | yes | — | yes | *(none — manual review)* | 1 | `vehicle.manual_review_required` | no |
+| not `maintenance` | no | yes | — | `maintenance` | 2 | `vehicle.service_threshold_reached` | yes |
+| `maintenance` | no | yes | — | *(none — already correct)* | 2 | `vehicle.no_conflict` | n/a |
+| not `blocked` | no | no | yes | `blocked` | 3 | `vehicle.booking_conflict` | yes |
+| `blocked` | no | no | yes | *(none — already correct)* | 3 | `vehicle.no_conflict` | n/a |
+| `rented` | no | no | no | `available` | 4 | `vehicle.rental_ended` | yes |
+| `available` / `cleaning` / `blocked` | no | no | no | *(none — already correct)* | 4 | `vehicle.no_conflict` | n/a |
+| `maintenance` | no | no | no | *(none — stays in maintenance)* | 4 | `vehicle.no_conflict` | n/a |
+| anything not covered above | — | — | — | *(none — manual review)* | 5 | `vehicle.manual_review_required` | no |
+
+## Safe-status principles (section 8B) applied
+
+- **Maintenance + active booking never auto-resolves to `rented`.** Being currently in
+  `maintenance` is itself treated as a blocking fact (row 2 above) — an active booking
+  is never proof the vehicle should be marked rented; it is a real contradiction that
+  requires a human to investigate (e.g. was the vehicle released from the workshop
+  without updating status, or is the booking itself stale).
+- **`available` + any booking never auto-resolves to `rented` silently past a real
+  blocker.** The `rented` recommendation only fires when there is no competing blocking
+  fact (no service-threshold breach, no booking conflict, not already in maintenance).
+- **An open issue disappearing never auto-resolves to `available`.** Leaving
+  `maintenance` requires a human decision — this evaluator holds no fact that proves
+  maintenance work is actually finished (no completed-service record is modelled), so a
+  vehicle sitting in `maintenance` with no active rental and no other blocker stays
+  `vehicle.no_conflict` (left alone) rather than being auto-promoted to `available`.
+- **Every branch re-derives facts; nothing is cached.** `blocking_reasons` is always
+  computed fresh from `service_threshold_reached`, `has_booking_conflict`, and the
+  current status itself — never from a proxy like "is some other high-severity issue
+  still open".
+
+## Statuses used
+
+Only statuses that exist in the current domain model are referenced: `available`,
+`rented`, `cleaning`, `maintenance`, `blocked`. `cleaning` is never a recommendation
+target from this evaluator (no fact here proves cleaning is required or complete); it is
+only ever an input `current_status` that, absent any blocker, is left alone
+(`vehicle.no_conflict`).
+
+## Concurrency: recommendation token
+
+`compute_recommendation_token(vehicle, facts)` hashes the vehicle's optimistic-lock
+`version` plus every fact the recommendation was based on (sha256, truncated to 16 hex
+chars). The preview endpoint returns this token; the apply endpoint recomputes it from
+freshly-gathered facts inside the same transaction and rejects the request
+(`RECOMMENDATION_STALE`) if it no longer matches — the frontend must never assume a
+previously-shown preview is still valid without server revalidation (section 8F).
+
+## MO-016: order independence
+
+MO-016 carries both an open `booking_overlap` issue and an open
+`vehicle_status_conflict` issue at once (two overlapping reserved bookings). Because
+`gather_vehicle_status_facts` re-queries `overlapping_booking_pairs` and
+`open_booking_overlap_issue_ref` fresh every call, resolving the booking-overlap issue
+first vs. resolving the status-conflict issue first both converge on the same final
+vehicle status — see `test_mo_016_status_conflict_recommendation_is_order_independent`
+in `backend/tests/test_data_quality.py`.
diff --git a/frontend/e2e/demo-accessibility.spec.ts b/frontend/e2e/demo-accessibility.spec.ts
index af2d696..ff7bd52 100644
--- a/frontend/e2e/demo-accessibility.spec.ts
+++ b/frontend/e2e/demo-accessibility.spec.ts
@@ -85,3 +85,38 @@ test("key demo pages load without console errors", async ({ page }) => {
 
   expect(errors, `Unexpected console errors: ${errors.join("\n")}`).toEqual([]);
 });
+
+test("status-recommendation panel is fully keyboard operable, respects reduced motion, and never signals status by colour alone", async ({
+  page,
+  request,
+}) => {
+  await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  await request.post("/api/v1/demo/reset");
+  await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+
+  await page.emulateMedia({ reducedMotion: "reduce" });
+  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-STATUS");
+
+  const reviewButton = page.getByRole("button", { name: "Aanbeveling bekijken" });
+  await reviewButton.focus();
+  await expect(reviewButton).toBeFocused();
+  await page.keyboard.press("Enter");
+
+  const confirmButton = page.getByRole("button", { name: /^Status wijzigen naar/ });
+  await expect(confirmButton).toBeVisible();
+
+  // Status is never conveyed by colour alone: the badge always carries its own text.
+  const badge = page.locator(".status-decision .badge").first();
+  await expect(badge).not.toHaveText("");
+
+  // The confirm action itself is a real, focusable, keyboard-activatable button (the
+  // previous "Aanbeveling bekijken" button is unmounted once the decision panel
+  // replaces it, so focus is verified directly rather than via a Tab chain from it).
+  await confirmButton.focus();
+  await expect(confirmButton).toBeFocused();
+  await page.keyboard.press("Enter");
+  await expect(page.getByText("Toegepast", { exact: false })).toBeVisible();
+});
diff --git a/frontend/e2e/fleet-ops-correction.spec.ts b/frontend/e2e/fleet-ops-correction.spec.ts
new file mode 100644
index 0000000..1bd0ba8
--- /dev/null
+++ b/frontend/e2e/fleet-ops-correction.spec.ts
@@ -0,0 +1,379 @@
+import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+
+// Targeted end-to-end coverage for the Fleet Ops correction brief (docs/fleet-ops-
+// correction/): branding, the redesigned status-recommendation flow (preview/apply/
+// manual-review/stale-token), MO-016 order independence, trilingual knowledge
+// grounding, and localized audit/automation content. See also i18n-coverage.spec.ts
+// (key parity, brand invariant, translation-quality) and responsive-i18n.spec.ts
+// (breakpoint matrix) for the complementary static-content checks.
+
+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();
+  // /api/v1/demo/reset deletes the session cookie (it recreates the users table), so any
+  // further authenticated call through this same request context needs a fresh login.
+  const relogin = await request.post("/api/v1/demo/login", { data: { role: "operations_manager" } });
+  expect(relogin.ok()).toBeTruthy();
+}
+
+const EXPLORE_OPS_MANAGER: Record<string, string> = {
+  "nl-BE": "Verken als Operations Manager",
+  "en-GB": "Explore as Operations Manager",
+  "fr-BE": "Explorer en tant qu'Operations Manager",
+};
+
+const REVIEW_RECOMMENDATION: Record<string, string> = {
+  "nl-BE": "Aanbeveling bekijken",
+  "en-GB": "Review recommendation",
+  "fr-BE": "Voir la recommandation",
+};
+
+const CHANGE_STATUS_PREFIX: Record<string, RegExp> = {
+  "nl-BE": /^Status wijzigen naar/,
+  "en-GB": /^Change status to/,
+  "fr-BE": /^Changer le statut vers/,
+};
+
+const MANUAL_REVIEW_HEADING: Record<string, string> = {
+  "nl-BE": "Handmatige beoordeling vereist",
+  "en-GB": "Manual review required",
+  "fr-BE": "Évaluation manuelle requise",
+};
+
+async function loginAsOpsManager(page: Page, lang: string) {
+  await page.addInitScript((l) => localStorage.setItem("fleetops.language", l), lang);
+  await page.goto("/login");
+  await page.getByRole("button", { name: EXPLORE_OPS_MANAGER[lang] }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+}
+
+test.describe.configure({ mode: "serial" });
+
+test.describe("branding", () => {
+  for (const lang of ["nl-BE", "en-GB", "fr-BE"]) {
+    test(`Fleet Ops is the visible brand and no MobilityOps/PoC leaks through (${lang})`, async ({
+      page,
+      request,
+    }) => {
+      await resetDemoData(request);
+      await loginAsOpsManager(page, lang);
+      await expect(page.locator(".brand-mark").first()).toBeVisible();
+      await expect(page.getByText("Fleet Ops", { exact: true }).first()).toBeVisible();
+      await expect(page.locator(".app-footer")).toContainText("Fleet Ops");
+      await expect(page.locator("html")).toHaveAttribute("lang", lang);
+
+      for (const path of ["/dashboard", "/vehicles", "/data-quality", "/audit", "/automation", "/knowledge"]) {
+        await page.goto(path);
+        const text = await page.locator("body").innerText();
+        expect(text, `${path} (${lang})`).not.toContain("MobilityOps");
+        expect(text, `${path} (${lang})`).not.toMatch(/\bPoC\b/);
+      }
+    });
+  }
+});
+
+test("language switcher control changes the UI and persists across a reload", async ({ page, request }) => {
+  await resetDemoData(request);
+  // Deliberately not using loginAsOpsManager here: its addInitScript would re-force
+  // nl-BE on every reload, defeating exactly the persistence behaviour under test.
+  await page.goto("/login");
+  await page.getByRole("button", { name: EXPLORE_OPS_MANAGER["nl-BE"] }).click();
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await expect(page.getByRole("heading", { name: "Aandachtspunten" })).toBeVisible();
+
+  await page.getByRole("combobox", { name: "Taal" }).selectOption("fr-BE");
+  await expect(page.getByRole("heading", { name: "File d'attention" })).toBeVisible();
+  await expect(page.locator("html")).toHaveAttribute("lang", "fr-BE");
+
+  await page.reload();
+  await expect(page.getByRole("heading", { name: "File d'attention" })).toBeVisible();
+  await expect(page.locator("html")).toHaveAttribute("lang", "fr-BE");
+});
+
+test.describe("status-recommendation flow", () => {
+  test("preview does not mutate anything, apply names the exact target status", async ({ page, request }) => {
+    await resetDemoData(request);
+    await loginAsOpsManager(page, "nl-BE");
+    await page.goto("/data-quality/DQ-DEMO-STATUS");
+    await expect(page.getByRole("heading", { name: "DQ-DEMO-STATUS" })).toBeVisible();
+
+    await page.getByRole("button", { name: REVIEW_RECOMMENDATION["nl-BE"] }).click();
+    await expect(page.getByText("Aanbevolen status")).toBeVisible();
+    await expect(page.getByRole("heading", { name: "Waarom" })).toBeVisible();
+    await expect(page.getByRole("heading", { name: "Gevolg" })).toBeVisible();
+
+    // Previewing must not have resolved the issue -- still open, using the page's own
+    // authenticated session (page.request shares cookies with the browser context).
+    const issue = await page.request.get("/api/v1/data-quality/issues/DQ-DEMO-STATUS");
+    expect((await issue.json()).status).toBe("open");
+
+    const confirmButton = page.getByRole("button", { name: CHANGE_STATUS_PREFIX["nl-BE"] });
+    await expect(confirmButton).toHaveText(/Geblokkeerd/);
+    await confirmButton.click();
+    await expect(page.getByText("Toegepast", { exact: false })).toBeVisible();
+
+    const resolved = await page.request.get("/api/v1/data-quality/issues/DQ-DEMO-STATUS");
+    expect((await resolved.json()).status).toBe("resolved");
+  });
+
+  test("manual review state offers no generic apply button for a genuine fact contradiction", async ({
+    page,
+    request,
+  }) => {
+    await resetDemoData(request);
+    const issues = await (
+      await request.get("/api/v1/data-quality/issues", {
+        params: { rule_type: "vehicle_status_conflict", status: "open" },
+      })
+    ).json();
+    const conflicted = issues.find((i: { entity_ref: string }) => i.entity_ref === "MO-024");
+    expect(conflicted, "expected MO-024's vehicle_status_conflict issue to exist after reset").toBeTruthy();
+
+    await loginAsOpsManager(page, "en-GB");
+    await page.goto(`/data-quality/${conflicted.public_ref}`);
+    await page.getByRole("button", { name: REVIEW_RECOMMENDATION["en-GB"] }).click();
+
+    await expect(page.getByRole("heading", { name: MANUAL_REVIEW_HEADING["en-GB"] })).toBeVisible();
+    await expect(page.getByRole("button", { name: /^Change status to/ })).toHaveCount(0);
+  });
+
+  test("a stale recommendation is rejected and the user must review again before applying", async ({
+    page,
+    request,
+  }) => {
+    await resetDemoData(request);
+    await loginAsOpsManager(page, "en-GB");
+    await page.goto("/data-quality/DQ-DEMO-STATUS");
+    await page.getByRole("button", { name: REVIEW_RECOMMENDATION["en-GB"] }).click();
+    await expect(page.getByRole("button", { name: /^Change status to/ })).toBeVisible();
+
+    // Simulate the underlying facts changing after the preview was shown (the same
+    // session resolves the booking overlap in the meantime) -- the previously-fetched
+    // recommendation token must no longer be accepted.
+    await page.evaluate(async () => {
+      await fetch("/api/v1/data-quality/issues/DQ-DEMO-OVERLAP/resolve-overlap", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ booking_ref: "BK-DEMO-OVERLAP-B" }),
+      });
+    });
+
+    await page.getByRole("button", { name: /^Change status to/ }).click();
+    await expect(page.getByText(/situation has changed/i)).toBeVisible();
+    await expect(page.getByRole("button", { name: REVIEW_RECOMMENDATION["en-GB"] })).toBeVisible();
+  });
+});
+
+test.describe("MO-016 status conflict is order-independent", () => {
+  // Order independence does NOT mean "the same final vehicle status regardless of
+  // order" -- resolving the booking overlap first genuinely removes the conflict, so
+  // there is correctly nothing left to apply afterwards. What must hold in either
+  // order: the recommendation always reflects the real, current facts (never a stale
+  // "was some other issue open" proxy), and nothing unsafe is ever applied (never
+  // "rented").
+
+  test("resolving the booking overlap first correctly leaves nothing to apply", async ({ page, request }) => {
+    await resetDemoData(request);
+    await loginAsOpsManager(page, "nl-BE");
+    await page.goto("/data-quality/DQ-DEMO-OVERLAP");
+    await page.getByRole("radio", { name: /BK-DEMO-OVERLAP-B blokkeren/ }).check();
+    await page.getByRole("button", { name: /BK-DEMO-OVERLAP-B blokkeren/ }).click();
+    await expect(page.getByText("Opgelost").first()).toBeVisible();
+
+    await page.goto("/data-quality/DQ-DEMO-STATUS");
+    await page.getByRole("button", { name: REVIEW_RECOMMENDATION["nl-BE"] }).click();
+    await expect(page.getByRole("heading", { name: "Geen wijziging nodig" })).toBeVisible();
+    await expect(page.getByRole("button", { name: CHANGE_STATUS_PREFIX["nl-BE"] })).toHaveCount(0);
+
+    const vehicle = await request.get("/api/v1/vehicles/MO-016");
+    expect((await vehicle.json()).operational_status).toBe("available");
+  });
+
+  test("resolving the status conflict first safely blocks the vehicle, unaffected by the later overlap fix", async ({
+    page,
+    request,
+  }) => {
+    await resetDemoData(request);
+    await loginAsOpsManager(page, "nl-BE");
+    await page.goto("/data-quality/DQ-DEMO-STATUS");
+    await page.getByRole("button", { name: REVIEW_RECOMMENDATION["nl-BE"] }).click();
+    await page.getByRole("button", { name: CHANGE_STATUS_PREFIX["nl-BE"] }).click();
+    await expect(page.getByText("Toegepast", { exact: false })).toBeVisible();
+
+    const vehicleMid = await request.get("/api/v1/vehicles/MO-016");
+    const statusAfterApply = (await vehicleMid.json()).operational_status;
+    expect(statusAfterApply).not.toBe("rented");
+
+    await page.goto("/data-quality/DQ-DEMO-OVERLAP");
+    await page.getByRole("radio", { name: /BK-DEMO-OVERLAP-B blokkeren/ }).check();
+    await page.getByRole("button", { name: /BK-DEMO-OVERLAP-B blokkeren/ }).click();
+    await expect(page.getByText("Opgelost").first()).toBeVisible();
+
+    // Resolving the now-redundant overlap afterwards must not itself change the
+    // vehicle's status as a side effect.
+    const vehicleFinal = await request.get("/api/v1/vehicles/MO-016");
+    const statusFinal = (await vehicleFinal.json()).operational_status;
+    expect(statusFinal).toBe(statusAfterApply);
+    expect(statusFinal).not.toBe("rented");
+
+    await resetDemoData(request);
+  });
+});
+
+test.describe("knowledge base is grounded in the operator's own language", () => {
+  const cases: { lang: string; question: string; sourceHint: RegExp }[] = [
+    {
+      lang: "nl-BE",
+      question: "Wat moet ik doen wanneer een voertuig beschadigd terugkomt?",
+      sourceHint: /schadeafhandeling/i,
+    },
+    {
+      lang: "en-GB",
+      question: "What should I do when a vehicle returns with damage?",
+      sourceHint: /damage/i,
+    },
+    {
+      lang: "fr-BE",
+      question: "Que dois-je faire lorsqu'un véhicule revient endommagé ?",
+      sourceHint: /dommages/i,
+    },
+  ];
+
+  for (const { lang, question, sourceHint } of cases) {
+    test(`grounded ${lang} answer cites a ${lang} source about damage`, async ({ page, request }) => {
+      await resetDemoData(request);
+      await loginAsOpsManager(page, lang);
+      await page.goto("/knowledge");
+      await page.locator("#knowledge-question").fill(question);
+      await page.getByRole("button", { name: /^(Vraag stellen|Ask|Demander)$/ }).click();
+      await expect(page.getByText(sourceHint).first()).toBeVisible({ timeout: 10_000 });
+    });
+  }
+});
+
+test("audit trail shows localized action and field labels with raw codes only in technical details", async ({
+  page,
+  request,
+}) => {
+  await resetDemoData(request);
+  await loginAsOpsManager(page, "nl-BE");
+  await page.goto("/data-quality/DQ-DEMO-STATUS");
+  await page.getByRole("button", { name: REVIEW_RECOMMENDATION["nl-BE"] }).click();
+  await page.getByRole("button", { name: CHANGE_STATUS_PREFIX["nl-BE"] }).click();
+  await expect(page.getByText("Toegepast", { exact: false })).toBeVisible();
+
+  await page.goto("/audit");
+
+  // Applying resolves both the vehicle status and the issue in one correlated action --
+  // expand the group's "technical events" toggle so the other audit row's diff renders
+  // too, regardless of which one the grouping picked as primary.
+  const toggle = page.getByRole("button", { name: /technische gebeurtenis/ }).first();
+  await expect(toggle).toBeVisible();
+  await toggle.click();
+  await expect(page.getByRole("button", { name: "Technische gebeurtenissen verbergen" })).toBeVisible();
+
+  await expect(page.getByText("Aanbevolen status toegepast").first()).toBeVisible();
+  const diffs = page.locator(".change-diff");
+  await expect(diffs.first()).toBeVisible();
+  const combinedDiffText = (await diffs.allInnerTexts()).join(" ");
+  expect(combinedDiffText).toContain("Operationele status");
+  expect(combinedDiffText).not.toContain("operational_status");
+});
+
+test("automation shows a localized error explanation with the raw error only under technical details", async ({
+  page,
+  request,
+}) => {
+  await resetDemoData(request);
+  await loginAsOpsManager(page, "nl-BE");
+  await page.goto("/automation");
+
+  await expect(page.getByText(/tijdelijk niet bereikbaar/).first()).toBeVisible();
+  await expect(page.getByText("Synthetic connection timeout to n8n")).not.toBeVisible();
+  await page.getByText("Technische details").first().click();
+  await expect(page.getByText("Synthetic connection timeout to n8n")).toBeVisible();
+});
+
+test.describe("route matrix (section 11F)", () => {
+  // Opens every main route in all 3 languages: no console errors, correct html[lang],
+  // and a real, non-empty page heading (proving the route actually rendered content
+  // instead of silently falling back to a raw i18next key or a blank screen). Key
+  // parity across locale files is already proven structurally by i18n-coverage.spec.ts
+  // (every key that exists in nl-BE also exists, non-empty, in en-GB/fr-BE), so this
+  // matrix focuses on what only a live render can catch.
+  const routes = [
+    "/dashboard",
+    "/vehicles",
+    "/vehicles/MO-001",
+    "/bookings",
+    "/bookings/BK-DEMO-RETURN",
+    "/data-quality",
+    "/data-quality/DQ-DEMO-STATUS",
+    "/automation",
+    "/knowledge",
+    "/audit",
+    "/scenarios",
+    "/about",
+  ];
+
+  for (const lang of ["nl-BE", "en-GB", "fr-BE"]) {
+    test(`every main route renders correctly with no console errors (${lang})`, async ({ page, request }) => {
+      await resetDemoData(request);
+
+      const errors: string[] = [];
+      page.on("console", (msg) => {
+        if (msg.type() !== "error") return;
+        if (msg.text().includes("401") && msg.text().includes("Unauthorized")) return;
+        errors.push(msg.text());
+      });
+      page.on("pageerror", (err) => errors.push(err.message));
+
+      await loginAsOpsManager(page, lang);
+
+      for (const route of routes) {
+        await page.goto(route);
+        await expect(page.locator("html")).toHaveAttribute("lang", lang);
+        const heading = page.getByRole("heading", { level: 1 });
+        await expect(heading, `${route} (${lang})`).toBeVisible();
+        const headingText = (await heading.first().textContent())?.trim() ?? "";
+        expect(headingText, `${route} (${lang}) heading text`).not.toBe("");
+        // A raw, unresolved i18next key looks like "namespace:some.key.path" -- real
+        // page headings never contain a colon followed by a dotted identifier.
+        expect(headingText, `${route} (${lang}) heading looks like a raw i18n key`).not.toMatch(
+          /^[a-zA-Z]+:[\w.]+$/,
+        );
+      }
+
+      expect(errors, `Console errors across the route matrix (${lang}):\n${errors.join("\n")}`).toEqual([]);
+    });
+  }
+});
+
+test.describe("data-quality evidence summary is localized, not raw English (section 6)", () => {
+  // The primary evidence line at the top of every issue's detail page must render the
+  // structured `evidence.signals` in the operator's language; the legacy English
+  // `evidence.summary` string is a technical fallback only, visible solely inside
+  // "Technical details". Live-caught: this line was unconditionally showing raw
+  // English ("vehicle marked available while reserved bookings conflict") in every
+  // language until fixed.
+  const cases: { lang: string; expectedText: RegExp }[] = [
+    { lang: "nl-BE", expectedText: /overlappende reserveringen/i },
+    { lang: "en-GB", expectedText: /overlapping bookings/i },
+    { lang: "fr-BE", expectedText: /chevauchent|chevauchement/i },
+  ];
+
+  for (const { lang, expectedText } of cases) {
+    test(`vehicle_status_conflict evidence is localized (${lang})`, async ({ page, request }) => {
+      await resetDemoData(request);
+      await loginAsOpsManager(page, lang);
+      await page.goto("/data-quality/DQ-DEMO-STATUS");
+
+      const summarySection = page.locator(".record-surface-evidence");
+      await expect(summarySection).toBeVisible();
+      await expect(summarySection).toContainText(expectedText);
+      await expect(summarySection).not.toContainText("vehicle marked available while reserved bookings conflict");
+    });
+  }
+});
diff --git a/frontend/e2e/i18n-coverage.spec.ts b/frontend/e2e/i18n-coverage.spec.ts
index f5d3079..c83e01c 100644
--- a/frontend/e2e/i18n-coverage.spec.ts
+++ b/frontend/e2e/i18n-coverage.spec.ts
@@ -71,3 +71,187 @@ test("no locale file contains an empty string value", () => {
     }
   }
 });
+
+// --- Brand-invariant: "Fleet Ops" is a fixed constant, never a translation value ---
+// (see frontend/src/product.ts and docs/fleet-ops-correction/current-gap-audit.md §1).
+// A regression here means someone re-introduced a per-locale brand key/value instead of
+// interpolating {{productName}} from the shared constant.
+
+test("no locale file defines an 'appName' key or the literal brand string", () => {
+  for (const language of LANGUAGES) {
+    for (const namespace of namespaces) {
+      const data = loadNamespace(language, namespace);
+      const raw = JSON.stringify(data);
+      expect(
+        raw.includes("Fleet Ops"),
+        `${language}/${namespace}.json contains the literal brand string "Fleet Ops" -- ` +
+          `use {{productName}} interpolation instead so the brand can never drift per locale`,
+      ).toBe(false);
+      const keys = collectKeyPaths(data);
+      expect(
+        keys.some((k) => k === "appName" || k.endsWith(".appName")),
+        `${language}/${namespace}.json defines an "appName" key -- the brand name must come ` +
+          `from the PRODUCT_NAME constant, never a translatable key`,
+      ).toBe(false);
+    }
+  }
+});
+
+// --- Translation-quality: prove values were actually translated, not copy-pasted ---
+// Sleutelpariteit alone doesn't prove translation happened (a locale file could contain
+// the literal English string under the right key and still pass). For every "real prose"
+// string (>=8 chars, not on the allowlist below), assert nl-BE and fr-BE differ from
+// en-GB, and that fr-BE differs from nl-BE -- catching both "still English" and
+// "Dutch text copy-pasted into French" in one pass.
+
+// Exact (namespace, key-path) pairs that are legitimately identical across two or more
+// locales: real proper nouns/brand names, deliberately-untranslated role titles, and
+// genuine cross-language cognates (identical spelling in Dutch/French/English). This is
+// a precise allowlist by key path, not a broad word-level allowlist, so it can't quietly
+// hide an unrelated real mistranslation under the same key in a different namespace.
+const IDENTICAL_VALUE_ALLOWLIST = new Set([
+  "audit.title", // "Audit trail" kept as an established cross-language compliance term
+  "audit.diff.was", // "{{field}}: was {{value}}" -- "was" is spelled identically in Dutch
+  "auth.roleOperationsManager", // deliberately-untranslated role title (see demo.json roles)
+  "auth.roleRentalEmployee",
+  "demo.scenarios.roles.operations_manager", // same convention, scenario-overview role labels
+  "demo.scenarios.roles.rental_employee",
+  "common.language.nl-BE", // language-picker options show each language's own endonym
+  "common.language.fr-BE",
+  "common.footer.productLine", // "{{productName}} Demo" -- brief-specified exact footer text
+  "common.orgName", // "Northstar Mobility" -- fictional org proper noun, same in all 3
+  "dashboard.attention.openRecord", // "Open {{title}}" -- "open" is also the Dutch imperative
+  "demo.scenarios.durationValue", // "± {{minutes}} min" -- unit abbreviation, same in all 3
+  "demo.scenarios.startScenario", // "start"/"scenario" are naturalised loanwords in Dutch
+  "demo.about.limitationsTitle", // "Limitations" -- identical spelling in French
+  "demo.integrationSummary.titles.mcp_hub", // "ITWorx MCP Hub" -- proper noun
+  "fleet.list.columns.attention", // "Attention" -- identical spelling in French
+  "fleet.detail.tabs.inspections", // "Inspections" -- identical spelling in French
+  "integrations.cards.orchestrationKicker", // "Orchestration" -- identical in French
+  "knowledge.questionLabel", // "Question" -- identical spelling in French
+  "knowledge.retrievalFlow.question",
+  "knowledge.questionLabelExchange",
+  "navigation.items.audit", // "Audit trail" kept as an established cross-language term
+  "returns.result.inspection", // "Inspection" -- identical spelling in French
+]);
+
+function isTranslatableProse(value: unknown): value is string {
+  if (typeof value !== "string") return false;
+  if (value.trim().length < 8) return false;
+  // Strip interpolation placeholders and non-letter characters; if nothing substantial
+  // remains (pure numbers/punctuation/units), it's not "prose" that needs translating.
+  const stripped = value
+    .replace(/\{\{[^}]+\}\}/g, " ")
+    .replace(/[^a-zA-Zà-öø-ÿÀ-ÖØ-ß]/g, "");
+  return stripped.trim().length >= 3;
+}
+
+test("nl-BE and fr-BE translations are not suspiciously identical to en-GB or each other", () => {
+  for (const namespace of namespaces) {
+    const en = loadNamespace("en-GB", namespace);
+    const nl = loadNamespace("nl-BE", namespace);
+    const fr = loadNamespace("fr-BE", namespace);
+    const keys = collectKeyPaths(en);
+
+    for (const keyPath of keys) {
+      if (IDENTICAL_VALUE_ALLOWLIST.has(`${namespace}.${keyPath}`)) continue;
+      const at = (data: Record<string, unknown>) =>
+        keyPath.split(".").reduce<unknown>((acc, part) => {
+          if (acc && typeof acc === "object") return (acc as Record<string, unknown>)[part];
+          return undefined;
+        }, data);
+
+      const enValue = at(en);
+      if (!isTranslatableProse(enValue)) continue;
+      const nlValue = at(nl);
+      const frValue = at(fr);
+
+      expect(
+        nlValue,
+        `${namespace}.json:${keyPath} — nl-BE is identical to en-GB ("${enValue}"); ` +
+          `looks untranslated (add to IDENTICAL_VALUE_ALLOWLIST if this is intentional)`,
+      ).not.toBe(enValue);
+      expect(
+        frValue,
+        `${namespace}.json:${keyPath} — fr-BE is identical to en-GB ("${enValue}"); ` +
+          `looks untranslated (add to IDENTICAL_VALUE_ALLOWLIST if this is intentional)`,
+      ).not.toBe(enValue);
+      expect(
+        frValue,
+        `${namespace}.json:${keyPath} — fr-BE is identical to nl-BE ("${nlValue}"); ` +
+          `looks like Dutch text was copy-pasted into the French locale`,
+      ).not.toBe(nlValue);
+    }
+  }
+});
+
+// --- Hardcoded JSX text (section 11D) ---
+// A targeted, deliberately narrow static scan: JSX text nodes (`>literal text<`, not a
+// `{...}` expression) containing two or more real words are almost always user-facing
+// prose that should go through t(...). This is not a full parser, so a short, explicit
+// allowlist covers technical tokens/proper nouns that are correctly never translated
+// (MobilityOps.md is checked for absence elsewhere; this list is for things that ARE
+// expected to appear literally in JSX).
+const SRC_DIR = path.resolve(__dirname, "../src");
+const SCAN_DIRS = ["pages", "components"];
+
+const ALLOWED_LITERAL_TEXT = new Set([
+  "Fleet Ops", // the non-localizable brand name (frontend/src/product.ts)
+  "Northstar Mobility", // fictional demo org, a proper noun
+  "ITWorx MCP Hub", // proper noun
+]);
+
+function collectTsxFiles(dir: string): string[] {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  return entries.flatMap((entry) => {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) return collectTsxFiles(full);
+    return entry.name.endsWith(".tsx") ? [full] : [];
+  });
+}
+
+function findHardcodedJsxText(filePath: string): string[] {
+  const source = fs.readFileSync(filePath, "utf-8");
+  const findings: string[] = [];
+  // Matches `<Tag ...>text</Tag>` where the closing tag name backreferences the
+  // opening one -- this specifically excludes TypeScript generics like
+  // `useState<string | null>(null)`, which have no matching `</string | null>` closer,
+  // unlike a naive `>...<` scan would. Deliberately spans newlines (Prettier commonly
+  // puts JSX text on its own line) and does not attempt to parse JSX properly -- it is
+  // a fast, approximate net for the common mistake, not a compiler.
+  const jsxTextPattern = /<([A-Za-z][\w.]*)(?:\s[^<>]*)?>([^<>{}]{3,200})<\/\1>/gs;
+  let match: RegExpExecArray | null;
+  while ((match = jsxTextPattern.exec(source)) !== null) {
+    const text = match[2].trim();
+    if (!text) continue;
+    if (ALLOWED_LITERAL_TEXT.has(text)) continue;
+    // Needs at least two alphabetic words to count as "prose" -- filters out numbers,
+    // single technical words, units (km, %), punctuation-only fragments, and JSX
+    // whitespace artifacts.
+    const words = text.match(/[A-Za-z]+/g) ?? [];
+    if (words.length < 2) continue;
+    // Skip anything that is itself an i18next interpolation artifact leaking through
+    // (shouldn't happen, but never flag `{{...}}`-shaped remnants) or looks like a URL
+    // or path.
+    if (/^https?:\/\//.test(text) || text.includes("/") || text.includes("{{")) continue;
+    findings.push(`${path.relative(SRC_DIR, filePath)}: "${text}"`);
+  }
+  return findings;
+}
+
+test("no hardcoded user-facing JSX text outside the approved technical-token allowlist", () => {
+  const allFindings: string[] = [];
+  for (const dir of SCAN_DIRS) {
+    const files = collectTsxFiles(path.join(SRC_DIR, dir));
+    for (const file of files) {
+      allFindings.push(...findHardcodedJsxText(file));
+    }
+  }
+  expect(
+    allFindings,
+    `Found ${allFindings.length} likely hardcoded JSX string(s) bypassing t(...). ` +
+      `Either route it through the translation system, or add the exact literal to ` +
+      `ALLOWED_LITERAL_TEXT in this test if it's a genuine proper noun/technical token:\n` +
+      allFindings.join("\n"),
+  ).toEqual([]);
+});
diff --git a/frontend/e2e/interactive-elements.spec.ts b/frontend/e2e/interactive-elements.spec.ts
index a00160c..c771b80 100644
--- a/frontend/e2e/interactive-elements.spec.ts
+++ b/frontend/e2e/interactive-elements.spec.ts
@@ -130,9 +130,13 @@ test("return preview correctly reports blocked (not maintenance) for damage repo
 
   // The preview is the server's authoritative evaluation: damage always routes to
   // "blocked", never "maintenance" -- this used to be guessed client-side and wrong.
-  await expect(page.getByText("Damage was reported on return.")).toBeVisible();
+  // The localized reason is the primary text; the raw code sits behind "Technical
+  // details" so it isn't visible until expanded.
+  await expect(page.getByText("Damage was reported on this return.")).toBeVisible();
   const statusRegion = page.locator(".impact-preview");
   await expect(statusRegion.getByText("blocked", { exact: true })).toBeVisible();
+  await page.getByText("Technical details").click();
+  await expect(page.getByText("Damage was reported on return.")).toBeVisible();
 });
 
 test("data quality page: status and rule-type filters work", async ({ page }) => {
@@ -201,8 +205,8 @@ test("data quality: applying the recommended status resolves a vehicle conflict"
   await page.goto("/data-quality/DQ-DEMO-STATUS");
   await expect(page.getByRole("heading", { name: "DQ-DEMO-STATUS" })).toBeVisible();
 
-  await page.getByRole("button", { name: "Calculate and apply recommended status" }).click();
-  await page.getByRole("button", { name: "Yes, apply" }).click();
+  await page.getByRole("button", { name: "Review recommendation" }).click();
+  await page.getByRole("button", { name: /^Change status to/ }).click();
 
   await expect(page.getByText("Applied", { exact: false })).toBeVisible();
 });
diff --git a/frontend/src/api/types.ts b/frontend/src/api/types.ts
index df0bc30..d6de408 100644
--- a/frontend/src/api/types.ts
+++ b/frontend/src/api/types.ts
@@ -109,6 +109,7 @@ export interface AutomationRun {
   status: string;
   attempts: number;
   last_error: string | null;
+  last_error_code: string | null;
   occurred_at: string;
 }
 
@@ -154,6 +155,8 @@ export interface ReturnPreviewResult {
   resulting_odometer_km: number;
   resulting_vehicle_status: string;
   status_reason: string;
+  status_reason_code: string;
+  status_reason_params: Record<string, string | number>;
   would_create_quality_issue: boolean;
   attention_reasons: string[];
   next_booking_risk: NextBookingRisk | null;
@@ -173,7 +176,27 @@ export interface DataQualityIssueDetail extends DataQualityIssue {
 export interface ApplyRecommendedStatusResult {
   issue: DataQualityIssue;
   applied_status: string;
-  reason: string;
+  reason_code: string;
+}
+
+export interface VehicleStatusFacts {
+  active_booking_refs: string[];
+  overlapping_booking_pairs: string[][];
+  service_threshold_reached: boolean;
+  odometer_km: number;
+  next_service_km: number;
+  open_booking_overlap_issue_ref: string | null;
+}
+
+export interface StatusRecommendation {
+  current_status: string;
+  recommended_status: string | null;
+  recommendation_code: string;
+  safe_to_apply: boolean;
+  manual_review_required: boolean;
+  facts: VehicleStatusFacts;
+  blocking_reasons: string[];
+  recommendation_token: string;
 }
 
 export interface ScanResult {
@@ -183,7 +206,8 @@ export interface ScanResult {
 export interface SearchResultItem {
   type: "vehicle" | "booking" | "data_quality_issue" | "section";
   label: string;
-  detail: string;
+  detail_code: string;
+  detail_params: Record<string, string>;
   link: string;
 }
 
diff --git a/frontend/src/components/DemoGuide.tsx b/frontend/src/components/DemoGuide.tsx
index 55a7caf..8be19c1 100644
--- a/frontend/src/components/DemoGuide.tsx
+++ b/frontend/src/components/DemoGuide.tsx
@@ -8,6 +8,7 @@ import { useDemoManifest } from "../context/DemoManifestContext";
 import { useViewportTier } from "../hooks/useViewportTier";
 import { DEMO_GUIDE_STEPS } from "../data/demoGuideSteps";
 import { Icon } from "./Icons";
+import { PRODUCT_NAME } from "../product";
 
 export function DemoGuideTrigger() {
   const { t } = useTranslation("demo");
@@ -206,7 +207,7 @@ export function DemoGuide() {
               <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>
+              <p><strong>{t("guide.expectedOutcome")}</strong><br />{t(`guide.steps.${step.id}.expectedOutcome`, { productName: PRODUCT_NAME })}</p>
             </div>
           )}
 
diff --git a/frontend/src/components/Layout.tsx b/frontend/src/components/Layout.tsx
index 1aa6907..4b05fa5 100644
--- a/frontend/src/components/Layout.tsx
+++ b/frontend/src/components/Layout.tsx
@@ -10,6 +10,7 @@ import { DemoGuide, DemoGuideTrigger } from "./DemoGuide";
 import { LanguageSwitcher } from "./LanguageSwitcher";
 import { useDemoGuide } from "../context/DemoGuideContext";
 import { useDemoManifest } from "../context/DemoManifestContext";
+import { PRODUCT_NAME } from "../product";
 
 const SEARCH_ICON: Record<SearchResultItem["type"], IconName> = {
   vehicle: "fleet",
@@ -18,6 +19,31 @@ const SEARCH_ICON: Record<SearchResultItem["type"], IconName> = {
   section: "chevron",
 };
 
+// The backend only ever sends a stable code + raw data params (never English prose) --
+// see app/api/routers/search.py. Localizing here means the label/detail always follow
+// the operator's selected locale, in every namespace search results can point to.
+function searchResultLabel(t: (key: string, opts?: Record<string, unknown>) => string, item: SearchResultItem): string {
+  if (item.type === "section") return t(`navigation:items.${item.label}`, { defaultValue: item.label });
+  return item.label;
+}
+
+function searchResultDetail(t: (key: string, opts?: Record<string, unknown>) => string, item: SearchResultItem): string {
+  switch (item.type) {
+    case "section":
+      return t(`searchSections.${item.detail_code}`, { defaultValue: item.detail_code });
+    case "vehicle":
+      return t("searchVehicleSummary", { ...item.detail_params });
+    case "booking":
+      return t(`bookings:statuses.${item.detail_code}`, { defaultValue: item.detail_code });
+    case "data_quality_issue":
+      return t(`quality:ruleTypes.${item.detail_code}`, {
+        defaultValue: item.detail_code.replace(/_/g, " "),
+      });
+    default:
+      return item.detail_code;
+  }
+}
+
 interface NavItem {
   to: string;
   labelKey: string;
@@ -177,7 +203,7 @@ export function Layout() {
       <aside className={`sidebar ${mobileOpen ? "is-open" : ""}`}>
         <div className="brand-lockup">
           <BrandMark className="brand-mark" />
-          <div><strong>{t("common:appName")}</strong><span>{t("common:brandTagline")}</span></div>
+          <div><strong>{PRODUCT_NAME}</strong><span>{t("common:brandTagline")}</span></div>
         </div>
         <div className="sidebar-language">
           <LanguageSwitcher />
@@ -234,7 +260,7 @@ export function Layout() {
           </button>
           <div className="global-search" role="search" ref={searchBox}>
             <Icon name="search" />
-            <label className="visually-hidden" htmlFor="global-search-input">{t("searchLabel")}</label>
+            <label className="visually-hidden" htmlFor="global-search-input">{t("searchLabel", { productName: PRODUCT_NAME })}</label>
             <input
               id="global-search-input"
               ref={searchInput}
@@ -276,8 +302,8 @@ export function Layout() {
                     >
                       <Icon name={SEARCH_ICON[item.type]} />
                       <span className="search-result-copy">
-                        <strong>{item.label}</strong>
-                        <small>{item.detail}</small>
+                        <strong>{searchResultLabel(t, item)}</strong>
+                        <small>{searchResultDetail(t, item)}</small>
                       </span>
                     </button>
                   ))}
@@ -302,7 +328,7 @@ export function Layout() {
         </header>
 
         <main id="main-content" tabIndex={-1}><Outlet /></main>
-        <footer className="app-footer"><span>{t("common:footer.productLine")}</span><span>{t("common:footer.locale")}</span></footer>
+        <footer className="app-footer"><span>{t("common:footer.productLine", { productName: PRODUCT_NAME })}</span><span>{t("common:footer.locale")}</span></footer>
       </div>
 
       <nav className="mobile-nav" aria-label={t("mobileNavLabel")}>
diff --git a/frontend/src/components/ReturnForm.tsx b/frontend/src/components/ReturnForm.tsx
index 724504f..142a096 100644
--- a/frontend/src/components/ReturnForm.tsx
+++ b/frontend/src/components/ReturnForm.tsx
@@ -220,7 +220,17 @@ export function ReturnForm({
           <Icon name={preview.attention_reasons.length > 0 ? "alert" : "check"} />
           <div>
             <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>
+            <p>{t(`review.reasonCodes.${preview.status_reason_code}`, {
+              defaultValue: preview.status_reason,
+              threshold_km:
+                typeof preview.status_reason_params.threshold_km === "number"
+                  ? formatNumber(preview.status_reason_params.threshold_km)
+                  : undefined,
+            })}</p>
+            <details className="evidence-disclosure">
+              <summary>{t("common:actions.technicalDetails")}</summary>
+              <pre className="evidence-block">{preview.status_reason}</pre>
+            </details>
           </div>
         </div>
         {preview.odometer_regression && (
diff --git a/frontend/src/i18n/locales/en-GB/audit.json b/frontend/src/i18n/locales/en-GB/audit.json
index 2dfcae1..b5422e6 100644
--- a/frontend/src/i18n/locales/en-GB/audit.json
+++ b/frontend/src/i18n/locales/en-GB/audit.json
@@ -40,6 +40,29 @@
     "was": "{{field}}: was {{value}}",
     "changed": "{{field}}: {{before}} → {{after}}"
   },
+  "actorTypes": {
+    "user": "User",
+    "system": "System",
+    "service": "Service"
+  },
+  "fields": {
+    "status": "Status",
+    "operational_status": "Operational status",
+    "registration_number": "Registration number",
+    "make": "Make",
+    "model": "Model",
+    "location": "Location",
+    "first_name": "First name",
+    "last_name": "Last name",
+    "email": "Email",
+    "phone": "Phone",
+    "postal_code": "Postal code",
+    "city": "City",
+    "booking_end_odometer_km": "Booking end odometer",
+    "vehicle_odometer_km": "Vehicle odometer",
+    "survivor": "Retained profile",
+    "loser": "Merged profile"
+  },
   "actions": {
     "demo_login": "Logged in",
     "demo_logout": "Logged out",
diff --git a/frontend/src/i18n/locales/en-GB/auth.json b/frontend/src/i18n/locales/en-GB/auth.json
index 29b5e44..aae3dd1 100644
--- a/frontend/src/i18n/locales/en-GB/auth.json
+++ b/frontend/src/i18n/locales/en-GB/auth.json
@@ -3,7 +3,7 @@
   "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.",
+  "defaultDescription": "{{productName}} 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",
diff --git a/frontend/src/i18n/locales/en-GB/common.json b/frontend/src/i18n/locales/en-GB/common.json
index 432ce01..84a09c7 100644
--- a/frontend/src/i18n/locales/en-GB/common.json
+++ b/frontend/src/i18n/locales/en-GB/common.json
@@ -1,5 +1,4 @@
 {
-  "appName": "Fleet Ops",
   "orgName": "Northstar Mobility",
   "brandTagline": "Control Centre",
   "actions": {
@@ -35,7 +34,7 @@
     "fr-BE": "Français"
   },
   "footer": {
-    "productLine": "Fleet Ops Demo",
+    "productLine": "{{productName}} Demo",
     "locale": "Europe/Brussels · Synthetic demo data"
   },
   "demo": {
diff --git a/frontend/src/i18n/locales/en-GB/demo.json b/frontend/src/i18n/locales/en-GB/demo.json
index 503cdae..3c91913 100644
--- a/frontend/src/i18n/locales/en-GB/demo.json
+++ b/frontend/src/i18n/locales/en-GB/demo.json
@@ -83,7 +83,7 @@
         "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."
+        "expectedOutcome": "You can explain yourself what {{productName}} is and isn't, with no verbal explanation needed."
       }
     }
   },
@@ -146,16 +146,16 @@
   },
   "about": {
     "eyebrow": "About this demo",
-    "title": "What Fleet Ops is and isn't",
+    "title": "What {{productName}} 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.",
+    "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. {{productName}} 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.",
+    "scopeBody": "This demo is for anyone who wants to see how {{productName}} 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",
diff --git a/frontend/src/i18n/locales/en-GB/fleet.json b/frontend/src/i18n/locales/en-GB/fleet.json
index c36f9eb..6a5b865 100644
--- a/frontend/src/i18n/locales/en-GB/fleet.json
+++ b/frontend/src/i18n/locales/en-GB/fleet.json
@@ -63,6 +63,14 @@
     "noQualityIssues": "No quality issues recorded.",
     "fuel": "Fuel {{percent}}%",
     "damage": "Damage",
-    "technicalWarning": "Technical warning"
+    "technicalWarning": "Technical warning",
+    "inspectionTypes": {
+      "departure": "Departure inspection",
+      "return": "Return inspection"
+    },
+    "maintenanceCategories": {
+      "periodic_service": "Periodic service",
+      "repair": "Repair"
+    }
   }
 }
diff --git a/frontend/src/i18n/locales/en-GB/integrations.json b/frontend/src/i18n/locales/en-GB/integrations.json
index b3f8ab1..73c5e4d 100644
--- a/frontend/src/i18n/locales/en-GB/integrations.json
+++ b/frontend/src/i18n/locales/en-GB/integrations.json
@@ -65,6 +65,13 @@
     "noAction": "—",
     "eventTypes": {
       "vehicle.returned.v1": "Vehicle return processed"
+    },
+    "errorCodes": {
+      "connectionError": "The workflow service was temporarily unreachable. The return was safely saved and can be retried.",
+      "malformedPayload": "The job contained incomplete data and could not be delivered. The underlying data remains safely stored.",
+      "remoteReportedFailure": "The workflow service declined the delivery. The job can be retried.",
+      "staleLeaseRecovered": "This job was recovered after an earlier delivery attempt stalled without a result.",
+      "unknownError": "An unexpected error occurred while delivering this job."
     }
   }
 }
diff --git a/frontend/src/i18n/locales/en-GB/knowledge.json b/frontend/src/i18n/locales/en-GB/knowledge.json
index 80e5c53..87fc924 100644
--- a/frontend/src/i18n/locales/en-GB/knowledge.json
+++ b/frontend/src/i18n/locales/en-GB/knowledge.json
@@ -24,7 +24,7 @@
     "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.",
+  "emptyDescription": "Ask about returns, damage, inspections or another indexed procedure. {{productName}} will not invent an answer when evidence is missing.",
   "retrievalFlow": {
     "question": "Question",
     "sources": "Sources",
diff --git a/frontend/src/i18n/locales/en-GB/navigation.json b/frontend/src/i18n/locales/en-GB/navigation.json
index 03fba39..f479b28 100644
--- a/frontend/src/i18n/locales/en-GB/navigation.json
+++ b/frontend/src/i18n/locales/en-GB/navigation.json
@@ -27,12 +27,22 @@
   "resetConfirmYes": "Yes, reset",
   "resetCancel": "Cancel",
   "resetFailed": "Could not reset demo data.",
-  "searchLabel": "Search Fleet Ops",
+  "searchLabel": "Search {{productName}}",
   "searchPlaceholder": "Search fleet, booking or section…",
   "searchShortcutHint": "Ctrl K",
   "searchSearching": "Searching…",
   "searchUnavailable": "Search is unavailable right now.",
   "searchNoResults": "No matches for \"{{query}}\".",
+  "searchVehicleSummary": "{{make}} {{model}} · {{location}}",
+  "searchSections": {
+    "overview": "Operations dashboard",
+    "fleet": "Vehicle registry",
+    "bookings": "Rental bookings",
+    "quality": "Quality workbench",
+    "knowledge": "Procedure assistant",
+    "integrations": "Automation and integration status",
+    "audit": "Audit history"
+  },
   "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
index 7f9a1c7..6a6531b 100644
--- a/frontend/src/i18n/locales/en-GB/quality.json
+++ b/frontend/src/i18n/locales/en-GB/quality.json
@@ -101,6 +101,17 @@
         "whyItMatters": "An incorrect status can make an unavailable vehicle appear bookable, or keep an available vehicle hidden from the fleet."
       }
     },
+    "evidence": {
+      "duplicate.exact_email": "Identical email address",
+      "duplicate.exact_phone": "Identical phone number",
+      "duplicate.same_postal_code": "Same postal code",
+      "duplicateSimilarName": "Strongly similar name (score {{score}})",
+      "missingField": "Missing field: {{field}}",
+      "overlapReservedBookings": "Overlapping bookings: {{refs}}",
+      "odometerRegression": "Booking {{laterRef}} recorded {{laterKm}} km, below the {{earlierKm}} km recorded by earlier booking {{earlierRef}}.",
+      "upcomingBookingMissingInspection": "Booking {{bookingRef}} starts soon but the required operational inspection is still missing.",
+      "seedPlaceholder": "Synthetic seed data with no further detail."
+    },
     "duplicateCustomer": {
       "heading": "Compare and merge",
       "description": "Choose the canonical customer and review each conflicting field.",
@@ -180,13 +191,48 @@
       "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?",
+      "reviewRecommendation": "Review recommendation",
+      "loadingRecommendation": "Loading recommendation…",
+      "recommendationFailed": "Could not load a recommendation.",
+      "recommendedStatus": "Recommended status",
+      "whyHeading": "Why",
+      "evidenceHeading": "Facts",
+      "consequenceHeading": "Consequence",
+      "consequence": {
+        "statusWillChange": "The vehicle status will change to {{status}}.",
+        "issueWillBeRechecked": "This quality issue will be re-checked.",
+        "changeWillBeAudited": "The change will be recorded in the audit trail.",
+        "bookingsNotDeleted": "The bookings themselves are not deleted."
+      },
+      "changeStatusTo": "Change status to {{status}}",
       "applying": "Applying…",
-      "confirmYes": "Yes, apply",
       "applied": "Applied {{status}} — {{reason}}",
-      "applyFailed": "Could not apply a recommended status."
+      "applyFailed": "Could not apply a recommended status.",
+      "staleRecommendation": "The situation has changed since this recommendation was shown. Review it again before applying.",
+      "reviewAgain": "Review recommendation again",
+      "manualReview": {
+        "heading": "Manual review required",
+        "body": "The facts for this vehicle contradict each other. An Operations Manager needs to review this in person rather than apply an automatic status change.",
+        "hint": "Use 'Defer' or 'Reject' below, or investigate the vehicle and the related bookings manually."
+      },
+      "noConflict": {
+        "heading": "No change needed",
+        "body": "This vehicle's current status already matches the facts."
+      },
+      "evidence": {
+        "activeBookings": "Active booking(s): {{refs}}",
+        "overlappingBookings": "Overlapping bookings: {{pairs}}",
+        "serviceThresholdReached": "Odometer reading ({{odometer}} km) has reached the service threshold ({{threshold}} km).",
+        "openOverlapIssue": "Open booking-overlap issue: {{ref}}"
+      },
+      "reasonCodes": {
+        "vehicle.active_rental": "This vehicle has an active rental but is not recorded as rented. The status is corrected to reflect the actual situation.",
+        "vehicle.service_threshold_reached": "This vehicle has reached its service threshold. It is set to maintenance so it is not deployed before servicing takes place.",
+        "vehicle.booking_conflict": "This vehicle has two overlapping bookings. Blocking it prevents it from being considered available again before the booking conflict is resolved.",
+        "vehicle.rental_ended": "The rental for this vehicle has ended and there is no active booking left. It is set back to available.",
+        "vehicle.manual_review_required": "The facts for this vehicle contradict each other (for example, an active booking while the vehicle is in maintenance, or a service threshold reached alongside an active rental). This requires a human review rather than an automatic status change.",
+        "vehicle.no_conflict": "This vehicle's current status already matches the facts. No change is needed."
+      }
     }
   }
 }
diff --git a/frontend/src/i18n/locales/en-GB/returns.json b/frontend/src/i18n/locales/en-GB/returns.json
index d6913f9..ebddbb7 100644
--- a/frontend/src/i18n/locales/en-GB/returns.json
+++ b/frontend/src/i18n/locales/en-GB/returns.json
@@ -36,6 +36,13 @@
     "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.",
+    "reasonCodes": {
+      "returnBlockedDamageAndTechnical": "Both damage and a technical warning were reported on this return.",
+      "returnBlockedDamage": "Damage was reported on this return.",
+      "returnBlockedTechnicalWarning": "A technical warning was reported on this return.",
+      "returnServiceThresholdReached": "The odometer reading has reached the {{threshold_km}} km service threshold.",
+      "returnRoutedToCleaning": "No damage, technical warning or service threshold reached; the vehicle goes to cleaning."
+    },
     "commitList": {
       "inspection": "Create a return inspection",
       "updateAtomic": "Update the booking and vehicle atomically",
@@ -66,8 +73,9 @@
     "continueDemo": "Continue the demo"
   },
   "scenario": {
+    "ariaLabel": "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.",
+    "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 {{productName}} detects and handles this.",
     "preparing": "Preparing scenario…"
   }
 }
diff --git a/frontend/src/i18n/locales/fr-BE/audit.json b/frontend/src/i18n/locales/fr-BE/audit.json
index dc72532..e7cda2e 100644
--- a/frontend/src/i18n/locales/fr-BE/audit.json
+++ b/frontend/src/i18n/locales/fr-BE/audit.json
@@ -40,6 +40,29 @@
     "was": "{{field}} : était {{value}}",
     "changed": "{{field}} : {{before}} → {{after}}"
   },
+  "actorTypes": {
+    "user": "Utilisateur",
+    "system": "Système",
+    "service": "Service"
+  },
+  "fields": {
+    "status": "Statut",
+    "operational_status": "Statut opérationnel",
+    "registration_number": "Plaque d'immatriculation",
+    "make": "Marque",
+    "model": "Modèle",
+    "location": "Emplacement",
+    "first_name": "Prénom",
+    "last_name": "Nom",
+    "email": "E-mail",
+    "phone": "Téléphone",
+    "postal_code": "Code postal",
+    "city": "Ville",
+    "booking_end_odometer_km": "Kilométrage final de la réservation",
+    "vehicle_odometer_km": "Kilométrage du véhicule",
+    "survivor": "Profil conservé",
+    "loser": "Profil fusionné"
+  },
   "actions": {
     "demo_login": "Connecté",
     "demo_logout": "Déconnecté",
diff --git a/frontend/src/i18n/locales/fr-BE/auth.json b/frontend/src/i18n/locales/fr-BE/auth.json
index 2b7695e..ead5bc9 100644
--- a/frontend/src/i18n/locales/fr-BE/auth.json
+++ b/frontend/src/i18n/locales/fr-BE/auth.json
@@ -3,7 +3,7 @@
   "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.",
+  "defaultDescription": "{{productName}} 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",
diff --git a/frontend/src/i18n/locales/fr-BE/common.json b/frontend/src/i18n/locales/fr-BE/common.json
index 74c52e9..f938e76 100644
--- a/frontend/src/i18n/locales/fr-BE/common.json
+++ b/frontend/src/i18n/locales/fr-BE/common.json
@@ -1,5 +1,4 @@
 {
-  "appName": "Fleet Ops",
   "orgName": "Northstar Mobility",
   "brandTagline": "Centre de contrôle",
   "actions": {
@@ -35,7 +34,7 @@
     "fr-BE": "Français"
   },
   "footer": {
-    "productLine": "Fleet Ops Demo",
+    "productLine": "{{productName}} Demo",
     "locale": "Europe/Bruxelles · Données de démonstration synthétiques"
   },
   "demo": {
diff --git a/frontend/src/i18n/locales/fr-BE/demo.json b/frontend/src/i18n/locales/fr-BE/demo.json
index 18874ed..fc5f02e 100644
--- a/frontend/src/i18n/locales/fr-BE/demo.json
+++ b/frontend/src/i18n/locales/fr-BE/demo.json
@@ -83,7 +83,7 @@
         "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."
+        "expectedOutcome": "Vous pouvez expliquer vous-même ce que {{productName}} est et n'est pas, sans explication verbale nécessaire."
       }
     }
   },
@@ -146,16 +146,16 @@
   },
   "about": {
     "eyebrow": "À propos de cette démo",
-    "title": "Ce que Fleet Ops est et n'est pas",
+    "title": "Ce que {{productName}} 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.",
+    "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. {{productName}} 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.",
+    "scopeBody": "Cette démo s'adresse à quiconque veut voir comment {{productName}} 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",
diff --git a/frontend/src/i18n/locales/fr-BE/fleet.json b/frontend/src/i18n/locales/fr-BE/fleet.json
index 5678d7c..44819bd 100644
--- a/frontend/src/i18n/locales/fr-BE/fleet.json
+++ b/frontend/src/i18n/locales/fr-BE/fleet.json
@@ -63,6 +63,14 @@
     "noQualityIssues": "Aucun problème de qualité enregistré.",
     "fuel": "Carburant {{percent}}%",
     "damage": "Dommage",
-    "technicalWarning": "Avertissement technique"
+    "technicalWarning": "Avertissement technique",
+    "inspectionTypes": {
+      "departure": "Inspection de départ",
+      "return": "Inspection de retour"
+    },
+    "maintenanceCategories": {
+      "periodic_service": "Entretien périodique",
+      "repair": "Réparation"
+    }
   }
 }
diff --git a/frontend/src/i18n/locales/fr-BE/integrations.json b/frontend/src/i18n/locales/fr-BE/integrations.json
index 9d775cc..6ee7997 100644
--- a/frontend/src/i18n/locales/fr-BE/integrations.json
+++ b/frontend/src/i18n/locales/fr-BE/integrations.json
@@ -65,6 +65,13 @@
     "noAction": "—",
     "eventTypes": {
       "vehicle.returned.v1": "Retour de véhicule traité"
+    },
+    "errorCodes": {
+      "connectionError": "Le service d'automatisation était temporairement injoignable. Le retour a été enregistré en toute sécurité et peut être soumis à nouveau.",
+      "malformedPayload": "La tâche contenait des données incomplètes et n'a pas pu être livrée. Les données sous-jacentes restent enregistrées en toute sécurité.",
+      "remoteReportedFailure": "Le service d'automatisation a refusé la livraison. La tâche peut être soumise à nouveau.",
+      "staleLeaseRecovered": "Cette tâche a été récupérée après qu'une tentative de livraison précédente s'est arrêtée sans résultat.",
+      "unknownError": "Une erreur inattendue s'est produite lors de la livraison de cette tâche."
     }
   }
 }
diff --git a/frontend/src/i18n/locales/fr-BE/knowledge.json b/frontend/src/i18n/locales/fr-BE/knowledge.json
index 60f935d..34e0100 100644
--- a/frontend/src/i18n/locales/fr-BE/knowledge.json
+++ b/frontend/src/i18n/locales/fr-BE/knowledge.json
@@ -24,7 +24,7 @@
     "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.",
+  "emptyDescription": "Posez des questions sur les retours, les dommages, les inspections ou une autre procédure indexée. {{productName}} n'invente jamais de réponse en l'absence de preuves.",
   "retrievalFlow": {
     "question": "Question",
     "sources": "Sources",
diff --git a/frontend/src/i18n/locales/fr-BE/navigation.json b/frontend/src/i18n/locales/fr-BE/navigation.json
index 2c648d3..ff1d92b 100644
--- a/frontend/src/i18n/locales/fr-BE/navigation.json
+++ b/frontend/src/i18n/locales/fr-BE/navigation.json
@@ -27,12 +27,22 @@
   "resetConfirmYes": "Oui, réinitialiser",
   "resetCancel": "Annuler",
   "resetFailed": "Impossible de réinitialiser les données de démo.",
-  "searchLabel": "Rechercher dans Fleet Ops",
+  "searchLabel": "Rechercher dans {{productName}}",
   "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}} ».",
+  "searchVehicleSummary": "{{make}} {{model}} · {{location}}",
+  "searchSections": {
+    "overview": "Tableau de bord opérationnel",
+    "fleet": "Registre de la flotte",
+    "bookings": "Réservations de location",
+    "quality": "Atelier qualité",
+    "knowledge": "Assistant de procédures",
+    "integrations": "Statut d'automatisation et d'intégration",
+    "audit": "Historique d'audit"
+  },
   "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
index 215d06b..f0571d6 100644
--- a/frontend/src/i18n/locales/fr-BE/quality.json
+++ b/frontend/src/i18n/locales/fr-BE/quality.json
@@ -101,6 +101,17 @@
         "whyItMatters": "Un statut incorrect peut faire apparaître un véhicule indisponible comme réservable, ou masquer un véhicule disponible de la flotte."
       }
     },
+    "evidence": {
+      "duplicate.exact_email": "Adresse e-mail identique",
+      "duplicate.exact_phone": "Numéro de téléphone identique",
+      "duplicate.same_postal_code": "Même code postal",
+      "duplicateSimilarName": "Nom fortement similaire (score {{score}})",
+      "missingField": "Champ manquant : {{field}}",
+      "overlapReservedBookings": "Réservations qui se chevauchent : {{refs}}",
+      "odometerRegression": "La réservation {{laterRef}} a enregistré {{laterKm}} km, en dessous des {{earlierKm}} km enregistrés par la réservation antérieure {{earlierRef}}.",
+      "upcomingBookingMissingInspection": "La réservation {{bookingRef}} commence bientôt mais l'inspection opérationnelle requise est encore manquante.",
+      "seedPlaceholder": "Donnée de démonstration synthétique sans autre détail."
+    },
     "duplicateCustomer": {
       "heading": "Comparer et fusionner",
       "description": "Choisissez le client de référence et examinez chaque champ divergent.",
@@ -180,13 +191,48 @@
       "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 ?",
+      "reviewRecommendation": "Voir la recommandation",
+      "loadingRecommendation": "Chargement de la recommandation…",
+      "recommendationFailed": "Impossible de charger une recommandation.",
+      "recommendedStatus": "Statut recommandé",
+      "whyHeading": "Pourquoi",
+      "evidenceHeading": "Faits",
+      "consequenceHeading": "Conséquence",
+      "consequence": {
+        "statusWillChange": "Le statut du véhicule sera changé en {{status}}.",
+        "issueWillBeRechecked": "Ce problème de qualité sera à nouveau contrôlé.",
+        "changeWillBeAudited": "Le changement sera enregistré dans la piste d'audit.",
+        "bookingsNotDeleted": "Les réservations elles-mêmes ne sont pas supprimées."
+      },
+      "changeStatusTo": "Changer le statut vers {{status}}",
       "applying": "Application en cours…",
-      "confirmYes": "Oui, appliquer",
       "applied": "Appliqué {{status}} — {{reason}}",
-      "applyFailed": "Impossible d'appliquer un statut recommandé."
+      "applyFailed": "Impossible d'appliquer un statut recommandé.",
+      "staleRecommendation": "La situation a changé depuis l'affichage de cette recommandation. Consultez-la à nouveau avant de l'appliquer.",
+      "reviewAgain": "Revoir la recommandation",
+      "manualReview": {
+        "heading": "Évaluation manuelle requise",
+        "body": "Les faits concernant ce véhicule se contredisent. Un Operations Manager doit évaluer la situation en personne plutôt que d'appliquer un changement de statut automatique.",
+        "hint": "Utilisez « Reporter » ou « Rejeter » ci-dessous, ou examinez manuellement le véhicule et les réservations concernées."
+      },
+      "noConflict": {
+        "heading": "Aucun changement nécessaire",
+        "body": "Le statut actuel de ce véhicule correspond déjà aux faits."
+      },
+      "evidence": {
+        "activeBookings": "Réservation(s) active(s) : {{refs}}",
+        "overlappingBookings": "Réservations qui se chevauchent : {{pairs}}",
+        "serviceThresholdReached": "Le kilométrage ({{odometer}} km) a atteint le seuil d'entretien ({{threshold}} km).",
+        "openOverlapIssue": "Problème de chevauchement de réservation ouvert : {{ref}}"
+      },
+      "reasonCodes": {
+        "vehicle.active_rental": "Ce véhicule a une location active mais n'est pas enregistré comme loué. Le statut est corrigé pour refléter la situation réelle.",
+        "vehicle.service_threshold_reached": "Ce véhicule a atteint son seuil d'entretien. Il est placé en entretien afin qu'il ne soit pas utilisé avant que la révision ait eu lieu.",
+        "vehicle.booking_conflict": "Ce véhicule a deux réservations qui se chevauchent. Le bloquer évite qu'il soit à nouveau considéré comme disponible avant que le conflit de réservation ne soit résolu.",
+        "vehicle.rental_ended": "La location de ce véhicule est terminée et il n'y a plus de réservation active. Il est remis en disponible.",
+        "vehicle.manual_review_required": "Les faits concernant ce véhicule se contredisent (par exemple, une réservation active alors que le véhicule est en entretien, ou un seuil d'entretien atteint en même temps qu'une location active). Cela nécessite une évaluation humaine plutôt qu'un changement de statut automatique.",
+        "vehicle.no_conflict": "Le statut actuel de ce véhicule correspond déjà aux faits. Aucun changement n'est nécessaire."
+      }
     }
   }
 }
diff --git a/frontend/src/i18n/locales/fr-BE/returns.json b/frontend/src/i18n/locales/fr-BE/returns.json
index fe43257..8ba24d3 100644
--- a/frontend/src/i18n/locales/fr-BE/returns.json
+++ b/frontend/src/i18n/locales/fr-BE/returns.json
@@ -36,6 +36,13 @@
     "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.",
+    "reasonCodes": {
+      "returnBlockedDamageAndTechnical": "Des dégâts et une alerte technique ont tous deux été signalés lors de ce retour.",
+      "returnBlockedDamage": "Des dégâts ont été signalés lors de ce retour.",
+      "returnBlockedTechnicalWarning": "Une alerte technique a été signalée lors de ce retour.",
+      "returnServiceThresholdReached": "Le kilométrage a atteint le seuil d'entretien de {{threshold_km}} km.",
+      "returnRoutedToCleaning": "Aucun dégât, alerte technique ou seuil d'entretien atteint ; le véhicule part en nettoyage."
+    },
     "commitList": {
       "inspection": "Créer une inspection de retour",
       "updateAtomic": "Mettre à jour la réservation et le véhicule de façon atomique",
@@ -66,8 +73,9 @@
     "continueDemo": "Poursuivre la démo"
   },
   "scenario": {
+    "ariaLabel": "Scénario de démo",
     "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.",
+    "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 {{productName}} détecte et traite cela.",
     "preparing": "Préparation du scénario…"
   }
 }
diff --git a/frontend/src/i18n/locales/nl-BE/audit.json b/frontend/src/i18n/locales/nl-BE/audit.json
index c5d7278..e6dd60b 100644
--- a/frontend/src/i18n/locales/nl-BE/audit.json
+++ b/frontend/src/i18n/locales/nl-BE/audit.json
@@ -40,6 +40,29 @@
     "was": "{{field}}: was {{value}}",
     "changed": "{{field}}: {{before}} → {{after}}"
   },
+  "actorTypes": {
+    "user": "Gebruiker",
+    "system": "Systeem",
+    "service": "Dienst"
+  },
+  "fields": {
+    "status": "Status",
+    "operational_status": "Operationele status",
+    "registration_number": "Kenteken",
+    "make": "Merk",
+    "model": "Model",
+    "location": "Locatie",
+    "first_name": "Voornaam",
+    "last_name": "Achternaam",
+    "email": "E-mail",
+    "phone": "Telefoon",
+    "postal_code": "Postcode",
+    "city": "Stad",
+    "booking_end_odometer_km": "Eindkilometerstand boeking",
+    "vehicle_odometer_km": "Kilometerstand voertuig",
+    "survivor": "Behouden profiel",
+    "loser": "Samengevoegd profiel"
+  },
   "actions": {
     "demo_login": "Ingelogd",
     "demo_logout": "Uitgelogd",
diff --git a/frontend/src/i18n/locales/nl-BE/auth.json b/frontend/src/i18n/locales/nl-BE/auth.json
index dda3d67..e92c159 100644
--- a/frontend/src/i18n/locales/nl-BE/auth.json
+++ b/frontend/src/i18n/locales/nl-BE/auth.json
@@ -3,7 +3,7 @@
   "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.",
+  "defaultDescription": "{{productName}} 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",
diff --git a/frontend/src/i18n/locales/nl-BE/common.json b/frontend/src/i18n/locales/nl-BE/common.json
index 22c3df6..8818499 100644
--- a/frontend/src/i18n/locales/nl-BE/common.json
+++ b/frontend/src/i18n/locales/nl-BE/common.json
@@ -1,5 +1,4 @@
 {
-  "appName": "Fleet Ops",
   "orgName": "Northstar Mobility",
   "brandTagline": "Bedieningscentrum",
   "actions": {
@@ -35,7 +34,7 @@
     "fr-BE": "Français"
   },
   "footer": {
-    "productLine": "Fleet Ops Demo",
+    "productLine": "{{productName}} Demo",
     "locale": "Europa/Brussel · Synthetische demogegevens"
   },
   "demo": {
diff --git a/frontend/src/i18n/locales/nl-BE/demo.json b/frontend/src/i18n/locales/nl-BE/demo.json
index 1ca0527..dadb4e2 100644
--- a/frontend/src/i18n/locales/nl-BE/demo.json
+++ b/frontend/src/i18n/locales/nl-BE/demo.json
@@ -83,7 +83,7 @@
         "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."
+        "expectedOutcome": "Je kan zelf uitleggen wat {{productName}} wel en niet is, zonder mondelinge toelichting."
       }
     }
   },
@@ -146,16 +146,16 @@
   },
   "about": {
     "eyebrow": "Over deze demo",
-    "title": "Wat Fleet Ops wel en niet is",
+    "title": "Wat {{productName}} 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.",
+    "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. {{productName}} 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.",
+    "scopeBody": "Deze demo is bedoeld voor wie wil zien hoe {{productName}} 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",
diff --git a/frontend/src/i18n/locales/nl-BE/fleet.json b/frontend/src/i18n/locales/nl-BE/fleet.json
index 70ebd95..389ea4b 100644
--- a/frontend/src/i18n/locales/nl-BE/fleet.json
+++ b/frontend/src/i18n/locales/nl-BE/fleet.json
@@ -63,6 +63,14 @@
     "noQualityIssues": "Geen kwaliteitsproblemen geregistreerd.",
     "fuel": "Brandstof {{percent}}%",
     "damage": "Schade",
-    "technicalWarning": "Technische melding"
+    "technicalWarning": "Technische melding",
+    "inspectionTypes": {
+      "departure": "Vertrekinspectie",
+      "return": "Retourinspectie"
+    },
+    "maintenanceCategories": {
+      "periodic_service": "Periodiek onderhoud",
+      "repair": "Herstelling"
+    }
   }
 }
diff --git a/frontend/src/i18n/locales/nl-BE/integrations.json b/frontend/src/i18n/locales/nl-BE/integrations.json
index 1d64153..f08c916 100644
--- a/frontend/src/i18n/locales/nl-BE/integrations.json
+++ b/frontend/src/i18n/locales/nl-BE/integrations.json
@@ -65,6 +65,13 @@
     "noAction": "—",
     "eventTypes": {
       "vehicle.returned.v1": "Voertuigretour verwerkt"
+    },
+    "errorCodes": {
+      "connectionError": "De workflowdienst was tijdelijk niet bereikbaar. De retour is veilig opgeslagen en kan opnieuw worden aangeboden.",
+      "malformedPayload": "De opdracht bevatte onvolledige gegevens en kon niet worden afgeleverd. De onderliggende gegevens blijven veilig bewaard.",
+      "remoteReportedFailure": "De workflowdienst heeft de aflevering geweigerd. De opdracht kan opnieuw worden aangeboden.",
+      "staleLeaseRecovered": "Deze opdracht werd hersteld nadat een eerdere afleverpoging vastliep zonder resultaat.",
+      "unknownError": "Er is een onverwachte fout opgetreden bij het afleveren van deze opdracht."
     }
   }
 }
diff --git a/frontend/src/i18n/locales/nl-BE/knowledge.json b/frontend/src/i18n/locales/nl-BE/knowledge.json
index 54f3da2..8f4c6f1 100644
--- a/frontend/src/i18n/locales/nl-BE/knowledge.json
+++ b/frontend/src/i18n/locales/nl-BE/knowledge.json
@@ -24,7 +24,7 @@
     "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.",
+  "emptyDescription": "Vraag naar retours, schade, inspecties of een andere geïndexeerde procedure. {{productName}} verzint geen antwoord wanneer evidentie ontbreekt.",
   "retrievalFlow": {
     "question": "Vraag",
     "sources": "Bronnen",
diff --git a/frontend/src/i18n/locales/nl-BE/navigation.json b/frontend/src/i18n/locales/nl-BE/navigation.json
index 8ab013a..0f1f1cc 100644
--- a/frontend/src/i18n/locales/nl-BE/navigation.json
+++ b/frontend/src/i18n/locales/nl-BE/navigation.json
@@ -27,12 +27,22 @@
   "resetConfirmYes": "Ja, herstellen",
   "resetCancel": "Annuleren",
   "resetFailed": "Demogegevens konden niet hersteld worden.",
-  "searchLabel": "Zoek in Fleet Ops",
+  "searchLabel": "Zoek in {{productName}}",
   "searchPlaceholder": "Zoek wagenpark, boeking of onderdeel…",
   "searchShortcutHint": "Ctrl K",
   "searchSearching": "Zoeken…",
   "searchUnavailable": "Zoeken is momenteel niet beschikbaar.",
   "searchNoResults": "Geen resultaten voor \"{{query}}\".",
+  "searchVehicleSummary": "{{make}} {{model}} · {{location}}",
+  "searchSections": {
+    "overview": "Operationeel dashboard",
+    "fleet": "Wagenparkregister",
+    "bookings": "Verhuurboekingen",
+    "quality": "Kwaliteitswerkbank",
+    "knowledge": "Procedureassistent",
+    "integrations": "Automatiserings- en integratiestatus",
+    "audit": "Auditgeschiedenis"
+  },
   "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
index 6806bf8..07c9a2c 100644
--- a/frontend/src/i18n/locales/nl-BE/quality.json
+++ b/frontend/src/i18n/locales/nl-BE/quality.json
@@ -101,6 +101,17 @@
         "whyItMatters": "Een foutieve status kan een niet-beschikbaar voertuig boekbaar laten lijken, of een beschikbaar voertuig verbergen voor het wagenpark."
       }
     },
+    "evidence": {
+      "duplicate.exact_email": "Identiek e-mailadres",
+      "duplicate.exact_phone": "Identiek telefoonnummer",
+      "duplicate.same_postal_code": "Dezelfde postcode",
+      "duplicateSimilarName": "Sterk gelijkende naam (score {{score}})",
+      "missingField": "Ontbrekend veld: {{field}}",
+      "overlapReservedBookings": "Overlappende reserveringen: {{refs}}",
+      "odometerRegression": "Boeking {{laterRef}} registreerde {{laterKm}} km, lager dan de {{earlierKm}} km van eerdere boeking {{earlierRef}}.",
+      "upcomingBookingMissingInspection": "Boeking {{bookingRef}} start binnenkort maar de vereiste operationele inspectie ontbreekt nog.",
+      "seedPlaceholder": "Synthetisch demogegeven zonder verder detail."
+    },
     "duplicateCustomer": {
       "heading": "Vergelijken en samenvoegen",
       "description": "Kies de klant die behouden blijft en bekijk elk afwijkend veld.",
@@ -180,13 +191,48 @@
       "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?",
+      "reviewRecommendation": "Aanbeveling bekijken",
+      "loadingRecommendation": "Aanbeveling laden…",
+      "recommendationFailed": "Kon geen aanbeveling ophalen.",
+      "recommendedStatus": "Aanbevolen status",
+      "whyHeading": "Waarom",
+      "evidenceHeading": "Feiten",
+      "consequenceHeading": "Gevolg",
+      "consequence": {
+        "statusWillChange": "De voertuigstatus wordt gewijzigd naar {{status}}.",
+        "issueWillBeRechecked": "Dit kwaliteitsprobleem wordt opnieuw gecontroleerd.",
+        "changeWillBeAudited": "De wijziging wordt vastgelegd in de audit trail.",
+        "bookingsNotDeleted": "De boekingen zelf worden niet verwijderd."
+      },
+      "changeStatusTo": "Status wijzigen naar {{status}}",
       "applying": "Bezig met toepassen…",
-      "confirmYes": "Ja, toepassen",
       "applied": "Toegepast {{status}} — {{reason}}",
-      "applyFailed": "Kon geen aanbevolen status toepassen."
+      "applyFailed": "Kon geen aanbevolen status toepassen.",
+      "staleRecommendation": "De situatie is intussen gewijzigd. Bekijk de aanbeveling opnieuw voor u ze toepast.",
+      "reviewAgain": "Aanbeveling opnieuw bekijken",
+      "manualReview": {
+        "heading": "Handmatige beoordeling vereist",
+        "body": "De feiten voor dit voertuig spreken elkaar tegen. Een Operations Manager moet dit persoonlijk beoordelen in plaats van een automatische statuswijziging toe te passen.",
+        "hint": "Gebruik 'Uitstellen' of 'Verwerpen' hieronder, of onderzoek het voertuig en de betrokken boekingen manueel."
+      },
+      "noConflict": {
+        "heading": "Geen wijziging nodig",
+        "body": "De huidige status van dit voertuig komt al overeen met de feiten."
+      },
+      "evidence": {
+        "activeBookings": "Actieve boeking(en): {{refs}}",
+        "overlappingBookings": "Overlappende reserveringen: {{pairs}}",
+        "serviceThresholdReached": "Kilometerstand ({{odometer}} km) heeft de onderhoudsdrempel ({{threshold}} km) bereikt.",
+        "openOverlapIssue": "Openstaand boekingsoverlapprobleem: {{ref}}"
+      },
+      "reasonCodes": {
+        "vehicle.active_rental": "Dit voertuig heeft een actieve verhuring maar staat niet als verhuurd geregistreerd. De status wordt gecorrigeerd zodat ze de werkelijke situatie weerspiegelt.",
+        "vehicle.service_threshold_reached": "Dit voertuig heeft de onderhoudsdrempel bereikt. Het wordt naar onderhoud gezet zodat het niet wordt ingezet voordat de service is uitgevoerd.",
+        "vehicle.booking_conflict": "Dit voertuig heeft twee overlappende reserveringen. Het blokkeren voorkomt dat het opnieuw als inzetbaar wordt beschouwd voordat het boekingsconflict is opgelost.",
+        "vehicle.rental_ended": "De verhuring voor dit voertuig is beëindigd en er is geen actieve boeking meer. Het wordt terug beschikbaar gezet.",
+        "vehicle.manual_review_required": "De feiten voor dit voertuig spreken elkaar tegen (bijvoorbeeld een actieve boeking terwijl het voertuig in onderhoud staat, of een onderhoudsdrempel die samenvalt met een actieve verhuring). Dit vereist een menselijke beoordeling in plaats van een automatische statuswijziging.",
+        "vehicle.no_conflict": "De huidige status van dit voertuig komt al overeen met de feiten. Er is geen wijziging nodig."
+      }
     }
   }
 }
diff --git a/frontend/src/i18n/locales/nl-BE/returns.json b/frontend/src/i18n/locales/nl-BE/returns.json
index d64d2cc..416db01 100644
--- a/frontend/src/i18n/locales/nl-BE/returns.json
+++ b/frontend/src/i18n/locales/nl-BE/returns.json
@@ -36,6 +36,13 @@
     "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.",
+    "reasonCodes": {
+      "returnBlockedDamageAndTechnical": "Zowel schade als een technische melding werden gemeld bij deze retour.",
+      "returnBlockedDamage": "Er werd schade gemeld bij deze retour.",
+      "returnBlockedTechnicalWarning": "Er werd een technische melding gemeld bij deze retour.",
+      "returnServiceThresholdReached": "De kilometerstand heeft de onderhoudsdrempel van {{threshold_km}} km bereikt.",
+      "returnRoutedToCleaning": "Geen schade, technische melding of onderhoudsdrempel; het voertuig gaat naar reiniging."
+    },
     "commitList": {
       "inspection": "Retourinspectie aanmaken",
       "updateAtomic": "Boeking en voertuig atomair bijwerken",
@@ -66,8 +73,9 @@
     "continueDemo": "Ga verder met de demo"
   },
   "scenario": {
+    "ariaLabel": "Demonstratiescenario",
     "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.",
+    "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 {{productName}} dit detecteert en afhandelt.",
     "preparing": "Scenario voorbereiden…"
   }
 }
diff --git a/frontend/src/pages/AboutDemo.tsx b/frontend/src/pages/AboutDemo.tsx
index 4699ff2..3fde557 100644
--- a/frontend/src/pages/AboutDemo.tsx
+++ b/frontend/src/pages/AboutDemo.tsx
@@ -5,6 +5,7 @@ import { useDemoManifest } from "../context/DemoManifestContext";
 import { useLocaleFormat } from "../i18n/format";
 import { Icon } from "../components/Icons";
 import { IntegrationMark, LoadingState, PageHeader, SectionHeading } from "../components/PageChrome";
+import { PRODUCT_NAME } from "../product";
 
 const INTEGRATION_ICON: Record<string, "n8n" | "rag" | "mcp"> = {
   n8n: "n8n",
@@ -36,7 +37,7 @@ export function AboutDemo() {
     <div className="page">
       <PageHeader
         eyebrow={t("about.eyebrow")}
-        title={t("about.title")}
+        title={t("about.title", { productName: PRODUCT_NAME })}
         description={manifest ? t("about.description", { orgName: manifest.organization_name }) : undefined}
       />
 
@@ -58,12 +59,12 @@ export function AboutDemo() {
 
           <section className="record-surface about-card">
             <h2>{t("about.problemTitle")}</h2>
-            <p>{t("about.problemBody", { orgName: manifest.organization_name })}</p>
+            <p>{t("about.problemBody", { orgName: manifest.organization_name, productName: PRODUCT_NAME })}</p>
           </section>
 
           <section className="record-surface about-card">
             <h2>{t("about.scopeTitle")}</h2>
-            <p>{t("about.scopeBody")}</p>
+            <p>{t("about.scopeBody", { productName: PRODUCT_NAME })}</p>
           </section>
 
           <section className="record-surface about-card">
diff --git a/frontend/src/pages/Audit.tsx b/frontend/src/pages/Audit.tsx
index a2c6aeb..8269de9 100644
--- a/frontend/src/pages/Audit.tsx
+++ b/frontend/src/pages/Audit.tsx
@@ -36,7 +36,7 @@ function ChangeDiff({
     const b = before?.[key];
     const a = after?.[key];
     if (JSON.stringify(b) === JSON.stringify(a)) continue;
-    const field = humanizeField(key);
+    const field = t(`fields.${key}`, { defaultValue: 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) }) });
@@ -163,7 +163,7 @@ export function Audit() {
                       <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>
+                      <span><strong>{e.actor_label}</strong> <small className="table-subtext">{t(`actorTypes.${e.actor_type}`, { defaultValue: e.actor_type })}</small></span>
                       {e.entity_link ? (
                         <Link to={e.entity_link}>{e.entity_ref ?? e.entity_type}</Link>
                       ) : (
diff --git a/frontend/src/pages/Automation.tsx b/frontend/src/pages/Automation.tsx
index 6f52886..6e5c401 100644
--- a/frontend/src/pages/Automation.tsx
+++ b/frontend/src/pages/Automation.tsx
@@ -118,7 +118,21 @@ export function Automation() {
           <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.lastError")}>
+          {r.last_error_code ? (
+            <>
+              <span>{t(`ledger.errorCodes.${r.last_error_code}`, { defaultValue: r.last_error ?? r.last_error_code })}</span>
+              {r.last_error && (
+                <details className="evidence-disclosure">
+                  <summary>{t("common:actions.technicalDetails")}</summary>
+                  <pre className="evidence-block">{r.last_error}</pre>
+                </details>
+              )}
+            </>
+          ) : (
+            "—"
+          )}
+        </td>
         <td data-label={t("ledger.columns.when")}>
           <time dateTime={r.occurred_at}>{formatDateTime(r.occurred_at)}</time>
         </td>
diff --git a/frontend/src/pages/BookingDetail.tsx b/frontend/src/pages/BookingDetail.tsx
index 0096c87..4c40e3e 100644
--- a/frontend/src/pages/BookingDetail.tsx
+++ b/frontend/src/pages/BookingDetail.tsx
@@ -9,6 +9,7 @@ import { StatusBadge } from "../components/Badge";
 import { ReturnForm, ReturnResultPanel } from "../components/ReturnForm";
 import { Icon } from "../components/Icons";
 import { ErrorState, LoadingState, PageHeader } from "../components/PageChrome";
+import { PRODUCT_NAME } from "../product";
 
 export function BookingDetail() {
   const { t } = useTranslation(["bookings", "returns"]);
@@ -73,11 +74,11 @@ export function BookingDetail() {
       </dl></section>
 
       {isReturnAnomalyScenario && !returnResult && canonicalOdometerKm !== null && (
-        <section className="record-surface scenario-callout" aria-label="Demo scenario">
+        <section className="record-surface scenario-callout" aria-label={t("returns:scenario.ariaLabel")}>
           <Icon name="spark" />
           <div>
             <strong>{t("returns:scenario.title")}</strong>
-            <p>{t("returns:scenario.body", { odometer: formatNumber(canonicalOdometerKm) })}</p>
+            <p>{t("returns:scenario.body", { odometer: formatNumber(canonicalOdometerKm), productName: PRODUCT_NAME })}</p>
           </div>
         </section>
       )}
diff --git a/frontend/src/pages/DataQualityIssueDetail.tsx b/frontend/src/pages/DataQualityIssueDetail.tsx
index ef57e45..157455f 100644
--- a/frontend/src/pages/DataQualityIssueDetail.tsx
+++ b/frontend/src/pages/DataQualityIssueDetail.tsx
@@ -6,6 +6,7 @@ import type {
   ApplyRecommendedStatusResult,
   DataQualityIssueDetail as IssueDetail,
   EntitySnapshot,
+  StatusRecommendation,
 } from "../api/types";
 import { SeverityBadge, StatusBadge } from "../components/Badge";
 import { useAuth } from "../context/AuthContext";
@@ -45,6 +46,79 @@ function EvidenceDisclosure({ issue }: { issue: IssueDetail }) {
   );
 }
 
+interface EvidenceSignal {
+  code: string;
+  params?: Record<string, unknown>;
+}
+
+// The backend never emits prose for evidence -- only stable signal codes + raw data
+// params (see app/services/data_quality.py::_open_issue). This is the one place that
+// turns them into the operator's selected language; the legacy `evidence.summary`
+// string is a technical fallback only, shown solely inside EvidenceDisclosure above.
+// A handful of seed-only rows (generic filler, not tied to a scripted demo scenario)
+// carry no structured signals -- rather than show nothing, this known placeholder
+// summary gets a localized rendering. Any other un-signalled legacy text still falls
+// back to the raw string (better than a blank primary evidence area), but only
+// "Technical details" is meant to guarantee raw-text visibility.
+const SEED_PLACEHOLDER_SUMMARY = "Synthetic deterministic seed issue";
+
+function EvidenceSignalList({ issue }: { issue: IssueDetail }) {
+  const { t } = useTranslation("quality");
+  const { formatNumber } = useLocaleFormat();
+  const signals = (issue.evidence.signals as EvidenceSignal[] | undefined) ?? [];
+  if (signals.length === 0) {
+    const rawSummary = String(issue.evidence.summary ?? "");
+    if (!rawSummary) return null;
+    const text =
+      rawSummary === SEED_PLACEHOLDER_SUMMARY
+        ? t("detail.evidence.seedPlaceholder")
+        : rawSummary;
+    return (
+      <ul className="evidence-signal-list">
+        <li>{text}</li>
+      </ul>
+    );
+  }
+
+  function describe(signal: EvidenceSignal): string {
+    const { code, params = {} } = signal;
+    if (code.startsWith("vehicle.")) {
+      return t(`detail.vehicleStatusConflict.reasonCodes.${code}`, { defaultValue: code });
+    }
+    switch (code) {
+      case "missing_field":
+        return t("detail.evidence.missingField", {
+          field: t(`detail.missingField.fields.${params.field}`, { defaultValue: String(params.field) }),
+        });
+      case "overlap.reserved_bookings":
+        return t("detail.evidence.overlapReservedBookings", {
+          refs: Array.isArray(params.refs) ? params.refs.join(" ↔ ") : "",
+        });
+      case "odometer.regression":
+        return t("detail.evidence.odometerRegression", {
+          laterRef: params.later_ref,
+          laterKm: formatNumber(Number(params.later_km ?? 0)),
+          earlierRef: params.earlier_ref,
+          earlierKm: formatNumber(Number(params.earlier_km ?? 0)),
+        });
+      case "duplicate.similar_name":
+        return t("detail.evidence.duplicateSimilarName", { score: params.score });
+      case "attention.upcoming_booking_missing_inspection":
+        return t("detail.evidence.upcomingBookingMissingInspection", { bookingRef: params.booking_ref });
+      default:
+        return t(`detail.evidence.${code}`, { defaultValue: code });
+    }
+  }
+
+  return (
+    <ul className="evidence-signal-list">
+      {signals.map((signal, index) => (
+        <li key={`${signal.code}-${index}`}>{describe(signal)}</li>
+      ))}
+    </ul>
+  );
+}
+
 function DuplicateCustomerPanel({ issue, onResolved }: { issue: IssueDetail; onResolved: () => void }) {
   const { t } = useTranslation("quality");
   const { user } = useAuth();
@@ -443,15 +517,62 @@ function BookingOverlapPanel({ issue, onResolved }: { issue: IssueDetail; onReso
   );
 }
 
+function statusLabel(t: (key: string, opts?: Record<string, unknown>) => string, status: string): string {
+  const raw = t(`fleet:statuses.${status}`, { defaultValue: status });
+  return raw.charAt(0).toUpperCase() + raw.slice(1);
+}
+
+function StatusRecommendationEvidence({ recommendation }: { recommendation: StatusRecommendation }) {
+  const { t } = useTranslation("quality");
+  const { formatNumber } = useLocaleFormat();
+  const facts = recommendation.facts;
+  const lines: string[] = [];
+  if (facts.active_booking_refs.length > 0) {
+    lines.push(
+      t("detail.vehicleStatusConflict.evidence.activeBookings", { refs: facts.active_booking_refs.join(", ") }),
+    );
+  }
+  if (facts.overlapping_booking_pairs.length > 0) {
+    lines.push(
+      t("detail.vehicleStatusConflict.evidence.overlappingBookings", {
+        pairs: facts.overlapping_booking_pairs.map((pair) => pair.join(" ↔ ")).join(", "),
+      }),
+    );
+  }
+  if (facts.service_threshold_reached) {
+    lines.push(
+      t("detail.vehicleStatusConflict.evidence.serviceThresholdReached", {
+        odometer: formatNumber(facts.odometer_km),
+        threshold: formatNumber(facts.next_service_km),
+      }),
+    );
+  }
+  if (facts.open_booking_overlap_issue_ref) {
+    lines.push(
+      t("detail.vehicleStatusConflict.evidence.openOverlapIssue", { ref: facts.open_booking_overlap_issue_ref }),
+    );
+  }
+  if (lines.length === 0) return null;
+  return (
+    <ul className="evidence-list">
+      {lines.map((line) => (
+        <li key={line}>{line}</li>
+      ))}
+    </ul>
+  );
+}
+
 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 [recommendation, setRecommendation] = useState<StatusRecommendation | null>(null);
+  const [loadingRecommendation, setLoadingRecommendation] = useState(false);
+  const [stale, setStale] = useState(false);
   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();
@@ -465,25 +586,60 @@ function VehicleStatusConflictPanel({ issue, onResolved }: { issue: IssueDetail;
   // visibility via `result` rather than disappearing the instant the reload lands.
   if (issue.status !== "open" && !result) return null;
 
+  async function loadRecommendation() {
+    setError(null);
+    setStale(false);
+    setLoadingRecommendation(true);
+    try {
+      const preview = await api.post<StatusRecommendation>(
+        `/api/v1/data-quality/issues/${issue.public_ref}/status-recommendation`,
+      );
+      setRecommendation(preview);
+    } catch (err) {
+      setError(err instanceof ApiError ? err.message : t("detail.vehicleStatusConflict.recommendationFailed"));
+    } finally {
+      setLoadingRecommendation(false);
+    }
+  }
+
   async function handleApply() {
+    if (!recommendation) return;
     setError(null);
     setSubmitting(true);
     try {
       const applied = await api.post<ApplyRecommendedStatusResult>(
         `/api/v1/data-quality/issues/${issue.public_ref}/apply-recommended-status`,
+        { recommendation_token: recommendation.recommendation_token },
       );
       setResult(applied);
       onResolved();
     } catch (err) {
-      setError(err instanceof ApiError ? err.message : t("detail.vehicleStatusConflict.applyFailed"));
-      setConfirming(false);
+      if (err instanceof ApiError && err.code === "RECOMMENDATION_STALE") {
+        setError(t("detail.vehicleStatusConflict.staleRecommendation"));
+        setRecommendation(null);
+        setStale(true);
+      } else {
+        setError(err instanceof ApiError ? err.message : t("detail.vehicleStatusConflict.applyFailed"));
+      }
     } finally {
       setSubmitting(false);
     }
   }
 
+  // safe_to_apply is only ever true alongside a non-null recommended_status, so it must
+  // not be used to detect "manual review needed" -- a genuine no_conflict recommendation
+  // also carries safe_to_apply: false (there is nothing to apply), and conflating the two
+  // would show "manual review required" for a vehicle that needs no attention at all.
+  const needsManualReview = recommendation !== null && recommendation.manual_review_required;
+  const noChangeNeeded = recommendation !== null && !needsManualReview && recommendation.recommended_status === null;
+  const hasSafeRecommendation =
+    recommendation !== null &&
+    !needsManualReview &&
+    recommendation.recommended_status !== null &&
+    recommendation.safe_to_apply;
+
   return (
-    <section className="panel" aria-labelledby="status-conflict-heading">
+    <section className="panel" aria-labelledby="status-conflict-heading" aria-live="polite">
       <SectionHeading
         headingId="status-conflict-heading"
         title={t("detail.vehicleStatusConflict.heading")}
@@ -496,7 +652,12 @@ function VehicleStatusConflictPanel({ issue, onResolved }: { issue: IssueDetail;
       {result ? (
         <>
           <p className="quiet-empty">
-            <Icon name="check" /> {t("detail.vehicleStatusConflict.applied", { status: result.applied_status, reason: result.reason })}
+            <Icon name="check" /> {t("detail.vehicleStatusConflict.applied", {
+              status: statusLabel(t, result.applied_status),
+              reason: t(`detail.vehicleStatusConflict.reasonCodes.${result.reason_code}`, {
+                defaultValue: result.reason_code,
+              }),
+            })}
           </p>
           <div className="result-links">
             <Link className="button button-secondary" to="/audit">{t("detail.resolved.viewAudit")}<Icon name="chevron" /></Link>
@@ -508,21 +669,63 @@ function VehicleStatusConflictPanel({ issue, onResolved }: { issue: IssueDetail;
             )}
           </div>
         </>
-      ) : !confirming ? (
-        <button type="button" className="button button-primary" onClick={() => setConfirming(true)}>
-          {t("detail.vehicleStatusConflict.calculateAndApply")}
+      ) : !recommendation ? (
+        <button type="button" className="button button-primary" onClick={loadRecommendation} disabled={loadingRecommendation}>
+          {loadingRecommendation
+            ? t("detail.vehicleStatusConflict.loadingRecommendation")
+            : t(stale ? "detail.vehicleStatusConflict.reviewAgain" : "detail.vehicleStatusConflict.reviewRecommendation")}
         </button>
-      ) : (
-        <div className="confirm-bar" role="alertdialog" aria-label={t("detail.vehicleStatusConflict.confirmTitle")}>
-          <p>{t("detail.vehicleStatusConflict.confirmBody")}</p>
+      ) : needsManualReview ? (
+        <div className="status-decision" role="status">
+          <h3>{t("detail.vehicleStatusConflict.manualReview.heading")}</h3>
+          <p>{t("detail.vehicleStatusConflict.manualReview.body")}</p>
+          <StatusRecommendationEvidence recommendation={recommendation} />
+          <p className="table-subtext">{t("detail.vehicleStatusConflict.manualReview.hint")}</p>
+        </div>
+      ) : noChangeNeeded ? (
+        <div className="status-decision" role="status">
+          <h3>{t("detail.vehicleStatusConflict.noConflict.heading")}</h3>
+          <p>{t("detail.vehicleStatusConflict.noConflict.body")}</p>
+        </div>
+      ) : hasSafeRecommendation && recommendation.recommended_status ? (
+        <div className="status-decision" role="group" aria-label={t("detail.vehicleStatusConflict.recommendedStatus")}>
+          <dl className="detail-grid">
+            <div>
+              <dt>{t("detail.vehicleStatusConflict.recommendedStatus")}</dt>
+              <dd>
+                <StatusBadge
+                  status={recommendation.recommended_status}
+                  label={t(`fleet:statuses.${recommendation.recommended_status}`, {
+                    defaultValue: recommendation.recommended_status,
+                  })}
+                />
+              </dd>
+            </div>
+          </dl>
+          <h3>{t("detail.vehicleStatusConflict.whyHeading")}</h3>
+          <p>{t(`detail.vehicleStatusConflict.reasonCodes.${recommendation.recommendation_code}`, {
+            defaultValue: recommendation.recommendation_code,
+          })}</p>
+          <h3>{t("detail.vehicleStatusConflict.evidenceHeading")}</h3>
+          <StatusRecommendationEvidence recommendation={recommendation} />
+          <h3>{t("detail.vehicleStatusConflict.consequenceHeading")}</h3>
+          <ul className="evidence-list">
+            <li>{t("detail.vehicleStatusConflict.consequence.statusWillChange", {
+              status: statusLabel(t, recommendation.recommended_status),
+            })}</li>
+            <li>{t("detail.vehicleStatusConflict.consequence.issueWillBeRechecked")}</li>
+            <li>{t("detail.vehicleStatusConflict.consequence.changeWillBeAudited")}</li>
+            <li>{t("detail.vehicleStatusConflict.consequence.bookingsNotDeleted")}</li>
+          </ul>
           <button type="button" className="button button-primary" onClick={handleApply} disabled={submitting}>
-            {submitting ? t("detail.vehicleStatusConflict.applying") : t("detail.vehicleStatusConflict.confirmYes")}
-          </button>
-          <button type="button" className="button button-secondary" onClick={() => setConfirming(false)} disabled={submitting}>
-            {t("list.cancel")}
+            {submitting
+              ? t("detail.vehicleStatusConflict.applying")
+              : t("detail.vehicleStatusConflict.changeStatusTo", {
+                  status: statusLabel(t, recommendation.recommended_status),
+                })}
           </button>
         </div>
-      )}
+      ) : null}
     </section>
   );
 }
@@ -596,8 +799,11 @@ export function DataQualityIssueDetail() {
       <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>
+      <div className="record-surface-evidence">
+        <dt>{t("detail.summary.evidenceSummary")}</dt>
+        <EvidenceSignalList issue={issue} />
+      </div>
       <EvidenceDisclosure issue={issue} /></section>
 
       <RuleExplainer ruleType={issue.rule_type} />
diff --git a/frontend/src/pages/Knowledge.tsx b/frontend/src/pages/Knowledge.tsx
index 8da4b30..a09b35a 100644
--- a/frontend/src/pages/Knowledge.tsx
+++ b/frontend/src/pages/Knowledge.tsx
@@ -4,6 +4,7 @@ import { api, ApiError } from "../api/client";
 import type { GroundedAnswer, KnowledgeHealth } from "../api/types";
 import { Icon } from "../components/Icons";
 import { PageHeader } from "../components/PageChrome";
+import { PRODUCT_NAME } from "../product";
 
 interface Exchange {
   question: string;
@@ -121,7 +122,7 @@ export function Knowledge() {
         <div className="knowledge-empty">
           <span><Icon name="knowledge" /></span>
           <h2>{t("emptyTitle")}</h2>
-          <p>{t("emptyDescription")}</p>
+          <p>{t("emptyDescription", { productName: PRODUCT_NAME })}</p>
           <div className="retrieval-flow" aria-hidden="true">
             <span>{t("retrievalFlow.question")}</span><i />
             <span>{providerLabel}</span><i />
diff --git a/frontend/src/pages/Login.tsx b/frontend/src/pages/Login.tsx
index b1efa4e..e1bb596 100644
--- a/frontend/src/pages/Login.tsx
+++ b/frontend/src/pages/Login.tsx
@@ -6,6 +6,7 @@ import { useDemoManifest } from "../context/DemoManifestContext";
 import { LanguageSwitcher } from "../components/LanguageSwitcher";
 import type { Role } from "../api/types";
 import { BrandMark, Icon } from "../components/Icons";
+import { PRODUCT_NAME } from "../product";
 
 export function Login() {
   const { t } = useTranslation(["auth", "common"]);
@@ -25,14 +26,14 @@ export function Login() {
   }
 
   const orgName = manifest?.organization_name ?? t("common:orgName");
-  const description = t("defaultDescription");
+  const description = t("defaultDescription", { productName: PRODUCT_NAME });
 
   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>{t("common:appName")}</strong><span>{t("brandTagline")}</span></div>
+          <div><strong>{PRODUCT_NAME}</strong><span>{t("brandTagline")}</span></div>
         </div>
         <div className="login-message">
           <p className="eyebrow">{t("orgLine", { orgName })}</p>
diff --git a/frontend/src/pages/VehicleDetail.tsx b/frontend/src/pages/VehicleDetail.tsx
index 82ff1e3..4aabb34 100644
--- a/frontend/src/pages/VehicleDetail.tsx
+++ b/frontend/src/pages/VehicleDetail.tsx
@@ -83,7 +83,7 @@ export function VehicleDetail() {
           {vehicle.inspections.length === 0 && <li>{t("detail.noInspections")}</li>}
           {vehicle.inspections.map((i) => (
             <li key={i.public_ref}>
-              <span>{i.type}</span>
+              <span>{t(`fleet:detail.inspectionTypes.${i.type}`, { defaultValue: i.type })}</span>
               <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>}
@@ -99,7 +99,7 @@ export function VehicleDetail() {
           {vehicle.maintenance.length === 0 && <li>{t("detail.noMaintenance")}</li>}
           {vehicle.maintenance.map((m) => (
             <li key={m.public_ref}>
-              <span>{m.category}</span>
+              <span>{t(`fleet:detail.maintenanceCategories.${m.category}`, { defaultValue: m.category })}</span>
               <span>{m.summary}</span>
               <time dateTime={m.occurred_at}>{formatShortDate(m.occurred_at)}</time>
             </li>
diff --git a/frontend/src/product.ts b/frontend/src/product.ts
new file mode 100644
index 0000000..cffd7b6
--- /dev/null
+++ b/frontend/src/product.ts
@@ -0,0 +1,5 @@
+// The visible product name is a fixed brand constant, never a translatable string: it
+// must read identically ("Fleet Ops") in every supported locale. Keeping it out of the
+// i18n resource files makes that a structural guarantee rather than a convention a
+// translator could accidentally break by editing one locale's JSON.
+export const PRODUCT_NAME = "Fleet Ops";
diff --git a/frontend/src/styles.css b/frontend/src/styles.css
index ee64c2f..966c7cd 100644
--- a/frontend/src/styles.css
+++ b/frontend/src/styles.css
@@ -239,6 +239,10 @@ 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; }
+.record-surface-evidence { padding: 0 18px 16px; }
+.record-surface-evidence dt { margin: 0 0 6px; color: var(--muted); font-size: .63rem; font-weight: 700; text-transform: uppercase; letter-spacing: .065em; }
+.record-surface-evidence .evidence-signal-list { margin: 0; padding-left: 18px; color: var(--ink); font-size: .82rem; font-weight: 700; line-height: 1.6; }
+.record-surface-evidence .evidence-signal-list li { margin-bottom: 3px; }
 .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; }
@@ -273,6 +277,14 @@ details summary { cursor: pointer; color: var(--teal-dark); }.data-table details
 .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; }
 
+.status-decision { margin-top: 16px; padding: 16px 18px; background: var(--surface-subtle); border: 1px solid var(--line); border-radius: var(--radius); }
+.status-decision h3 { margin: 16px 0 6px; color: var(--ink); font-size: .72rem; font-weight: 700; text-transform: uppercase; letter-spacing: .05em; }
+.status-decision h3:first-child { margin-top: 0; }
+.status-decision > .detail-grid { margin-bottom: 4px; }
+.evidence-list { margin: 0; padding-left: 18px; color: var(--ink-soft); font-size: .78rem; line-height: 1.6; }
+.evidence-list li { margin-bottom: 2px; }
+.status-decision .button { margin-top: 16px; }
+
 .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); }
diff --git a/knowledge/procedures/en-GB/02-vehicle-return.md b/knowledge/procedures/en-GB/02-vehicle-return.md
index 199784a..dcf26c2 100644
--- a/knowledge/procedures/en-GB/02-vehicle-return.md
+++ b/knowledge/procedures/en-GB/02-vehicle-return.md
@@ -22,4 +22,4 @@ Damage or a technical warning requires a blocked state. A reached service thresh
 
 ## 4. Follow-up
 
-The return automation may create a cleaning or maintenance follow-up, but MobilityOps remains the source of truth for the vehicle state.
+The return automation may create a cleaning or maintenance follow-up, but Fleet Ops remains the source of truth for the vehicle state.
diff --git a/knowledge/procedures/en-GB/03-damage-handling.md b/knowledge/procedures/en-GB/03-damage-handling.md
index 3713b42..0eced1e 100644
--- a/knowledge/procedures/en-GB/03-damage-handling.md
+++ b/knowledge/procedures/en-GB/03-damage-handling.md
@@ -14,7 +14,7 @@ When a vehicle returns with visible or reported damage, mark damage in the retur
 
 ## 2. Evidence
 
-Record at least four photographs in the source inspection system: full affected side, close view, wider context and vehicle registration. MobilityOps may store only the evidence reference in this PoC.
+Record at least four photographs in the source inspection system: full affected side, close view, wider context and vehicle registration. Fleet Ops stores only the evidence reference in this demo environment.
 
 ## 3. Escalation
 
diff --git a/knowledge/procedures/en-GB/05-cleaning-checklist.md b/knowledge/procedures/en-GB/05-cleaning-checklist.md
index 733fac7..68255c8 100644
--- a/knowledge/procedures/en-GB/05-cleaning-checklist.md
+++ b/knowledge/procedures/en-GB/05-cleaning-checklist.md
@@ -18,4 +18,4 @@ Inspect windows, lights, tyres and bodywork while cleaning. Report newly observe
 
 ## 3. Completion
 
-Cleaning completion alone does not make a blocked or maintenance vehicle available. MobilityOps derives availability from all active restrictions.
+Cleaning completion alone does not make a blocked or maintenance vehicle available. Fleet Ops derives availability from all active restrictions.
diff --git a/knowledge/procedures/en-GB/07-customer-documents.md b/knowledge/procedures/en-GB/07-customer-documents.md
index 8653f78..c7fc3d0 100644
--- a/knowledge/procedures/en-GB/07-customer-documents.md
+++ b/knowledge/procedures/en-GB/07-customer-documents.md
@@ -14,7 +14,7 @@ The customer identity and valid driving licence must be verified in the source p
 
 ## 2. Data minimisation
 
-MobilityOps records only completion status and source references for this PoC. It does not store identity-document images.
+Fleet Ops records only completion status and source references for this demo environment. It does not store identity-document images.
 
 ## 3. Missing information
 
diff --git a/knowledge/procedures/en-GB/09-booking-conflicts.md b/knowledge/procedures/en-GB/09-booking-conflicts.md
index 7b5b020..0d77fe6 100644
--- a/knowledge/procedures/en-GB/09-booking-conflicts.md
+++ b/knowledge/procedures/en-GB/09-booking-conflicts.md
@@ -14,7 +14,7 @@ Two reserved or active bookings for the same vehicle may not overlap. Imported l
 
 ## 2. Resolution
 
-Operations reviews both bookings, confirms source-system ownership and reassigns or cancels one booking in the authoritative booking system. MobilityOps records the reviewed outcome.
+Operations reviews both bookings, confirms source-system ownership and reassigns or cancels one booking in the authoritative booking system. Fleet Ops records the reviewed outcome.
 
 ## 3. Safety
 
diff --git a/knowledge/procedures/fr-BE/03-damage-handling.md b/knowledge/procedures/fr-BE/03-damage-handling.md
index a524244..ca65194 100644
--- a/knowledge/procedures/fr-BE/03-damage-handling.md
+++ b/knowledge/procedures/fr-BE/03-damage-handling.md
@@ -14,7 +14,7 @@ Lorsqu'un véhicule revient avec des dommages visibles ou signalés, marquez le
 
 ## 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.
+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 cet environnement de démo.
 
 ## 3. Escalade
 
diff --git a/knowledge/procedures/fr-BE/07-customer-documents.md b/knowledge/procedures/fr-BE/07-customer-documents.md
index dfda656..641ccbb 100644
--- a/knowledge/procedures/fr-BE/07-customer-documents.md
+++ b/knowledge/procedures/fr-BE/07-customer-documents.md
@@ -14,7 +14,7 @@ L'identité du client et un permis de conduire valide doivent être vérifiés d
 
 ## 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.
+Fleet Ops n'enregistre dans cet environnement de démo 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
 
diff --git a/knowledge/procedures/nl-BE/03-damage-handling.md b/knowledge/procedures/nl-BE/03-damage-handling.md
index 6e5e87c..f666818 100644
--- a/knowledge/procedures/nl-BE/03-damage-handling.md
+++ b/knowledge/procedures/nl-BE/03-damage-handling.md
@@ -14,7 +14,7 @@ Wanneer een voertuig terugkomt met zichtbare of gemelde schade, markeer de schad
 
 ## 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.
+Registreer minstens vier foto's in het bron-inspectiesysteem: volledige aangetaste zijde, close-up, ruimere context en kentekenplaat. Fleet Ops mag in deze demo-omgeving enkel de verwijzing naar dat bewijs opslaan.
 
 ## 3. Escalatie
 
diff --git a/knowledge/procedures/nl-BE/07-customer-documents.md b/knowledge/procedures/nl-BE/07-customer-documents.md
index ffc2865..a7085e6 100644
--- a/knowledge/procedures/nl-BE/07-customer-documents.md
+++ b/knowledge/procedures/nl-BE/07-customer-documents.md
@@ -14,7 +14,7 @@ De identiteit van de klant en een geldig rijbewijs moeten geverifieerd zijn in h
 
 ## 2. Dataminimalisatie
 
-Fleet Ops registreert in deze PoC enkel de afhandelingsstatus en bronverwijzingen. Er worden geen afbeeldingen van identiteitsdocumenten opgeslagen.
+Fleet Ops registreert in deze demo-omgeving enkel de afhandelingsstatus en bronverwijzingen. Er worden geen afbeeldingen van identiteitsdocumenten opgeslagen.
 
 ## 3. Ontbrekende informatie