fix: skip one-sided cross-validation and clean indicator reasoning (#1038)

Avoid penalizing assessments when paired backends have no matching data, and prevent empty indicator headers in OpenAlex reasoning output.

[AI-assisted]

Co-authored-by: florath-ai-assistant[bot] <Andreas.Florath@telekom.de>

Author: coding-ai-assistant[bot]

src/aletheia_probe/backends/openalex_analyzer.py

@@ -824,14 +824,16 @@ def _generate_reasoning(
     ) -> list[str]:
         """Generate human-readable reasoning for the assessment."""
         reasoning = []
+        normalized_green_flags = [flag.strip() for flag in green_flags if flag.strip()]
+        normalized_red_flags = [flag.strip() for flag in red_flags if flag.strip()]
 
-        if green_flags:
+        if normalized_green_flags:
             reasoning.append("Positive indicators:")
-            reasoning.extend([f"  • {flag}" for flag in green_flags])
+            reasoning.extend([f"  • {flag}" for flag in normalized_green_flags])
 
-        if red_flags:
+        if normalized_red_flags:
             reasoning.append("Warning signs:")
-            reasoning.extend([f"  • {flag}" for flag in red_flags])
+            reasoning.extend([f"  • {flag}" for flag in normalized_red_flags])
 
         # Add summary statistics
         reasoning.append(
@@ -841,7 +843,7 @@ def _generate_reasoning(
             f"Citation metrics: {metrics['citation_ratio']:.2f} citations per paper on average"
         )
 
-        if not green_flags and not red_flags:
+        if not normalized_green_flags and not normalized_red_flags:
             reasoning.append("Mixed or insufficient signals for clear assessment")
 
         return reasoning

src/aletheia_probe/dispatcher.py

@@ -163,6 +163,7 @@ def _apply_cross_validation(
 
         cross_validation_applied = False
         adjusted_results = []
+        max_total_adjustment = 0.25
 
         for result in backend_results:
             if result.status != BackendStatus.FOUND:
@@ -171,8 +172,8 @@ def _apply_cross_validation(
                 continue
 
             # Check if this result can be cross-validated with any other result
-            confidence_adjustment = 0.0
-            cross_validation_data = None
+            pair_adjustments: list[float] = []
+            cross_validation_data_list: list[dict[str, Any]] = []
             backend_name = result.backend_name
 
             for backend1, backend2 in registered_pairs:
@@ -183,21 +184,31 @@ def _apply_cross_validation(
                 else:
                     continue
 
+                # Cross-validation requires actual findings from both backends.
+                if other_result.status != BackendStatus.FOUND:
+                    continue
+
                 # Apply cross-validation for this pair
                 validation_result = self.cross_validation_registry.validate_pair(
                     backend_name, result, other_result.backend_name, other_result
                 )
 
                 if validation_result:
-                    confidence_adjustment = validation_result.get(
-                        "confidence_adjustment", 0.0
+                    adjustment = float(
+                        validation_result.get("confidence_adjustment", 0.0)
+                    )
+                    pair_adjustments.append(adjustment)
+                    cross_validation_data_list.append(
+                        {
+                            **validation_result,
+                            "paired_backend": other_result.backend_name,
+                        }
                     )
-                    cross_validation_data = validation_result
                     cross_validation_applied = True
 
                     self.detail_logger.debug(
                         f"Cross-validation applied between {backend_name} and {other_result.backend_name}: "
-                        f"adjustment={confidence_adjustment:+.3f}"
+                        f"adjustment={adjustment:+.3f}"
                     )
 
                     # Add cross-validation reasoning
@@ -211,28 +222,34 @@ def _apply_cross_validation(
                                 for reason in validation_result["reasoning"][:3]
                             ]
                         )
-
-                    break  # Apply only first matching cross-validation
+            confidence_adjustment = max(
+                -max_total_adjustment,
+                min(max_total_adjustment, sum(pair_adjustments)),
+            )
 
             # Create adjusted result
             new_confidence = max(
                 0.0, min(1.0, result.confidence + confidence_adjustment)
             )
 
+            data_with_cross_validation = {**result.data}
+            if cross_validation_data_list:
+                data_with_cross_validation["cross_validations"] = (
+                    cross_validation_data_list
+                )
+                if len(cross_validation_data_list) == 1:
+                    # Backward compatibility with existing consumers/tests.
+                    data_with_cross_validation["cross_validation"] = (
+                        cross_validation_data_list[0]
+                    )
+
             # Create new result with adjusted confidence and cross-validation data
             adjusted_result = BackendResult(
                 backend_name=result.backend_name,
                 status=result.status,
                 confidence=new_confidence,
                 assessment=result.assessment,
-                data={
-                    **result.data,
-                    **(
-                        {"cross_validation": cross_validation_data}
-                        if cross_validation_data
-                        else {}
-                    ),
-                },
+                data=data_with_cross_validation,
                 sources=result.sources,
                 error_message=result.error_message,
                 response_time=result.response_time,

tests/unit/backends/test_openalex_analyzer.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: MIT
+"""Tests for OpenAlex analyzer backend."""
+
+from aletheia_probe.backends.openalex_analyzer import OpenAlexAnalyzerBackend
+
+
+class TestOpenAlexAnalyzerReasoning:
+    """Tests for OpenAlex reasoning generation."""
+
+    def test_generate_reasoning_skips_empty_indicator_headers(self):
+        """Do not render indicator headers when flags are empty or blank."""
+        backend = OpenAlexAnalyzerBackend()
+        metrics = {"total_publications": 100, "years_active": 10, "citation_ratio": 2.5}
+
+        reasoning = backend._generate_reasoning(
+            red_flags=["", "   "],
+            green_flags=["  "],
+            metrics=metrics,
+        )
+
+        assert "Positive indicators:" not in reasoning
+        assert "Warning signs:" not in reasoning
+        assert "Mixed or insufficient signals for clear assessment" in reasoning

tests/unit/test_dispatcher.py

@@ -18,6 +18,26 @@
 )
 
 
+def _make_backend_result(
+    backend_name: str,
+    confidence: float,
+    status: BackendStatus = BackendStatus.FOUND,
+    assessment: AssessmentType | None = AssessmentType.LEGITIMATE,
+) -> BackendResult:
+    """Create a minimal BackendResult for dispatcher cross-validation tests."""
+    return BackendResult(
+        fallback_chain=QueryFallbackChain([]),
+        backend_name=backend_name,
+        status=status,
+        confidence=confidence,
+        assessment=assessment,
+        data={},
+        sources=[backend_name],
+        response_time=0.1,
+        evidence_type=EvidenceType.HEURISTIC.value,
+    )
+
+
 @pytest.fixture
 def dispatcher():
     """Create a QueryDispatcher instance for testing."""
@@ -487,3 +507,108 @@ def test_get_enabled_backends_without_email_config(self, dispatcher):
             # Verify that get_backend was called (not create_backend)
             mock_registry.get_backend.assert_called_once_with("doaj")
             mock_registry.create_backend.assert_not_called()
+
+    def test_apply_cross_validation_aggregates_multiple_pairs(self, dispatcher):
+        """Test that cross-validation aggregates adjustments from all matching pairs."""
+        backend_results = [
+            _make_backend_result("backend_a", confidence=0.5),
+            _make_backend_result("backend_b", confidence=0.6),
+            _make_backend_result("backend_c", confidence=0.7),
+        ]
+        reasoning: list[str] = []
+
+        with (
+            patch.object(
+                dispatcher.cross_validation_registry,
+                "get_registered_pairs",
+                return_value=[("backend_a", "backend_b"), ("backend_a", "backend_c")],
+            ),
+            patch.object(
+                dispatcher.cross_validation_registry, "validate_pair"
+            ) as mock_validate_pair,
+        ):
+            mock_validate_pair.side_effect = [
+                {"confidence_adjustment": 0.10, "reasoning": ["AB agreement"]},
+                {"confidence_adjustment": 0.08, "reasoning": ["AC agreement"]},
+                None,
+                None,
+            ]
+
+            adjusted_results = dispatcher._apply_cross_validation(
+                backend_results, reasoning
+            )
+
+        adjusted_a = next(r for r in adjusted_results if r.backend_name == "backend_a")
+        assert adjusted_a.confidence == pytest.approx(0.68)
+        assert "cross_validations" in adjusted_a.data
+        assert len(adjusted_a.data["cross_validations"]) == 2
+        assert "AB agreement" in " ".join(reasoning)
+        assert "AC agreement" in " ".join(reasoning)
+
+    def test_apply_cross_validation_caps_total_adjustment(self, dispatcher):
+        """Test that aggregated cross-validation adjustment is capped."""
+        backend_results = [
+            _make_backend_result("backend_a", confidence=0.5),
+            _make_backend_result("backend_b", confidence=0.6),
+            _make_backend_result("backend_c", confidence=0.7),
+        ]
+        reasoning: list[str] = []
+
+        with (
+            patch.object(
+                dispatcher.cross_validation_registry,
+                "get_registered_pairs",
+                return_value=[("backend_a", "backend_b"), ("backend_a", "backend_c")],
+            ),
+            patch.object(
+                dispatcher.cross_validation_registry, "validate_pair"
+            ) as mock_validate_pair,
+        ):
+            mock_validate_pair.side_effect = [
+                {"confidence_adjustment": 0.20, "reasoning": ["AB agreement"]},
+                {"confidence_adjustment": 0.20, "reasoning": ["AC agreement"]},
+                None,
+                None,
+            ]
+
+            adjusted_results = dispatcher._apply_cross_validation(
+                backend_results, reasoning
+            )
+
+        adjusted_a = next(r for r in adjusted_results if r.backend_name == "backend_a")
+        # Capped at +0.25 total adjustment for a single backend.
+        assert adjusted_a.confidence == pytest.approx(0.75)
+
+    def test_apply_cross_validation_skips_pairs_without_found_match(self, dispatcher):
+        """Test cross-validation is not applied when paired backend is not FOUND."""
+        backend_results = [
+            _make_backend_result(
+                "backend_a", confidence=0.5, status=BackendStatus.FOUND
+            ),
+            _make_backend_result(
+                "backend_b",
+                confidence=0.0,
+                status=BackendStatus.NOT_FOUND,
+                assessment=None,
+            ),
+        ]
+        reasoning: list[str] = []
+
+        with (
+            patch.object(
+                dispatcher.cross_validation_registry,
+                "get_registered_pairs",
+                return_value=[("backend_a", "backend_b")],
+            ),
+            patch.object(
+                dispatcher.cross_validation_registry, "validate_pair"
+            ) as mock_validate_pair,
+        ):
+            adjusted_results = dispatcher._apply_cross_validation(
+                backend_results, reasoning
+            )
+
+        adjusted_a = next(r for r in adjusted_results if r.backend_name == "backend_a")
+        assert adjusted_a.confidence == pytest.approx(0.5)
+        assert "cross_validations" not in adjusted_a.data
+        mock_validate_pair.assert_not_called()