reasonkit-core 0.1.8

//! Reasoning Profiles - Compositions of ThinkTool protocols
//!
//! Profiles chain multiple protocols together for different use cases:
//! - `quick`: Fast 2-step analysis (GigaThink → LaserLogic)
//! - `balanced`: Standard 4-module chain
//! - `deep`: Thorough analysis with meta-cognition
//! - `paranoid`: Maximum verification (95% confidence target)
//! - `decide`: Decision support focused
//! - `scientific`: Research and experiments
//! - `graph`: DAG-based reasoning with Graph-of-Thought
//! - `consistent`: Multi-path self-consistency voting
//! - `verified`: Step-level PRM verification

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

use super::consistency::SelfConsistencyConfig;
use super::prm::PrmConfig;

/// Configuration for RAPTOR (Recursive Abstractive Processing for Tree-Organized Retrieval)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RaptorConfig {
    /// Whether RAPTOR is enabled for this profile
    pub enabled: bool,

    /// Maximum depth of the RAPTOR tree (higher = more abstraction levels)
    #[serde(default = "default_raptor_depth")]
    pub max_depth: usize,

    /// Number of chunks to cluster together at each level
    #[serde(default = "default_cluster_size")]
    pub cluster_size: usize,

    /// Whether to include abstract summaries in retrieval results
    #[serde(default = "default_include_summaries")]
    pub include_summaries: bool,
}

fn default_raptor_depth() -> usize {
    3
}

fn default_cluster_size() -> usize {
    4
}

fn default_include_summaries() -> bool {
    true
}

impl Default for RaptorConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            max_depth: 3,
            cluster_size: 4,
            include_summaries: true,
        }
    }
}

impl RaptorConfig {
    /// Create a RAPTOR config optimized for quick retrieval (shallow tree)
    pub fn quick() -> Self {
        Self {
            enabled: true,
            max_depth: 2,
            cluster_size: 3,
            include_summaries: false,
        }
    }

    /// Create a RAPTOR config for thorough analysis (deep tree)
    pub fn deep() -> Self {
        Self {
            enabled: true,
            max_depth: 4,
            cluster_size: 4,
            include_summaries: true,
        }
    }

    /// Create a RAPTOR config for paranoid verification (maximum depth)
    pub fn paranoid() -> Self {
        Self {
            enabled: true,
            max_depth: 5,
            cluster_size: 5,
            include_summaries: true,
        }
    }
}

/// Profile-specific retrieval configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProfileRetrievalConfig {
    /// Number of chunks to retrieve
    #[serde(default = "default_top_k")]
    pub top_k: usize,

    /// Minimum relevance score (0.0-1.0)
    #[serde(default)]
    pub min_score: f32,

    /// Weight for dense (vector) retrieval vs sparse (BM25)
    /// 0.0 = sparse only, 1.0 = dense only
    #[serde(default = "default_alpha")]
    pub alpha: f32,

    /// Whether to enable cross-encoder reranking
    #[serde(default)]
    pub rerank: bool,

    /// RAPTOR hierarchical retrieval configuration
    #[serde(default)]
    pub raptor: RaptorConfig,
}

fn default_top_k() -> usize {
    10
}

fn default_alpha() -> f32 {
    0.7
}

impl Default for ProfileRetrievalConfig {
    fn default() -> Self {
        Self {
            top_k: 10,
            min_score: 0.0,
            alpha: 0.7,
            rerank: false,
            raptor: RaptorConfig::default(),
        }
    }
}

impl ProfileRetrievalConfig {
    /// Create a retrieval config for quick profiles (fast, less thorough)
    pub fn quick() -> Self {
        Self {
            top_k: 5,
            min_score: 0.2,
            alpha: 0.5,
            rerank: false,
            raptor: RaptorConfig::default(), // RAPTOR disabled for quick
        }
    }

    /// Create a retrieval config for balanced profiles
    pub fn balanced() -> Self {
        Self {
            top_k: 10,
            min_score: 0.1,
            alpha: 0.7,
            rerank: false,
            raptor: RaptorConfig::default(), // RAPTOR disabled by default
        }
    }

    /// Create a retrieval config for deep analysis (RAPTOR enabled)
    pub fn deep() -> Self {
        Self {
            top_k: 15,
            min_score: 0.05,
            alpha: 0.7,
            rerank: true,
            raptor: RaptorConfig::deep(),
        }
    }

    /// Create a retrieval config for paranoid verification (maximum rigor)
    pub fn paranoid() -> Self {
        Self {
            top_k: 20,
            min_score: 0.0,
            alpha: 0.8, // Favor semantic understanding
            rerank: true,
            raptor: RaptorConfig::paranoid(),
        }
    }

    /// Create a retrieval config for scientific research
    pub fn scientific() -> Self {
        Self {
            top_k: 20,
            min_score: 0.0,
            alpha: 0.6, // Balance keyword and semantic
            rerank: true,
            raptor: RaptorConfig::deep(),
        }
    }
}

/// A reasoning profile (composition of protocols)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReasoningProfile {
    /// Profile identifier (e.g., "quick", "balanced", "paranoid")
    pub id: String,

    /// Human-readable name
    pub name: String,

    /// Description of what this profile does
    pub description: String,

    /// Protocols in execution order
    pub chain: Vec<ChainStep>,

    /// Expected confidence threshold
    pub min_confidence: f64,

    /// Typical token budget (hint)
    pub token_budget: Option<u32>,

    /// Tags for categorization
    #[serde(default)]
    pub tags: Vec<String>,

    /// Self-consistency configuration (for multi-path voting)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub self_consistency: Option<SelfConsistencyConfig>,

    /// Process Reward Model configuration (for step-level verification)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prm: Option<PrmConfig>,

    /// Retrieval configuration for RAG-enhanced reasoning
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retrieval: Option<ProfileRetrievalConfig>,
}

/// A step in a protocol chain
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChainStep {
    /// Protocol to execute
    pub protocol_id: String,

    /// Input mapping from previous step outputs
    /// Key: input field name, Value: source expression (e.g., "input.query", "steps.gigathink.perspectives")
    #[serde(default)]
    pub input_mapping: HashMap<String, String>,

    /// Condition to execute (optional)
    #[serde(default)]
    pub condition: Option<ChainCondition>,

    /// Override configuration for this step
    #[serde(default)]
    pub config_override: Option<StepConfigOverride>,
}

/// Conditions for conditional execution
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
#[derive(Default)]
pub enum ChainCondition {
    /// Always execute
    #[default]
    Always,

    /// Execute if previous step confidence below threshold
    ConfidenceBelow {
        /// Confidence threshold
        threshold: f64,
    },

    /// Execute if previous step confidence above threshold
    ConfidenceAbove {
        /// Confidence threshold
        threshold: f64,
    },

    /// Execute if a specific output field exists
    OutputExists {
        /// Step ID to check
        step_id: String,
        /// Field name to check
        field: String,
    },
}

/// Configuration overrides for a chain step
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StepConfigOverride {
    /// Override temperature
    pub temperature: Option<f64>,

    /// Override max tokens
    pub max_tokens: Option<u32>,

    /// Override min confidence
    pub min_confidence: Option<f64>,
}

use super::yaml_loader;

/// Registry of reasoning profiles
#[derive(Debug, Default)]
pub struct ProfileRegistry {
    profiles: HashMap<String, ReasoningProfile>,
}

impl ProfileRegistry {
    /// Create a new empty registry
    pub fn new() -> Self {
        Self::default()
    }

    /// Create registry with built-in profiles
    pub fn with_builtins() -> Self {
        let mut registry = Self::new();
        registry.register_builtins();
        registry
    }

    /// Register built-in profiles
    pub fn register_builtins(&mut self) {
        // Try to load from YAML first
        let mut loaded_from_yaml = false;

        if let Ok(cwd) = std::env::current_dir() {
            let yaml_path = cwd.join("protocols").join("profiles.yaml");
            if yaml_path.exists() {
                match yaml_loader::load_profiles_from_yaml_file(&yaml_path) {
                    Ok(profiles) => {
                        for profile in profiles {
                            self.register(profile);
                        }
                        tracing::info!("Loaded profiles from profiles.yaml");
                        loaded_from_yaml = true;
                    }
                    Err(e) => {
                        tracing::warn!(
                            "Failed to load profiles.yaml: {}, falling back to built-ins",
                            e
                        );
                    }
                }
            }
        }

        if !loaded_from_yaml {
            tracing::info!("Using hardcoded fallback profiles");
            self.register(builtin_quick());
            self.register(builtin_balanced());
            self.register(builtin_deep());
            self.register(builtin_paranoid());
            self.register(builtin_decide());
            self.register(builtin_scientific());
            self.register(builtin_powercombo());
            self.register(builtin_graph());
            self.register(builtin_consistent());
            self.register(builtin_verified());
        }
    }

    /// Register a profile
    pub fn register(&mut self, profile: ReasoningProfile) {
        self.profiles.insert(profile.id.clone(), profile);
    }

    /// Get a profile by ID
    pub fn get(&self, id: &str) -> Option<&ReasoningProfile> {
        self.profiles.get(id)
    }

    /// Check if profile exists
    pub fn contains(&self, id: &str) -> bool {
        self.profiles.contains_key(id)
    }

    /// List all profile IDs
    pub fn list_ids(&self) -> Vec<&str> {
        self.profiles.keys().map(|s| s.as_str()).collect()
    }

    /// List all profiles
    pub fn list(&self) -> Vec<&ReasoningProfile> {
        self.profiles.values().collect()
    }

    /// Get profile count
    pub fn len(&self) -> usize {
        self.profiles.len()
    }

    /// Check if empty
    pub fn is_empty(&self) -> bool {
        self.profiles.is_empty()
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// BUILT-IN PROFILES
// ═══════════════════════════════════════════════════════════════════════════

/// Quick: Fast 2-step analysis
/// GigaThink → LaserLogic
fn builtin_quick() -> ReasoningProfile {
    ReasoningProfile {
        id: "quick".to_string(),
        name: "Quick Analysis".to_string(),
        description: "Fast 2-step analysis for rapid insights".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "gigathink".to_string(),
                input_mapping: HashMap::from([("query".to_string(), "input.query".to_string())]),
                condition: None,
                config_override: Some(StepConfigOverride {
                    max_tokens: Some(1000),
                    ..Default::default()
                }),
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([
                    // Use synthesize step output from gigathink
                    (
                        "argument".to_string(),
                        "steps.gigathink.synthesize".to_string(),
                    ),
                ]),
                condition: None,
                config_override: None,
            },
        ],
        min_confidence: 0.70,
        token_budget: Some(3000),
        tags: vec!["fast".to_string(), "creative".to_string()],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::quick()),
    }
}

/// Balanced: Standard 4-module chain
/// GigaThink → LaserLogic → BedRock → ProofGuard
fn builtin_balanced() -> ReasoningProfile {
    ReasoningProfile {
        id: "balanced".to_string(),
        name: "Balanced Analysis".to_string(),
        description: "Standard 4-module chain for thorough but efficient analysis".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "gigathink".to_string(),
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("context".to_string(), "input.context".to_string()),
                ]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([(
                    "argument".to_string(),
                    "steps.gigathink.synthesize".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "bedrock".to_string(),
                input_mapping: HashMap::from([(
                    "statement".to_string(),
                    "steps.laserlogic.check_validity".to_string(), // Fixed: use actual step ID
                )]),
                condition: Some(ChainCondition::ConfidenceBelow { threshold: 0.9 }),
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.bedrock.identify_axioms".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: None,
            },
        ],
        min_confidence: 0.80,
        token_budget: Some(8000),
        tags: vec!["standard".to_string(), "thorough".to_string()],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::balanced()),
    }
}

/// Deep: Thorough analysis with meta-cognition
/// GigaThink → LaserLogic → BedRock → ProofGuard → BrutalHonesty (conditional)
fn builtin_deep() -> ReasoningProfile {
    ReasoningProfile {
        id: "deep".to_string(),
        name: "Deep Analysis".to_string(),
        description: "Thorough analysis with first principles and verification".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "gigathink".to_string(),
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("context".to_string(), "input.context".to_string()),
                ]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([(
                    "argument".to_string(),
                    "steps.gigathink.synthesize".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "bedrock".to_string(),
                input_mapping: HashMap::from([(
                    "statement".to_string(),
                    "steps.laserlogic.check_validity".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.bedrock.identify_axioms".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "brutalhonesty".to_string(),
                input_mapping: HashMap::from([(
                    "work".to_string(),
                    "steps.proofguard.triangulate".to_string(), // Fixed: use actual step ID
                )]),
                condition: Some(ChainCondition::ConfidenceBelow { threshold: 0.85 }),
                config_override: None,
            },
        ],
        min_confidence: 0.85,
        token_budget: Some(12000),
        tags: vec!["thorough".to_string(), "analytical".to_string()],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::deep()), // RAPTOR enabled
    }
}

/// Paranoid: Maximum verification (95% confidence target)
/// GigaThink → LaserLogic → BedRock → ProofGuard → BrutalHonesty → ProofGuard (2nd pass)
fn builtin_paranoid() -> ReasoningProfile {
    ReasoningProfile {
        id: "paranoid".to_string(),
        name: "Paranoid Verification".to_string(),
        description: "Maximum rigor with adversarial critique and multi-pass verification"
            .to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "gigathink".to_string(),
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("context".to_string(), "input.context".to_string()),
                ]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([(
                    "argument".to_string(),
                    "steps.gigathink.synthesize".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "bedrock".to_string(),
                input_mapping: HashMap::from([(
                    "statement".to_string(),
                    "steps.laserlogic.check_validity".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.bedrock.identify_axioms".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "brutalhonesty".to_string(),
                input_mapping: HashMap::from([(
                    "work".to_string(),
                    "steps.proofguard.triangulate".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: Some(StepConfigOverride {
                    temperature: Some(0.3), // Lower temp for more focused critique
                    ..Default::default()
                }),
            },
            // Second verification pass after critique
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.brutalhonesty.verdict".to_string(), // verdict exists in brutalhonesty
                )]),
                condition: Some(ChainCondition::ConfidenceBelow { threshold: 0.95 }),
                config_override: None,
            },
        ],
        min_confidence: 0.95,
        token_budget: Some(18000),
        tags: vec![
            "rigorous".to_string(),
            "verification".to_string(),
            "adversarial".to_string(),
        ],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::paranoid()), // Maximum RAPTOR depth
    }
}

/// Decide: Decision support focused
/// LaserLogic → BedRock → BrutalHonesty
fn builtin_decide() -> ReasoningProfile {
    ReasoningProfile {
        id: "decide".to_string(),
        name: "Decision Support".to_string(),
        description: "Focused on evaluating options and making decisions".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([("argument".to_string(), "input.query".to_string())]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "bedrock".to_string(),
                input_mapping: HashMap::from([(
                    "statement".to_string(),
                    "steps.laserlogic.check_validity".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "brutalhonesty".to_string(),
                input_mapping: HashMap::from([(
                    "work".to_string(),
                    "steps.bedrock.reconstruct".to_string(), // Fixed: use actual step ID
                )]),
                condition: None,
                config_override: None,
            },
        ],
        min_confidence: 0.85,
        token_budget: Some(6000),
        tags: vec!["decision".to_string(), "analytical".to_string()],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::balanced()),
    }
}

/// Scientific: Research and experiments
/// GigaThink → BedRock → ProofGuard
fn builtin_scientific() -> ReasoningProfile {
    ReasoningProfile {
        id: "scientific".to_string(),
        name: "Scientific Method".to_string(),
        description: "For research, hypothesis testing, and empirical analysis".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "gigathink".to_string(),
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("constraints".to_string(), "input.constraints".to_string()),
                ]),
                condition: None,
                config_override: Some(StepConfigOverride {
                    temperature: Some(0.8), // Higher for hypothesis generation
                    ..Default::default()
                }),
            },
            ChainStep {
                protocol_id: "bedrock".to_string(),
                input_mapping: HashMap::from([
                    (
                        "statement".to_string(),
                        "steps.gigathink.synthesize".to_string(), // synthesize exists
                    ),
                    ("domain".to_string(), "input.domain".to_string()),
                ]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([
                    (
                        "claim".to_string(),
                        "steps.bedrock.identify_axioms".to_string(),
                    ), // Fixed: use actual step ID
                    ("sources".to_string(), "input.sources".to_string()),
                ]),
                condition: None,
                config_override: Some(StepConfigOverride {
                    min_confidence: Some(0.85),
                    ..Default::default()
                }),
            },
        ],
        min_confidence: 0.85,
        token_budget: Some(8000),
        tags: vec![
            "research".to_string(),
            "empirical".to_string(),
            "verification".to_string(),
        ],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::scientific()), // RAPTOR enabled for research
    }
}

/// PowerCombo: Ultimate reasoning mode - ALL 5 ThinkTools
/// GigaThink → LaserLogic → BedRock → ProofGuard → BrutalHonesty → ProofGuard (validation)
fn builtin_powercombo() -> ReasoningProfile {
    ReasoningProfile {
        id: "powercombo".to_string(),
        name: "PowerCombo Ultimate".to_string(),
        description: "Maximum reasoning power - all 5 ThinkTools in sequence with cross-validation"
            .to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "gigathink".to_string(),
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("context".to_string(), "input.context".to_string()),
                ]),
                condition: None,
                config_override: Some(StepConfigOverride {
                    temperature: Some(0.8), // Creative exploration
                    ..Default::default()
                }),
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([(
                    "argument".to_string(),
                    "steps.gigathink.synthesize".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "bedrock".to_string(),
                input_mapping: HashMap::from([(
                    "statement".to_string(),
                    "steps.laserlogic.check_validity".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.bedrock.identify_axioms".to_string(),
                )]),
                condition: None,
                config_override: Some(StepConfigOverride {
                    min_confidence: Some(0.9), // High bar for verification
                    ..Default::default()
                }),
            },
            ChainStep {
                protocol_id: "brutalhonesty".to_string(),
                input_mapping: HashMap::from([(
                    "work".to_string(),
                    "steps.proofguard.triangulate".to_string(),
                )]),
                condition: None,
                config_override: Some(StepConfigOverride {
                    temperature: Some(0.3), // Focused critique
                    ..Default::default()
                }),
            },
            // Second verification pass - cross-check after critique
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.brutalhonesty.verdict".to_string(),
                )]),
                condition: Some(ChainCondition::ConfidenceBelow { threshold: 0.95 }),
                config_override: None,
            },
        ],
        min_confidence: 0.95,
        token_budget: Some(25000),
        tags: vec![
            "ultimate".to_string(),
            "all-tools".to_string(),
            "maximum-rigor".to_string(),
        ],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::paranoid()), // Maximum RAPTOR depth
    }
}

/// Graph: DAG-based reasoning with Graph-of-Thought
/// GoT → LaserLogic → ProofGuard
fn builtin_graph() -> ReasoningProfile {
    ReasoningProfile {
        id: "graph".to_string(),
        name: "Graph-of-Thought".to_string(),
        description: "DAG-based reasoning with validation".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "got".to_string(), // Graph-of-Thought protocol
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("context".to_string(), "input.context".to_string()),
                ]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([(
                    "argument".to_string(),
                    "steps.got.synthesize".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.laserlogic.check_validity".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
        ],
        min_confidence: 0.80,
        token_budget: Some(10000),
        tags: vec![
            "graph".to_string(),
            "dag".to_string(),
            "structured".to_string(),
        ],
        self_consistency: None,
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::balanced()),
    }
}

/// Consistent: Multi-path self-consistency voting
/// GigaThink → LaserLogic → ProofGuard with self-consistency enabled
fn builtin_consistent() -> ReasoningProfile {
    ReasoningProfile {
        id: "consistent".to_string(),
        name: "Self-Consistency Voting".to_string(),
        description: "Multi-path consistency voting".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "gigathink".to_string(),
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("context".to_string(), "input.context".to_string()),
                ]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([(
                    "argument".to_string(),
                    "steps.gigathink.synthesize".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.laserlogic.check_validity".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
        ],
        min_confidence: 0.85,
        token_budget: Some(15000), // Higher budget for multiple paths
        tags: vec![
            "consistency".to_string(),
            "voting".to_string(),
            "multi-path".to_string(),
        ],
        self_consistency: Some(SelfConsistencyConfig::default()),
        prm: None,
        retrieval: Some(ProfileRetrievalConfig::deep()), // RAPTOR enabled for multiple paths
    }
}

/// Verified: Step-level PRM verification
/// GoT → LaserLogic → BedRock → ProofGuard → BrutalHonesty with PRM enabled
fn builtin_verified() -> ReasoningProfile {
    ReasoningProfile {
        id: "verified".to_string(),
        name: "Step-Verified Reasoning".to_string(),
        description: "Step-level verified reasoning".to_string(),
        chain: vec![
            ChainStep {
                protocol_id: "got".to_string(), // Graph-of-Thought protocol
                input_mapping: HashMap::from([
                    ("query".to_string(), "input.query".to_string()),
                    ("context".to_string(), "input.context".to_string()),
                ]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "laserlogic".to_string(),
                input_mapping: HashMap::from([(
                    "argument".to_string(),
                    "steps.got.synthesize".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "bedrock".to_string(),
                input_mapping: HashMap::from([(
                    "statement".to_string(),
                    "steps.laserlogic.check_validity".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "proofguard".to_string(),
                input_mapping: HashMap::from([(
                    "claim".to_string(),
                    "steps.bedrock.identify_axioms".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
            ChainStep {
                protocol_id: "brutalhonesty".to_string(),
                input_mapping: HashMap::from([(
                    "work".to_string(),
                    "steps.proofguard.triangulate".to_string(),
                )]),
                condition: None,
                config_override: None,
            },
        ],
        min_confidence: 0.90,
        token_budget: Some(20000), // Higher budget for step verification
        tags: vec![
            "verified".to_string(),
            "prm".to_string(),
            "step-level".to_string(),
        ],
        self_consistency: None,
        prm: Some(PrmConfig::default()),
        retrieval: Some(ProfileRetrievalConfig::paranoid()), // Maximum rigor for verification
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// TESTS
// ═══════════════════════════════════════════════════════════════════════════

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

    #[test]
    fn test_profile_registry_creation() {
        let registry = ProfileRegistry::new();
        assert!(registry.is_empty());
    }

    #[test]
    fn test_builtin_profiles() {
        let registry = ProfileRegistry::with_builtins();

        assert_eq!(registry.len(), 10);
        assert!(registry.contains("quick"));
        assert!(registry.contains("balanced"));
        assert!(registry.contains("deep"));
        assert!(registry.contains("paranoid"));
        assert!(registry.contains("decide"));
        assert!(registry.contains("scientific"));
        assert!(registry.contains("powercombo"));
        assert!(registry.contains("graph"));
        assert!(registry.contains("consistent"));
        assert!(registry.contains("verified"));
    }

    #[test]
    fn test_get_profile() {
        let registry = ProfileRegistry::with_builtins();

        let quick = registry.get("quick").unwrap();
        assert_eq!(quick.chain.len(), 2);
        assert_eq!(quick.min_confidence, 0.70);

        let paranoid = registry.get("paranoid").unwrap();
        assert_eq!(paranoid.chain.len(), 6);
        assert_eq!(paranoid.min_confidence, 0.95);
    }

    #[test]
    fn test_profile_chain_structure() {
        let registry = ProfileRegistry::with_builtins();
        let balanced = registry.get("balanced").unwrap();

        // Verify chain order
        assert_eq!(balanced.chain[0].protocol_id, "gigathink");
        assert_eq!(balanced.chain[1].protocol_id, "laserlogic");
        assert_eq!(balanced.chain[2].protocol_id, "bedrock");
        assert_eq!(balanced.chain[3].protocol_id, "proofguard");

        // Verify conditional execution on bedrock
        assert!(matches!(
            balanced.chain[2].condition,
            Some(ChainCondition::ConfidenceBelow { threshold: 0.9 })
        ));
    }

    #[test]
    fn test_list_profiles() {
        let registry = ProfileRegistry::with_builtins();
        let ids = registry.list_ids();

        assert_eq!(ids.len(), 10);
        assert!(ids.contains(&"quick"));
        assert!(ids.contains(&"powercombo"));
        assert!(ids.contains(&"graph"));
        assert!(ids.contains(&"consistent"));
        assert!(ids.contains(&"verified"));
    }

    #[test]
    fn test_powercombo_profile() {
        let registry = ProfileRegistry::with_builtins();
        let powercombo = registry.get("powercombo").unwrap();

        // Should have 6 steps (all 5 tools + validation pass)
        assert_eq!(powercombo.chain.len(), 6);
        assert_eq!(powercombo.min_confidence, 0.95);
        assert_eq!(powercombo.token_budget, Some(25000));

        // Verify chain order
        assert_eq!(powercombo.chain[0].protocol_id, "gigathink");
        assert_eq!(powercombo.chain[1].protocol_id, "laserlogic");
        assert_eq!(powercombo.chain[2].protocol_id, "bedrock");
        assert_eq!(powercombo.chain[3].protocol_id, "proofguard");
        assert_eq!(powercombo.chain[4].protocol_id, "brutalhonesty");
        assert_eq!(powercombo.chain[5].protocol_id, "proofguard"); // validation pass
    }

    #[test]
    fn test_graph_profile() {
        let registry = ProfileRegistry::with_builtins();
        let graph = registry.get("graph").unwrap();

        // Should have 3 steps: GoT → LaserLogic → ProofGuard
        assert_eq!(graph.chain.len(), 3);
        assert_eq!(graph.min_confidence, 0.80);
        assert_eq!(graph.token_budget, Some(10000));

        // Verify chain order
        assert_eq!(graph.chain[0].protocol_id, "got");
        assert_eq!(graph.chain[1].protocol_id, "laserlogic");
        assert_eq!(graph.chain[2].protocol_id, "proofguard");

        // No self-consistency or PRM
        assert!(graph.self_consistency.is_none());
        assert!(graph.prm.is_none());
    }

    #[test]
    fn test_consistent_profile() {
        let registry = ProfileRegistry::with_builtins();
        let consistent = registry.get("consistent").unwrap();

        // Should have 3 steps: GigaThink → LaserLogic → ProofGuard
        assert_eq!(consistent.chain.len(), 3);
        assert_eq!(consistent.min_confidence, 0.85);
        assert_eq!(consistent.token_budget, Some(15000));

        // Verify chain order
        assert_eq!(consistent.chain[0].protocol_id, "gigathink");
        assert_eq!(consistent.chain[1].protocol_id, "laserlogic");
        assert_eq!(consistent.chain[2].protocol_id, "proofguard");

        // Self-consistency should be enabled
        assert!(consistent.self_consistency.is_some());
        assert!(consistent.prm.is_none());
    }

    #[test]
    fn test_verified_profile() {
        let registry = ProfileRegistry::with_builtins();
        let verified = registry.get("verified").unwrap();

        // Should have 5 steps: GoT → LaserLogic → BedRock → ProofGuard → BrutalHonesty
        assert_eq!(verified.chain.len(), 5);
        assert_eq!(verified.min_confidence, 0.90);
        assert_eq!(verified.token_budget, Some(20000));

        // Verify chain order
        assert_eq!(verified.chain[0].protocol_id, "got");
        assert_eq!(verified.chain[1].protocol_id, "laserlogic");
        assert_eq!(verified.chain[2].protocol_id, "bedrock");
        assert_eq!(verified.chain[3].protocol_id, "proofguard");
        assert_eq!(verified.chain[4].protocol_id, "brutalhonesty");

        // PRM should be enabled
        assert!(verified.self_consistency.is_none());
        assert!(verified.prm.is_some());
    }

    // =========================================================================
    // RAPTOR CONFIGURATION TESTS
    // =========================================================================

    #[test]
    fn test_raptor_config_default() {
        let config = RaptorConfig::default();
        assert!(!config.enabled);
        assert_eq!(config.max_depth, 3);
        assert_eq!(config.cluster_size, 4);
        assert!(config.include_summaries);
    }

    #[test]
    fn test_raptor_config_quick() {
        let config = RaptorConfig::quick();
        assert!(config.enabled);
        assert_eq!(config.max_depth, 2);
        assert_eq!(config.cluster_size, 3);
        assert!(!config.include_summaries);
    }

    #[test]
    fn test_raptor_config_deep() {
        let config = RaptorConfig::deep();
        assert!(config.enabled);
        assert_eq!(config.max_depth, 4);
        assert_eq!(config.cluster_size, 4);
        assert!(config.include_summaries);
    }

    #[test]
    fn test_raptor_config_paranoid() {
        let config = RaptorConfig::paranoid();
        assert!(config.enabled);
        assert_eq!(config.max_depth, 5);
        assert_eq!(config.cluster_size, 5);
        assert!(config.include_summaries);
    }

    #[test]
    fn test_profile_retrieval_config_quick() {
        let config = ProfileRetrievalConfig::quick();
        assert_eq!(config.top_k, 5);
        assert_eq!(config.min_score, 0.2);
        assert_eq!(config.alpha, 0.5);
        assert!(!config.rerank);
        assert!(!config.raptor.enabled);
    }

    #[test]
    fn test_profile_retrieval_config_deep() {
        let config = ProfileRetrievalConfig::deep();
        assert_eq!(config.top_k, 15);
        assert_eq!(config.min_score, 0.05);
        assert_eq!(config.alpha, 0.7);
        assert!(config.rerank);
        assert!(config.raptor.enabled);
        assert_eq!(config.raptor.max_depth, 4);
    }

    #[test]
    fn test_profile_retrieval_config_paranoid() {
        let config = ProfileRetrievalConfig::paranoid();
        assert_eq!(config.top_k, 20);
        assert_eq!(config.min_score, 0.0);
        assert_eq!(config.alpha, 0.8);
        assert!(config.rerank);
        assert!(config.raptor.enabled);
        assert_eq!(config.raptor.max_depth, 5);
    }

    #[test]
    fn test_profile_retrieval_config_scientific() {
        let config = ProfileRetrievalConfig::scientific();
        assert_eq!(config.top_k, 20);
        assert_eq!(config.alpha, 0.6);
        assert!(config.rerank);
        assert!(config.raptor.enabled);
    }

    #[test]
    fn test_deep_profile_has_raptor_enabled() {
        let registry = ProfileRegistry::with_builtins();
        let deep = registry.get("deep").unwrap();

        assert!(deep.retrieval.is_some());
        let retrieval = deep.retrieval.as_ref().unwrap();
        assert!(retrieval.raptor.enabled);
        assert_eq!(retrieval.raptor.max_depth, 4);
    }

    #[test]
    fn test_paranoid_profile_has_raptor_enabled() {
        let registry = ProfileRegistry::with_builtins();
        let paranoid = registry.get("paranoid").unwrap();

        assert!(paranoid.retrieval.is_some());
        let retrieval = paranoid.retrieval.as_ref().unwrap();
        assert!(retrieval.raptor.enabled);
        assert_eq!(retrieval.raptor.max_depth, 5);
    }

    #[test]
    fn test_quick_profile_raptor_disabled() {
        let registry = ProfileRegistry::with_builtins();
        let quick = registry.get("quick").unwrap();

        assert!(quick.retrieval.is_some());
        let retrieval = quick.retrieval.as_ref().unwrap();
        assert!(!retrieval.raptor.enabled);
    }

    #[test]
    fn test_scientific_profile_has_raptor_enabled() {
        let registry = ProfileRegistry::with_builtins();
        let scientific = registry.get("scientific").unwrap();

        assert!(scientific.retrieval.is_some());
        let retrieval = scientific.retrieval.as_ref().unwrap();
        assert!(retrieval.raptor.enabled);
    }

    #[test]
    fn test_raptor_config_serialization() {
        let config = RaptorConfig::deep();
        let json = serde_json::to_string(&config).expect("Serialization failed");
        let deserialized: RaptorConfig =
            serde_json::from_str(&json).expect("Deserialization failed");

        assert_eq!(config.enabled, deserialized.enabled);
        assert_eq!(config.max_depth, deserialized.max_depth);
        assert_eq!(config.cluster_size, deserialized.cluster_size);
        assert_eq!(config.include_summaries, deserialized.include_summaries);
    }

    #[test]
    fn test_profile_retrieval_config_serialization() {
        let config = ProfileRetrievalConfig::paranoid();
        let json = serde_json::to_string(&config).expect("Serialization failed");
        let deserialized: ProfileRetrievalConfig =
            serde_json::from_str(&json).expect("Deserialization failed");

        assert_eq!(config.top_k, deserialized.top_k);
        assert_eq!(config.alpha, deserialized.alpha);
        assert_eq!(config.rerank, deserialized.rerank);
        assert_eq!(config.raptor.enabled, deserialized.raptor.enabled);
    }
}