cellstate_core/

scoring.rs

//! Deterministic scoring formula with transparency
//!
//! The scoring formula computes a weighted sum of N orthogonal factors,
//! each normalized to [0, 1]:
//!
//! ```text
//! score = Σ wᵢ · Sᵢ   where Σ wᵢ = 1 and 0 ≤ Sᵢ ≤ 1
//! ```
//!
//! This guarantees the final score is also in [0, 1] (convex combination).
//!
//! Re-export path: cellstate_core::scoring::*

use crate::Timestamp;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Weights for deterministic scoring formula.
///
/// Seven orthogonal factors, each weight ∈ [0, 1], summing to 1.0 (±ε).
///
/// ```text
/// score = w_v·S_vector + w_w·S_warmth + w_r·S_recency
///       + w_a·S_abstraction + w_g·S_graph + w_k·S_keyword
///       + w_c·S_causal
/// ```
///
/// The `causal` factor scores entities by their proximity to recent events
/// in the Event DAG. When no Event DAG data is available, adaptive weight
/// renormalization zeros `causal` and redistributes its budget to the
/// remaining factors.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct ScoringWeights {
    /// Cosine similarity between query embedding and entity embedding
    pub vector: f32,
    /// Access frequency with temporal decay
    pub warmth: f32,
    /// Creation time decay (newer = higher)
    pub recency: f32,
    /// Abstraction level (Principle > Summary > Raw)
    pub abstraction: f32,
    /// Graph proximity via edge traversal (degrees of separation)
    pub graph: f32,
    /// Keyword/substring match score
    pub keyword: f32,
    /// Event DAG causal proximity (how recently events reference this entity)
    pub causal: f32,
}

impl Default for ScoringWeights {
    fn default() -> Self {
        Self {
            vector: 0.30,
            warmth: 0.12,
            recency: 0.13,
            abstraction: 0.08,
            graph: 0.12,
            keyword: 0.08,
            causal: 0.17,
        }
    }
}

impl ScoringWeights {
    /// Validate that all weights sum to 1.0 within epsilon tolerance.
    ///
    /// The tolerance matches the PostgreSQL `weights_sum_to_one` CHECK
    /// constraint: `ABS(sum - 1.0) < 0.001`.
    pub fn validate(&self) -> bool {
        const EPSILON: f32 = 0.001;
        let sum = self.sum();
        (sum - 1.0).abs() <= EPSILON
    }

    /// Normalize weights so they sum to exactly 1.0, preserving ratios.
    ///
    /// # Mathematical Properties
    ///
    /// - **Idempotent**: `normalize(normalize(w)) = normalize(w)`
    /// - **Ratio-preserving**: `wᵢ/wⱼ` is invariant under normalization
    /// - **No-op on zero**: if all weights are 0, remains all zeros
    pub fn normalize(&mut self) {
        let sum = self.sum();
        if sum > 0.0 {
            self.vector /= sum;
            self.warmth /= sum;
            self.recency /= sum;
            self.abstraction /= sum;
            self.graph /= sum;
            self.keyword /= sum;
            self.causal /= sum;
        }
    }

    /// Legacy 6-factor weights for backward compatibility.
    ///
    /// Returns weights with `causal = 0.0` and the original 6-factor
    /// defaults. Useful when Event DAG is not available.
    pub fn legacy_six_factor() -> Self {
        Self {
            vector: 0.35,
            warmth: 0.15,
            recency: 0.15,
            abstraction: 0.10,
            graph: 0.15,
            keyword: 0.10,
            causal: 0.0,
        }
    }

    /// Sum of all weights.
    #[inline]
    fn sum(&self) -> f32 {
        self.vector
            + self.warmth
            + self.recency
            + self.abstraction
            + self.graph
            + self.keyword
            + self.causal
    }

    /// Compute the weighted score given per-factor raw scores.
    ///
    /// Each raw score should be in [0, 1]. The result is in [0, 1] when
    /// weights are valid (sum to 1.0).
    ///
    /// Non-finite factor values (NaN, ±Inf) are clamped to [0, 1] to prevent
    /// silent propagation through downstream scoring.
    pub fn score(&self, factors: &ScoringFactors) -> f32 {
        let result = self.vector * factors.vector.clamp(0.0, 1.0)
            + self.warmth * factors.warmth.clamp(0.0, 1.0)
            + self.recency * factors.recency.clamp(0.0, 1.0)
            + self.abstraction * factors.abstraction.clamp(0.0, 1.0)
            + self.graph * factors.graph.clamp(0.0, 1.0)
            + self.keyword * factors.keyword.clamp(0.0, 1.0)
            + self.causal * factors.causal.clamp(0.0, 1.0);
        // Guard against NaN from 0.0 * clamped-NaN (NaN.clamp returns NaN on some platforms)
        if result.is_finite() {
            result
        } else {
            0.0
        }
    }
}

/// Raw per-factor scores, each in [0, 1].
#[derive(Debug, Clone, Default)]
pub struct ScoringFactors {
    pub vector: f32,
    pub warmth: f32,
    pub recency: f32,
    pub abstraction: f32,
    pub graph: f32,
    pub keyword: f32,
    pub causal: f32,
}

/// Debug output for scoring transparency
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct ScoringDebug {
    pub item_id: String,
    pub final_score: f32,
    pub components: HashMap<String, ScoringComponent>,
    pub weights_used: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub struct ScoringComponent {
    pub raw: f32,
    pub weighted: f32,
}

/// Source quality tracking (P2)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SourceQuality {
    pub source_id: String,
    pub reliability_score: f32,
    pub freshness: Timestamp,
    pub citation_count: u32,
}

// ── Belief-to-Scoring Bridge ─────────────────────────────────────────

/// Apply belief-confidence modifiers to a base score.
///
/// When an agent holds beliefs about scored entities, the belief confidence
/// acts as a multiplier:
///
/// ```text
/// adjusted_score = base_score * belief_modifier(confidence)
/// ```
///
/// The modifier uses a piecewise linear function:
/// - confidence >= 0.8  →  modifier = 1.0 (full score, strong belief)
/// - confidence in [0.3, 0.8) → modifier = 0.5 + (confidence - 0.3) * (0.5 / 0.5)
///   (linear interpolation from 0.5 to 1.0)
/// - confidence < 0.3  →  modifier = 0.5 * (confidence / 0.3)
///   (linear from 0.0 to 0.5, penalises low-confidence beliefs)
///
/// This ensures:
/// - High-confidence beliefs don't distort scores (modifier ≈ 1.0)
/// - Low-confidence beliefs suppress scores proportionally
/// - The output is always in [0, base_score]
#[inline]
pub fn belief_confidence_modifier(confidence: f32) -> f32 {
    let c = confidence.clamp(0.0, 1.0);
    if c >= 0.8 {
        1.0
    } else if c >= 0.3 {
        0.5 + (c - 0.3)
    } else {
        0.5 * (c / 0.3)
    }
}

/// Aggregate belief confidence across multiple beliefs about the same entity.
///
/// Uses max-confidence (optimistic) policy: the strongest supporting belief
/// determines the modifier. Returns 1.0 (no modifier) if no beliefs apply.
#[inline]
pub fn aggregate_belief_modifier(confidences: &[f32]) -> f32 {
    if confidences.is_empty() {
        return 1.0;
    }
    let max_confidence = confidences.iter().copied().fold(0.0f32, f32::max);
    belief_confidence_modifier(max_confidence)
}

#[cfg(test)]
mod tests {
    use super::*;

    // ── Default weights ──────────────────────────────────────────────

    #[test]
    fn test_default_weights_sum_to_one() {
        let weights = ScoringWeights::default();
        let sum = weights.sum();
        assert!(
            (sum - 1.0).abs() < 0.001,
            "Default weights should sum to 1.0, got {}",
            sum
        );
    }

    #[test]
    fn test_default_weights_validate() {
        let weights = ScoringWeights::default();
        assert!(weights.validate(), "Default weights should validate");
    }

    #[test]
    fn test_legacy_six_factor_validates_after_normalize() {
        let mut weights = ScoringWeights::legacy_six_factor();
        // Legacy has causal=0.0, so sum=1.0 already
        assert!(
            weights.validate(),
            "Legacy 6-factor should already be valid"
        );
        weights.normalize();
        assert!(
            weights.validate(),
            "Legacy should still validate after normalize"
        );
    }

    // ── Validation ───────────────────────────────────────────────────

    #[test]
    fn test_validate_returns_true_for_valid_weights() {
        let weights = ScoringWeights {
            vector: 0.3,
            warmth: 0.15,
            recency: 0.15,
            abstraction: 0.1,
            graph: 0.1,
            keyword: 0.05,
            causal: 0.15,
        };
        assert!(weights.validate(), "Valid weights should pass validation");
    }

    #[test]
    fn test_validate_returns_false_when_sum_too_high() {
        let weights = ScoringWeights {
            vector: 0.5,
            warmth: 0.3,
            recency: 0.3,
            abstraction: 0.2,
            graph: 0.2,
            keyword: 0.2,
            causal: 0.2,
        };
        assert!(
            !weights.validate(),
            "Weights summing to > 1.0 should fail validation"
        );
    }

    #[test]
    fn test_validate_returns_false_when_sum_too_low() {
        let weights = ScoringWeights {
            vector: 0.1,
            warmth: 0.1,
            recency: 0.1,
            abstraction: 0.05,
            graph: 0.05,
            keyword: 0.05,
            causal: 0.05,
        };
        assert!(
            !weights.validate(),
            "Weights summing to < 1.0 should fail validation"
        );
    }

    #[test]
    fn test_validate_accepts_values_within_epsilon() {
        let weights = ScoringWeights {
            vector: 0.3005,
            warmth: 0.12,
            recency: 0.13,
            abstraction: 0.08,
            graph: 0.12,
            keyword: 0.08,
            causal: 0.1695,
        };
        assert!(weights.validate(), "Weights within epsilon should validate");
    }

    // ── Normalization ────────────────────────────────────────────────

    #[test]
    fn test_normalize_fixes_invalid_weights() {
        let mut weights = ScoringWeights {
            vector: 0.7,
            warmth: 0.3,
            recency: 0.3,
            abstraction: 0.2,
            graph: 0.3,
            keyword: 0.2,
            causal: 0.3,
        };

        assert!(
            !weights.validate(),
            "Weights should be invalid before normalization"
        );
        weights.normalize();
        assert!(
            weights.validate(),
            "Weights should be valid after normalization"
        );
    }

    #[test]
    fn test_normalize_preserves_ratios() {
        let mut weights = ScoringWeights {
            vector: 0.4,
            warmth: 0.2,
            recency: 0.2,
            abstraction: 0.1,
            graph: 0.2,
            keyword: 0.1,
            causal: 0.2,
        };

        let sum = weights.sum(); // 1.4
        weights.normalize();

        assert!((weights.vector - 0.4 / sum).abs() < 0.0001);
        assert!((weights.warmth - 0.2 / sum).abs() < 0.0001);
        assert!((weights.recency - 0.2 / sum).abs() < 0.0001);
        assert!((weights.abstraction - 0.1 / sum).abs() < 0.0001);
        assert!((weights.graph - 0.2 / sum).abs() < 0.0001);
        assert!((weights.keyword - 0.1 / sum).abs() < 0.0001);
        assert!((weights.causal - 0.2 / sum).abs() < 0.0001);
    }

    #[test]
    fn test_normalize_handles_small_values() {
        let mut weights = ScoringWeights {
            vector: 0.01,
            warmth: 0.01,
            recency: 0.01,
            abstraction: 0.01,
            graph: 0.01,
            keyword: 0.01,
            causal: 0.01,
        };

        weights.normalize();
        assert!(
            weights.validate(),
            "Normalized small weights should validate"
        );
    }

    #[test]
    fn test_normalize_handles_large_values() {
        let mut weights = ScoringWeights {
            vector: 100.0,
            warmth: 50.0,
            recency: 50.0,
            abstraction: 25.0,
            graph: 50.0,
            keyword: 25.0,
            causal: 50.0,
        };

        weights.normalize();
        assert!(
            weights.validate(),
            "Normalized large weights should validate"
        );
    }

    #[test]
    fn test_normalize_handles_zero_weights() {
        let mut weights = ScoringWeights {
            vector: 1.0,
            warmth: 0.0,
            recency: 0.0,
            abstraction: 0.0,
            graph: 0.0,
            keyword: 0.0,
            causal: 0.0,
        };

        weights.normalize();
        assert!(
            weights.validate(),
            "Normalized weights with zeros should validate"
        );
        assert!(
            (weights.vector - 1.0).abs() < 0.0001,
            "Single non-zero weight should become 1.0"
        );
    }

    #[test]
    fn test_normalize_handles_all_zeros() {
        let mut weights = ScoringWeights {
            vector: 0.0,
            warmth: 0.0,
            recency: 0.0,
            abstraction: 0.0,
            graph: 0.0,
            keyword: 0.0,
            causal: 0.0,
        };

        weights.normalize();
        assert_eq!(weights.vector, 0.0);
        assert_eq!(weights.warmth, 0.0);
        assert_eq!(weights.causal, 0.0);
    }

    #[test]
    fn test_normalize_idempotent() {
        let mut weights = ScoringWeights {
            vector: 0.7,
            warmth: 0.3,
            recency: 0.3,
            abstraction: 0.2,
            graph: 0.3,
            keyword: 0.2,
            causal: 0.3,
        };

        weights.normalize();
        let first_vector = weights.vector;
        let first_warmth = weights.warmth;
        let first_causal = weights.causal;

        weights.normalize();
        assert!(
            (weights.vector - first_vector).abs() < 0.00001,
            "normalize() should be idempotent"
        );
        assert!(
            (weights.warmth - first_warmth).abs() < 0.00001,
            "normalize() should be idempotent"
        );
        assert!(
            (weights.causal - first_causal).abs() < 0.00001,
            "normalize() should be idempotent for causal"
        );
    }

    #[test]
    fn test_normalize_maintains_relative_weights() {
        let mut weights = ScoringWeights {
            vector: 0.4,
            warmth: 0.2,
            recency: 0.2,
            abstraction: 0.1,
            graph: 0.2,
            keyword: 0.1,
            causal: 0.2,
        };

        weights.normalize();

        // Vector should be 2x warmth (0.4 / 0.2 = 2)
        assert!((weights.vector / weights.warmth - 2.0).abs() < 0.0001);
        // Warmth should equal recency
        assert!((weights.warmth - weights.recency).abs() < 0.0001);
        // Warmth should equal causal (both started at 0.2)
        assert!((weights.warmth - weights.causal).abs() < 0.0001);
    }

    // ── Score computation ────────────────────────────────────────────

    #[test]
    fn test_score_all_ones_equals_one() {
        let weights = ScoringWeights::default();
        let factors = ScoringFactors {
            vector: 1.0,
            warmth: 1.0,
            recency: 1.0,
            abstraction: 1.0,
            graph: 1.0,
            keyword: 1.0,
            causal: 1.0,
        };
        let score = weights.score(&factors);
        assert!(
            (score - 1.0).abs() < 0.01,
            "All-ones factors with valid weights should score ~1.0, got {}",
            score
        );
    }

    #[test]
    fn test_score_all_zeros_equals_zero() {
        let weights = ScoringWeights::default();
        let factors = ScoringFactors::default();
        let score = weights.score(&factors);
        assert_eq!(score, 0.0);
    }

    #[test]
    fn test_score_single_factor() {
        let weights = ScoringWeights::default();
        let factors = ScoringFactors {
            vector: 1.0,
            ..Default::default()
        };
        let score = weights.score(&factors);
        assert!(
            (score - weights.vector).abs() < 0.0001,
            "Single vector=1.0 should give score = vector weight"
        );
    }

    // ── NaN/Inf guard ──────────────────────────────────────────────

    #[test]
    fn test_score_nan_factor_returns_zero() {
        let weights = ScoringWeights::default();
        let factors = ScoringFactors {
            vector: f32::NAN,
            warmth: 1.0,
            recency: 1.0,
            abstraction: 1.0,
            graph: 1.0,
            keyword: 1.0,
            causal: 1.0,
        };
        let score = weights.score(&factors);
        assert!(score.is_finite(), "NaN factor should not produce NaN score");
    }

    #[test]
    fn test_score_inf_factor_clamped() {
        let weights = ScoringWeights::default();
        let factors = ScoringFactors {
            vector: f32::INFINITY,
            warmth: 0.0,
            recency: 0.0,
            abstraction: 0.0,
            graph: 0.0,
            keyword: 0.0,
            causal: 0.0,
        };
        let score = weights.score(&factors);
        assert!(score.is_finite(), "Inf factor should be clamped");
        assert!(
            (score - weights.vector).abs() < 0.001,
            "Inf clamped to 1.0 should produce weight value"
        );
    }

    #[test]
    fn test_score_neg_inf_factor_clamped() {
        let weights = ScoringWeights::default();
        let factors = ScoringFactors {
            vector: f32::NEG_INFINITY,
            ..Default::default()
        };
        let score = weights.score(&factors);
        assert!(score.is_finite(), "Neg Inf factor should be clamped to 0.0");
        assert_eq!(score, 0.0);
    }

    // ── Belief-to-Scoring bridge ──────────────────────────────────────

    #[test]
    fn test_belief_modifier_high_confidence() {
        assert_eq!(belief_confidence_modifier(1.0), 1.0);
        assert_eq!(belief_confidence_modifier(0.9), 1.0);
        assert_eq!(belief_confidence_modifier(0.8), 1.0);
    }

    #[test]
    fn test_belief_modifier_medium_confidence() {
        let m = belief_confidence_modifier(0.55);
        assert!(
            (m - 0.75).abs() < 0.01,
            "0.55 confidence should give ~0.75 modifier, got {m}"
        );
    }

    #[test]
    fn test_belief_modifier_low_confidence() {
        let m = belief_confidence_modifier(0.15);
        assert!(
            (m - 0.25).abs() < 0.01,
            "0.15 confidence should give ~0.25 modifier, got {m}"
        );
        assert_eq!(belief_confidence_modifier(0.0), 0.0);
    }

    #[test]
    fn test_belief_modifier_boundary_0_3() {
        let m = belief_confidence_modifier(0.3);
        assert!(
            (m - 0.5).abs() < 0.01,
            "0.3 confidence should give ~0.5 modifier, got {m}"
        );
    }

    #[test]
    fn test_belief_modifier_clamped() {
        assert_eq!(belief_confidence_modifier(-0.5), 0.0);
        assert_eq!(belief_confidence_modifier(2.0), 1.0);
    }

    #[test]
    fn test_aggregate_belief_modifier_empty() {
        assert_eq!(aggregate_belief_modifier(&[]), 1.0);
    }

    #[test]
    fn test_aggregate_belief_modifier_uses_max() {
        // Two beliefs: 0.3 and 0.9 — should use 0.9 (high confidence = 1.0 modifier)
        let m = aggregate_belief_modifier(&[0.3, 0.9]);
        assert_eq!(m, 1.0);
    }

    #[test]
    fn test_aggregate_belief_modifier_all_low() {
        let m = aggregate_belief_modifier(&[0.1, 0.2]);
        // max is 0.2 → modifier = 0.5 * (0.2/0.3) ≈ 0.333
        assert!((m - 0.333).abs() < 0.01, "got {m}");
    }

    // ── Property tests ───────────────────────────────────────────────

    mod prop {
        use super::*;
        use proptest::prelude::*;

        proptest! {
            #![proptest_config(ProptestConfig::with_cases(1000))]

            /// Normalization always produces valid weights (when sum > 0)
            #[test]
            fn prop_normalize_produces_valid(
                v in 0.0f32..10.0, w in 0.0f32..10.0, r in 0.0f32..10.0,
                a in 0.0f32..10.0, g in 0.0f32..10.0, k in 0.0f32..10.0,
                c in 0.0f32..10.0,
            ) {
                prop_assume!(v + w + r + a + g + k + c > 0.0);
                let mut weights = ScoringWeights {
                    vector: v, warmth: w, recency: r,
                    abstraction: a, graph: g, keyword: k, causal: c,
                };
                weights.normalize();
                prop_assert!(weights.validate(),
                    "Normalized weights should validate, sum={}",
                    weights.sum());
            }

            /// Normalization is idempotent
            #[test]
            fn prop_normalize_idempotent(
                v in 0.01f32..10.0, w in 0.01f32..10.0, r in 0.01f32..10.0,
                a in 0.01f32..10.0, g in 0.01f32..10.0, k in 0.01f32..10.0,
                c in 0.01f32..10.0,
            ) {
                let mut w1 = ScoringWeights {
                    vector: v, warmth: w, recency: r,
                    abstraction: a, graph: g, keyword: k, causal: c,
                };
                w1.normalize();
                let snapshot = w1.clone();
                w1.normalize();
                prop_assert!((w1.vector - snapshot.vector).abs() < 1e-5);
                prop_assert!((w1.causal - snapshot.causal).abs() < 1e-5);
            }

            /// Normalization preserves pairwise ratios
            #[test]
            fn prop_normalize_preserves_ratios(
                v in 0.01f32..10.0, w in 0.01f32..10.0, r in 0.01f32..10.0,
                a in 0.01f32..10.0, g in 0.01f32..10.0, k in 0.01f32..10.0,
                c in 0.01f32..10.0,
            ) {
                let ratio_before = v / w;
                let mut weights = ScoringWeights {
                    vector: v, warmth: w, recency: r,
                    abstraction: a, graph: g, keyword: k, causal: c,
                };
                weights.normalize();
                let ratio_after = weights.vector / weights.warmth;
                prop_assert!(
                    (ratio_before - ratio_after).abs() < 0.01,
                    "Ratio v/w changed: {} → {}",
                    ratio_before, ratio_after
                );
            }

            /// Score is bounded in [0, 1] when weights are valid and factors in [0, 1]
            #[test]
            fn prop_score_bounded(
                sv in 0.0f32..1.0, sw in 0.0f32..1.0, sr in 0.0f32..1.0,
                sa in 0.0f32..1.0, sg in 0.0f32..1.0, sk in 0.0f32..1.0,
                sc in 0.0f32..1.0,
            ) {
                let weights = ScoringWeights::default();
                let factors = ScoringFactors {
                    vector: sv, warmth: sw, recency: sr,
                    abstraction: sa, graph: sg, keyword: sk, causal: sc,
                };
                let score = weights.score(&factors);
                prop_assert!(
                    (0.0..=1.01).contains(&score),
                    "Score {} not in [0, 1] with factors {:?}",
                    score, factors
                );
            }

            /// Score is monotone in each factor (increasing one factor ⟹ score increases)
            #[test]
            fn prop_score_monotone_per_vector(
                base in 0.0f32..0.5,
                delta in 0.01f32..0.5,
            ) {
                let weights = ScoringWeights::default();
                let f1 = ScoringFactors { vector: base, ..Default::default() };
                let f2 = ScoringFactors { vector: base + delta, ..Default::default() };
                prop_assert!(weights.score(&f2) >= weights.score(&f1));
            }
        }
    }

    // ── Moved from integration tests (scoring_property_tests.rs) ─────

    #[test]
    fn test_scoring_weights_default_has_causal() {
        let w = ScoringWeights::default();
        assert!(w.causal > 0.0, "default causal weight should be positive");
        assert!(
            (w.causal - 0.17).abs() < 0.01,
            "default causal should be ~0.17"
        );
    }

    #[test]
    fn test_legacy_weights_still_valid() {
        let mut w = ScoringWeights {
            vector: 0.35,
            warmth: 0.15,
            recency: 0.15,
            abstraction: 0.10,
            graph: 0.15,
            keyword: 0.10,
            causal: 0.0,
        };
        let sum = w.vector + w.warmth + w.recency + w.abstraction + w.graph + w.keyword;
        assert!(
            (sum - 1.0).abs() < 0.001,
            "legacy 6-factor sum should be ~1.0"
        );

        let total = sum + w.causal;
        w.vector /= total;
        w.warmth /= total;
        w.recency /= total;
        w.abstraction /= total;
        w.graph /= total;
        w.keyword /= total;
        w.causal /= total;

        let new_sum =
            w.vector + w.warmth + w.recency + w.abstraction + w.graph + w.keyword + w.causal;
        assert!(
            (new_sum - 1.0).abs() < 0.001,
            "renormalized sum should be ~1.0"
        );
    }

    mod prop_integration {
        use super::super::*;
        use proptest::prelude::*;

        fn arb_scoring_weights() -> impl Strategy<Value = ScoringWeights> {
            proptest::array::uniform7(0.01_f32..1.0).prop_map(|raw: [f32; 7]| {
                let sum: f32 = raw.iter().sum();
                ScoringWeights {
                    vector: raw[0] / sum,
                    warmth: raw[1] / sum,
                    recency: raw[2] / sum,
                    abstraction: raw[3] / sum,
                    graph: raw[4] / sum,
                    keyword: raw[5] / sum,
                    causal: raw[6] / sum,
                }
            })
        }

        fn arb_legacy_weights() -> impl Strategy<Value = ScoringWeights> {
            proptest::array::uniform6(0.01_f32..1.0).prop_map(|raw: [f32; 6]| {
                let sum: f32 = raw.iter().sum();
                ScoringWeights {
                    vector: raw[0] / sum,
                    warmth: raw[1] / sum,
                    recency: raw[2] / sum,
                    abstraction: raw[3] / sum,
                    graph: raw[4] / sum,
                    keyword: raw[5] / sum,
                    causal: 0.0,
                }
            })
        }

        proptest! {
            #![proptest_config(ProptestConfig::with_cases(500))]

            #[test]
            fn prop_adaptive_renorm_preserves_sum(
                weights in arb_scoring_weights(),
                zero_vector in proptest::bool::ANY,
                zero_graph in proptest::bool::ANY,
                zero_causal in proptest::bool::ANY,
            ) {
                let mut w = weights;
                if zero_vector { w.vector = 0.0; }
                if zero_graph { w.graph = 0.0; }
                if zero_causal { w.causal = 0.0; }

                let sum = w.vector + w.warmth + w.recency
                    + w.abstraction + w.graph + w.keyword + w.causal;
                if sum > 1e-6 {
                    w.vector /= sum;
                    w.warmth /= sum;
                    w.recency /= sum;
                    w.abstraction /= sum;
                    w.graph /= sum;
                    w.keyword /= sum;
                    w.causal /= sum;

                    let new_sum = w.vector + w.warmth + w.recency
                        + w.abstraction + w.graph + w.keyword + w.causal;
                    prop_assert!((new_sum - 1.0).abs() < 0.01,
                        "renormalized sum should be ~1.0, got {}", new_sum);
                }
            }

            #[test]
            fn prop_legacy_compat_score_valid(
                weights in arb_legacy_weights(),
                s_vector in 0.0_f32..=1.0,
                s_warmth in 0.0_f32..=1.0,
                s_recency in 0.0_f32..=1.0,
                s_abstraction in 0.0_f32..=1.0,
                s_graph in 0.0_f32..=1.0,
                s_keyword in 0.0_f32..=1.0,
            ) {
                let score = weights.vector * s_vector
                    + weights.warmth * s_warmth
                    + weights.recency * s_recency
                    + weights.abstraction * s_abstraction
                    + weights.graph * s_graph
                    + weights.keyword * s_keyword
                    + weights.causal * 0.0;

                prop_assert!((-1e-6..=1.0 + 1e-6).contains(&score),
                    "legacy 6-factor score {} should be in [0,1]", score);
            }

            #[test]
            fn prop_7factor_score_bounded(
                weights in arb_scoring_weights(),
                s_vector in 0.0_f32..=1.0,
                s_warmth in 0.0_f32..=1.0,
                s_recency in 0.0_f32..=1.0,
                s_abstraction in 0.0_f32..=1.0,
                s_graph in 0.0_f32..=1.0,
                s_keyword in 0.0_f32..=1.0,
                s_causal in 0.0_f32..=1.0,
            ) {
                let score = weights.vector * s_vector
                    + weights.warmth * s_warmth
                    + weights.recency * s_recency
                    + weights.abstraction * s_abstraction
                    + weights.graph * s_graph
                    + weights.keyword * s_keyword
                    + weights.causal * s_causal;

                prop_assert!((-1e-6..=1.0 + 1e-6).contains(&score),
                    "7-factor score {} should be in [0,1]", score);
            }

            #[test]
            fn prop_default_weights_sum_one(_dummy in 0..1u8) {
                let w = ScoringWeights::default();
                let sum = w.vector + w.warmth + w.recency
                    + w.abstraction + w.graph + w.keyword + w.causal;
                prop_assert!((sum - 1.0).abs() < 0.001,
                    "default weights sum should be ~1.0, got {}", sum);
            }
        }
    }
}