Make Auto launch policy conservative and stop aggressive environment injection

- Refactor `WineTkgRunner` to make `Auto` graphics policies conservative:
  - `GraphicsBackendPolicy::Auto` now defaults to baseline WineD3D unless manual overrides are set.
  - `D3D12ProviderPolicy::Auto` now defaults to None unless explicitly requested.
  - GPU selection now defaults to system default (no forced offload) if unset.
- Stop unconditional injection of DXVK/VKD3D paths and overrides based only on detection.
- Filter `WINEDLLPATH` to only include directories for components actively selected for use.
- Refine `populate_effective_graphics_stack` to distinguish between "default/unset" and "forced" states.
- Update `LaunchInvariantValidator` to enforce that no injection occurs for unset components.
- Ensure diagnostics clearly separate "Detected" availability from "Applied" runtime usage.

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

Author: google-labs-jules[bot]

src/infra/runners/tests.rs

@@ -106,17 +106,26 @@ mod tests {
                 target: LaunchTarget::WindowsProton,
             },
             launcher_config: config,
-            user_config: Some(user_config),
+            user_config: Some(user_config.clone()),
             proton_path: Some(runner_path.to_string_lossy().to_string()),
             dll_resolutions: Vec::new(),
         };
 
         let runner = WineTkgRunner;
         let env = runner.build_env(&ctx).await.unwrap();
 
-        // Since we simulated DXVK, Auto should have enabled it
+        // Auto is now CONSERVATIVE: it should NOT have enabled DXVK even if simulated on disk
         let overrides = env.get("WINEDLLOVERRIDES").unwrap();
-        assert!(overrides.contains("d3d11=n,b"));
+        assert!(!overrides.contains("d3d11=n,b"));
+
+        // Explicitly requesting DXVK should still enable it
+        let mut user_config_dxvk = user_config.clone();
+        user_config_dxvk.graphics_layers.graphics_backend_policy = GraphicsBackendPolicy::DXVK;
+        let mut ctx_dxvk = ctx.clone();
+        ctx_dxvk.user_config = Some(user_config_dxvk);
+        let env_dxvk = runner.build_env(&ctx_dxvk).await.unwrap();
+        let overrides_dxvk = env_dxvk.get("WINEDLLOVERRIDES").unwrap();
+        assert!(overrides_dxvk.contains("d3d11=n,b"));
     }
 
     #[tokio::test]

src/infra/runners/wine_tkg.rs

@@ -308,14 +308,16 @@ impl Runner for WineTkgRunner {
                 .unwrap_or("wine")
         };
 
-        let components = crate::utils::detect_runner_components(
+        let _components = crate::utils::detect_runner_components(
             &crate::utils::resolve_runner(proton, &library_root),
             Some(&game_wineprefix),
         );
 
-        // 1. Resolve DX8-11 policy (GraphicsBackendPolicy)
+        // 1. Resolve DX8-11 policy (GraphicsBackendPolicy) - CONSERVATIVE
         let (policy_dxvk, force_builtin) = match glc.graphics_backend_policy {
-            crate::models::GraphicsBackendPolicy::Auto => (components.dxvk.is_some(), false),
+            // Auto is now conservative: it does NOT automatically enable DXVK
+            // even if detected on disk. It prefers default Wine behavior.
+            crate::models::GraphicsBackendPolicy::Auto => (false, false),
             crate::models::GraphicsBackendPolicy::WineD3D => (false, true),
             crate::models::GraphicsBackendPolicy::DXVK => (true, false),
         };
@@ -326,17 +328,10 @@ impl Runner for WineTkgRunner {
         // If user explicitly selected WineD3D and didn't force DXVK, we use builtins.
         let force_builtin_d3d = force_builtin && !effective_dxvk;
 
-        // 2. Resolve DX12 policy (D3D12ProviderPolicy)
+        // 2. Resolve DX12 policy (D3D12ProviderPolicy) - CONSERVATIVE
         let (policy_vkd3dp, policy_vkd3dw) = match glc.d3d12_policy {
-            crate::models::D3D12ProviderPolicy::Auto => {
-                if components.vkd3d_proton.is_some() {
-                    (true, false)
-                } else if components.vkd3d.is_some() {
-                    (false, true)
-                } else {
-                    (false, false)
-                }
-            }
+            // Auto is now conservative: no forced D3D12 provider unless explicitly requested.
+            crate::models::D3D12ProviderPolicy::Auto => (false, false),
             crate::models::D3D12ProviderPolicy::Vkd3dProton => (true, false),
             crate::models::D3D12ProviderPolicy::Vkd3dWine => (false, true),
         };
@@ -371,11 +366,23 @@ impl Runner for WineTkgRunner {
 
         // Translate Runner-resolved DLL paths into WINEDLLPATH so Wine can
         // actually find the bundled DLLs (VKD3D-Proton, DXVK, etc.) in the runner.
-        // Without this, d3d12=n,b finds whatever is in the prefix's system32 instead.
+        // WITHOUT THIS, d3d12=n,b finds whatever is in the prefix's system32 instead.
+        // CONSERVATIVE: only include paths for DLLs that are actually requested to be native.
         let mut wine_dll_dirs: Vec<String> = Vec::new();
 
         for res in &ctx.dll_resolutions {
             if let crate::launch::dll_provider_resolver::DllProvider::Runner = res.chosen_provider {
+                // Check if this DLL is actually selected for use by the current policy/overrides
+                let name = res.name.to_lowercase();
+                let is_dxvk_dll = matches!(name.as_str(), "d3d8" | "d3d9" | "d3d10" | "d3d10_1" | "d3d10core" | "d3d11" | "dxgi");
+                let is_d3d12_dll = matches!(name.as_str(), "d3d12" | "d3d12core" | "libvkd3d-1" | "libvkd3d-shader-1");
+
+                let selected = (is_dxvk_dll && effective_dxvk) || (is_d3d12_dll && (effective_vkd3d_proton || effective_vkd3d));
+
+                if !selected {
+                    continue;
+                }
+
                 if let Some(path) = &res.chosen_path {
                     if let Some(parent) = path.parent() {
                         let dir = parent.to_string_lossy().to_string();
@@ -458,7 +465,7 @@ impl Runner for WineTkgRunner {
             env.insert("XDG_RUNTIME_DIR".to_string(), xdg_runtime);
         }
 
-        // Apply GPU preference if specified, otherwise fall back to auto-detecting PRIME/Optimus
+        // Apply GPU preference if specified. CONSERVATIVE: No forced offload if unset.
         if let Some(gpu_pref) = ctx.user_config.as_ref().and_then(|c| c.gpu_preference.as_ref()) {
             let available_gpus = crate::utils::list_available_gpus();
             if let Some(gpu) = available_gpus.iter().find(|g| &g.name == gpu_pref) {
@@ -486,11 +493,6 @@ impl Runner for WineTkgRunner {
                     }
                 }
             }
-        } else {
-            // Auto-inject PRIME/Optimus GPU selection
-            for (k, v) in crate::utils::detect_prime_env() {
-                env.entry(k).or_insert(v);
-            }
         }
 
         if let Some(config) = &ctx.user_config {
@@ -499,12 +501,12 @@ impl Runner for WineTkgRunner {
             }
 
             // Add debug toggles
-            if config.graphics_layers.dxvk_enabled {
+            if effective_dxvk {
                 if !env.contains_key("DXVK_HUD") {
                     env.insert("DXVK_HUD".to_string(), "compiler".to_string());
                 }
             }
-            if config.graphics_layers.vkd3d_proton_enabled || config.graphics_layers.vkd3d_enabled {
+            if effective_vkd3d_proton || effective_vkd3d {
                  if !env.contains_key("VKD3D_DEBUG") {
                     env.insert("VKD3D_DEBUG".to_string(), "warn".to_string());
                 }

src/launch/pipeline.rs

@@ -447,17 +447,21 @@ impl LaunchPipeline {
 
                  ctx.graphics_stack.effective_backend = if has_dxvk { "DXVK" } else { "WineD3D (Baseline)" }.to_string();
                  ctx.graphics_stack.effective_d3d12_provider = if has_vkd3dp { "vkd3d-proton" } else if has_vkd3dw { "vkd3d" } else { "None" }.to_string();
+             } else {
+                 ctx.graphics_stack.effective_backend = "WineD3D (Baseline)".to_string();
+                 ctx.graphics_stack.effective_d3d12_provider = "None".to_string();
              }
 
              // GPU Selection
+             ctx.graphics_stack.effective_gpu = None;
              if let Some(val) = spec.env.get("__NV_PRIME_RENDER_OFFLOAD") {
                  if val == "1" {
                      ctx.graphics_stack.effective_gpu = Some("NVIDIA Discrete GPU".to_string());
                  }
              } else if let Some(val) = spec.env.get("DRI_PRIME") {
                  if val == "1" {
                      ctx.graphics_stack.effective_gpu = Some("Secondary GPU (DRI_PRIME=1)".to_string());
-                 } else {
+                 } else if val == "0" {
                      ctx.graphics_stack.effective_gpu = Some("Primary GPU (DRI_PRIME=0)".to_string());
                  }
              }

src/launch/validators/invariants.rs

@@ -9,28 +9,86 @@ impl LaunchValidator for LaunchInvariantValidator {
     fn validate(&self, ctx: &mut PipelineContext) {
         let mut warnings = Vec::new();
 
-        // 1. Invariant B: baseline/WineD3D must not keep forced native DXVK/VKD3D overrides
-        if ctx.graphics_stack.effective_backend == "WineD3D (Baseline)" {
+        // Invariant A: If effective GPU is unset/default, there must be no forced GPU-selection env vars.
+        if ctx.graphics_stack.effective_gpu.is_none() {
+            if let Some(spec) = &ctx.command_spec {
+                for key in &[
+                    "DRI_PRIME",
+                    "__NV_PRIME_RENDER_OFFLOAD",
+                    "__NV_PRIME_RENDER_OFFLOAD_PROVIDER",
+                    "__GLX_VENDOR_LIBRARY_NAME",
+                    "__VK_LAYER_NV_optimus",
+                ] {
+                    if spec.env.contains_key(*key) {
+                        warnings.push((
+                            "INVARIANT_A_VIOLATION",
+                            format!("Effective GPU is unset but found GPU-forcing env var: {}", key),
+                        ));
+                    }
+                }
+            }
+        }
+
+        // Invariant B: If effective backend is not DXVK, there must be no DXVK-forcing overrides or DXVK-only DLL path injection.
+        if ctx.graphics_stack.effective_backend != "DXVK" {
             if let Some(spec) = &ctx.command_spec {
                 if let Some(overrides) = spec.env.get("WINEDLLOVERRIDES") {
-                    let conflicts = ["d3d8", "d3d9", "d3d10", "d3d10_1", "d3d10core", "d3d11", "dxgi", "d3d12", "d3d12core"];
+                    let dxvk_dlls = ["d3d8", "d3d9", "d3d10", "d3d10core", "d3d11", "dxgi"];
                     for part in overrides.split(';') {
                         if let Some((dll, mode)) = part.split_once('=') {
                             let dll_trimmed = dll.trim().to_lowercase();
-                            if conflicts.contains(&dll_trimmed.as_str()) && mode.contains('n') {
+                            if dxvk_dlls.contains(&dll_trimmed.as_str()) && mode.contains('n') {
                                 warnings.push((
-                                    "INVARIANT_B_CONFLICT",
-                                    format!("Forced native override '{dll}={mode}' found in baseline mode. Graphics may fail.")
+                                    "INVARIANT_B_VIOLATION",
+                                    format!("Effective backend is not DXVK but found native override for DXVK DLL: {}", dll),
                                 ));
                             }
                         }
                     }
                 }
+                if let Some(dll_path) = spec.env.get("WINEDLLPATH") {
+                    if dll_path.contains("dxvk") {
+                        warnings.push((
+                            "INVARIANT_B_VIOLATION",
+                            "Effective backend is not DXVK but WINEDLLPATH contains 'dxvk'".into(),
+                        ));
+                    }
+                }
             }
         }
 
-        // 2. Invariant C: effective D3D12 provider must match resolved provider paths
-        if !ctx.graphics_stack.effective_d3d12_provider.is_empty() {
+        // Invariant C: If effective D3D12 provider is unset/default/not-selected, there must be no forced D3D12 provider injection.
+        if ctx.graphics_stack.effective_d3d12_provider == "None" {
+            if let Some(spec) = &ctx.command_spec {
+                if let Some(overrides) = spec.env.get("WINEDLLOVERRIDES") {
+                    let d3d12_dlls = ["d3d12", "d3d12core"];
+                    for part in overrides.split(';') {
+                        if let Some((dll, mode)) = part.split_once('=') {
+                            let dll_trimmed = dll.trim().to_lowercase();
+                            if d3d12_dlls.contains(&dll_trimmed.as_str()) && mode.contains('n') {
+                                warnings.push((
+                                    "INVARIANT_C_VIOLATION",
+                                    format!("Effective D3D12 provider is None but found native override for DLL: {}", dll),
+                                ));
+                            }
+                        }
+                    }
+                }
+                if let Some(dll_path) = spec.env.get("WINEDLLPATH") {
+                    if dll_path.contains("vkd3d") {
+                        warnings.push((
+                            "INVARIANT_C_VIOLATION",
+                            "Effective D3D12 provider is None but WINEDLLPATH contains 'vkd3d'".into(),
+                        ));
+                    }
+                }
+            }
+        }
+
+        // Detailed Invariant C: Effective D3D12 provider must match resolved provider paths if one is active.
+        // If effective is "vkd3d-proton", we expect to see it in the path.
+        // If effective is "vkd3d", we expect to see vkd3d but NOT vkd3d-proton in the path.
+        if ctx.graphics_stack.effective_d3d12_provider != "None" {
              let provider = &ctx.graphics_stack.effective_d3d12_provider;
              for res in &ctx.dll_resolutions {
                  if res.name == "d3d12" || res.name == "d3d12core" {
@@ -52,9 +110,15 @@ impl LaunchValidator for LaunchInvariantValidator {
              }
         }
 
-        // 3. Invariant D: explicit user setting must not be silently overwritten
+        // Invariant D: explicit user setting must not be silently overwritten
         if !ctx.graphics_stack.requested_backend.is_empty() && ctx.graphics_stack.requested_backend != "Auto" {
-            if ctx.graphics_stack.requested_backend != ctx.graphics_stack.effective_backend {
+            // requested_backend is likely Debug string of enum, e.g. "DXVK" or "WineD3D"
+            let req = &ctx.graphics_stack.requested_backend;
+            let eff = &ctx.graphics_stack.effective_backend;
+
+            let mismatch = (req == "DXVK" && eff != "DXVK") || (req == "WineD3D" && eff != "WineD3D (Baseline)");
+
+            if mismatch {
                 let reason = ctx.graphics_stack.fallback_reasons.get("graphics_backend").cloned().unwrap_or_else(|| "unknown".into());
                 warnings.push((
                     "INVARIANT_D_BACKEND_MISMATCH",
@@ -76,7 +140,15 @@ impl LaunchValidator for LaunchInvariantValidator {
         }
 
         if let Some(requested_gpu) = &ctx.graphics_stack.requested_gpu {
-            if ctx.graphics_stack.effective_gpu.as_ref() != Some(requested_gpu) {
+            let mut mismatch = true;
+            if let Some(effective_gpu) = &ctx.graphics_stack.effective_gpu {
+                 // Check for partial match since effective names are synthesized
+                 if effective_gpu.contains(requested_gpu) || requested_gpu.contains("NVIDIA") && effective_gpu.contains("NVIDIA") {
+                     mismatch = false;
+                 }
+            }
+
+            if mismatch {
                 let reason = ctx.graphics_stack.fallback_reasons.get("gpu").cloned().unwrap_or_else(|| "unknown".into());
                 warnings.push((
                     "INVARIANT_D_GPU_MISMATCH",