use crate::validate::types::*;
pub struct CalibrationWeights {
pub v1_source: f64,
pub v2_content: f64,
pub v3_freshness: f64,
pub v4_cross_source: f64,
pub v5_extraction: f64,
pub v6_output: f64,
}
impl Default for CalibrationWeights {
fn default() -> Self {
Self {
v1_source: 0.15,
v2_content: 0.25,
v3_freshness: 0.15,
v4_cross_source: 0.25,
v5_extraction: 0.10,
v6_output: 0.10,
}
}
}
#[derive(Default)]
pub struct ConfidenceCalibrator {
weights: CalibrationWeights,
}
impl ConfidenceCalibrator {
pub fn calibrate(&self, layer_results: &[LayerResult]) -> f64 {
let mut weighted_sum = 0.0;
let mut weight_total = 0.0;
for lr in layer_results {
let w = self.weight_for(lr.layer);
weighted_sum += lr.score * w;
weight_total += w;
}
if weight_total == 0.0 {
return 0.5;
}
(weighted_sum / weight_total).clamp(0.0, 1.0)
}
pub fn build_result(
&self,
mode: ValidationMode,
layer_results: Vec<LayerResult>,
contradictions: Vec<Contradiction>,
consensus: Vec<ClaimConsensus>,
) -> ValidationResult {
let mut confidence = self.calibrate(&layer_results);
if layer_results.iter().any(|lr| {
lr.issues.iter().any(|issue| {
matches!(
issue.code.as_str(),
"V4_INSUFFICIENT_HIGH_STAKES_EVIDENCE" | "V4_LOW_SOURCE_DIVERSITY"
)
})
}) {
confidence = confidence.min(0.35);
}
let passed = layer_results.iter().all(|lr| lr.passed);
ValidationResult {
layers_run: layer_results.iter().map(|lr| lr.layer).collect(),
layer_results,
passed,
confidence,
contradictions,
consensus,
mode,
}
}
fn weight_for(&self, layer: ValidationLayerId) -> f64 {
match layer {
ValidationLayerId::V1Source => self.weights.v1_source,
ValidationLayerId::V2Content => self.weights.v2_content,
ValidationLayerId::V3Freshness => self.weights.v3_freshness,
ValidationLayerId::V4CrossSource => self.weights.v4_cross_source,
ValidationLayerId::V5ExtractionQuality => self.weights.v5_extraction,
ValidationLayerId::V6OutputIntegrity => self.weights.v6_output,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn all_perfect_layers() {
let cal = ConfidenceCalibrator::default();
let layers = vec![
LayerResult {
layer: ValidationLayerId::V1Source,
passed: true,
score: 1.0,
issues: vec![],
duration_ms: 1,
},
LayerResult {
layer: ValidationLayerId::V2Content,
passed: true,
score: 1.0,
issues: vec![],
duration_ms: 1,
},
];
let conf = cal.calibrate(&layers);
assert!(conf > 0.9);
}
#[test]
fn failed_layer_drops_confidence() {
let cal = ConfidenceCalibrator::default();
let layers = vec![LayerResult {
layer: ValidationLayerId::V4CrossSource,
passed: false,
score: 0.1,
issues: vec![],
duration_ms: 1,
}];
let conf = cal.calibrate(&layers);
assert!(conf < 0.2);
}
#[test]
fn empty_layers_returns_half() {
let cal = ConfidenceCalibrator::default();
assert_eq!(cal.calibrate(&[]), 0.5);
}
#[test]
fn build_result_populates_all_fields() {
let cal = ConfidenceCalibrator::default();
let lr = LayerResult {
layer: ValidationLayerId::V1Source,
passed: true,
score: 0.8,
issues: vec![],
duration_ms: 5,
};
let result = cal.build_result(ValidationMode::Standard, vec![lr], vec![], vec![]);
assert!(result.passed);
assert!(result.confidence > 0.0);
assert_eq!(result.mode, ValidationMode::Standard);
}
#[test]
fn high_stakes_evidence_failure_caps_confidence() {
let cal = ConfidenceCalibrator::default();
let lr = LayerResult {
layer: ValidationLayerId::V4CrossSource,
passed: false,
score: 0.6,
issues: vec![ValidationIssue {
severity: IssueSeverity::Error,
code: "V4_INSUFFICIENT_HIGH_STAKES_EVIDENCE".into(),
message: "Need more independent sources".into(),
source_url: None,
}],
duration_ms: 1,
};
let result = cal.build_result(ValidationMode::Standard, vec![lr], vec![], vec![]);
assert!(result.confidence <= 0.35);
}
}