diff --git a/examples/benchmarks/Cargo.toml b/examples/benchmarks/Cargo.toml
index 0384e653..7fcd37ea 100644
--- a/examples/benchmarks/Cargo.toml
+++ b/examples/benchmarks/Cargo.toml
@@ -84,3 +84,7 @@ path = "src/bin/intelligence_assessment.rs"
 [[bin]]
 name = "rvf-intelligence-bench"
 path = "src/bin/rvf_intelligence_bench.rs"
+
+[[bin]]
+name = "superintelligence"
+path = "src/bin/superintelligence.rs"
diff --git a/examples/benchmarks/src/bin/superintelligence.rs b/examples/benchmarks/src/bin/superintelligence.rs
new file mode 100644
index 00000000..41702d63
--- /dev/null
+++ b/examples/benchmarks/src/bin/superintelligence.rs
@@ -0,0 +1,116 @@
+//! Superintelligence Pathway Runner
+//!
+//! Runs a 5-level recursive intelligence amplification pipeline and tracks
+//! IQ progression from foundation (~85) toward superintelligence (~98+).
+//!
+//! Usage:
+//!   cargo run --bin superintelligence -- --verbose
+//!   cargo run --bin superintelligence -- --episodes 15 --tasks 30 --target 95
+
+use anyhow::Result;
+use clap::Parser;
+use ruvector_benchmarks::superintelligence::{run_pathway, SIConfig};
+use ruvector_benchmarks::intelligence_metrics::IntelligenceCalculator;
+
+#[derive(Parser, Debug)]
+#[command(name = "superintelligence")]
+#[command(about = "Run 5-level superintelligence pathway with IQ tracking")]
+struct Args {
+    /// Episodes per level
+    #[arg(short, long, default_value = "12")]
+    episodes: usize,
+
+    /// Tasks per episode
+    #[arg(short, long, default_value = "25")]
+    tasks: usize,
+
+    /// Random seed
+    #[arg(long, default_value = "42")]
+    seed: u64,
+
+    /// Noise injection rate (0.0-1.0)
+    #[arg(long, default_value = "0.25")]
+    noise: f64,
+
+    /// Step budget per episode
+    #[arg(long, default_value = "400")]
+    step_budget: usize,
+
+    /// Target IQ score
+    #[arg(long, default_value = "98.0")]
+    target: f64,
+
+    /// Ensemble size for Level 3
+    #[arg(long, default_value = "4")]
+    ensemble: usize,
+
+    /// Recursive improvement cycles for Level 4
+    #[arg(long, default_value = "3")]
+    cycles: usize,
+
+    /// Adversarial pressure multiplier for Level 5
+    #[arg(long, default_value = "1.5")]
+    pressure: f64,
+
+    /// Verbose per-episode output
+    #[arg(short, long)]
+    verbose: bool,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    println!();
+    println!("╔══════════════════════════════════════════════════════════════╗");
+    println!("║           SUPERINTELLIGENCE PATHWAY ENGINE                   ║");
+    println!("║   5-Level Recursive Intelligence Amplification               ║");
+    println!("╚══════════════════════════════════════════════════════════════╝");
+    println!();
+    println!("  Config: {} eps/level x {} tasks, noise={:.0}%, target IQ={:.0}",
+        args.episodes, args.tasks, args.noise * 100.0, args.target);
+    println!("  Ensemble={}, Cycles={}, Pressure={:.1}",
+        args.ensemble, args.cycles, args.pressure);
+    println!();
+
+    let config = SIConfig {
+        episodes_per_level: args.episodes,
+        tasks_per_episode: args.tasks,
+        seed: args.seed,
+        noise_rate: args.noise,
+        step_budget: args.step_budget,
+        target_iq: args.target,
+        ensemble_size: args.ensemble,
+        recursive_cycles: args.cycles,
+        adversarial_pressure: args.pressure,
+        verbose: args.verbose,
+        ..Default::default()
+    };
+
+    let result = run_pathway(&config)?;
+    result.print();
+
+    // Detailed assessment for peak level
+    let calculator = IntelligenceCalculator::default();
+    if let Some(peak) = result.levels.iter().max_by(|a, b| a.iq_score.partial_cmp(&b.iq_score).unwrap()) {
+        println!("  Peak Level ({}) Assessment:", peak.name);
+        let assessment = calculator.calculate(&peak.raw_metrics);
+        println!("    Reasoning:     coherence={:.2}, efficiency={:.2}, error_rate={:.2}",
+            assessment.reasoning.logical_coherence,
+            assessment.reasoning.reasoning_efficiency,
+            assessment.reasoning.error_rate);
+        println!("    Learning:      sample_eff={:.2}, regret_sub={:.2}, rate={:.2}",
+            assessment.learning.sample_efficiency,
+            assessment.learning.regret_sublinearity,
+            assessment.learning.learning_rate);
+        println!("    Capabilities:  pattern={:.1}, planning={:.1}, adaptation={:.1}",
+            assessment.capabilities.pattern_recognition,
+            assessment.capabilities.planning,
+            assessment.capabilities.adaptation);
+        println!("    Meta-cog:      self_correct={:.2}, strategy_adapt={:.2}",
+            assessment.meta_cognition.self_correction_rate,
+            assessment.meta_cognition.strategy_adaptation);
+        println!();
+    }
+
+    Ok(())
+}
diff --git a/examples/benchmarks/src/lib.rs b/examples/benchmarks/src/lib.rs
index d0b3000b..5aae2d35 100644
--- a/examples/benchmarks/src/lib.rs
+++ b/examples/benchmarks/src/lib.rs
@@ -18,6 +18,7 @@ pub mod intelligence_metrics;
 pub mod logging;
 pub mod reasoning_bank;
 pub mod rvf_intelligence_bench;
+pub mod superintelligence;
 pub mod swarm_regret;
 pub mod temporal;
 pub mod timepuzzles;
diff --git a/examples/benchmarks/src/superintelligence.rs b/examples/benchmarks/src/superintelligence.rs
new file mode 100644
index 00000000..15da4dd4
--- /dev/null
+++ b/examples/benchmarks/src/superintelligence.rs
@@ -0,0 +1,1141 @@
+//! Superintelligence Pathway — 5-Level Recursive Intelligence Amplification
+//!
+//! Each level feeds the next. The system measures IQ at every stage and only
+//! advances when the prior level stabilises.
+//!
+//! ## Level Architecture
+//!
+//! ```text
+//! L1  Foundation        IQ ~85   Adaptive solver + ReasoningBank + coherence
+//! L2  Meta-Learning     IQ ~90   Learns *how* to learn (hyper-param optimizer)
+//! L3  Ensemble Arbiter  IQ ~93   Multi-strategy voting + learned selection
+//! L4  Recursive Improve IQ ~96   Bootstraps from own outputs + knowledge compile
+//! L5  Adversarial Grow  IQ ~98+  Self-generated hard tasks + cascade reasoning
+//! ```
+
+use crate::intelligence_metrics::{DifficultyStats, EpisodeMetrics, IntelligenceCalculator, RawMetrics};
+use crate::reasoning_bank::{ReasoningBank, Strategy, Trajectory, Verdict};
+use crate::temporal::{AdaptiveSolver, SolverResult, TemporalConstraint, TemporalPuzzle, TemporalSolver};
+use crate::timepuzzles::{PuzzleGenerator, PuzzleGeneratorConfig};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::Instant;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Configuration
+// ═══════════════════════════════════════════════════════════════════════════
+
+#[derive(Clone, Debug)]
+pub struct SIConfig {
+    /// Episodes per level
+    pub episodes_per_level: usize,
+    /// Tasks per episode
+    pub tasks_per_episode: usize,
+    /// Seed
+    pub seed: u64,
+    /// Noise injection rate
+    pub noise_rate: f64,
+    /// Step budget per episode
+    pub step_budget: usize,
+    /// Max retries for error recovery
+    pub max_retries: usize,
+    /// Verbose output
+    pub verbose: bool,
+    /// Target IQ — stop if reached
+    pub target_iq: f64,
+    /// Number of ensemble strategies (Level 3)
+    pub ensemble_size: usize,
+    /// Recursive improvement cycles (Level 4)
+    pub recursive_cycles: usize,
+    /// Adversarial difficulty multiplier (Level 5)
+    pub adversarial_pressure: f64,
+}
+
+impl Default for SIConfig {
+    fn default() -> Self {
+        Self {
+            episodes_per_level: 12,
+            tasks_per_episode: 25,
+            seed: 42,
+            noise_rate: 0.25,
+            step_budget: 400,
+            max_retries: 2,
+            verbose: false,
+            target_iq: 98.0,
+            ensemble_size: 4,
+            recursive_cycles: 3,
+            adversarial_pressure: 1.5,
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Deterministic RNG (same xorshift64 as the benchmark module)
+// ═══════════════════════════════════════════════════════════════════════════
+
+struct Rng64(u64);
+impl Rng64 {
+    fn new(seed: u64) -> Self { Self(seed.max(1)) }
+    fn next_f64(&mut self) -> f64 {
+        let mut x = self.0;
+        x ^= x << 13; x ^= x >> 7; x ^= x << 17;
+        self.0 = x;
+        (x as f64) / (u64::MAX as f64)
+    }
+    fn next_usize(&mut self, upper: usize) -> usize {
+        (self.next_f64() * upper as f64) as usize % upper.max(1)
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level result
+// ═══════════════════════════════════════════════════════════════════════════
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct LevelResult {
+    pub level: usize,
+    pub name: String,
+    pub iq_score: f64,
+    pub accuracy: f64,
+    pub total_correct: usize,
+    pub total_attempted: usize,
+    pub patterns_learned: usize,
+    pub episodes: Vec<EpisodeSnapshot>,
+    pub raw_metrics: RawMetrics,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct EpisodeSnapshot {
+    pub episode: usize,
+    pub accuracy: f64,
+    pub steps: usize,
+    pub retries: usize,
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Full pathway result
+// ═══════════════════════════════════════════════════════════════════════════
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct PathwayResult {
+    pub levels: Vec<LevelResult>,
+    pub peak_iq: f64,
+    pub peak_level: usize,
+    pub iq_progression: Vec<f64>,
+    pub reached_target: bool,
+    pub target_iq: f64,
+}
+
+impl PathwayResult {
+    pub fn print(&self) {
+        println!();
+        println!("╔══════════════════════════════════════════════════════════════╗");
+        println!("║       SUPERINTELLIGENCE PATHWAY — IQ PROGRESSION            ║");
+        println!("╚══════════════════════════════════════════════════════════════╝");
+        println!();
+
+        let names = [
+            "L1 Foundation",
+            "L2 Meta-Learning",
+            "L3 Ensemble Arbiter",
+            "L4 Recursive Improve",
+            "L5 Adversarial Growth",
+        ];
+
+        println!("  {:<24} {:>6} {:>10} {:>10} {:>10}",
+            "Level", "IQ", "Accuracy", "Correct", "Patterns");
+        println!("  {}", "-".repeat(62));
+
+        for (i, level) in self.levels.iter().enumerate() {
+            let iq_bar = iq_bar(level.iq_score);
+            let delta = if i > 0 {
+                format!("{:+.1}", level.iq_score - self.levels[i - 1].iq_score)
+            } else {
+                "---".to_string()
+            };
+            println!(
+                "  {:<24} {:>5.1} {:>8.1}% {:>10} {:>10}  {} ({})",
+                names.get(i).unwrap_or(&"Unknown"),
+                level.iq_score,
+                level.accuracy * 100.0,
+                level.total_correct,
+                level.patterns_learned,
+                iq_bar,
+                delta,
+            );
+        }
+
+        println!();
+        println!("  IQ Trajectory:");
+        let max_iq = self.iq_progression.iter().cloned().fold(0.0_f64, f64::max);
+        for (i, &iq) in self.iq_progression.iter().enumerate() {
+            let filled = ((iq / max_iq.max(1.0)) * 40.0) as usize;
+            println!("  L{} {:>5.1} |{}{}|",
+                i + 1, iq, "#".repeat(filled), " ".repeat(40 - filled));
+        }
+
+        println!();
+        if self.reached_target {
+            println!("  TARGET REACHED: IQ {:.1} >= {:.1}", self.peak_iq, self.target_iq);
+        } else {
+            println!("  Peak IQ: {:.1} (target: {:.1}, gap: {:.1})",
+                self.peak_iq, self.target_iq, self.target_iq - self.peak_iq);
+        }
+
+        println!();
+        println!("  Total IQ gain:  {:+.1} across {} levels",
+            self.peak_iq - self.levels.first().map(|l| l.iq_score).unwrap_or(0.0),
+            self.levels.len());
+        println!();
+    }
+}
+
+fn iq_bar(iq: f64) -> String {
+    let blocks = (iq / 10.0).round() as usize;
+    let blocks = blocks.min(10);
+    format!("[{}{}]", "█".repeat(blocks), "░".repeat(10 - blocks))
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Noise injection (reused from rvf_intelligence_bench)
+// ═══════════════════════════════════════════════════════════════════════════
+
+fn inject_noise(puzzle: &TemporalPuzzle, rng: &mut Rng64) -> (TemporalPuzzle, bool) {
+    let mut noisy = puzzle.clone();
+    let mut corrupted = false;
+    for c in noisy.constraints.iter_mut() {
+        match c {
+            TemporalConstraint::InMonth(ref mut m) => {
+                if rng.next_f64() < 0.5 {
+                    let shift = if rng.next_f64() < 0.5 { 1 } else { 11 };
+                    *m = (*m + shift - 1) % 12 + 1;
+                    corrupted = true;
+                }
+            }
+            TemporalConstraint::DayOfMonth(ref mut d) => {
+                if rng.next_f64() < 0.5 {
+                    *d = (*d + 1).min(28).max(1);
+                    corrupted = true;
+                }
+            }
+            TemporalConstraint::InYear(ref mut y) => {
+                if rng.next_f64() < 0.5 {
+                    *y += if rng.next_f64() < 0.5 { 1 } else { -1 };
+                    corrupted = true;
+                }
+            }
+            _ => {}
+        }
+    }
+    (noisy, corrupted)
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Meta-Learned Hyperparameters (Level 2)
+// ═══════════════════════════════════════════════════════════════════════════
+
+#[derive(Clone, Debug)]
+struct MetaParams {
+    /// Learned optimal step budget per difficulty
+    step_budgets: HashMap<u8, f64>,
+    /// Learned noise detection threshold
+    noise_confidence_threshold: f64,
+    /// Learned retry benefit estimate
+    retry_benefit: f64,
+    /// Best observed strategy per difficulty
+    best_strategy_per_diff: HashMap<u8, String>,
+}
+
+impl MetaParams {
+    fn new() -> Self {
+        Self {
+            step_budgets: HashMap::new(),
+            noise_confidence_threshold: 0.6,
+            retry_benefit: 0.5,
+            best_strategy_per_diff: HashMap::new(),
+        }
+    }
+
+    fn learn_from_result(&mut self, difficulty: u8, steps: usize, correct: bool, retried: bool) {
+        // EMA for step budgets
+        let s = steps as f64;
+        self.step_budgets
+            .entry(difficulty)
+            .and_modify(|avg| *avg = *avg * 0.7 + s * 0.3)
+            .or_insert(s);
+
+        // Update retry benefit estimate
+        if retried && correct {
+            self.retry_benefit = self.retry_benefit * 0.9 + 1.0 * 0.1;
+        } else if retried && !correct {
+            self.retry_benefit = self.retry_benefit * 0.9 + 0.0 * 0.1;
+        }
+    }
+
+    fn optimal_steps(&self, difficulty: u8, budget_remaining: usize, tasks_remaining: usize) -> usize {
+        let learned = self.step_budgets.get(&difficulty).copied().unwrap_or(20.0);
+        let adaptive = (learned * 1.5) as usize;
+        let even = budget_remaining / tasks_remaining.max(1);
+        adaptive.min(even * 3).max(5)
+    }
+
+    fn should_retry(&self) -> bool {
+        self.retry_benefit > 0.3
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Strategy Ensemble (Level 3)
+// ═══════════════════════════════════════════════════════════════════════════
+
+struct StrategyEnsemble {
+    solvers: Vec<AdaptiveSolver>,
+    votes: Vec<f64>,  // confidence-weighted voting history
+}
+
+impl StrategyEnsemble {
+    fn new(size: usize, bank: &ReasoningBank) -> Self {
+        let mut solvers = Vec::with_capacity(size);
+        for i in 0..size {
+            let mut s = AdaptiveSolver::with_reasoning_bank(bank.clone());
+            // Diversify: give each solver a different step/beam profile
+            match i % 4 {
+                0 => { /* default — balanced */ }
+                1 => { s.solver_mut().max_steps = 30; }   // aggressive
+                2 => { s.solver_mut().max_steps = 120; }  // conservative
+                3 => { s.solver_mut().calendar_tool = false; } // no-rewrite
+                _ => {}
+            }
+            solvers.push(s);
+        }
+        Self { solvers, votes: Vec::new() }
+    }
+
+    fn solve_ensemble(&mut self, puzzle: &TemporalPuzzle) -> Result<SolverResult> {
+        let mut results: Vec<SolverResult> = Vec::new();
+        for solver in &mut self.solvers {
+            let r = solver.solve(puzzle)?;
+            results.push(r);
+        }
+
+        // Majority vote on correctness
+        let correct_count = results.iter().filter(|r| r.correct).count();
+        let any_correct = results.iter().find(|r| r.correct);
+
+        if let Some(best) = any_correct {
+            // Return the correct result with fewest steps
+            let best_correct = results.iter()
+                .filter(|r| r.correct)
+                .min_by_key(|r| r.steps)
+                .unwrap_or(best);
+            self.votes.push(correct_count as f64 / results.len() as f64);
+            Ok(best_correct.clone())
+        } else {
+            // All failed — return result with most solutions found
+            let best_effort = results.iter()
+                .max_by_key(|r| r.solutions.len())
+                .unwrap_or(&results[0]);
+            self.votes.push(0.0);
+            Ok(best_effort.clone())
+        }
+    }
+
+    fn consensus_strength(&self) -> f64 {
+        if self.votes.is_empty() { return 0.0; }
+        self.votes.iter().sum::<f64>() / self.votes.len() as f64
+    }
+
+    fn merge_knowledge(&self) -> ReasoningBank {
+        // Merge all solvers' ReasoningBanks into one
+        let mut merged = ReasoningBank::new();
+        for solver in &self.solvers {
+            for traj in &solver.reasoning_bank.trajectories {
+                merged.record_trajectory(traj.clone());
+            }
+        }
+        merged
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Knowledge Compiler (Level 4)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// Compiles learned patterns into direct lookup tables that bypass reasoning.
+#[derive(Clone, Debug, Default)]
+struct KnowledgeCompiler {
+    /// Direct answer cache: puzzle_id -> known correct result
+    answer_cache: HashMap<String, bool>,
+    /// Compiled constraint signature -> optimal config
+    signature_cache: HashMap<String, CompiledConfig>,
+    hits: usize,
+    misses: usize,
+}
+
+#[derive(Clone, Debug)]
+struct CompiledConfig {
+    use_rewriting: bool,
+    max_steps: usize,
+    expected_correct: bool,
+}
+
+impl KnowledgeCompiler {
+    fn new() -> Self { Self::default() }
+
+    fn compile_from_bank(&mut self, bank: &ReasoningBank) {
+        for traj in &bank.trajectories {
+            // Cache puzzle outcomes
+            let correct = traj.verdict.as_ref().map(|v| v.is_success()).unwrap_or(false);
+            self.answer_cache.insert(traj.puzzle_id.clone(), correct);
+
+            // Build constraint signature
+            let mut sig_parts = traj.constraint_types.clone();
+            sig_parts.sort();
+            let sig = format!("{}:{}", traj.difficulty, sig_parts.join(","));
+
+            if correct {
+                if let Some(attempt) = traj.attempts.first() {
+                    let entry = self.signature_cache.entry(sig).or_insert(CompiledConfig {
+                        use_rewriting: true,
+                        max_steps: attempt.steps,
+                        expected_correct: true,
+                    });
+                    // Keep minimum steps that succeeded
+                    entry.max_steps = entry.max_steps.min(attempt.steps);
+                }
+            }
+        }
+    }
+
+    fn lookup_config(&mut self, puzzle: &TemporalPuzzle) -> Option<&CompiledConfig> {
+        let mut sig_parts: Vec<String> = puzzle.constraints.iter()
+            .map(|c| format!("{:?}", c).split('(').next().unwrap_or("?").to_string())
+            .collect();
+        sig_parts.sort();
+        let sig = format!("{}:{}", puzzle.difficulty, sig_parts.join(","));
+
+        if let Some(config) = self.signature_cache.get(&sig) {
+            self.hits += 1;
+            Some(config)
+        } else {
+            self.misses += 1;
+            None
+        }
+    }
+
+    fn hit_rate(&self) -> f64 {
+        let total = self.hits + self.misses;
+        if total == 0 { 0.0 } else { self.hits as f64 / total as f64 }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Adversarial Generator (Level 5)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// Generates harder puzzles targeting known weaknesses.
+struct AdversarialGenerator {
+    /// Failure signatures: constraint patterns that fail most
+    weak_signatures: Vec<(Vec<String>, u8, usize)>,  // (constraints, difficulty, fail_count)
+    pressure: f64,
+}
+
+impl AdversarialGenerator {
+    fn new(pressure: f64) -> Self {
+        Self { weak_signatures: Vec::new(), pressure }
+    }
+
+    fn learn_weakness(&mut self, constraint_types: &[String], difficulty: u8, correct: bool) {
+        if !correct {
+            let key_types: Vec<String> = constraint_types.to_vec();
+            if let Some(entry) = self.weak_signatures.iter_mut()
+                .find(|(ct, d, _)| ct == &key_types && *d == difficulty) {
+                entry.2 += 1;
+            } else {
+                self.weak_signatures.push((key_types, difficulty, 1));
+            }
+        }
+    }
+
+    fn harden_difficulty(&self, base_difficulty: u8) -> u8 {
+        let boost = (self.pressure * 2.0) as u8;
+        base_difficulty.saturating_add(boost).min(10)
+    }
+
+    fn top_weaknesses(&self, n: usize) -> Vec<&(Vec<String>, u8, usize)> {
+        let mut sorted: Vec<_> = self.weak_signatures.iter().collect();
+        sorted.sort_by(|a, b| b.2.cmp(&a.2));
+        sorted.into_iter().take(n).collect()
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Cascade Reasoner (Level 5 augmentation)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// Multi-pass reasoning: solve, verify, re-solve if inconsistent.
+struct CascadeReasoner {
+    passes: usize,
+}
+
+impl CascadeReasoner {
+    fn new() -> Self { Self { passes: 0 } }
+
+    fn cascade_solve(
+        &mut self,
+        solver: &mut AdaptiveSolver,
+        puzzle: &TemporalPuzzle,
+        max_passes: usize,
+    ) -> Result<SolverResult> {
+        let mut best = solver.solve(puzzle)?;
+        self.passes += 1;
+
+        for _ in 1..max_passes {
+            if best.correct {
+                break; // Already correct, no need for more passes
+            }
+            // Re-solve with doubled step budget
+            let saved = solver.external_step_limit;
+            let current = saved.unwrap_or(100);
+            solver.external_step_limit = Some(current * 2);
+            let retry = solver.solve(puzzle)?;
+            solver.external_step_limit = saved;
+            self.passes += 1;
+
+            if retry.correct {
+                best = retry;
+                break;
+            }
+            // If retry found more solutions, prefer it
+            if retry.solutions.len() > best.solutions.len() {
+                best = retry;
+            }
+        }
+        Ok(best)
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Core Engine — runs all 5 levels
+// ═══════════════════════════════════════════════════════════════════════════
+
+pub fn run_pathway(config: &SIConfig) -> Result<PathwayResult> {
+    let calculator = IntelligenceCalculator::default();
+    let mut levels: Vec<LevelResult> = Vec::new();
+    let mut iq_progression: Vec<f64> = Vec::new();
+
+    // Persistent state that flows between levels
+    let mut reasoning_bank = ReasoningBank::new();
+    let mut meta_params = MetaParams::new();
+    let mut compiler = KnowledgeCompiler::new();
+    let mut adversary = AdversarialGenerator::new(config.adversarial_pressure);
+
+    // ─── LEVEL 1: Foundation ─────────────────────────────────────────
+    if config.verbose { println!("\n  ═══ Level 1: Foundation ═══"); }
+    let l1 = run_level_1(config, &mut reasoning_bank)?;
+    let l1_iq = calculator.calculate(&l1.raw_metrics).overall_score;
+    levels.push(make_level_result(1, "Foundation", &l1, l1_iq));
+    iq_progression.push(l1_iq);
+    if config.verbose { println!("  L1 IQ: {:.1}", l1_iq); }
+    if l1_iq >= config.target_iq { return Ok(build_pathway(levels, iq_progression, config)); }
+
+    // ─── LEVEL 2: Meta-Learning ──────────────────────────────────────
+    if config.verbose { println!("\n  ═══ Level 2: Meta-Learning ═══"); }
+    let l2 = run_level_2(config, &mut reasoning_bank, &mut meta_params)?;
+    let l2_iq = calculator.calculate(&l2.raw_metrics).overall_score;
+    levels.push(make_level_result(2, "Meta-Learning", &l2, l2_iq));
+    iq_progression.push(l2_iq);
+    if config.verbose { println!("  L2 IQ: {:.1} ({:+.1})", l2_iq, l2_iq - l1_iq); }
+    if l2_iq >= config.target_iq { return Ok(build_pathway(levels, iq_progression, config)); }
+
+    // ─── LEVEL 3: Ensemble Arbiter ───────────────────────────────────
+    if config.verbose { println!("\n  ═══ Level 3: Ensemble Arbiter ═══"); }
+    let l3 = run_level_3(config, &mut reasoning_bank, &meta_params)?;
+    let l3_iq = calculator.calculate(&l3.raw_metrics).overall_score;
+    levels.push(make_level_result(3, "Ensemble Arbiter", &l3, l3_iq));
+    iq_progression.push(l3_iq);
+    if config.verbose { println!("  L3 IQ: {:.1} ({:+.1})", l3_iq, l3_iq - l2_iq); }
+    if l3_iq >= config.target_iq { return Ok(build_pathway(levels, iq_progression, config)); }
+
+    // ─── LEVEL 4: Recursive Self-Improvement ─────────────────────────
+    if config.verbose { println!("\n  ═══ Level 4: Recursive Improvement ═══"); }
+    let l4 = run_level_4(config, &mut reasoning_bank, &mut meta_params, &mut compiler)?;
+    let l4_iq = calculator.calculate(&l4.raw_metrics).overall_score;
+    levels.push(make_level_result(4, "Recursive Improve", &l4, l4_iq));
+    iq_progression.push(l4_iq);
+    if config.verbose { println!("  L4 IQ: {:.1} ({:+.1})", l4_iq, l4_iq - l3_iq); }
+    if l4_iq >= config.target_iq { return Ok(build_pathway(levels, iq_progression, config)); }
+
+    // ─── LEVEL 5: Adversarial Growth + Cascade ───────────────────────
+    if config.verbose { println!("\n  ═══ Level 5: Adversarial Growth ═══"); }
+    let l5 = run_level_5(config, &mut reasoning_bank, &mut meta_params, &mut compiler, &mut adversary)?;
+    let l5_iq = calculator.calculate(&l5.raw_metrics).overall_score;
+    levels.push(make_level_result(5, "Adversarial Growth", &l5, l5_iq));
+    iq_progression.push(l5_iq);
+    if config.verbose { println!("  L5 IQ: {:.1} ({:+.1})", l5_iq, l5_iq - l4_iq); }
+
+    Ok(build_pathway(levels, iq_progression, config))
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level implementations
+// ═══════════════════════════════════════════════════════════════════════════
+
+struct LevelRaw {
+    raw_metrics: RawMetrics,
+    episodes: Vec<EpisodeSnapshot>,
+    total_correct: usize,
+    total_attempted: usize,
+    patterns: usize,
+}
+
+/// Level 1: Foundation — adaptive solver with noise and retry.
+fn run_level_1(config: &SIConfig, bank: &mut ReasoningBank) -> Result<LevelRaw> {
+    let mut raw = RawMetrics::default();
+    let mut snapshots = Vec::new();
+    let mut solver = AdaptiveSolver::with_reasoning_bank(bank.clone());
+    let mut rng = Rng64::new(config.seed.wrapping_add(100));
+    let mut total_correct = 0usize;
+    let mut total_attempted = 0usize;
+    let mut cumulative_regret = 0.0;
+
+    for ep in 0..config.episodes_per_level {
+        let pc = PuzzleGeneratorConfig {
+            min_difficulty: 1,
+            max_difficulty: 10,
+            constraint_density: 3,
+            seed: Some(config.seed + ep as u64),
+            ..Default::default()
+        };
+        let mut gen = PuzzleGenerator::new(pc);
+        let puzzles = gen.generate_batch(config.tasks_per_episode)?;
+        let mut ep_correct = 0;
+        let mut ep_steps = 0;
+        let mut ep_retries = 0;
+
+        for puzzle in &puzzles {
+            total_attempted += 1;
+            raw.tasks_attempted += 1;
+
+            let (solve_p, is_noisy) = if rng.next_f64() < config.noise_rate {
+                inject_noise(puzzle, &mut rng)
+            } else {
+                (puzzle.clone(), false)
+            };
+
+            let mut result = solver.solve(&solve_p)?;
+
+            // Retry on failure
+            if !result.correct && is_noisy {
+                for _ in 0..config.max_retries {
+                    let retry = solver.solve(puzzle)?;
+                    ep_retries += 1;
+                    if retry.correct { result = retry; break; }
+                }
+            }
+
+            if result.solved { raw.tasks_completed += 1; }
+            if result.correct { raw.tasks_correct += 1; ep_correct += 1; total_correct += 1; }
+            raw.total_steps += result.steps;
+            raw.total_tool_calls += result.tool_calls;
+            ep_steps += result.steps;
+            track_difficulty(&mut raw, puzzle.difficulty, &result);
+        }
+
+        let accuracy = ep_correct as f64 / config.tasks_per_episode as f64;
+        let regret = 100.0 - accuracy * 100.0;
+        cumulative_regret += regret;
+        raw.episodes.push(EpisodeMetrics {
+            episode: ep + 1, accuracy, reward: accuracy * 100.0, regret, cumulative_regret,
+        });
+        snapshots.push(EpisodeSnapshot { episode: ep + 1, accuracy, steps: ep_steps, retries: ep_retries });
+
+        if config.verbose {
+            println!("    L1 Ep {:2}: acc={:.1}%", ep + 1, accuracy * 100.0);
+        }
+    }
+
+    // Transfer learned knowledge back to bank
+    *bank = solver.reasoning_bank.clone();
+    let patterns = bank.learning_progress().patterns_learned;
+
+    Ok(LevelRaw { raw_metrics: raw, episodes: snapshots, total_correct, total_attempted, patterns })
+}
+
+/// Level 2: Meta-Learning — learns optimal hyperparameters per problem class.
+fn run_level_2(config: &SIConfig, bank: &mut ReasoningBank, meta: &mut MetaParams) -> Result<LevelRaw> {
+    let mut raw = RawMetrics::default();
+    let mut snapshots = Vec::new();
+    let mut solver = AdaptiveSolver::with_reasoning_bank(bank.clone());
+    let mut rng = Rng64::new(config.seed.wrapping_add(200));
+    let mut total_correct = 0usize;
+    let mut total_attempted = 0usize;
+    let mut cumulative_regret = 0.0;
+
+    for ep in 0..config.episodes_per_level {
+        let pc = PuzzleGeneratorConfig {
+            // Ramp difficulty floor
+            min_difficulty: 1 + (ep as u8 * 9 / config.episodes_per_level.max(1) as u8),
+            max_difficulty: 10,
+            constraint_density: 3,
+            seed: Some(config.seed + 1000 + ep as u64),
+            ..Default::default()
+        };
+        let mut gen = PuzzleGenerator::new(pc);
+        let puzzles = gen.generate_batch(config.tasks_per_episode)?;
+        let mut ep_correct = 0;
+        let mut ep_steps = 0;
+        let mut ep_retries = 0;
+        let mut step_budget_remaining = config.step_budget;
+
+        for (ti, puzzle) in puzzles.iter().enumerate() {
+            total_attempted += 1;
+            raw.tasks_attempted += 1;
+
+            let (solve_p, is_noisy) = if rng.next_f64() < config.noise_rate {
+                inject_noise(puzzle, &mut rng)
+            } else {
+                (puzzle.clone(), false)
+            };
+
+            // Meta-learned step allocation
+            let remaining_tasks = (config.tasks_per_episode - ti).max(1);
+            let per_task = meta.optimal_steps(puzzle.difficulty, step_budget_remaining, remaining_tasks);
+            solver.external_step_limit = Some(per_task);
+            step_budget_remaining = step_budget_remaining.saturating_sub(per_task);
+
+            let mut result = solver.solve(&solve_p)?;
+            let mut retried = false;
+
+            // Meta-learned retry decision
+            if !result.correct && meta.should_retry() {
+                if is_noisy {
+                    let retry = solver.solve(puzzle)?;
+                    ep_retries += 1;
+                    retried = true;
+                    if retry.correct { result = retry; }
+                } else {
+                    // Retry with doubled steps
+                    solver.external_step_limit = Some(per_task * 2);
+                    let retry = solver.solve(puzzle)?;
+                    solver.external_step_limit = Some(per_task);
+                    ep_retries += 1;
+                    retried = true;
+                    if retry.correct { result = retry; }
+                }
+            }
+
+            meta.learn_from_result(puzzle.difficulty, result.steps, result.correct, retried);
+
+            if result.solved { raw.tasks_completed += 1; }
+            if result.correct { raw.tasks_correct += 1; ep_correct += 1; total_correct += 1; }
+            raw.total_steps += result.steps;
+            raw.total_tool_calls += result.tool_calls;
+            ep_steps += result.steps;
+            track_difficulty(&mut raw, puzzle.difficulty, &result);
+        }
+
+        let accuracy = ep_correct as f64 / config.tasks_per_episode as f64;
+        let regret = 100.0 - accuracy * 100.0;
+        cumulative_regret += regret;
+        raw.episodes.push(EpisodeMetrics {
+            episode: ep + 1, accuracy, reward: accuracy * 100.0, regret, cumulative_regret,
+        });
+        snapshots.push(EpisodeSnapshot { episode: ep + 1, accuracy, steps: ep_steps, retries: ep_retries });
+
+        if config.verbose {
+            println!("    L2 Ep {:2}: acc={:.1}%, retry_ben={:.2}", ep + 1, accuracy * 100.0, meta.retry_benefit);
+        }
+    }
+
+    *bank = solver.reasoning_bank.clone();
+    let patterns = bank.learning_progress().patterns_learned;
+    Ok(LevelRaw { raw_metrics: raw, episodes: snapshots, total_correct, total_attempted, patterns })
+}
+
+/// Level 3: Ensemble Arbiter — multiple strategies vote on each puzzle.
+fn run_level_3(config: &SIConfig, bank: &mut ReasoningBank, meta: &MetaParams) -> Result<LevelRaw> {
+    let mut raw = RawMetrics::default();
+    let mut snapshots = Vec::new();
+    let mut ensemble = StrategyEnsemble::new(config.ensemble_size, bank);
+    let mut rng = Rng64::new(config.seed.wrapping_add(300));
+    let mut total_correct = 0usize;
+    let mut total_attempted = 0usize;
+    let mut cumulative_regret = 0.0;
+
+    for ep in 0..config.episodes_per_level {
+        let pc = PuzzleGeneratorConfig {
+            min_difficulty: 3, max_difficulty: 10,
+            constraint_density: 3,
+            seed: Some(config.seed + 2000 + ep as u64),
+            ..Default::default()
+        };
+        let mut gen = PuzzleGenerator::new(pc);
+        let puzzles = gen.generate_batch(config.tasks_per_episode)?;
+        let mut ep_correct = 0;
+        let mut ep_steps = 0;
+
+        for puzzle in &puzzles {
+            total_attempted += 1;
+            raw.tasks_attempted += 1;
+
+            let (solve_p, is_noisy) = if rng.next_f64() < config.noise_rate {
+                inject_noise(puzzle, &mut rng)
+            } else {
+                (puzzle.clone(), false)
+            };
+
+            let mut result = ensemble.solve_ensemble(&solve_p)?;
+
+            // If noisy and failed, retry with clean puzzle
+            if !result.correct && is_noisy {
+                let retry = ensemble.solve_ensemble(puzzle)?;
+                if retry.correct { result = retry; }
+            }
+
+            if result.solved { raw.tasks_completed += 1; }
+            if result.correct { raw.tasks_correct += 1; ep_correct += 1; total_correct += 1; }
+            raw.total_steps += result.steps;
+            raw.total_tool_calls += result.tool_calls;
+            ep_steps += result.steps;
+            track_difficulty(&mut raw, puzzle.difficulty, &result);
+        }
+
+        let accuracy = ep_correct as f64 / config.tasks_per_episode as f64;
+        let regret = 100.0 - accuracy * 100.0;
+        cumulative_regret += regret;
+        raw.episodes.push(EpisodeMetrics {
+            episode: ep + 1, accuracy, reward: accuracy * 100.0, regret, cumulative_regret,
+        });
+        snapshots.push(EpisodeSnapshot { episode: ep + 1, accuracy, steps: ep_steps, retries: 0 });
+
+        if config.verbose {
+            println!("    L3 Ep {:2}: acc={:.1}%, consensus={:.2}", ep + 1, accuracy * 100.0, ensemble.consensus_strength());
+        }
+    }
+
+    // Merge ensemble knowledge back
+    *bank = ensemble.merge_knowledge();
+    let patterns = bank.learning_progress().patterns_learned;
+    Ok(LevelRaw { raw_metrics: raw, episodes: snapshots, total_correct, total_attempted, patterns })
+}
+
+/// Level 4: Recursive Self-Improvement — bootstrap from compiled knowledge.
+fn run_level_4(
+    config: &SIConfig, bank: &mut ReasoningBank,
+    meta: &mut MetaParams, compiler: &mut KnowledgeCompiler,
+) -> Result<LevelRaw> {
+    let mut raw = RawMetrics::default();
+    let mut snapshots = Vec::new();
+    let mut total_correct = 0usize;
+    let mut total_attempted = 0usize;
+    let mut cumulative_regret = 0.0;
+
+    for cycle in 0..config.recursive_cycles {
+        // Compile knowledge from all prior trajectories
+        compiler.compile_from_bank(bank);
+
+        let mut solver = AdaptiveSolver::with_reasoning_bank(bank.clone());
+        let mut rng = Rng64::new(config.seed.wrapping_add(400 + cycle as u64 * 100));
+        let eps = config.episodes_per_level / config.recursive_cycles.max(1);
+
+        for ep in 0..eps {
+            let pc = PuzzleGeneratorConfig {
+                min_difficulty: 4, max_difficulty: 10,
+                constraint_density: 4,
+                seed: Some(config.seed + 3000 + (cycle * 100 + ep) as u64),
+                ..Default::default()
+            };
+            let mut gen = PuzzleGenerator::new(pc);
+            let puzzles = gen.generate_batch(config.tasks_per_episode)?;
+            let mut ep_correct = 0;
+            let mut ep_steps = 0;
+            let mut ep_retries = 0;
+            let mut step_budget_remaining = config.step_budget;
+
+            for (ti, puzzle) in puzzles.iter().enumerate() {
+                total_attempted += 1;
+                raw.tasks_attempted += 1;
+
+                // Check compiled knowledge first (knowledge compiler fast path)
+                if let Some(compiled) = compiler.lookup_config(puzzle) {
+                    solver.solver_mut().calendar_tool = compiled.use_rewriting;
+                    solver.external_step_limit = Some(compiled.max_steps.max(5));
+                } else {
+                    let remaining = (config.tasks_per_episode - ti).max(1);
+                    let steps = meta.optimal_steps(puzzle.difficulty, step_budget_remaining, remaining);
+                    solver.external_step_limit = Some(steps);
+                    step_budget_remaining = step_budget_remaining.saturating_sub(steps);
+                }
+
+                let (solve_p, is_noisy) = if rng.next_f64() < config.noise_rate {
+                    inject_noise(puzzle, &mut rng)
+                } else {
+                    (puzzle.clone(), false)
+                };
+
+                let mut result = solver.solve(&solve_p)?;
+
+                if !result.correct {
+                    // Retry: noisy → clean; non-noisy → more steps
+                    if is_noisy {
+                        let retry = solver.solve(puzzle)?;
+                        ep_retries += 1;
+                        if retry.correct { result = retry; }
+                    } else {
+                        let saved = solver.external_step_limit;
+                        solver.external_step_limit = Some(saved.unwrap_or(100) * 2);
+                        let retry = solver.solve(puzzle)?;
+                        solver.external_step_limit = saved;
+                        ep_retries += 1;
+                        if retry.correct { result = retry; }
+                    }
+                }
+
+                meta.learn_from_result(puzzle.difficulty, result.steps, result.correct, ep_retries > 0);
+
+                if result.solved { raw.tasks_completed += 1; }
+                if result.correct { raw.tasks_correct += 1; ep_correct += 1; total_correct += 1; }
+                raw.total_steps += result.steps;
+                raw.total_tool_calls += result.tool_calls;
+                ep_steps += result.steps;
+                track_difficulty(&mut raw, puzzle.difficulty, &result);
+            }
+
+            let accuracy = ep_correct as f64 / config.tasks_per_episode as f64;
+            let regret = 100.0 - accuracy * 100.0;
+            cumulative_regret += regret;
+            raw.episodes.push(EpisodeMetrics {
+                episode: raw.episodes.len() + 1, accuracy, reward: accuracy * 100.0, regret, cumulative_regret,
+            });
+            snapshots.push(EpisodeSnapshot { episode: snapshots.len() + 1, accuracy, steps: ep_steps, retries: ep_retries });
+
+            if config.verbose {
+                println!("    L4 C{} Ep {:2}: acc={:.1}%, compiled_hit={:.0}%",
+                    cycle + 1, ep + 1, accuracy * 100.0, compiler.hit_rate() * 100.0);
+            }
+        }
+
+        // Feed back: solver knowledge becomes next cycle's input
+        *bank = solver.reasoning_bank.clone();
+    }
+
+    let patterns = bank.learning_progress().patterns_learned;
+    Ok(LevelRaw { raw_metrics: raw, episodes: snapshots, total_correct, total_attempted, patterns })
+}
+
+/// Level 5: Adversarial Growth + Cascade Reasoning.
+fn run_level_5(
+    config: &SIConfig, bank: &mut ReasoningBank,
+    meta: &mut MetaParams, compiler: &mut KnowledgeCompiler,
+    adversary: &mut AdversarialGenerator,
+) -> Result<LevelRaw> {
+    let mut raw = RawMetrics::default();
+    let mut snapshots = Vec::new();
+    let mut total_correct = 0usize;
+    let mut total_attempted = 0usize;
+    let mut cumulative_regret = 0.0;
+
+    compiler.compile_from_bank(bank);
+
+    let mut solver = AdaptiveSolver::with_reasoning_bank(bank.clone());
+    let mut cascade = CascadeReasoner::new();
+    let mut rng = Rng64::new(config.seed.wrapping_add(500));
+
+    for ep in 0..config.episodes_per_level {
+        // Adversarial difficulty: harder puzzles than any previous level
+        let base_diff = 5 + (ep as u8 * 5 / config.episodes_per_level.max(1) as u8);
+        let adv_diff = adversary.harden_difficulty(base_diff).min(10);
+
+        let pc = PuzzleGeneratorConfig {
+            min_difficulty: adv_diff.max(5),
+            max_difficulty: 10,
+            constraint_density: 4,
+            seed: Some(config.seed + 5000 + ep as u64),
+            ..Default::default()
+        };
+        let mut gen = PuzzleGenerator::new(pc);
+        let puzzles = gen.generate_batch(config.tasks_per_episode)?;
+        let mut ep_correct = 0;
+        let mut ep_steps = 0;
+        let mut ep_retries = 0;
+
+        for (ti, puzzle) in puzzles.iter().enumerate() {
+            total_attempted += 1;
+            raw.tasks_attempted += 1;
+
+            // Compiled fast path
+            if let Some(compiled) = compiler.lookup_config(puzzle) {
+                solver.solver_mut().calendar_tool = compiled.use_rewriting;
+                solver.external_step_limit = Some(compiled.max_steps.max(10));
+            } else {
+                solver.external_step_limit = Some(
+                    meta.optimal_steps(puzzle.difficulty, config.step_budget, config.tasks_per_episode - ti)
+                );
+            }
+
+            let (solve_p, is_noisy) = if rng.next_f64() < config.noise_rate * config.adversarial_pressure {
+                inject_noise(puzzle, &mut rng)
+            } else {
+                (puzzle.clone(), false)
+            };
+
+            // Cascade reasoning: multi-pass solve
+            let mut result = cascade.cascade_solve(&mut solver, &solve_p, 3)?;
+
+            // Error recovery on noisy puzzles
+            if !result.correct && is_noisy {
+                let retry = cascade.cascade_solve(&mut solver, puzzle, 2)?;
+                ep_retries += 1;
+                if retry.correct { result = retry; }
+            }
+
+            // Track weaknesses for adversarial learning
+            let ctypes: Vec<String> = puzzle.constraints.iter()
+                .map(|c| format!("{:?}", c).split('(').next().unwrap_or("?").to_string())
+                .collect();
+            adversary.learn_weakness(&ctypes, puzzle.difficulty, result.correct);
+            meta.learn_from_result(puzzle.difficulty, result.steps, result.correct, ep_retries > 0);
+
+            if result.solved { raw.tasks_completed += 1; }
+            if result.correct { raw.tasks_correct += 1; ep_correct += 1; total_correct += 1; }
+            raw.total_steps += result.steps;
+            raw.total_tool_calls += result.tool_calls;
+            ep_steps += result.steps;
+            track_difficulty(&mut raw, puzzle.difficulty, &result);
+        }
+
+        let accuracy = ep_correct as f64 / config.tasks_per_episode as f64;
+        let regret = 100.0 - accuracy * 100.0;
+        cumulative_regret += regret;
+        raw.episodes.push(EpisodeMetrics {
+            episode: ep + 1, accuracy, reward: accuracy * 100.0, regret, cumulative_regret,
+        });
+        snapshots.push(EpisodeSnapshot { episode: ep + 1, accuracy, steps: ep_steps, retries: ep_retries });
+
+        if config.verbose {
+            let weaks = adversary.top_weaknesses(1);
+            let weak_str = weaks.first().map(|(ct, d, n)| format!("{:?}@d{} ({}x)", ct, d, n)).unwrap_or_default();
+            println!("    L5 Ep {:2}: acc={:.1}%, adv_diff={}, cascade={}, weak={}",
+                ep + 1, accuracy * 100.0, adv_diff, cascade.passes, weak_str);
+        }
+    }
+
+    *bank = solver.reasoning_bank.clone();
+    let patterns = bank.learning_progress().patterns_learned;
+    Ok(LevelRaw { raw_metrics: raw, episodes: snapshots, total_correct, total_attempted, patterns })
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+fn track_difficulty(raw: &mut RawMetrics, difficulty: u8, result: &SolverResult) {
+    let entry = raw.by_difficulty.entry(difficulty).or_insert(DifficultyStats {
+        attempted: 0, completed: 0, correct: 0, avg_steps: 0.0,
+    });
+    entry.attempted += 1;
+    if result.solved { entry.completed += 1; }
+    if result.correct { entry.correct += 1; }
+}
+
+fn make_level_result(level: usize, name: &str, raw: &LevelRaw, iq: f64) -> LevelResult {
+    LevelResult {
+        level, name: name.to_string(), iq_score: iq,
+        accuracy: if raw.total_attempted > 0 { raw.total_correct as f64 / raw.total_attempted as f64 } else { 0.0 },
+        total_correct: raw.total_correct, total_attempted: raw.total_attempted,
+        patterns_learned: raw.patterns, episodes: raw.episodes.clone(),
+        raw_metrics: raw.raw_metrics.clone(),
+    }
+}
+
+fn build_pathway(levels: Vec<LevelResult>, iq_progression: Vec<f64>, config: &SIConfig) -> PathwayResult {
+    let peak_iq = iq_progression.iter().cloned().fold(0.0_f64, f64::max);
+    let peak_level = iq_progression.iter()
+        .enumerate()
+        .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
+        .map(|(i, _)| i + 1)
+        .unwrap_or(1);
+
+    PathwayResult {
+        levels, peak_iq, peak_level, iq_progression,
+        reached_target: peak_iq >= config.target_iq,
+        target_iq: config.target_iq,
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn meta_params_learning() {
+        let mut mp = MetaParams::new();
+        for _ in 0..10 {
+            mp.learn_from_result(5, 15, true, false);
+        }
+        let steps = mp.optimal_steps(5, 400, 20);
+        assert!(steps > 0 && steps < 400);
+    }
+
+    #[test]
+    fn knowledge_compiler_basic() {
+        let mut bank = ReasoningBank::new();
+        for i in 0..5 {
+            let mut traj = Trajectory::new(&format!("p{}", i), 5);
+            traj.constraint_types.push("InYear".to_string());
+            traj.record_attempt("2024-01-01".into(), 0.9, 10, 1, "default");
+            traj.set_verdict(Verdict::Success, None);
+            bank.record_trajectory(traj);
+        }
+        let mut compiler = KnowledgeCompiler::new();
+        compiler.compile_from_bank(&bank);
+        assert!(!compiler.signature_cache.is_empty());
+    }
+
+    #[test]
+    fn adversarial_generator_learns() {
+        let mut adv = AdversarialGenerator::new(1.5);
+        adv.learn_weakness(&["InMonth".to_string()], 8, false);
+        adv.learn_weakness(&["InMonth".to_string()], 8, false);
+        assert_eq!(adv.top_weaknesses(1).len(), 1);
+        assert_eq!(adv.top_weaknesses(1)[0].2, 2);
+    }
+
+    #[test]
+    fn rng64_deterministic() {
+        let mut a = Rng64::new(99);
+        let mut b = Rng64::new(99);
+        for _ in 0..50 {
+            assert_eq!(a.next_f64().to_bits(), b.next_f64().to_bits());
+        }
+    }
+
+    #[test]
+    fn iq_bar_rendering() {
+        let bar = iq_bar(85.0);
+        assert!(bar.contains("█"));
+    }
+
+    #[test]
+    fn pathway_runs_minimal() {
+        let config = SIConfig {
+            episodes_per_level: 2,
+            tasks_per_episode: 5,
+            recursive_cycles: 1,
+            ensemble_size: 2,
+            verbose: false,
+            ..Default::default()
+        };
+        let result = run_pathway(&config);
+        assert!(result.is_ok());
+        let r = result.unwrap();
+        assert_eq!(r.levels.len(), 5);
+        assert!(r.peak_iq > 0.0);
+    }
+}