Enforce strict architecture-aware DXVK policy and normalize architecture detection

This change addresses misleading behavior when DXVK is explicitly selected
but not used by the runtime, particularly for Win32 games like Batman: Arkham Origins.

Key changes:
- Implemented robust PE header architecture detection for Windows executables.
- Normalized architecture into a consistent `ExecutableArchitecture` enum
  (X86, X86_64, Unknown) and propagated it through the launch pipeline.
- ResolveDllProvidersStage now fails early if required DXVK DLLs for the
  detected architecture are missing when the DXVK policy is explicitly selected.
- DllProviderResolver now strictly filters runner-bundled DLLs by architecture
  (i386-windows vs x86_64-windows) to prevent cross-architecture resolution.
- Improved diagnostics output to clearly report the target architecture
  (e.g., target_architecture = "x86") and the detection method.
- Introduced LaunchResult::Degraded to distinguish between process spawn
  success and backend policy violations.
- Fixed runtime evidence scanner in LaunchPipeline to use the actual
  configured WINE_LOG_OUTPUT path, resolving "Wine log missing" errors.
- Updated LaunchInvariantValidator to emit STRICT_POLICY_VIOLATION and
  STRICT_DXVK_EVIDENCE_MISSING codes for better diagnostics.
- Ensured WineTkgRunner correctly reflects the effective backend without
  silent degradation in explicit modes.

Co-authored-by: weter11 <14630689+weter11@users.noreply.github.com>

Author: google-labs-jules[bot]

src/infra/logging/session.rs

@@ -90,6 +90,7 @@ pub struct EffectiveSettingsConfig {
     pub effective_d3d12_provider: String,
     pub requested_gpu: Option<String>,
     pub effective_gpu: Option<String>,
+    pub target_architecture: crate::models::ExecutableArchitecture,
     pub dll_resolutions: Vec<crate::launch::dll_provider_resolver::DllResolution>,
     pub wine_dll_overrides: Option<String>,
     pub runtime_evidence: Option<crate::launch::pipeline::RuntimeEvidence>,

src/launch/pipeline.rs

@@ -34,6 +34,7 @@ pub struct GraphicsStackInfo {
     pub effective_d3d12_provider: String,
     pub requested_gpu: Option<String>,
     pub effective_gpu: Option<String>,
+    pub target_architecture: crate::models::ExecutableArchitecture,
     pub fallback_reasons: HashMap<String, String>,
     pub runtime_evidence: RuntimeEvidence,
     pub env_propagation: HashMap<String, bool>,
@@ -459,6 +460,9 @@ impl LaunchPipeline {
         // After stages are complete (or failed), populate effective stack and scan logs for evidence
         self.record_dll_provider_diagnostics(ctx);
 
+        // Sync architecture to diagnostics
+        ctx.graphics_stack.target_architecture = ctx.target_architecture;
+
         // Populate effective graphics stack info from command spec/env BEFORE scanning logs
         // so that evidence expectations align with what was actually resolved.
         self.populate_effective_graphics_stack(ctx);
@@ -851,6 +855,7 @@ impl LaunchPipeline {
                          effective_d3d12_provider: ctx.graphics_stack.effective_d3d12_provider.clone(),
                          requested_gpu: ctx.graphics_stack.requested_gpu.clone(),
                          effective_gpu: ctx.graphics_stack.effective_gpu.clone(),
+                         target_architecture: ctx.target_architecture,
                          dll_resolutions: ctx.dll_resolutions.clone(),
                          wine_dll_overrides: spec.env.get("WINEDLLOVERRIDES").cloned(),
                          runtime_evidence: Some(ctx.graphics_stack.runtime_evidence.clone()),
@@ -907,6 +912,7 @@ impl LaunchPipeline {
                  metadata.insert("backend".to_string(), ctx.graphics_stack.effective_backend.clone());
                  metadata.insert("d3d12_provider".to_string(), ctx.graphics_stack.effective_d3d12_provider.clone());
                  metadata.insert("gpu".to_string(), ctx.graphics_stack.effective_gpu.clone().unwrap_or_else(|| "default".to_string()));
+                 metadata.insert("arch".to_string(), format!("{:?}", ctx.target_architecture).to_lowercase());
                  if let Some(spec) = &ctx.command_spec {
                      if let Some(overrides) = spec.env.get("WINEDLLOVERRIDES") {
                          metadata.insert("overrides".to_string(), overrides.clone());

src/launch/stages/preflight.rs

@@ -13,7 +13,7 @@ pub struct PreflightCheck {
 pub struct PreflightReport {
     pub success: bool,
     pub checks: Vec<PreflightCheck>,
-    pub arch_hint: String,
+    pub target_architecture: crate::models::ExecutableArchitecture,
     pub runner_path: String,
 }
 
@@ -29,7 +29,6 @@ impl PipelineStage for PreflightStage {
 
         let mut checks = Vec::new();
         let runner_path = spec.program.to_string_lossy().to_string();
-        let arch_hint = if runner_path.contains("64") { "x64" } else { "x86/Unknown" }.to_string();
 
         let mut final_res: std::result::Result<(), LaunchError> = Ok(());
 
@@ -170,7 +169,7 @@ impl PipelineStage for PreflightStage {
         let report = PreflightReport {
             success: final_res.is_ok(),
             checks,
-            arch_hint,
+            target_architecture: ctx.target_architecture,
             runner_path,
         };
 
@@ -182,7 +181,7 @@ impl PipelineStage for PreflightStage {
         if let Some(logger) = &ctx.logger {
             let mut metadata = std::collections::HashMap::new();
             metadata.insert("runner_path".to_string(), report.runner_path.clone());
-            metadata.insert("arch_hint".to_string(), report.arch_hint.clone());
+            metadata.insert("target_architecture".to_string(), format!("{:?}", report.target_architecture).to_lowercase());
             metadata.insert("success".to_string(), report.success.to_string());
 
             let event_type = if report.success { "preflight_success" } else { "preflight_failure" };

src/launch/stages/resolve_dll_providers.rs

@@ -49,9 +49,23 @@ impl PipelineStage for ResolveDllProvidersStage {
         let components = crate::utils::detect_runner_components(&resolved_runner, wineprefix.as_deref());
         let d3d12_policy = ctx.user_config.as_ref().map(|c| c.graphics_layers.d3d12_policy.clone()).unwrap_or_default();
 
-        // Detect architecture before resolution if we have a resolved executable path
-        if let Some(exe_path) = &ctx.resolved_executable_path {
-            ctx.target_architecture = crate::utils::detect_exe_architecture(exe_path);
+        // Detect architecture before resolution
+        let mut exe_path = PathBuf::from(install_path);
+        if let Some(info) = &ctx.launch_info {
+            exe_path = exe_path.join(info.executable.replace('\\', "/"));
+        }
+        if exe_path.exists() {
+            ctx.target_architecture = crate::utils::detect_exe_architecture(&exe_path);
+            // Pre-populate this so downstream stages can use it
+            ctx.resolved_executable_path = Some(exe_path.clone());
+
+            if let Some(logger) = &ctx.logger {
+                let mut metadata = std::collections::HashMap::new();
+                metadata.insert("exe_path".into(), exe_path.to_string_lossy().to_string());
+                metadata.insert("detected_arch".into(), format!("{:?}", ctx.target_architecture).to_lowercase());
+                metadata.insert("detection_method".into(), "PE header".to_string());
+                let _ = logger.info("arch_detected", "Target executable architecture determined".into(), Some("ResolveDllProviders".into()), metadata);
+            }
         }
 
         let (resolutions, scan_report) = resolver.resolve(&game_exe_dir, &resolved_runner, &components, &d3d12_policy, &ctx.target_architecture);