fix(integration): force-enable ADP for the Windows runtime

Agent 7.80 added sanitizeDataPlaneConfig, which installs an authoritative
data_plane.enabled=false override on any platform other than Linux (macOS
was allowlisted later) unless DD_DATA_PLANE_FORCE_ENABLE=true. The Windows
integration target runs the Core Agent inside the container (via the ADP
entrypoint), so on the 7.80.2 Windows base the Agent streamed
data_plane.enabled=false to ADP and ADP exited with "Agent Data Plane is
not enabled" -- failing 18/28 Windows integration tests after the Windows
base image was bumped off the pre-7.80 7.78.0 pin.

Mirror the macOS host-process path (unix_runner::build_core_agent_forced_env)
by injecting DD_DATA_PLANE_FORCE_ENABLE=true into the Windows container env
whenever DD_DATA_PLANE_ENABLED=true. Linux is unaffected (allowlisted) and
an explicit value is preserved.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jszwedko

bin/correctness/panoramic/src/runner.rs

@@ -96,6 +96,18 @@ fn normalize_env_for_runtime(mut env: HashMap<String, String>, runtime: &str) ->
                 env.entry((*target).to_string()).or_insert(value);
             }
         }
+
+        // As of Agent 7.80, the Core Agent only honors `data_plane.enabled` on Linux (and later
+        // macOS); on every other platform `sanitizeDataPlaneConfig` installs an authoritative
+        // `data_plane.enabled=false` override unless `DD_DATA_PLANE_FORCE_ENABLE=true` is set. The
+        // Core Agent runs inside the Windows target container (started by the ADP entrypoint) and
+        // reads this flat env var, so without it the Agent streams `data_plane.enabled=false` to ADP
+        // and ADP exits with "Agent Data Plane is not enabled." Mirror the macOS host-process path
+        // (see `unix_runner::build_core_agent_forced_env`) and force-enable when ADP is requested.
+        if env.get("DD_DATA_PLANE_ENABLED").is_some_and(|value| value == "true") {
+            env.entry("DD_DATA_PLANE_FORCE_ENABLE".to_string())
+                .or_insert_with(|| "true".to_string());
+        }
     }
 
     env
@@ -1142,4 +1154,46 @@ mod tests {
 
         assert!(!normalized.contains_key("DD_DATA_PLANE__ENABLED"));
     }
+
+    #[test]
+    fn windows_runtime_force_enables_adp_when_enabled() {
+        let env = HashMap::from([("DD_DATA_PLANE_ENABLED".to_string(), "true".to_string())]);
+
+        let normalized = normalize_env_for_runtime(env, crate::config::WINDOWS_RUNTIME);
+
+        // The Core Agent in the Windows target container needs DD_DATA_PLANE_FORCE_ENABLE on
+        // non-Linux platforms (Agent 7.80+ `sanitizeDataPlaneConfig`), otherwise it streams
+        // data_plane.enabled=false to ADP and ADP exits.
+        assert_eq!(normalized.get("DD_DATA_PLANE_FORCE_ENABLE"), Some(&"true".to_string()));
+    }
+
+    #[test]
+    fn windows_runtime_does_not_force_enable_adp_when_disabled() {
+        let env = HashMap::from([("DD_DATA_PLANE_ENABLED".to_string(), "false".to_string())]);
+
+        let normalized = normalize_env_for_runtime(env, crate::config::WINDOWS_RUNTIME);
+
+        assert!(!normalized.contains_key("DD_DATA_PLANE_FORCE_ENABLE"));
+    }
+
+    #[test]
+    fn windows_runtime_preserves_explicit_force_enable_value() {
+        let env = HashMap::from([
+            ("DD_DATA_PLANE_ENABLED".to_string(), "true".to_string()),
+            ("DD_DATA_PLANE_FORCE_ENABLE".to_string(), "false".to_string()),
+        ]);
+
+        let normalized = normalize_env_for_runtime(env, crate::config::WINDOWS_RUNTIME);
+
+        assert_eq!(normalized.get("DD_DATA_PLANE_FORCE_ENABLE"), Some(&"false".to_string()));
+    }
+
+    #[test]
+    fn linux_runtime_does_not_force_enable_adp() {
+        let env = HashMap::from([("DD_DATA_PLANE_ENABLED".to_string(), "true".to_string())]);
+
+        let normalized = normalize_env_for_runtime(env, crate::config::LINUX_RUNTIME);
+
+        assert!(!normalized.contains_key("DD_DATA_PLANE_FORCE_ENABLE"));
+    }
 }