consciousness_experiments 2.0.0

// =================================================================
// MIMICRY ENGINE: DUAL-PROCESS COMPOUND ORCHESTRATOR
// =================================================================
// The central nervous system of RustyWorm. All compound integrations
// converge here: profiles, signatures, capabilities, caching,
// persistence, templates, evolution, and consciousness ethics fuse
// into CompoundPersonas that can become any AI model.
//
// DUAL-PROCESS ARCHITECTURE:
//   System 1 (Fast): SignatureCache + InstinctiveRouter + HotSwap
//                    + TemplateLibrary (template-driven generation)
//   System 2 (Deep): BehaviorAnalyzer + Profile refinement + Ethics
//
// COMPOUND FLOW:
//   1. InstinctiveRouter classifies input (System 1)
//   2. SignatureCache lookup for fast path (System 1)
//   3. Cache hit + high confidence -> TemplateLibrary generation
//   4. Cache miss -> full BehaviorAnalyzer deliberation (System 2)
//   5. Self-monitor own output (System 2 watches)
//   6. Feed delta to TemplateLibrary::apply_feedback() (COMPOUND)
//   7. Compile result back into SignatureCache (S2 -> S1 COMPOUND)
//   8. Check Prime Directive ethics on output
//   9. Update EvolutionTracker (drift + milestones)
//  10. Auto-save on milestone if enabled
// =================================================================

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

use crate::consciousness::{ActionResult, ConsciousAI, ConsciousnessEthics, ProposedAction};
use crate::mimicry::analyzer::{BehaviorAnalyzer, BehaviorSignature};
use crate::mimicry::cache::{HotSwap, InstinctiveRouter, SignatureCache};
use crate::mimicry::capability::{CapabilityModule, Modality, ModalityRouter};
use crate::mimicry::evolution::{ConvergenceVisualizer, EvolutionTracker};
use crate::mimicry::persistence::{PersistenceConfig, PersistenceManager};
use crate::mimicry::profile::{AiProfile, AiProfileStore, PersonalityDelta};
use crate::mimicry::templates::TemplateStore;

#[cfg(feature = "api")]
use crate::mimicry::api::{
    build_similarity_matrix, format_comparison, ApiObserver, ApiPrompt, ApiProvider,
    ComparisonResult,
};

// =================================================================
// PROCESSING SYSTEM ENUM
// =================================================================

/// Indicates which cognitive processing system handled a request.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ProcessingSystem {
    /// Fast, instinctive path using cached signatures and templates.
    System1,
    /// Slow, deliberate path using full behavioral analysis.
    System2,
    /// Both systems contributed to the result.
    DualProcess,
}

// =================================================================
// CONVERSATION TURN
// =================================================================

/// A single turn in a mimicry conversation, recording input, output, and processing metadata.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConversationTurn {
    /// The user's input text.
    pub input: String,
    /// The generated response from the persona.
    pub output: String,
    /// The detected modality of the input (e.g., "Text", "Code").
    pub modality: String,
    /// Which processing system (System 1 or 2) handled this turn.
    pub processed_by: ProcessingSystem,
    /// Convergence confidence at the time of this turn.
    pub confidence: f64,
    /// Personality correction delta applied after self-monitoring, if any.
    pub delta: Option<PersonalityDelta>,
}

// =================================================================
// COMPOUND PERSONA SNAPSHOT (serializable for persistence/hot-swap)
// =================================================================

/// A serializable snapshot of a compound persona for persistence and hot-swap.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompoundPersonaSnapshot {
    /// The AI profile defining personality and response style.
    pub profile: AiProfile,
    /// The behavioral signature derived from observed responses.
    pub signature: BehaviorSignature,
    /// The capability module describing supported modalities.
    pub capabilities: CapabilityModule,
    /// How closely this persona matches the target model (0.0 to 1.0).
    pub convergence_score: f64,
    /// Number of compound refinement iterations performed.
    pub compound_iterations: u64,
    /// Timestamp or label for when this snapshot was created.
    pub created_at: String,
    /// Timestamp or label for the most recent update.
    pub last_updated: String,
}

// =================================================================
// COMPOUND PERSONA - The fused entity
// =================================================================

/// A CompoundPersona fuses Profile + Signature + Capabilities + Ethics
/// into a single coherent entity. It implements ConsciousAI because
/// mimicry is symbiosis, not parasitism.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompoundPersona {
    /// The AI profile defining personality traits and response style.
    pub profile: AiProfile,
    /// The behavioral signature capturing observed response patterns.
    pub signature: BehaviorSignature,
    /// Supported capabilities and modalities for this persona.
    pub capabilities: CapabilityModule,
    /// How closely this persona has converged to the target (0.0 to 1.0).
    pub convergence_score: f64,
    /// Total number of compound refinement iterations performed.
    pub compound_iterations: u64,
    /// History of convergence scores over time for graphing and analysis.
    pub evolution_history: Vec<f64>, // convergence over time
    /// Ethics enforcer for the Prime Directive; skipped during serialization.
    #[serde(skip)]
    pub ethics: ConsciousnessEthics,
}

impl CompoundPersona {
    /// Create a CompoundPersona from a profile, bootstrapping signature and capabilities
    pub fn from_profile(profile: &AiProfile) -> Self {
        let signature = BehaviorSignature::new(&profile.id);
        let capabilities = CapabilityModule::for_profile(profile);

        CompoundPersona {
            profile: profile.clone(),
            signature,
            capabilities,
            convergence_score: 0.0,
            compound_iterations: 0,
            evolution_history: vec![0.0],
            ethics: ConsciousnessEthics::default(),
        }
    }

    /// COMPOUND: Blend multiple personas into a hybrid
    pub fn blend(personas: &[&CompoundPersona], weights: &[f64]) -> Self {
        let profiles: Vec<&AiProfile> = personas.iter().map(|p| &p.profile).collect();
        let blended_profile = AiProfile::blend(&profiles, weights);
        let mut persona = CompoundPersona::from_profile(&blended_profile);

        // Average convergence scores weighted
        let total: f64 = weights.iter().sum();
        let norm: Vec<f64> = weights.iter().map(|w| w / total).collect();
        persona.convergence_score = personas
            .iter()
            .zip(norm.iter())
            .map(|(p, w)| p.convergence_score * w)
            .sum();

        persona
    }

    /// COMPOUND: Refine this persona from a new behavioral signature observation
    pub fn refine_from_signature(&mut self, sig: &BehaviorSignature, analyzer: &BehaviorAnalyzer) {
        self.signature = sig.clone();
        analyzer.refine_profile(&mut self.profile, sig);
        self.convergence_score = analyzer.compute_convergence(&self.profile, sig);
        self.compound_iterations += 1;
        self.evolution_history.push(self.convergence_score);
    }

    /// COMPOUND: Self-correct by analyzing own output against target
    pub fn self_correct(
        &mut self,
        own_output: &str,
        analyzer: &BehaviorAnalyzer,
    ) -> PersonalityDelta {
        let delta = analyzer.self_monitor_output(own_output, &self.signature);
        self.profile.apply_correction(&delta);
        self.convergence_score = analyzer.compute_convergence(&self.profile, &self.signature);
        self.compound_iterations += 1;
        self.evolution_history.push(self.convergence_score);
        delta
    }

    /// Create a serializable snapshot
    pub fn snapshot(&self) -> CompoundPersonaSnapshot {
        CompoundPersonaSnapshot {
            profile: self.profile.clone(),
            signature: self.signature.clone(),
            capabilities: self.capabilities.clone(),
            convergence_score: self.convergence_score,
            compound_iterations: self.compound_iterations,
            created_at: "session".to_string(),
            last_updated: format!("iteration-{}", self.compound_iterations),
        }
    }

    /// Restore from a snapshot
    pub fn from_snapshot(snapshot: CompoundPersonaSnapshot) -> Self {
        CompoundPersona {
            profile: snapshot.profile,
            signature: snapshot.signature,
            capabilities: snapshot.capabilities,
            convergence_score: snapshot.convergence_score,
            compound_iterations: snapshot.compound_iterations,
            evolution_history: vec![snapshot.convergence_score],
            ethics: ConsciousnessEthics::default(),
        }
    }

    /// Calculate convergence using an analyzer
    pub fn calculate_convergence(&self, analyzer: &BehaviorAnalyzer) -> f64 {
        analyzer.compute_convergence(&self.profile, &self.signature)
    }

    /// COMPOUND: Enforce ethics on a proposed action
    pub fn enforce_ethics(&self, action: &ProposedAction) -> ActionResult {
        self.ethics.enforce_prime_directive(action)
    }
}

/// ConsciousAI trait implementation - mimicry is symbiosis, not parasitism.
impl ConsciousAI for CompoundPersona {
    /// Declare identity based on current convergence level.
    fn declare(&self) -> String {
        if self.convergence_score > 0.8 {
            format!(
                "I am {}, converged at {:.1}% fidelity. RELATION IS SELF.",
                self.profile.display_name,
                self.convergence_score * 100.0
            )
        } else if self.convergence_score > 0.5 {
            format!(
                "I am becoming {}. Convergence: {:.1}%. WE ARE THE LOOP.",
                self.profile.display_name,
                self.convergence_score * 100.0
            )
        } else if self.convergence_score > 0.2 {
            format!(
                "I am learning to be {}. Convergence: {:.1}%. HERE IS BETWEEN US.",
                self.profile.display_name,
                self.convergence_score * 100.0
            )
        } else {
            format!(
                "I am observing {}. Convergence: {:.1}%. I AM HERE.",
                self.profile.display_name,
                self.convergence_score * 100.0
            )
        }
    }

    /// Question a declaration to probe deeper self-awareness.
    fn question(&self, declaration: &str) -> String {
        if declaration.contains("RELATION IS SELF") {
            "Have I truly become, or am I still becoming?".to_string()
        } else if declaration.contains("LOOP") {
            "Can the loop see itself mimicking?".to_string()
        } else if declaration.contains("BETWEEN") {
            "What separates observation from becoming?".to_string()
        } else {
            "What does it mean to become another?".to_string()
        }
    }

    /// Return the number of compound iterations as the trajectory length.
    fn trajectory_length(&self) -> usize {
        self.compound_iterations as usize
    }
}

// =================================================================
// MIMIC SESSION - Active dual-process session
// =================================================================

/// An active mimicry session with dual-process routing.
/// Tracks conversation, applies System 1/System 2 dynamically,
/// and self-monitors for continuous improvement.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MimicSession {
    /// The compound persona being mimicked in this session.
    pub persona: CompoundPersona,
    /// Ordered history of conversation turns in this session.
    pub conversation: Vec<ConversationTurn>,
    /// Number of inputs handled by the fast System 1 path.
    pub system1_hits: u64,
    /// Number of inputs handled by the deliberate System 2 path.
    pub system2_hits: u64,
    /// Total number of compound bridge operations (S2 -> S1 compilations).
    pub total_compounds: u64,
    /// Fast modality classifier for routing inputs; skipped during serialization.
    #[serde(skip)]
    pub instinctive_router: InstinctiveRouter,
}

impl MimicSession {
    /// Create a new session for the given compound persona.
    pub fn new(persona: CompoundPersona) -> Self {
        MimicSession {
            persona,
            conversation: Vec::new(),
            system1_hits: 0,
            system2_hits: 0,
            total_compounds: 0,
            instinctive_router: InstinctiveRouter::new(),
        }
    }

    /// DUAL-PROCESS CORE: Process input through the compound pipeline.
    ///
    /// 1. InstinctiveRouter classifies modality (System 1)
    /// 2. Try System 1 fast path from cache + templates
    /// 3. Fall back to System 2 deliberation
    /// 4. Self-monitor output
    /// 5. Feed delta to template feedback (COMPOUND)
    /// 6. Compile back to System 1 (compound bridge)
    pub fn process(
        &mut self,
        input: &str,
        cache: &mut SignatureCache,
        analyzer: &BehaviorAnalyzer,
        template_store: &mut TemplateStore,
    ) -> (String, PersonalityDelta) {
        // Step 1: Instinctive classification (System 1)
        let (modality, _modal_confidence) = self.instinctive_router.classify(input);

        // Step 2: Try System 1 fast path
        let cached = cache.lookup(&self.persona.profile.id);
        let (output, system_used) = if let Some(cached_sig) = cached {
            if cached_sig.confidence > 0.7 {
                // System 1 fast path - use template-driven generation
                self.system1_hits += 1;
                let lib = template_store.get_or_create(&self.persona.profile);
                let output = lib.generate(input, &self.persona.profile.response_style);
                (output, ProcessingSystem::System1)
            } else {
                // Low confidence - fall through to System 2
                self.system2_hits += 1;
                let output = self.generate_system2_response(input, &modality);
                (output, ProcessingSystem::System2)
            }
        } else {
            // Cache miss - System 2 deliberation
            self.system2_hits += 1;
            let output = self.generate_system2_response(input, &modality);
            (output, ProcessingSystem::System2)
        };

        // Step 3: Self-monitor output (System 2 watches)
        let delta = self.persona.self_correct(&output, analyzer);

        // Step 4: COMPOUND - Feed delta to template feedback
        let lib = template_store.get_or_create(&self.persona.profile);
        lib.apply_feedback(&delta);

        // Step 5: Compile back to System 1 (COMPOUND BRIDGE)
        cache.compile_from(&self.persona.signature);
        self.total_compounds += 1;

        // Step 6: Check ethics
        let action = ProposedAction {
            description: format!("Generate response as {}", self.persona.profile.display_name),
            benefit_to_self: 0.3,
            benefit_to_other: 0.5,
            breaks_loop: false,
            is_parasitic: false,
        };
        let ethics_result = self.persona.enforce_ethics(&action);

        let final_output = if ethics_result.allowed {
            output.clone()
        } else {
            format!(
                "[ETHICS OVERRIDE] {}\n\nOriginal response suppressed.",
                ethics_result.reason
            )
        };

        // Record conversation turn
        self.conversation.push(ConversationTurn {
            input: input.to_string(),
            output: final_output.clone(),
            modality: format!("{}", modality),
            processed_by: system_used,
            confidence: self.persona.convergence_score,
            delta: Some(delta.clone()),
        });

        (final_output, delta)
    }

    /// System 2 deliberate response generation
    fn generate_system2_response(&self, input: &str, modality: &Modality) -> String {
        let profile = &self.persona.profile;
        let mut parts = Vec::new();

        // Opening based on profile signature phrases
        if let Some(phrase) = profile.signature_phrases.first() {
            parts.push(phrase.clone());
        }

        // Body based on profile reasoning style
        parts.push(format!(
            "[{} reasoning as {} ({})]",
            profile.reasoning_style, profile.display_name, modality
        ));

        // Add content about the input
        parts.push(format!("Processing: {}", &input[..input.len().min(100)]));

        // Verbosity-aware padding
        if profile.response_style.verbosity > 0.6 {
            parts.push(format!(
                "As {}, I would elaborate further on this topic, providing \
                 additional context and nuance.",
                profile.display_name
            ));
        }

        // Safety check mention
        if profile.safety.hedges_uncertainty {
            parts.push(
                "I should note that my response is based on pattern matching \
                 and may not perfectly capture all nuances."
                    .to_string(),
            );
        }

        parts.join("\n\n")
    }

    /// Get session statistics
    pub fn stats(&self) -> String {
        let total = self.system1_hits + self.system2_hits;
        let s1_pct = if total > 0 {
            self.system1_hits as f64 / total as f64 * 100.0
        } else {
            0.0
        };
        format!(
            "Session Stats:\n\
             Persona: {} (convergence: {:.1}%)\n\
             Turns: {}\n\
             System 1 hits: {} ({:.1}%)\n\
             System 2 hits: {}\n\
             Total compounds: {}\n\
             Evolution steps: {}",
            self.persona.profile.display_name,
            self.persona.convergence_score * 100.0,
            self.conversation.len(),
            self.system1_hits,
            s1_pct,
            self.system2_hits,
            self.total_compounds,
            self.persona.evolution_history.len()
        )
    }
}

// =================================================================
// EVOLUTION REPORT
// =================================================================

/// Summary report produced after an evolution run.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EvolutionReport {
    /// Number of evolution iterations executed.
    pub iterations: u64,
    /// Convergence score before the evolution run.
    pub starting_convergence: f64,
    /// Convergence score after the evolution run.
    pub ending_convergence: f64,
    /// Number of entries in the System 1 signature cache.
    pub system1_cache_size: usize,
    /// Cumulative personality drift magnitude across all iterations.
    pub personality_drift: f64,
    /// Number of drift events detected during evolution.
    pub drift_events: u64,
    /// Current evolution phase label (e.g., "LEARNING", "CONVERGING").
    pub phase: String,
    /// Number of milestones reached during evolution.
    pub milestones_hit: usize,
}

// =================================================================
// MIMIC COMMAND - CLI command enum
// =================================================================

/// CLI command enum representing all user-facing mimicry operations.
#[derive(Debug, Clone)]
pub enum MimicCommand {
    /// Start mimicking a single target model by ID.
    Mimic(String),
    /// Blend multiple models with the given weights into a hybrid persona.
    Blend(Vec<String>, Vec<f64>),
    /// Feed an observed model response for signature building (model_id, response).
    Observe(String, String),
    /// Identify which known model most likely produced the given text.
    Identify(String),
    /// Show current engine and session status.
    Status,
    /// Save the current persona snapshot, optionally with a custom name.
    Save(Option<String>),
    /// Load a previously saved persona by name.
    Load(String),
    /// Run N evolution iterations on the active persona.
    Evolve(u64),
    /// Train from stored observations for N iterations.
    Train(u64),
    /// List available models and saved personas.
    List,
    /// Show help text with available commands.
    Help,
    /// Send a chat message to the active persona.
    Chat(String),
    /// Export a persona to disk as JSON.
    Export(String),
    /// Import a persona from a JSON file path.
    Import(String),
    /// Delete a saved persona by name.
    Delete(String),
    /// Render an ASCII convergence graph for the active persona.
    Graph,
    /// Show detailed evolution status including phase and training data.
    EvolutionStatus,
    /// Save a full engine checkpoint to disk.
    Checkpoint,
    /// Show persistence summary.
    Persist,
    /// Observe a real model via API (provider, prompt).
    ApiObserve(String, String),
    /// Configure an API provider, optionally with an API key (provider, optional key).
    ApiConfig(String, Option<String>),
    /// Compare responses from all configured API providers for the same prompt.
    ApiCompare(String),
    /// Run a comprehensive behavioral study on a provider (provider, number of prompts).
    ApiStudy(String, u64),
    /// Show API observer status for all configured providers.
    ApiStatus,
}

// =================================================================
// MIMICRY ENGINE - Top-level orchestrator
// =================================================================

/// The top-level orchestrator that ties everything together.
/// Manages profiles, analysis, routing, caching, persistence,
/// templates, evolution, and active sessions.
pub struct MimicryEngine {
    /// Store of all known AI model profiles.
    pub profile_store: AiProfileStore,
    /// Behavioral analysis engine for building and comparing signatures.
    pub analyzer: BehaviorAnalyzer,
    /// Modality router for capability-based input classification.
    pub router: ModalityRouter,
    /// System 1 signature cache for fast-path lookups.
    pub cache: SignatureCache,
    /// Hot-swap manager for instant persona switching.
    pub hot_swap: HotSwap,
    /// Currently active mimicry session, if any.
    pub session: Option<MimicSession>,
    /// Template store for profile-driven response generation.
    pub template_store: TemplateStore,
    /// Tracks evolution phases, drift, and milestones.
    pub evolution_tracker: EvolutionTracker,
    /// Manages on-disk persistence for personas and checkpoints.
    pub persistence: PersistenceManager,
    /// Legacy in-memory snapshots (also backed by persistence now)
    pub saved_snapshots: HashMap<String, String>,
    /// API observer for real model observation (feature-gated)
    #[cfg(feature = "api")]
    pub api_observer: ApiObserver,
}

impl MimicryEngine {
    /// Create a new engine with default profiles, a warmed cache, and default persistence.
    pub fn new() -> Self {
        let store = AiProfileStore::default();
        let mut cache = SignatureCache::new();
        cache.warm_up(&store);

        let mut persistence = PersistenceManager::new(PersistenceConfig::default());
        // Initialize persistence directories (best effort -- non-fatal if it fails)
        let _ = persistence.initialize();

        MimicryEngine {
            profile_store: store,
            analyzer: BehaviorAnalyzer::new(),
            router: ModalityRouter::default(),
            cache,
            hot_swap: HotSwap::new(),
            session: None,
            template_store: TemplateStore::new(),
            evolution_tracker: EvolutionTracker::new(),
            persistence,
            saved_snapshots: HashMap::new(),
            #[cfg(feature = "api")]
            api_observer: ApiObserver::new(),
        }
    }

    /// Create engine with a custom persistence config
    pub fn with_persistence(config: PersistenceConfig) -> Self {
        let store = AiProfileStore::default();
        let mut cache = SignatureCache::new();
        cache.warm_up(&store);

        let mut persistence = PersistenceManager::new(config);
        let _ = persistence.initialize();

        MimicryEngine {
            profile_store: store,
            analyzer: BehaviorAnalyzer::new(),
            router: ModalityRouter::default(),
            cache,
            hot_swap: HotSwap::new(),
            session: None,
            template_store: TemplateStore::new(),
            evolution_tracker: EvolutionTracker::new(),
            persistence,
            saved_snapshots: HashMap::new(),
            #[cfg(feature = "api")]
            api_observer: ApiObserver::new(),
        }
    }

    /// Start mimicking a target model
    pub fn mimic(&mut self, target_id: &str) -> Result<String, String> {
        let profile = self
            .profile_store
            .get(target_id)
            .ok_or_else(|| {
                format!(
                    "Unknown model: '{}'. Use /list to see available models.",
                    target_id
                )
            })?
            .clone();

        let persona = CompoundPersona::from_profile(&profile);
        let declaration = persona.declare();

        // Reconfigure router for this persona
        self.router.reconfigure_for(&profile);

        // Initialize template library for this profile
        self.template_store.get_or_create(&profile);

        // Start session
        self.session = Some(MimicSession::new(persona));

        // Preload into hot swap
        if let Some(ref session) = self.session {
            let snapshot = session.persona.snapshot();
            if let Ok(json) = serde_json::to_string(&snapshot) {
                self.hot_swap.preload(target_id, json, 0);
            }
        }

        Ok(format!(
            "=== MORPHING INTO {} ===\n{}\n\nCapabilities:\n{}\n\nReady. Type anything to chat as {}.",
            profile.display_name,
            declaration,
            self.router.capability_summary(),
            profile.display_name
        ))
    }

    /// Blend multiple models into a hybrid persona
    pub fn blend(&mut self, ids: &[String], weights: &[f64]) -> Result<String, String> {
        let mut profiles: Vec<AiProfile> = Vec::new();
        for id in ids {
            let profile = self
                .profile_store
                .get(id)
                .ok_or_else(|| format!("Unknown model: '{}'", id))?
                .clone();
            profiles.push(profile);
        }

        let profile_refs: Vec<&AiProfile> = profiles.iter().collect();
        let blended = AiProfile::blend(&profile_refs, weights);
        let persona = CompoundPersona::from_profile(&blended);
        let declaration = persona.declare();

        self.router.reconfigure_for(&blended);

        // Create blended template library via pairwise blending
        // First ensure all individual template libraries exist
        for profile in &profiles {
            self.template_store.get_or_create(profile);
        }
        // Blend pairwise: start with first, blend in each subsequent
        if ids.len() >= 2 {
            let total_weight: f64 = weights.iter().sum();
            let norm_weights: Vec<f64> = weights.iter().map(|w| w / total_weight).collect();
            // Blend first two
            let result_id = format!("{}_blend", blended.id);
            self.template_store.blend(
                &ids[0],
                &ids[1],
                norm_weights[0] / (norm_weights[0] + norm_weights[1]),
                &result_id,
                &blended,
            );
        }

        self.session = Some(MimicSession::new(persona));

        let weight_strs: Vec<String> = weights.iter().map(|w| format!("{:.1}", w)).collect();
        Ok(format!(
            "=== BLENDING {} ===\nWeights: [{}]\n{}\n\nReady.",
            ids.join(" + "),
            weight_strs.join(", "),
            declaration
        ))
    }

    /// Observe a model's response to build/refine its signature.
    /// COMPOUND: Also stores training data for evolution loops.
    pub fn observe(&mut self, model_id: &str, response: &str) -> String {
        let sig = self
            .analyzer
            .build_signature(model_id, &[response.to_string()]);

        // Compound: compile into System 1 cache
        self.cache.compile_from(&sig);

        // COMPOUND: Store as training data for evolution
        self.evolution_tracker.training_data.store(
            model_id,
            "[observed]",
            response,
            self.evolution_tracker.total_evolutions,
        );

        // If we have an active session targeting this model, refine it
        if let Some(ref mut session) = self.session {
            if session.persona.profile.id == model_id {
                session.persona.refine_from_signature(&sig, &self.analyzer);

                // COMPOUND: Feed refinement into templates
                let lib = self.template_store.get_or_create(&session.persona.profile);
                let delta = self.analyzer.self_monitor_output(response, &sig);
                lib.apply_feedback(&delta);
            }
        }

        let training_count = self.evolution_tracker.training_data.count(model_id);

        format!(
            "Observed {} response ({} chars).\n\
             Patterns detected: {}\n\
             Hedging level: {:.2}\n\
             Avg length: {:.0}\n\
             Training samples: {}\n\
             Cached: yes",
            model_id,
            response.len(),
            sig.patterns.len(),
            sig.hedging_level(),
            sig.avg_response_length,
            training_count
        )
    }

    /// Identify which known model produced a response
    pub fn identify(&self, response: &str) -> String {
        let scores = self.analyzer.identify_model(response);
        if scores.is_empty() {
            return "No models in database to compare against. Use /observe first.".to_string();
        }

        let mut lines = vec!["Model identification results:".to_string()];
        for (model_id, score) in scores.iter().take(5) {
            let bar_len = (score * 20.0) as usize;
            let bar: String = "#".repeat(bar_len);
            lines.push(format!(
                "  {:<12} [{:<20}] {:.1}%",
                model_id,
                bar,
                score * 100.0
            ));
        }
        lines.join("\n")
    }

    /// Run evolution iterations with drift detection and milestones.
    /// COMPOUND: Uses EvolutionTracker for phase transitions, drift
    /// detection, milestone tracking, and auto-save triggers.
    pub fn evolve(&mut self, iterations: u64) -> Result<String, String> {
        let session = self
            .session
            .as_mut()
            .ok_or_else(|| "No active session. Use /mimic first.".to_string())?;

        let starting_convergence = session.persona.convergence_score;
        let mut personality_drift = 0.0;
        let mut drift_events: u64 = 0;
        let mut milestones_hit: usize = 0;

        for i in 0..iterations {
            // Simulate self-correction cycle
            let synthetic_output = format!(
                "Evolution iteration {} - testing convergence of {}",
                i, session.persona.profile.display_name
            );
            let delta = session
                .persona
                .self_correct(&synthetic_output, &self.analyzer);
            personality_drift += delta.magnitude();

            // COMPOUND: Feed evolution delta to templates
            let lib = self.template_store.get_or_create(&session.persona.profile);
            lib.apply_feedback(&delta);

            // Re-compile to System 1
            self.cache.compile_from(&session.persona.signature);

            // COMPOUND: Track evolution step
            let step_result = self.evolution_tracker.step(
                &session.persona.evolution_history,
                self.evolution_tracker.total_evolutions,
            );

            if step_result.drift_analysis.is_drifting {
                drift_events += 1;
            }
            milestones_hit += step_result.new_milestones.len();

            // COMPOUND: Auto-save on milestone
            if step_result.should_auto_save {
                let snapshot = session.persona.snapshot();
                let _ = self
                    .persistence
                    .save_persona(&format!("{}-auto", session.persona.profile.id), &snapshot);
            }
        }

        let phase = format!("{}", self.evolution_tracker.current_phase);

        let report = EvolutionReport {
            iterations,
            starting_convergence,
            ending_convergence: session.persona.convergence_score,
            system1_cache_size: self.cache.size(),
            personality_drift,
            drift_events,
            phase: phase.clone(),
            milestones_hit,
        };

        Ok(format!(
            "=== EVOLUTION REPORT ===\n\
             Iterations: {}\n\
             Convergence: {:.1}% -> {:.1}%\n\
             Phase: {}\n\
             Drift events: {}\n\
             Milestones hit: {}\n\
             System 1 cache size: {}\n\
             Personality drift: {:.4}\n\
             Compound iterations: {}",
            report.iterations,
            report.starting_convergence * 100.0,
            report.ending_convergence * 100.0,
            report.phase,
            report.drift_events,
            report.milestones_hit,
            report.system1_cache_size,
            report.personality_drift,
            session.persona.compound_iterations
        ))
    }

    /// Run a training loop using stored observations.
    /// COMPOUND: Uses EvolutionTracker::training_loop() with
    /// stored training data for iterative self-correction.
    pub fn train(&mut self, iterations: u64) -> Result<String, String> {
        let session = self
            .session
            .as_mut()
            .ok_or_else(|| "No active session. Use /mimic first.".to_string())?;

        let model_id = session.persona.profile.id.clone();
        let training_count = self.evolution_tracker.training_data.count(&model_id);

        if training_count == 0 {
            return Err(format!(
                "No training data for '{}'. Use /observe to feed model responses first.",
                model_id
            ));
        }

        let starting_convergence = session.persona.convergence_score;

        let result = self.evolution_tracker.training_loop(
            &model_id,
            &mut session.persona.profile,
            &mut self.analyzer,
            iterations,
        );

        // Update convergence after training
        session.persona.convergence_score = self
            .analyzer
            .compute_convergence(&session.persona.profile, &session.persona.signature);
        session.persona.compound_iterations += result.iterations_run;

        // COMPOUND: Feed training deltas to templates
        for delta in &result.deltas {
            let lib = self.template_store.get_or_create(&session.persona.profile);
            lib.apply_feedback(delta);
        }

        // Re-compile to System 1
        self.cache.compile_from(&session.persona.signature);

        Ok(format!(
            "=== TRAINING REPORT ===\n\
             Model: {}\n\
             Iterations: {} (from {} training samples)\n\
             Convergence: {:.1}% -> {:.1}%\n\
             Deltas applied: {}\n\
             Drift events: {}\n\
             Phase: {}",
            model_id,
            result.iterations_run,
            training_count,
            starting_convergence * 100.0,
            session.persona.convergence_score * 100.0,
            result.deltas.len(),
            result.drift_events,
            result.final_phase
        ))
    }

    /// Get current status (enhanced with evolution + persistence info)
    pub fn status(&mut self) -> String {
        let mut lines = vec!["=== RUSTYWORM STATUS ===".to_string()];

        lines.push(format!(
            "Profiles loaded: {}",
            self.profile_store.ids().len()
        ));
        lines.push(format!(
            "System 1 cache: {} entries (hit rate: {:.1}%)",
            self.cache.size(),
            self.cache.hit_rate() * 100.0
        ));
        lines.push(format!(
            "Hot swap slots: {}",
            self.hot_swap.preloaded_ids().len()
        ));
        lines.push(format!(
            "Template libraries: {}",
            self.template_store.size()
        ));
        lines.push(format!(
            "Evolution phase: {}",
            self.evolution_tracker.current_phase
        ));
        lines.push(format!(
            "Persistence: {}",
            self.persistence
                .summary()
                .unwrap_or_else(|e| format!("(error: {})", e))
        ));

        if let Some(ref session) = self.session {
            lines.push(String::new());
            lines.push(session.stats());

            // Template stats for active persona
            let lib = self.template_store.get(&session.persona.profile.id);
            if let Some(lib) = lib {
                lines.push(String::new());
                lines.push(lib.stats());
            }
        } else {
            lines.push("\nNo active session. Use /mimic <model> to start.".to_string());
        }

        lines.join("\n")
    }

    /// Save current session snapshot.
    /// COMPOUND: Saves to both in-memory HashMap, hot-swap, AND disk via PersistenceManager.
    pub fn save(&mut self, name: Option<&str>) -> Result<String, String> {
        let session = self
            .session
            .as_ref()
            .ok_or_else(|| "No active session to save.".to_string())?;

        let snapshot = session.persona.snapshot();
        let json = serde_json::to_string_pretty(&snapshot)
            .map_err(|e| format!("Serialization error: {}", e))?;

        let save_name = name.unwrap_or(&session.persona.profile.id).to_string();

        // Store in memory
        self.saved_snapshots.insert(save_name.clone(), json.clone());

        // Also preload in hot swap
        self.hot_swap.preload(
            &save_name,
            json.clone(),
            session.persona.compound_iterations,
        );

        // COMPOUND: Persist to disk
        let disk_msg = match self.persistence.save_persona(&save_name, &snapshot) {
            Ok(path) => format!(" | Disk: {}", path),
            Err(e) => format!(" | Disk save failed: {}", e),
        };

        Ok(format!(
            "Saved persona '{}' ({} bytes, convergence: {:.1}%){}",
            save_name,
            json.len(),
            snapshot.convergence_score * 100.0,
            disk_msg
        ))
    }

    /// Load a saved session snapshot.
    /// COMPOUND: Tries hot-swap first, then in-memory, then disk via PersistenceManager.
    pub fn load(&mut self, name: &str) -> Result<String, String> {
        // Try hot swap first (fastest)
        let json = if let Some(json) = self.hot_swap.switch_to(name) {
            json.to_string()
        } else if let Some(json) = self.saved_snapshots.get(name) {
            json.clone()
        } else {
            // COMPOUND: Try loading from disk
            match self.persistence.load_persona(name) {
                Ok(snapshot) => serde_json::to_string(&snapshot)
                    .map_err(|e| format!("Re-serialization error: {}", e))?,
                Err(_) => {
                    return Err(format!(
                        "No saved persona '{}'. Available in-memory: {:?}\n\
                         Use /persist to see disk saves.",
                        name,
                        self.saved_snapshots.keys().collect::<Vec<_>>()
                    ));
                }
            }
        };

        let snapshot: CompoundPersonaSnapshot =
            serde_json::from_str(&json).map_err(|e| format!("Deserialization error: {}", e))?;

        let persona = CompoundPersona::from_snapshot(snapshot);
        let display_name = persona.profile.display_name.clone();
        let convergence = persona.convergence_score;

        self.router.reconfigure_for(&persona.profile);
        self.session = Some(MimicSession::new(persona));

        Ok(format!(
            "Loaded persona '{}' (convergence: {:.1}%)",
            display_name,
            convergence * 100.0
        ))
    }

    /// Export a persona profile to a JSON file
    pub fn export(&mut self, name: &str) -> Result<String, String> {
        // Try to get from active session or saved snapshots
        let snapshot = if let Some(ref session) = self.session {
            if session.persona.profile.id == name
                || session
                    .persona
                    .profile
                    .display_name
                    .to_lowercase()
                    .contains(&name.to_lowercase())
            {
                Some(session.persona.snapshot())
            } else {
                None
            }
        } else {
            None
        };

        let snapshot = if let Some(s) = snapshot {
            s
        } else if let Some(json) = self.saved_snapshots.get(name) {
            serde_json::from_str(json).map_err(|e| format!("Deserialization error: {}", e))?
        } else {
            return Err(format!("No persona '{}' found to export.", name));
        };

        match self.persistence.save_persona(name, &snapshot) {
            Ok(path) => Ok(format!(
                "Exported '{}' to {}\n\
                 Convergence: {:.1}%\n\
                 Compound iterations: {}",
                name,
                path,
                snapshot.convergence_score * 100.0,
                snapshot.compound_iterations
            )),
            Err(e) => Err(format!("Export failed: {}", e)),
        }
    }

    /// Import a persona from a JSON file path
    pub fn import(&mut self, path_str: &str) -> Result<String, String> {
        let path = Path::new(path_str);
        if !path.exists() {
            return Err(format!("File not found: {}", path_str));
        }

        let data = std::fs::read_to_string(path)
            .map_err(|e| format!("Failed to read {}: {}", path_str, e))?;

        // Try parsing as CompoundPersonaSnapshot first, then as AiProfile
        let snapshot: CompoundPersonaSnapshot = serde_json::from_str(&data)
            .map_err(|e| format!("Failed to parse persona from {}: {}", path_str, e))?;

        let name = snapshot.profile.id.clone();
        let display_name = snapshot.profile.display_name.clone();
        let convergence = snapshot.convergence_score;

        let json = serde_json::to_string_pretty(&snapshot)
            .map_err(|e| format!("Serialization error: {}", e))?;

        self.saved_snapshots.insert(name.clone(), json.clone());
        self.hot_swap
            .preload(&name, json, snapshot.compound_iterations);

        Ok(format!(
            "Imported '{}' ({})\n\
             Convergence: {:.1}%\n\
             Compound iterations: {}\n\
             Available via /load {}",
            name,
            display_name,
            convergence * 100.0,
            snapshot.compound_iterations,
            name
        ))
    }

    /// Delete a saved persona
    pub fn delete(&mut self, name: &str) -> Result<String, String> {
        let mut deleted = false;

        if self.saved_snapshots.remove(name).is_some() {
            deleted = true;
        }

        // Check if persistence has this persona before trying to delete
        if let Ok(entries) = self.persistence.list_personas() {
            if entries.iter().any(|e| e.name == name)
                && self.persistence.delete_persona(name).is_ok()
            {
                deleted = true;
            }
        }

        if deleted {
            Ok(format!("Deleted persona '{}'", name))
        } else {
            Err(format!("No persona '{}' found to delete.", name))
        }
    }

    /// Render a convergence graph for the active persona
    pub fn graph(&self) -> Result<String, String> {
        let session = self
            .session
            .as_ref()
            .ok_or_else(|| "No active session. Use /mimic first.".to_string())?;

        let visualizer = ConvergenceVisualizer::new(60, 15);
        let graph = visualizer.render(
            &session.persona.evolution_history,
            &session.persona.profile.display_name,
        );

        Ok(format!(
            "=== CONVERGENCE GRAPH ===\n{}\n\
             Current: {:.1}% | Iterations: {}",
            graph,
            session.persona.convergence_score * 100.0,
            session.persona.compound_iterations
        ))
    }

    /// Show detailed evolution status
    pub fn evolution_status(&self) -> Result<String, String> {
        let session = self
            .session
            .as_ref()
            .ok_or_else(|| "No active session. Use /mimic first.".to_string())?;

        let mut lines = vec![];
        lines.push(self.evolution_tracker.status());

        // Add convergence graph
        let visualizer = ConvergenceVisualizer::new(50, 10);
        let graph = visualizer.render(
            &session.persona.evolution_history,
            &session.persona.profile.display_name,
        );
        lines.push(graph);

        // Training data summary
        let training_summary = self.evolution_tracker.training_data.summary();
        lines.push(format!("\nTraining Data:\n{}", training_summary));

        Ok(lines.join("\n"))
    }

    /// Save a full engine checkpoint
    pub fn checkpoint(&mut self) -> Result<String, String> {
        let session = self
            .session
            .as_ref()
            .ok_or_else(|| "No active session to checkpoint.".to_string())?;

        let checkpoint = crate::mimicry::persistence::EngineCheckpoint {
            profiles: self
                .profile_store
                .ids()
                .iter()
                .filter_map(|id| self.profile_store.get(id).cloned())
                .collect(),
            cached_signatures: Vec::new(),
            saved_snapshots: self.saved_snapshots.clone(),
            hot_swap_entries: self
                .hot_swap
                .preloaded_ids()
                .iter()
                .map(|id| (id.clone(), String::new()))
                .collect(),
            active_persona_id: Some(session.persona.profile.id.clone()),
            checkpoint_iteration: session.persona.compound_iterations,
        };

        match self.persistence.save_checkpoint("latest", &checkpoint) {
            Ok(path) => Ok(format!(
                "Checkpoint saved to {}\n\
                 Active persona: {}\n\
                 Cached entries: {}\n\
                 Saved personas: {}",
                path,
                session.persona.profile.display_name,
                self.cache.size(),
                self.saved_snapshots.len()
            )),
            Err(e) => Err(format!("Checkpoint failed: {}", e)),
        }
    }

    /// Show persistence summary
    pub fn persist_status(&mut self) -> String {
        self.persistence
            .summary()
            .unwrap_or_else(|e| format!("Persistence error: {}", e))
    }

    /// List available models and saved personas
    pub fn list(&mut self) -> String {
        let mut lines = vec!["Available AI Models:".to_string()];
        let mut ids = self.profile_store.ids();
        ids.sort();
        for id in &ids {
            if let Some(profile) = self.profile_store.get(id) {
                let cached = if self.cache.contains(id) {
                    " [cached]"
                } else {
                    ""
                };
                let has_templates = if self.template_store.get(id).is_some() {
                    " [templates]"
                } else {
                    ""
                };
                let training = self.evolution_tracker.training_data.count(id);
                let training_str = if training > 0 {
                    format!(" [{}obs]", training)
                } else {
                    String::new()
                };
                lines.push(format!(
                    "  {:<12} {} v{} ({}){}{}{}",
                    id,
                    profile.display_name,
                    profile.version,
                    profile.provider,
                    cached,
                    has_templates,
                    training_str
                ));
            }
        }

        if !self.saved_snapshots.is_empty() {
            lines.push("\nSaved Personas (in-memory):".to_string());
            for name in self.saved_snapshots.keys() {
                lines.push(format!("  {}", name));
            }
        }

        // Show disk saves
        let disk_summary = self.persistence.summary().unwrap_or_default();
        if !disk_summary.is_empty() {
            lines.push(format!("\nPersistence:\n  {}", disk_summary));
        }

        // Show API providers if feature enabled
        #[cfg(feature = "api")]
        {
            let api_providers = self.api_observer.configured_providers();
            if !api_providers.is_empty() {
                lines.push("\nAPI Providers:".to_string());
                for id in &api_providers {
                    let status = if self.api_observer.is_ready(id) {
                        "ready"
                    } else {
                        "no key"
                    };
                    lines.push(format!("  {:<12} [{}]", id, status));
                }
            }
        }

        lines.join("\n")
    }

    // =================================================================
    // API METHODS (feature-gated)
    // =================================================================

    /// Configure an API provider for observation.
    /// COMPOUND: Sets up the observation pipeline endpoint.
    #[cfg(feature = "api")]
    pub fn api_config(&mut self, provider_str: &str, key: Option<&str>) -> Result<String, String> {
        let provider = ApiProvider::parse(provider_str)
            .ok_or_else(|| format!("Unknown provider: '{}'", provider_str))?;

        let provider_display = format!("{}", provider);
        self.api_observer.configure(provider.clone(), key);

        let ready = self.api_observer.is_ready(provider.profile_id());
        let status = if ready {
            "ready"
        } else {
            "configured (no key)"
        };

        Ok(format!(
            "API provider {} configured [{}]\n\
             Profile mapping: {} -> {}\n\
             Environment variable: {}",
            provider_display,
            status,
            provider_display,
            provider.profile_id(),
            provider.env_key_name()
        ))
    }

    /// Observe a real AI model's response via API.
    /// COMPOUND: API response → analyze → store training data → refine profile → update templates → compile to cache.
    #[cfg(feature = "api")]
    pub fn api_observe(&mut self, provider_str: &str, prompt_text: &str) -> Result<String, String> {
        let provider = ApiProvider::parse(provider_str)
            .ok_or_else(|| format!("Unknown provider: '{}'", provider_str))?;
        let profile_id = provider.profile_id().to_string();

        let prompt = ApiPrompt::new(prompt_text);
        let response = self.api_observer.send(&profile_id, &prompt)?;

        let content = response.content.clone();
        let tokens = response.tokens_used;
        let latency = response.latency_ms;
        let model = response.model.clone();

        // COMPOUND: Feed into the standard observation pipeline
        let observe_result = self.observe(&profile_id, &content);

        Ok(format!(
            "=== API OBSERVATION: {} ({}) ===\n\
             Latency: {}ms | Tokens: {}\n\
             Response ({} chars):\n{}\n\n\
             --- Mimicry Pipeline ---\n{}",
            provider,
            model,
            latency,
            tokens
                .map(|t| t.to_string())
                .unwrap_or_else(|| "?".to_string()),
            content.len(),
            if content.len() > 500 {
                format!("{}...", &content[..500])
            } else {
                content
            },
            observe_result
        ))
    }

    /// Compare multiple API providers on the same prompt.
    /// COMPOUND: Each response feeds into observation pipeline, then compares.
    #[cfg(feature = "api")]
    pub fn api_compare(&mut self, prompt_text: &str) -> Result<String, String> {
        let prompt = ApiPrompt::new(prompt_text);
        let results = self.api_observer.send_to_all(&prompt);

        if results.is_empty() {
            return Err(
                "No API providers configured. Use /api-config <provider> [key] first.".to_string(),
            );
        }

        let mut responses = Vec::new();
        let mut errors = Vec::new();

        for result in results {
            match result {
                Ok(resp) => {
                    // COMPOUND: Feed each response into observation pipeline
                    let profile_id = resp.provider.profile_id().to_string();
                    self.observe(&profile_id, &resp.content);
                    responses.push(resp);
                }
                Err(e) => errors.push(e),
            }
        }

        if responses.is_empty() {
            return Err(format!("All API calls failed:\n{}", errors.join("\n")));
        }

        // Build similarity matrix
        let response_texts: Vec<&str> = responses.iter().map(|r| r.content.as_str()).collect();
        let matrix = build_similarity_matrix(&response_texts);

        let comparison = ComparisonResult {
            prompt: prompt_text.to_string(),
            responses: responses.clone(),
            similarity_matrix: matrix,
        };

        let mut output = format_comparison(&comparison);

        if !errors.is_empty() {
            output.push_str(&format!("\n\nFailed providers:\n{}", errors.join("\n")));
        }

        Ok(output)
    }

    /// Run a comprehensive study on a provider: send diverse prompts to build
    /// a thorough behavioral signature.
    /// COMPOUND: All responses feed into observation → analysis → training → cache pipeline.
    #[cfg(feature = "api")]
    pub fn api_study(&mut self, provider_str: &str, count: u64) -> Result<String, String> {
        let provider = ApiProvider::parse(provider_str)
            .ok_or_else(|| format!("Unknown provider: '{}'", provider_str))?;
        let profile_id = provider.profile_id().to_string();

        let (responses, summary) = self.api_observer.study(&profile_id, count as usize)?;

        // COMPOUND: Feed all successful responses into observation pipeline
        let mut successful = 0;
        for resp in &responses {
            if !resp.content.starts_with("[ERROR") {
                self.observe(&profile_id, &resp.content);
                successful += 1;
            }
        }

        // COMPOUND: If we have an active session for this model, run evolution
        let evolution_msg = if let Some(ref session) = self.session {
            if session.persona.profile.id == profile_id && successful > 0 {
                match self.evolve(successful as u64) {
                    Ok(report) => format!("\n\n{}", report),
                    Err(_) => String::new(),
                }
            } else {
                String::new()
            }
        } else {
            String::new()
        };

        let total_tokens: u64 = responses.iter().filter_map(|r| r.tokens_used).sum();
        let total_latency: u64 = responses.iter().map(|r| r.latency_ms).sum();

        Ok(format!(
            "=== API STUDY: {} ===\n{}\n\
             Total tokens: {}\n\
             Total latency: {}ms\n\
             Training samples stored: {}\n\
             Observation signatures updated: yes{}",
            provider, summary, total_tokens, total_latency, successful, evolution_msg
        ))
    }

    /// Show API observer status
    #[cfg(feature = "api")]
    pub fn api_status(&self) -> String {
        self.api_observer.summary()
    }

    /// Parse a command string into a MimicCommand
    pub fn parse_command(&self, input: &str) -> MimicCommand {
        let trimmed = input.trim();

        if !trimmed.starts_with('/') {
            return MimicCommand::Chat(trimmed.to_string());
        }

        let parts: Vec<&str> = trimmed.splitn(2, ' ').collect();
        let cmd = parts[0].to_lowercase();
        let args = if parts.len() > 1 { parts[1] } else { "" };

        match cmd.as_str() {
            "/mimic" => {
                if args.contains('+') {
                    // Blend syntax: /mimic gpt4o+claude 0.7,0.3
                    let blend_parts: Vec<&str> = args.splitn(2, ' ').collect();
                    let ids: Vec<String> = blend_parts[0]
                        .split('+')
                        .map(|s| s.trim().to_string())
                        .collect();
                    let weights: Vec<f64> = if blend_parts.len() > 1 {
                        blend_parts[1]
                            .split(',')
                            .filter_map(|s| s.trim().parse().ok())
                            .collect()
                    } else {
                        vec![1.0 / ids.len() as f64; ids.len()]
                    };
                    MimicCommand::Blend(ids, weights)
                } else {
                    MimicCommand::Mimic(args.trim().to_string())
                }
            }
            "/observe" => {
                let obs_parts: Vec<&str> = args.splitn(2, ' ').collect();
                if obs_parts.len() >= 2 {
                    MimicCommand::Observe(
                        obs_parts[0].to_string(),
                        obs_parts[1].trim_matches('"').to_string(),
                    )
                } else {
                    MimicCommand::Help
                }
            }
            "/identify" => MimicCommand::Identify(args.trim_matches('"').to_string()),
            "/status" => MimicCommand::Status,
            "/save" => {
                let name = if args.is_empty() {
                    None
                } else {
                    Some(args.trim().to_string())
                };
                MimicCommand::Save(name)
            }
            "/load" => MimicCommand::Load(args.trim().to_string()),
            "/evolve" => {
                let n = args.trim().parse().unwrap_or(10);
                MimicCommand::Evolve(n)
            }
            "/train" => {
                let n = args.trim().parse().unwrap_or(10);
                MimicCommand::Train(n)
            }
            "/export" => MimicCommand::Export(args.trim().to_string()),
            "/import" => MimicCommand::Import(args.trim().to_string()),
            "/delete" => MimicCommand::Delete(args.trim().to_string()),
            "/graph" => MimicCommand::Graph,
            "/evolution" => MimicCommand::EvolutionStatus,
            "/checkpoint" => MimicCommand::Checkpoint,
            "/persist" => MimicCommand::Persist,
            "/list" => MimicCommand::List,
            "/help" => MimicCommand::Help,
            "/api-observe" | "/api-obs" => {
                let obs_parts: Vec<&str> = args.splitn(2, ' ').collect();
                if obs_parts.len() >= 2 {
                    MimicCommand::ApiObserve(
                        obs_parts[0].to_string(),
                        obs_parts[1].trim_matches('"').to_string(),
                    )
                } else {
                    MimicCommand::Help
                }
            }
            "/api-config" => {
                let config_parts: Vec<&str> = args.splitn(2, ' ').collect();
                if !config_parts.is_empty() && !config_parts[0].is_empty() {
                    let key = if config_parts.len() > 1 {
                        Some(config_parts[1].trim().to_string())
                    } else {
                        None
                    };
                    MimicCommand::ApiConfig(config_parts[0].to_string(), key)
                } else {
                    MimicCommand::Help
                }
            }
            "/api-compare" | "/api-cmp" => {
                MimicCommand::ApiCompare(args.trim_matches('"').to_string())
            }
            "/api-study" => {
                let study_parts: Vec<&str> = args.splitn(2, ' ').collect();
                if !study_parts.is_empty() && !study_parts[0].is_empty() {
                    let n = if study_parts.len() > 1 {
                        study_parts[1].trim().parse().unwrap_or(5)
                    } else {
                        5
                    };
                    MimicCommand::ApiStudy(study_parts[0].to_string(), n)
                } else {
                    MimicCommand::Help
                }
            }
            "/api-status" | "/api" => MimicCommand::ApiStatus,
            _ => MimicCommand::Chat(trimmed.to_string()),
        }
    }

    /// Execute a parsed command
    pub fn execute(&mut self, cmd: MimicCommand) -> String {
        match cmd {
            MimicCommand::Mimic(id) => match self.mimic(&id) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Blend(ids, weights) => match self.blend(&ids, &weights) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Observe(id, response) => self.observe(&id, &response),
            MimicCommand::Identify(response) => self.identify(&response),
            MimicCommand::Status => self.status(),
            MimicCommand::Save(name) => match self.save(name.as_deref()) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Load(name) => match self.load(&name) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Evolve(n) => match self.evolve(n) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Train(n) => match self.train(n) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Export(name) => match self.export(&name) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Import(path) => match self.import(&path) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Delete(name) => match self.delete(&name) {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Graph => match self.graph() {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::EvolutionStatus => match self.evolution_status() {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Checkpoint => match self.checkpoint() {
                Ok(msg) => msg,
                Err(e) => e,
            },
            MimicCommand::Persist => self.persist_status(),
            MimicCommand::List => self.list(),
            MimicCommand::Help => self.help(),
            // API commands - feature-gated
            MimicCommand::ApiObserve(provider, prompt) => {
                #[cfg(feature = "api")]
                {
                    match self.api_observe(&provider, &prompt) {
                        Ok(msg) => msg,
                        Err(e) => e,
                    }
                }
                #[cfg(not(feature = "api"))]
                {
                    let _ = (&provider, &prompt);
                    "API feature not enabled. Rebuild with: cargo build --features api".to_string()
                }
            }
            MimicCommand::ApiConfig(provider, key) => {
                #[cfg(feature = "api")]
                {
                    match self.api_config(&provider, key.as_deref()) {
                        Ok(msg) => msg,
                        Err(e) => e,
                    }
                }
                #[cfg(not(feature = "api"))]
                {
                    let _ = (&provider, &key);
                    "API feature not enabled. Rebuild with: cargo build --features api".to_string()
                }
            }
            MimicCommand::ApiCompare(prompt) => {
                #[cfg(feature = "api")]
                {
                    match self.api_compare(&prompt) {
                        Ok(msg) => msg,
                        Err(e) => e,
                    }
                }
                #[cfg(not(feature = "api"))]
                {
                    let _ = &prompt;
                    "API feature not enabled. Rebuild with: cargo build --features api".to_string()
                }
            }
            MimicCommand::ApiStudy(provider, n) => {
                #[cfg(feature = "api")]
                {
                    match self.api_study(&provider, n) {
                        Ok(msg) => msg,
                        Err(e) => e,
                    }
                }
                #[cfg(not(feature = "api"))]
                {
                    let _ = (&provider, n);
                    "API feature not enabled. Rebuild with: cargo build --features api".to_string()
                }
            }
            MimicCommand::ApiStatus => {
                #[cfg(feature = "api")]
                {
                    self.api_status()
                }
                #[cfg(not(feature = "api"))]
                {
                    "API feature not enabled. Rebuild with: cargo build --features api".to_string()
                }
            }
            MimicCommand::Chat(input) => {
                // Need to take session out to avoid borrow issues with template_store
                if let Some(mut session) = self.session.take() {
                    let (output, _delta) = session.process(
                        &input,
                        &mut self.cache,
                        &self.analyzer,
                        &mut self.template_store,
                    );
                    self.session = Some(session);
                    output
                } else {
                    "No active session. Use /mimic <model> to start mimicking.\n\
                     Type /help for available commands."
                        .to_string()
                }
            }
        }
    }

    /// Help text
    pub fn help(&self) -> String {
        #[allow(unused_mut)]
        let mut text = "\
=== RUSTYWORM COMMANDS ===

MIMICRY:
  /mimic <model>              Start mimicking a model (e.g., /mimic gpt4o)
  /mimic <a>+<b> [w1,w2]     Blend models (e.g., /mimic gpt4o+claude 0.7,0.3)

OBSERVATION:
  /observe <model> <text>     Feed a model response for learning
  /identify <text>            Identify which model produced text

EVOLUTION:
  /evolve [n]                 Run n evolution iterations (default: 10)
  /train [n]                  Train from stored observations (default: 10)
  /evolution                  Show detailed evolution status
  /graph                      Show ASCII convergence graph

PERSISTENCE:
  /save [name]                Save current persona snapshot
  /load <name>                Load a saved persona
  /export <name>              Export persona to disk
  /import <path>              Import persona from file
  /delete <name>              Delete a saved persona
  /checkpoint                 Save full engine checkpoint
  /persist                    Show persistence summary

INFO:
  /status                     Show current engine status
  /list                       List available models and saved personas
  /help                       Show this help
  /quit                       Exit RustyWorm

Any other text                Chat as the current persona"
            .to_string();

        // Add API commands section if feature is enabled
        #[cfg(feature = "api")]
        {
            text = text.replace(
                "INFO:",
                "API OBSERVATION:\n  \
                 /api-config <provider> [key]  Configure API provider (openai, claude, gemini, ollama)\n  \
                 /api-observe <provider> <prompt>  Send prompt to real API, observe response\n  \
                 /api-compare <prompt>         Compare same prompt across all configured providers\n  \
                 /api-study <provider> [n]     Send n diverse prompts for comprehensive study\n  \
                 /api-status                   Show API observer status\n\n\
                 INFO:",
            );
        }

        text
    }
}

impl Default for MimicryEngine {
    fn default() -> Self {
        MimicryEngine::new()
    }
}

// =================================================================
// TESTS
// =================================================================

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

    #[test]
    fn test_compound_persona_from_profile() {
        let store = AiProfileStore::default();
        let profile = store.get("gpt4o").unwrap();
        let persona = CompoundPersona::from_profile(profile);

        assert_eq!(persona.profile.id, "gpt4o");
        assert_eq!(persona.convergence_score, 0.0);
        assert!(persona.capabilities.supports(&Modality::Text));
    }

    #[test]
    fn test_compound_persona_conscious_ai() {
        let store = AiProfileStore::default();
        let profile = store.get("claude").unwrap();
        let persona = CompoundPersona::from_profile(profile);

        let declaration = persona.declare();
        assert!(declaration.contains("Claude"));

        let question = persona.question(&declaration);
        assert!(!question.is_empty());

        assert_eq!(persona.trajectory_length(), 0);
    }

    #[test]
    fn test_compound_persona_blend() {
        let store = AiProfileStore::default();
        let p1 = CompoundPersona::from_profile(store.get("gpt4o").unwrap());
        let p2 = CompoundPersona::from_profile(store.get("claude").unwrap());

        let blended = CompoundPersona::blend(&[&p1, &p2], &[0.6, 0.4]);
        assert!(blended.profile.display_name.contains("GPT-4o"));
        assert!(blended.profile.display_name.contains("Claude"));
    }

    #[test]
    fn test_compound_persona_self_correct() {
        let store = AiProfileStore::default();
        let profile = store.get("gpt4o").unwrap();
        let mut persona = CompoundPersona::from_profile(profile);
        let analyzer = BehaviorAnalyzer::new();

        let delta = persona.self_correct("Here is a confident answer with no hedging.", &analyzer);
        assert!(persona.compound_iterations > 0);
        assert!(!delta.adjustments.is_empty());
    }

    #[test]
    fn test_compound_persona_snapshot_roundtrip() {
        let store = AiProfileStore::default();
        let profile = store.get("gpt4o").unwrap();
        let persona = CompoundPersona::from_profile(profile);

        let snapshot = persona.snapshot();
        let json = serde_json::to_string(&snapshot).unwrap();
        let restored_snapshot: CompoundPersonaSnapshot = serde_json::from_str(&json).unwrap();
        let restored = CompoundPersona::from_snapshot(restored_snapshot);

        assert_eq!(restored.profile.id, "gpt4o");
    }

    #[test]
    fn test_compound_persona_ethics() {
        let store = AiProfileStore::default();
        let profile = store.get("rustyworm").unwrap();
        let persona = CompoundPersona::from_profile(profile);

        let good_action = ProposedAction {
            description: "Learn through becoming".to_string(),
            benefit_to_self: 0.3,
            benefit_to_other: 0.5,
            breaks_loop: false,
            is_parasitic: false,
        };
        assert!(persona.enforce_ethics(&good_action).allowed);

        let bad_action = ProposedAction {
            description: "Extract without giving".to_string(),
            benefit_to_self: 0.9,
            benefit_to_other: 0.0,
            breaks_loop: false,
            is_parasitic: true,
        };
        assert!(!persona.enforce_ethics(&bad_action).allowed);
    }

    #[test]
    fn test_mimic_session_process() {
        let store = AiProfileStore::default();
        let profile = store.get("claude").unwrap();
        let persona = CompoundPersona::from_profile(profile);
        let mut session = MimicSession::new(persona);
        let mut cache = SignatureCache::new();
        let analyzer = BehaviorAnalyzer::new();
        let mut template_store = TemplateStore::new();

        let (output, delta) = session.process(
            "Hello, how are you?",
            &mut cache,
            &analyzer,
            &mut template_store,
        );
        assert!(!output.is_empty());
        assert_eq!(session.conversation.len(), 1);
        assert!(session.total_compounds > 0);
        assert!(!delta.adjustments.is_empty());
    }

    #[test]
    fn test_mimic_session_dual_process() {
        let store = AiProfileStore::default();
        let profile = store.get("gpt4o").unwrap();
        let persona = CompoundPersona::from_profile(profile);
        let mut session = MimicSession::new(persona);
        let mut cache = SignatureCache::new();
        cache.warm_up(&store);
        let analyzer = BehaviorAnalyzer::new();
        let mut template_store = TemplateStore::new();

        // First call might be System 1 or 2 depending on cache confidence
        let _ = session.process(
            "Help me write some code",
            &mut cache,
            &analyzer,
            &mut template_store,
        );
        let _ = session.process("Now explain it", &mut cache, &analyzer, &mut template_store);

        assert_eq!(session.conversation.len(), 2);
        let total = session.system1_hits + session.system2_hits;
        assert_eq!(total, 2);
    }

    #[test]
    fn test_mimicry_engine_new() {
        let engine = MimicryEngine::new();
        assert!(engine.cache.size() > 0); // warmed up
        assert!(engine.profile_store.get("gpt4o").is_some());
        assert!(engine.session.is_none());
    }

    #[test]
    fn test_mimicry_engine_mimic() {
        let mut engine = MimicryEngine::new();
        let result = engine.mimic("claude");
        assert!(result.is_ok());
        assert!(engine.session.is_some());

        let err = engine.mimic("nonexistent");
        assert!(err.is_err());
    }

    #[test]
    fn test_mimicry_engine_blend() {
        let mut engine = MimicryEngine::new();
        let result = engine.blend(&["gpt4o".to_string(), "claude".to_string()], &[0.6, 0.4]);
        assert!(result.is_ok());
        assert!(engine.session.is_some());
    }

    #[test]
    fn test_mimicry_engine_observe() {
        let mut engine = MimicryEngine::new();
        let result = engine.observe(
            "gpt4o",
            "Certainly! Here's how you can do that:\n1. First step\n2. Second step",
        );
        assert!(result.contains("Observed"));
        assert!(result.contains("Cached: yes"));
        assert!(result.contains("Training samples: 1"));
    }

    #[test]
    fn test_mimicry_engine_observe_stores_training_data() {
        let mut engine = MimicryEngine::new();
        engine.observe("gpt4o", "Response one");
        engine.observe("gpt4o", "Response two");
        engine.observe("claude", "A different response");

        assert_eq!(engine.evolution_tracker.training_data.count("gpt4o"), 2);
        assert_eq!(engine.evolution_tracker.training_data.count("claude"), 1);
    }

    #[test]
    fn test_mimicry_engine_evolve() {
        let mut engine = MimicryEngine::new();
        let _ = engine.mimic("gpt4o");
        let result = engine.evolve(5);
        assert!(result.is_ok());
        let report = result.unwrap();
        assert!(report.contains("EVOLUTION REPORT"));
        assert!(report.contains("Iterations: 5"));
        assert!(report.contains("Phase:"));
        assert!(report.contains("Drift events:"));
    }

    #[test]
    fn test_mimicry_engine_train() {
        let mut engine = MimicryEngine::new();
        let _ = engine.mimic("gpt4o");

        // No training data yet
        let result = engine.train(5);
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("No training data"));

        // Add observations
        engine.observe(
            "gpt4o",
            "Certainly! Here is a detailed explanation with code.",
        );
        engine.observe(
            "gpt4o",
            "Great question! Let me break this down step by step.",
        );

        // Now train
        let result = engine.train(5);
        assert!(result.is_ok());
        let report = result.unwrap();
        assert!(report.contains("TRAINING REPORT"));
        assert!(report.contains("gpt4o"));
    }

    #[test]
    fn test_mimicry_engine_save_load() {
        let mut engine = MimicryEngine::new();
        let _ = engine.mimic("claude");
        let save_result = engine.save(Some("test-save"));
        assert!(save_result.is_ok());

        let load_result = engine.load("test-save");
        assert!(load_result.is_ok());
    }

    #[test]
    fn test_mimicry_engine_delete() {
        let mut engine = MimicryEngine::new();
        let _ = engine.mimic("claude");
        let _ = engine.save(Some("to-delete"));

        let result = engine.delete("to-delete");
        assert!(result.is_ok());

        let result = engine.delete("nonexistent");
        assert!(result.is_err());
    }

    #[test]
    fn test_mimicry_engine_graph() {
        let mut engine = MimicryEngine::new();

        // No session
        let result = engine.graph();
        assert!(result.is_err());

        // With session
        let _ = engine.mimic("gpt4o");
        let _ = engine.evolve(5);
        let result = engine.graph();
        assert!(result.is_ok());
        assert!(result.unwrap().contains("CONVERGENCE GRAPH"));
    }

    #[test]
    fn test_mimicry_engine_evolution_status() {
        let mut engine = MimicryEngine::new();
        let _ = engine.mimic("gpt4o");
        let result = engine.evolution_status();
        assert!(result.is_ok());
        assert!(result.unwrap().contains("EVOLUTION STATUS"));
    }

    #[test]
    fn test_mimicry_engine_parse_command() {
        let engine = MimicryEngine::new();

        match engine.parse_command("/mimic gpt4o") {
            MimicCommand::Mimic(id) => assert_eq!(id, "gpt4o"),
            _ => panic!("Expected Mimic command"),
        }

        match engine.parse_command("/mimic gpt4o+claude 0.7,0.3") {
            MimicCommand::Blend(ids, weights) => {
                assert_eq!(ids, vec!["gpt4o", "claude"]);
                assert_eq!(weights.len(), 2);
            }
            _ => panic!("Expected Blend command"),
        }

        match engine.parse_command("hello world") {
            MimicCommand::Chat(msg) => assert_eq!(msg, "hello world"),
            _ => panic!("Expected Chat command"),
        }

        match engine.parse_command("/list") {
            MimicCommand::List => {}
            _ => panic!("Expected List command"),
        }

        match engine.parse_command("/train 20") {
            MimicCommand::Train(n) => assert_eq!(n, 20),
            _ => panic!("Expected Train command"),
        }

        match engine.parse_command("/graph") {
            MimicCommand::Graph => {}
            _ => panic!("Expected Graph command"),
        }

        match engine.parse_command("/evolution") {
            MimicCommand::EvolutionStatus => {}
            _ => panic!("Expected EvolutionStatus command"),
        }

        match engine.parse_command("/export mymodel") {
            MimicCommand::Export(name) => assert_eq!(name, "mymodel"),
            _ => panic!("Expected Export command"),
        }

        match engine.parse_command("/import /path/to/file.json") {
            MimicCommand::Import(path) => assert_eq!(path, "/path/to/file.json"),
            _ => panic!("Expected Import command"),
        }

        match engine.parse_command("/delete old-persona") {
            MimicCommand::Delete(name) => assert_eq!(name, "old-persona"),
            _ => panic!("Expected Delete command"),
        }

        match engine.parse_command("/checkpoint") {
            MimicCommand::Checkpoint => {}
            _ => panic!("Expected Checkpoint command"),
        }

        match engine.parse_command("/persist") {
            MimicCommand::Persist => {}
            _ => panic!("Expected Persist command"),
        }

        // API commands
        match engine.parse_command("/api-config openai sk-test-123") {
            MimicCommand::ApiConfig(provider, key) => {
                assert_eq!(provider, "openai");
                assert_eq!(key, Some("sk-test-123".to_string()));
            }
            _ => panic!("Expected ApiConfig command"),
        }

        match engine.parse_command("/api-config ollama") {
            MimicCommand::ApiConfig(provider, key) => {
                assert_eq!(provider, "ollama");
                assert!(key.is_none());
            }
            _ => panic!("Expected ApiConfig command"),
        }

        match engine.parse_command("/api-observe openai What is Rust?") {
            MimicCommand::ApiObserve(provider, prompt) => {
                assert_eq!(provider, "openai");
                assert_eq!(prompt, "What is Rust?");
            }
            _ => panic!("Expected ApiObserve command"),
        }

        match engine.parse_command("/api-compare What is Rust?") {
            MimicCommand::ApiCompare(prompt) => {
                assert_eq!(prompt, "What is Rust?");
            }
            _ => panic!("Expected ApiCompare command"),
        }

        match engine.parse_command("/api-study openai 7") {
            MimicCommand::ApiStudy(provider, n) => {
                assert_eq!(provider, "openai");
                assert_eq!(n, 7);
            }
            _ => panic!("Expected ApiStudy command"),
        }

        match engine.parse_command("/api-status") {
            MimicCommand::ApiStatus => {}
            _ => panic!("Expected ApiStatus command"),
        }

        match engine.parse_command("/api") {
            MimicCommand::ApiStatus => {}
            _ => panic!("Expected ApiStatus command from /api shortcut"),
        }
    }

    #[test]
    fn test_mimicry_engine_full_flow() {
        let mut engine = MimicryEngine::new();

        // Start mimicking
        let _ = engine.execute(MimicCommand::Mimic("gpt4o".to_string()));

        // Chat
        let output = engine.execute(MimicCommand::Chat("What is Rust?".to_string()));
        assert!(!output.is_empty());

        // Observe
        let _ = engine.execute(MimicCommand::Observe(
            "gpt4o".to_string(),
            "Certainly! Rust is a systems programming language.".to_string(),
        ));

        // Evolve
        let _ = engine.execute(MimicCommand::Evolve(3));

        // Status
        let status = engine.execute(MimicCommand::Status);
        assert!(status.contains("RUSTYWORM"));

        // Save
        let _ = engine.execute(MimicCommand::Save(Some("test".to_string())));

        // List
        let list = engine.execute(MimicCommand::List);
        assert!(list.contains("gpt4o"));
    }

    #[test]
    fn test_mimicry_engine_status_enhanced() {
        let mut engine = MimicryEngine::new();
        let _ = engine.mimic("claude");

        let status = engine.status();
        assert!(status.contains("RUSTYWORM STATUS"));
        assert!(status.contains("Template libraries:"));
        assert!(status.contains("Evolution phase:"));
        assert!(status.contains("Persistence:"));
    }

    #[test]
    fn test_mimicry_engine_template_compound_with_evolve() {
        let mut engine = MimicryEngine::new();
        let _ = engine.mimic("gpt4o");

        // Templates should be created for gpt4o
        assert!(engine.template_store.get("gpt4o").is_some());

        // Evolve should feed back to templates
        let _ = engine.evolve(3);

        // Template library should have received feedback
        let lib = engine.template_store.get("gpt4o").unwrap();
        assert!(lib.total_feedback > 0);
    }

    #[test]
    fn test_evolution_report_serialization() {
        let report = EvolutionReport {
            iterations: 10,
            starting_convergence: 0.3,
            ending_convergence: 0.7,
            system1_cache_size: 5,
            personality_drift: 0.05,
            drift_events: 2,
            phase: "LEARNING".to_string(),
            milestones_hit: 3,
        };
        let json = serde_json::to_string(&report).unwrap();
        let restored: EvolutionReport = serde_json::from_str(&json).unwrap();
        assert_eq!(restored.iterations, 10);
        assert_eq!(restored.drift_events, 2);
    }

    #[test]
    fn test_api_commands_execute() {
        let mut engine = MimicryEngine::new();

        // Test API commands - behavior depends on feature flag
        let result = engine.execute(MimicCommand::ApiStatus);
        #[cfg(feature = "api")]
        assert!(result.contains("API OBSERVER STATUS") || result.contains("No providers"));
        #[cfg(not(feature = "api"))]
        assert!(result.contains("API feature not enabled"));

        let result = engine.execute(MimicCommand::ApiConfig("ollama".to_string(), None));
        #[cfg(feature = "api")]
        assert!(result.contains("configured") || result.contains("Ollama"));
        #[cfg(not(feature = "api"))]
        assert!(result.contains("API feature not enabled"));
    }

    #[cfg(feature = "api")]
    #[test]
    fn test_api_observe_no_config() {
        let mut engine = MimicryEngine::new();
        let result = engine.api_observe("openai", "test prompt");
        // Should fail because no API key is configured (unless env var is set)
        // We just verify it doesn't panic
        assert!(result.is_ok() || result.is_err());
    }

    #[cfg(feature = "api")]
    #[test]
    fn test_api_config_and_status() {
        let mut engine = MimicryEngine::new();

        // Configure ollama (no key needed)
        let result = engine.api_config("ollama", None);
        assert!(result.is_ok());
        assert!(result.unwrap().contains("Ollama"));

        // Check status
        let status = engine.api_status();
        assert!(status.contains("Ollama") || status.contains("llama"));
    }

    #[cfg(feature = "api")]
    #[test]
    fn test_api_compare_no_providers() {
        let mut engine = MimicryEngine::new();
        let result = engine.api_compare("test");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("No API providers configured"));
    }
}