fix(physics): add voltage auto-detect heuristic to prevent spurious early-exit

PhysicsConstraintLayer now skips voltage scoring when forecast values
are clearly not voltages (below half the lower voltage limit, ~103V).
This prevents synthetic evaluation data (normalised 0-1 features) from
triggering 100% early exit and bypassing the discriminative GNN layer.

The early_exit_threshold default of 0.9 remains correct for real grid
data where physics scores have meaningful variance. The fix is in data
type detection, not threshold tuning.

Key result: hybrid_full ROC-AUC goes from 0.50 to 1.00, ablation now
shows clear component differentiation (GNN=1.0, cascade=0.89,
physics=0.50), and hybrid vs gnn_only achieves p=0.0009 significance.

Author: vmehtacode

configs/hybrid_verifier.yaml

@@ -66,6 +66,9 @@ ensemble_weights:
 # Early-exit threshold: nodes with physics severity above this
 # skip GNN scoring and use physics score only.  High value (0.9)
 # means only severe violations trigger early exit.
+# Note: physics layer auto-detects data type — voltage scoring is
+# skipped when forecast values are clearly not voltages (e.g.,
+# normalised features), so this threshold only fires on real grid data.
 early_exit_threshold: 0.9
 
 # False-negative penalty ratio: FN (missed anomaly) is penalized

src/fyp/selfplay/hybrid_verifier.py

@@ -166,18 +166,33 @@ def evaluate(
         )
 
         # --- Voltage scoring ---
-        voltage_scores = np.array(
-            [
-                tolerance_band_score(
-                    float(v),
-                    self.voltage_lower_safe,
-                    self.voltage_upper_safe,
-                    self.voltage_lower_limit,
-                    self.voltage_upper_limit,
-                )
-                for v in v_data
-            ]
-        )
+        # Only scored when explicit voltage_values are provided or the
+        # data is in a plausible voltage range.  Heuristic: if the max
+        # absolute value is below half the lower voltage limit, these
+        # are clearly not voltage readings (e.g., normalised features
+        # or kW values) and would produce spurious severity=1.0.
+        if voltage_values is not None:
+            v_input = v_data
+        elif np.max(np.abs(v_data)) >= self.voltage_lower_limit / 2:
+            v_input = v_data
+        else:
+            v_input = None
+
+        if v_input is not None:
+            voltage_scores = np.array(
+                [
+                    tolerance_band_score(
+                        float(v),
+                        self.voltage_lower_safe,
+                        self.voltage_upper_safe,
+                        self.voltage_lower_limit,
+                        self.voltage_upper_limit,
+                    )
+                    for v in v_input
+                ]
+            )
+        else:
+            voltage_scores = np.zeros(n_nodes)
 
         # --- Capacity scoring ---
         # Only scored when power data is explicitly provided or the