pedalkernel_validate/

config.rs

//! YAML-based validation configuration.
//!
//! This module defines the configuration schema for validation test suites.
//! Configuration can be loaded from YAML files or constructed programmatically.
//!
//! # Configuration Structure
//!
//! ```yaml
//! global:
//!   sample_rate: 96000
//!   oversample: 4
//!   fft_size: 65536
//!
//! suites:
//!   linear:
//!     description: "Linear circuit tests"
//!     tests:
//!       rc_lowpass:
//!         circuit: "linear/rc_lowpass.pedal"
//!         description: "RC lowpass filter"
//!         signals:
//!           - type: impulse
//!             amplitude: 1.0
//!           - type: sine
//!             frequency: 1000.0
//!             duration: 0.1
//!         pass_criteria:
//!           normalized_rms_error_db: -60.0
//!           peak_error_db: -40.0
//! ```
//!
//! # Programmatic Usage
//!
//! ```rust
//! use pedalkernel_validate::config::{ValidationConfig, PassCriteria};
//!
//! // Load from file
//! // let config = ValidationConfig::load("validate.yaml").unwrap();
//!
//! // Or use defaults
//! let config = ValidationConfig::default_config();
//!
//! // Define custom pass criteria
//! let criteria = PassCriteria {
//!     normalized_rms_error_db: Some(-60.0),
//!     peak_error_db: Some(-40.0),
//!     thd_error_db: Some(1.0),
//!     ..Default::default()
//! };
//! ```

use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::path::Path;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum ConfigError {
    #[error("Failed to read config file: {0}")]
    IoError(#[from] std::io::Error),
    #[error("Failed to parse YAML: {0}")]
    YamlError(#[from] serde_yaml::Error),
}

/// Root configuration structure.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationConfig {
    pub global: GlobalConfig,
    pub suites: BTreeMap<String, TestSuite>,
}

/// Global settings for all tests.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GlobalConfig {
    #[serde(default = "default_sample_rate")]
    pub sample_rate: u32,
    #[serde(default = "default_oversample")]
    pub oversample: u32,
    #[serde(default = "default_fft_size")]
    pub fft_size: usize,
    /// Steady-state warmup trim: milliseconds to discard from the start of BOTH
    /// the WDF and golden signals before computing any metric (RMS, peak, THD,
    /// spectral).  Trimming happens at metric time; stored goldens are unaffected.
    ///
    /// Default: 10 ms.  Per-test overrides via `TestCase::warmup_trim_ms`.
    ///
    /// **Window math** (default settings: 96 kHz × 4× = 384 kHz internal):
    /// - 10 ms trim = 3840 samples removed.
    /// - Shortest signal = 50 ms = 19200 samples → 15360 remain (40 ms).
    /// - 1 kHz fundamental: 40 cycles in remaining window — adequate for both
    ///   THD (Blackman window needs ~5 cycles) and spectral resolution (25 Hz/bin).
    #[serde(default = "default_warmup_trim_ms")]
    pub warmup_trim_ms: f64,
    /// Steady-state SETTLE window in milliseconds: how long a coupling-cap /
    /// bias network must charge before its output reaches steady state.  Goldens
    /// (and the WDF side) are generated long enough to settle, and `settle_ms` of
    /// the head is discarded so EVERY metric is computed on the settled tail.
    ///
    /// Why this is distinct from `warmup_trim_ms`: a 10 ms trim only skips a
    /// fast turn-on transient.  An AC-coupled output with a 10 µF cap into a 10 k
    /// load has RC ≈ 100 ms, so it needs ~5–10 τ (0.5–1 s) to settle — measuring
    /// before that captures the DC charge-up ramp, not the gain.  Default 500 ms
    /// (= 5 τ for a 100 ms-RC coupling cap).  Slow circuits (e.g. the BA283 with
    /// two 10 µF caps) override per-test via [`TestCase::warmup_trim_ms`].
    ///
    /// The conservative default does not shorten any existing window: when the
    /// settle exceeds the signal length the trim clamps to the full slice, so
    /// short fast-settling tests are unaffected.
    #[serde(default = "default_settle_ms")]
    pub settle_ms: f64,
}

fn default_sample_rate() -> u32 {
    96000
}
fn default_oversample() -> u32 {
    4
}
fn default_fft_size() -> usize {
    65536
}
fn default_warmup_trim_ms() -> f64 {
    10.0
}
fn default_settle_ms() -> f64 {
    500.0
}

impl Default for GlobalConfig {
    fn default() -> Self {
        Self {
            sample_rate: default_sample_rate(),
            oversample: default_oversample(),
            fft_size: default_fft_size(),
            warmup_trim_ms: default_warmup_trim_ms(),
            settle_ms: default_settle_ms(),
        }
    }
}

/// A test suite (e.g., "linear", "nonlinear", "fairchild").
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestSuite {
    pub description: String,
    pub tests: BTreeMap<String, TestCase>,
}

/// A single test case.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TestCase {
    /// Path to the circuit file (.pedal for WDF, .spice for reference)
    pub circuit: String,
    pub description: String,
    pub signals: Vec<SignalConfig>,
    #[serde(default)]
    pub metrics: Vec<MetricConfig>,
    pub pass_criteria: PassCriteria,
    /// Per-test warmup trim in milliseconds.  `None` means use the global
    /// `GlobalConfig::warmup_trim_ms` value.
    #[serde(default)]
    pub warmup_trim_ms: Option<f64>,
    /// Pending-reference flag.  When `true` AND the golden `.npy` is missing,
    /// the test is reported as PENDING (skipped) and excluded from BOTH the
    /// passed count and the total in the pass-rate gate — so a committed test
    /// whose ngspice golden has not yet been generated does not move the gate
    /// denominator.  Once the golden file is dropped in, the test runs and is
    /// compared normally REGARDLESS of this flag (auto-activation, no code
    /// change).  A `false` (default) test with a missing golden still FAILS
    /// loudly, so accidental golden deletion is caught.
    #[serde(default)]
    pub pending_reference: bool,
    /// Path to the WDF `.pedal` source relative to the pedalkernel-pro repo root.
    ///
    /// Set this for circuits whose `.pedal` files are proprietary (live in
    /// `pedalkernel-pro`, never committed to the public engine repo).  When
    /// the public `circuit` path is not found in `--circuits`, the bootstrap
    /// command falls back to probing ancestor directories for
    /// `pedalkernel-pro/<pro_circuit_path>` via the same sibling-directory
    /// search used by `pro_pedal::load_pro_pedal_sub`.
    ///
    /// `None` means no private fallback: the circuit must exist at `circuit`.
    #[serde(default)]
    pub pro_circuit_path: Option<String>,
}

/// Signal configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SignalConfig {
    #[serde(rename = "impulse")]
    Impulse {
        #[serde(default = "default_amplitude")]
        amplitude: f64,
        #[serde(default)]
        label: Option<String>,
    },
    #[serde(rename = "sine")]
    Sine {
        frequency: f64,
        #[serde(default = "default_amplitude")]
        amplitude: f64,
        #[serde(default = "default_duration")]
        duration: f64,
        #[serde(default)]
        label: Option<String>,
    },
    #[serde(rename = "two_tone")]
    TwoTone {
        f1: f64,
        f2: f64,
        #[serde(default = "default_amplitude")]
        amplitude: f64,
        #[serde(default = "default_duration")]
        duration: f64,
        #[serde(default)]
        label: Option<String>,
    },
    #[serde(rename = "exp_sweep")]
    ExpSweep {
        f_start: f64,
        f_end: f64,
        #[serde(default = "default_amplitude")]
        amplitude: f64,
        #[serde(default = "default_sweep_duration")]
        duration: f64,
        #[serde(default)]
        label: Option<String>,
    },
    #[serde(rename = "silence")]
    Silence {
        #[serde(default = "default_duration")]
        duration: f64,
        #[serde(default)]
        label: Option<String>,
    },
    #[serde(rename = "tone_burst")]
    ToneBurst {
        frequency: f64,
        #[serde(default)]
        amplitude_dbvu: Option<f64>,
        #[serde(default = "default_amplitude")]
        amplitude: f64,
        on_ms: f64,
        off_ms: f64,
        #[serde(default = "default_repetitions")]
        repetitions: usize,
        #[serde(default)]
        label: Option<String>,
    },
    #[serde(rename = "level_sweep")]
    LevelSweep {
        frequency: f64,
        levels_dbvu: Vec<f64>,
        #[serde(default = "default_duration_per_level")]
        duration_per_level: f64,
        #[serde(default)]
        label: Option<String>,
    },
}

fn default_amplitude() -> f64 {
    1.0
}
fn default_duration() -> f64 {
    0.1
}
fn default_sweep_duration() -> f64 {
    1.0
}
fn default_repetitions() -> usize {
    1
}
fn default_duration_per_level() -> f64 {
    0.5
}

impl SignalConfig {
    /// Get the label for this signal.
    pub fn label(&self) -> String {
        match self {
            SignalConfig::Impulse { label, .. } => {
                label.clone().unwrap_or_else(|| "impulse".to_string())
            }
            SignalConfig::Sine { label, .. } => label.clone().unwrap_or_else(|| "sine".to_string()),
            SignalConfig::TwoTone { label, .. } => {
                label.clone().unwrap_or_else(|| "two_tone".to_string())
            }
            SignalConfig::ExpSweep { label, .. } => {
                label.clone().unwrap_or_else(|| "sweep".to_string())
            }
            SignalConfig::Silence { label, .. } => {
                label.clone().unwrap_or_else(|| "silence".to_string())
            }
            SignalConfig::ToneBurst { label, .. } => {
                label.clone().unwrap_or_else(|| "burst".to_string())
            }
            SignalConfig::LevelSweep { label, .. } => {
                label.clone().unwrap_or_else(|| "level_sweep".to_string())
            }
        }
    }

    /// Convert to a SignalSpec for generation.
    pub fn to_spec(&self) -> crate::signals::SignalSpec {
        use crate::signals::SignalSpec;
        match self {
            SignalConfig::Impulse { amplitude, .. } => SignalSpec::Impulse {
                amplitude: *amplitude,
            },
            SignalConfig::Sine {
                frequency,
                amplitude,
                duration,
                ..
            } => SignalSpec::Sine {
                frequency: *frequency,
                amplitude: *amplitude,
                duration: *duration,
            },
            SignalConfig::TwoTone {
                f1,
                f2,
                amplitude,
                duration,
                ..
            } => SignalSpec::TwoTone {
                f1: *f1,
                f2: *f2,
                amplitude: *amplitude,
                duration: *duration,
            },
            SignalConfig::ExpSweep {
                f_start,
                f_end,
                amplitude,
                duration,
                ..
            } => SignalSpec::ExpSweep {
                f_start: *f_start,
                f_end: *f_end,
                amplitude: *amplitude,
                duration: *duration,
            },
            SignalConfig::Silence { duration, .. } => SignalSpec::Silence {
                duration: *duration,
            },
            SignalConfig::ToneBurst {
                frequency,
                amplitude_dbvu,
                amplitude,
                on_ms,
                off_ms,
                repetitions,
                ..
            } => {
                let amp = amplitude_dbvu
                    .map(crate::signals::dbvu_to_peak)
                    .unwrap_or(*amplitude);
                SignalSpec::ToneBurst {
                    frequency: *frequency,
                    amplitude: amp,
                    on_ms: *on_ms,
                    off_ms: *off_ms,
                    repetitions: *repetitions,
                }
            }
            SignalConfig::LevelSweep {
                frequency,
                levels_dbvu,
                duration_per_level,
                ..
            } => SignalSpec::LevelSweep {
                frequency: *frequency,
                levels_dbvu: levels_dbvu.clone(),
                duration_per_level: *duration_per_level,
            },
        }
    }

    /// Get the fundamental frequency if applicable (for THD measurement).
    pub fn fundamental_hz(&self) -> Option<f64> {
        match self {
            SignalConfig::Sine { frequency, .. } => Some(*frequency),
            SignalConfig::TwoTone { f1, .. } => Some(*f1),
            SignalConfig::ToneBurst { frequency, .. } => Some(*frequency),
            SignalConfig::LevelSweep { frequency, .. } => Some(*frequency),
            _ => None,
        }
    }
}

/// Metric type configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum MetricConfig {
    #[serde(rename = "time_domain")]
    TimeDomain,
    #[serde(rename = "thd")]
    Thd { fundamental: f64 },
    #[serde(rename = "imd")]
    Imd { f1: f64, f2: f64 },
    #[serde(rename = "spectral")]
    Spectral,
    #[serde(rename = "even_odd_ratio")]
    EvenOddRatio,
    #[serde(rename = "dc_drift")]
    DcDrift,
    #[serde(rename = "transfer_function")]
    TransferFunction { reference: String },
}

/// Validation intent bucket for interpreting pass/fail thresholds.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ValidationProfile {
    /// Tight numerical equivalence gate. A pass means the engine should be
    /// considered regression-clean against the reference.
    Strict,
    /// Thresholds are set from the currently measured SPICE/WDF gap plus margin.
    MeasuredMargin,
    /// Behavioral smoke check: useful signal path coverage, but not a full
    /// harmonic/topology accuracy claim.
    Smoke,
    /// Known architectural or modeling gap intentionally kept visible.
    KnownGap,
    /// Reference or honest threshold is not ready yet; excluded from the gate
    /// when `pending_reference` is active and the golden is missing.
    Pending,
}

impl Default for ValidationProfile {
    fn default() -> Self {
        Self::MeasuredMargin
    }
}

impl ValidationProfile {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Strict => "strict",
            Self::MeasuredMargin => "measured_margin",
            Self::Smoke => "smoke",
            Self::KnownGap => "known_gap",
            Self::Pending => "pending",
        }
    }
}

/// Pass/fail criteria for a test.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PassCriteria {
    /// Maximum normalized RMS error in dB (e.g., -60.0)
    pub normalized_rms_error_db: Option<f64>,
    /// Maximum peak error in dB (e.g., -40.0)
    pub peak_error_db: Option<f64>,
    /// Maximum THD difference in dB (e.g., 1.0)
    pub thd_error_db: Option<f64>,
    /// Maximum THD+N difference in dB (includes broadband noise/intermod)
    #[serde(default)]
    pub thd_plus_n_error_db: Option<f64>,
    /// Maximum per-harmonic magnitude error in dB (gated at −100 dBFS)
    #[serde(default)]
    pub harmonic_mag_error_db: Option<f64>,
    /// Maximum even/odd ratio error in dB
    #[serde(default)]
    pub even_odd_ratio_error_db: Option<f64>,
    /// Maximum spectral error in dB (e.g., 3.0)
    pub spectral_error_db: Option<f64>,
    /// Maximum DC drift in mV
    pub max_dc_drift_mv: Option<f64>,
    /// Maximum magnitude error for transfer function in dB
    pub max_magnitude_error_db: Option<f64>,
    /// Maximum phase error in degrees
    pub max_phase_error_deg: Option<f64>,
}

impl TestCase {
    /// Resolve the effective warmup trim in milliseconds, preferring the
    /// per-test override when set, otherwise falling back to the global value.
    pub fn effective_warmup_trim_ms(&self, global: &GlobalConfig) -> f64 {
        self.warmup_trim_ms.unwrap_or(global.warmup_trim_ms)
    }

    /// Resolve the effective STEADY-STATE settle window in milliseconds.
    ///
    /// A per-test `warmup_trim_ms` override IS that test's settle window (a slow
    /// circuit sets it explicitly, e.g. 800 ms for the BA283's 10 µF coupling
    /// caps); otherwise the conservative `GlobalConfig::settle_ms` default
    /// applies.  Generators run long enough to cover this window and metrics are
    /// computed only on the settled tail past it.
    pub fn effective_settle_ms(&self, global: &GlobalConfig) -> f64 {
        self.warmup_trim_ms.unwrap_or(global.settle_ms)
    }

    /// Classify the test into a reporting bucket without changing pass/fail
    /// behavior. This keeps threshold intent visible while legacy configs are
    /// migrated toward explicit profiles.
    pub fn effective_profile(&self, suite_name: &str, test_name: &str) -> ValidationProfile {
        // Hot-drive tests expose known WDF square-law FET/MOSFET model gaps vs
        // SPICE Shockley/Level-1 models in the nonlinear region.  The gap is
        // expected and intentional (measuring it is the purpose of the test),
        // so classify as KnownGap regardless of suite or pending_reference flag.
        // This prevents hot tests from inflating the MeasuredMargin regression gate
        // and ensures the bucket is visible even when pending_reference was used
        // during initial golden generation.
        if test_name.ends_with("_hot") {
            return ValidationProfile::KnownGap;
        }

        if self.pending_reference {
            return ValidationProfile::Pending;
        }

        if suite_name == "compressor" {
            return ValidationProfile::KnownGap;
        }
        if suite_name == "stress" {
            return ValidationProfile::Smoke;
        }
        if suite_name == "tubes" && test_name == "single_ended_el34" {
            return ValidationProfile::Smoke;
        }

        match suite_name {
            "linear" | "opamp" | "canonical" | "eq" | "tape" | "extraction" => {
                ValidationProfile::Strict
            }
            "active" | "nonlinear" | "pedals" | "reactive" | "tubes" => {
                ValidationProfile::MeasuredMargin
            }
            _ => {
                let loose_rms = self
                    .pass_criteria
                    .normalized_rms_error_db
                    .is_some_and(|threshold| threshold >= 10.0);
                let loose_peak = self
                    .pass_criteria
                    .peak_error_db
                    .is_some_and(|threshold| threshold >= 10.0);
                if loose_rms || loose_peak {
                    ValidationProfile::KnownGap
                } else {
                    ValidationProfile::MeasuredMargin
                }
            }
        }
    }
}

impl ValidationConfig {
    /// Load configuration from a YAML file.
    pub fn load(path: impl AsRef<Path>) -> Result<Self, ConfigError> {
        let contents = std::fs::read_to_string(path)?;
        let config: Self = serde_yaml::from_str(&contents)?;
        Ok(config)
    }

    /// Create a default configuration with the standard test suites.
    pub fn default_config() -> Self {
        Self {
            global: GlobalConfig::default(),
            suites: default_suites(),
        }
    }
}

/// Create default test suites matching the SPICE harness.
fn default_suites() -> BTreeMap<String, TestSuite> {
    let mut suites = BTreeMap::new();

    // Linear suite
    suites.insert(
        "linear".to_string(),
        TestSuite {
            description: "Linear circuit transfer function validation".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // Simplest possible - pure resistor divider
                tests.insert(
                    "resistor_divider".to_string(),
                    TestCase {
                        circuit: "linear/resistor_divider.pedal".to_string(),
                        description: "Resistor divider, 10k/10k, expected -6dB".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-60.0),
                            peak_error_db: Some(-50.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests.insert(
                    "rc_lowpass".to_string(),
                    TestCase {
                        circuit: "linear/rc_lowpass.pedal".to_string(),
                        description: "First-order RC lowpass, R=10k C=10n, fc≈1.59kHz".to_string(),
                        signals: vec![
                            SignalConfig::Impulse {
                                amplitude: 1.0,
                                label: Some("impulse".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-40.0),
                            peak_error_db: Some(-30.0),
                            spectral_error_db: Some(1.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests.insert(
                    "rc_highpass".to_string(),
                    TestCase {
                        circuit: "linear/rc_highpass.pedal".to_string(),
                        description: "First-order RC highpass, R=10k C=100n, fc≈159Hz".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-40.0),
                            // Long SPICE PWL sweeps are capped for runtime, so the
                            // high-frequency chirp tail carries a small peak-only
                            // interpolation residual even when RMS/spectral match.
                            peak_error_db: Some(-25.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests.insert(
                    "rl_lowpass".to_string(),
                    TestCase {
                        circuit: "linear/rl_lowpass.pedal".to_string(),
                        description: "First-order RL lowpass, R=1k L=100mH, fc≈1.59kHz".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-40.0),
                            peak_error_db: Some(-30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Nonlinear suite
    suites.insert(
        "nonlinear".to_string(),
        TestSuite {
            description: "Nonlinear circuit SPICE comparison".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // Simplest nonlinear - single diode
                // WDF vs SPICE: ~2-3dB difference is expected due to algorithm differences
                tests.insert(
                    "single_diode".to_string(),
                    TestCase {
                        circuit: "nonlinear/single_diode.pedal".to_string(),
                        description: "Single diode half-wave rectifier".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -10.4dB / Peak -8.3dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-7.0),
                            peak_error_db: Some(-5.0),
                            // THD measured 4.04dB; 1N4148 diode model vs SPICE Shockley
                            // coefficients differ slightly. 3dB margin over measured.
                            thd_error_db: Some(8.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Anti-parallel diodes without input cap
                // WDF vs SPICE: ~3-4dB difference is expected
                tests.insert(
                    "diode_no_cap".to_string(),
                    TestCase {
                        circuit: "nonlinear/diode_no_cap.pedal".to_string(),
                        description: "Diode clipper without input coupling cap".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.05,
                                label: Some("low_level".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 5.0,
                                duration: 0.05,
                                label: Some("clipping".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: worst RMS -11.9dB (clipping) / Peak -8.7dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-9.0),
                            peak_error_db: Some(-6.0),
                            // low_level THD 21dB: near noise-floor, THD undefined at 0.5Vpk into
                            // diodes far from conduction threshold. clipping THD 0.23dB: well-defined.
                            // Gate at 25dB to capture the meaningful clipping case.
                            thd_error_db: Some(25.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Symmetric diode clipper with input coupling cap.
                // ENGINE GAP: peak error reaches +7dB on sweep — WDF diode model diverges
                // from SPICE Shockley model on the clipping knee. Tracked as a real failure.
                tests.insert(
                    "diode_clipper".to_string(),
                    TestCase {
                        circuit: "nonlinear/diode_clipper.pedal".to_string(),
                        description: "Symmetric Si diode clipper".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.05,
                                label: Some("low_level".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 5.0,
                                duration: 0.05,
                                label: Some("clipping".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                duration: 1.0,
                                amplitude: 2.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                            MetricConfig::Spectral,
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: worst RMS -0.9dB (sweep) / Peak +7.0dB (sweep).
                            // Peak is positive — WDF clipping knee lags SPICE. Engine gap, not noise.
                            // Honest gate: requires WDF to be within 3dB of reference on RMS.
                            // Peak intentionally kept negative; sweep peak failure is expected until
                            // diode model is fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // low_level THD 21dB: THD undefined near noise floor (0.5Vpk sub-threshold).
                            // clipping THD 0.05dB: excellent. Gate at 25dB covers both.
                            thd_error_db: Some(25.0),
                            // Measured spectral: worst 169.3dB (low_level noise floor), 143.8dB (clipping),
                            // 39.4dB (sweep). The 169.3dB figure: sub-threshold signal (0.5Vpk) is
                            // near diode cutoff — spectral comparison undefined at noise floor.
                            // Gate at 175dB (measured worst + 6dB). Sweep spectral (39.4dB) is the
                            // meaningful case; 175dB also covers the noise-floor signal.
                            spectral_error_db: Some(175.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );
                // Zener diode clipper (back-to-back 5.1V zeners)
                // Tests zener breakdown behavior for hard clipping
                tests.insert(
                    "zener_clipper".to_string(),
                    TestCase {
                        circuit: "nonlinear/zener_clipper.pedal".to_string(),
                        description: "Symmetric 5.1V zener clipper".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.05,
                                label: Some("low_level".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 10.0, // Drive into zener clipping
                                duration: 0.05,
                                label: Some("clipping".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: RMS -7.7dB (clipping) / Peak +2.5dB (clipping).
                            // Peak is positive — zener knee mismatch. Engine gap.
                            // Honest gate: RMS must stay within 3dB of reference.
                            // Peak intentionally negative; clipping peak failure expected until
                            // zener model is improved.
                            normalized_rms_error_db: Some(-5.0),
                            peak_error_db: Some(-3.0),
                            // low_level THD 25dB: sub-threshold, THD undefined. clipping 0.21dB: excellent.
                            // Gate at 28dB covers both.
                            thd_error_db: Some(28.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // BEHAVIORAL SMOKE CHECK: this DSL circuit currently compiles through a
                // one-port TriodeRoot with the cathode network folded into the WDF tree.
                // The SPICE fixture is a true three-terminal common-cathode circuit, so
                // tight equivalence belongs in the TriodeThreePort/MultiNL workstream
                // tracked by pedalkernel-tgbz.
                tests.insert(
                    "common_cathode_12ax7".to_string(),
                    TestCase {
                        circuit: "nonlinear/common_cathode_12ax7.pedal".to_string(),
                        description: "Single 12AX7 triode, common cathode".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.125,
                                duration: 0.05,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.5,
                                duration: 0.05,
                                label: Some("driven".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                            MetricConfig::Spectral,
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS -0.1dB / Peak -0.8dB,
                            // driven RMS -2.8dB / Peak -4.1dB.
                            // Threshold = worst measured + 3dB margin = 2.9dB/2.2dB → 3.0dB.
                            normalized_rms_error_db: Some(3.0),
                            peak_error_db: Some(3.0),
                            // THD: clean 0.71dB, driven 1.64dB. Gate at 5dB (3.4dB margin).
                            // One-port TriodeRoot vs SPICE three-terminal — some THD difference
                            // expected until pedalkernel-tgbz MultiNL triode lands.
                            thd_error_db: Some(5.0),
                            // Spectral: clean 37.5dB, driven 131.5dB.
                            // driven spectral is large — overdriven triode spectrum diverges from
                            // SPICE 3-terminal model due to one-port topology mismatch.
                            // Gate at 140dB (measured worst + 8dB margin).
                            spectral_error_db: Some(140.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );
                tests
            },
        },
    );

    // Active device suite
    suites.insert(
        "active".to_string(),
        TestSuite {
            description: "Active device (JFET, BJT, triode) validation".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // KNOWN LIMITATION: JFET source follower topology isn't properly supported.
                // The WDF JFET model uses externally-controlled Vgs (for phasers), not
                // circuit-derived Vgs. In a source follower, Vgs = Vgate - Vsource creates
                // a feedback relationship that requires bidirectional modeling.
                // For now, we allow very loose criteria.
                tests.insert(
                    "jfet_source_follower".to_string(),
                    TestCase {
                        circuit: "active/jfet_source_follower.pedal".to_string(),
                        description: "JFET source follower (unity gain buffer) [LIMITED SUPPORT]"
                            .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.1,
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS 0.0dB / Peak 0.0dB.
                            // WDF output matches reference exactly. Threshold = measured + 1dB margin.
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(1.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // BEHAVIORAL SMOKE CHECK: clean signal and THD sanity are close, but the
                // saturated germanium PNP waveform still differs from the AC128
                // Gummel-Poon SPICE reference. Tight saturation equivalence is tracked
                // by pedalkernel-9q7t.
                tests.insert(
                    "fuzz_face_pnp".to_string(),
                    TestCase {
                        circuit: "active/fuzz_face_pnp.pedal".to_string(),
                        description: "Fuzz Face PNP germanium two-transistor fuzz".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 440.0,
                                amplitude: 0.05, // Low level for clean-ish
                                duration: 0.05,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 440.0,
                                amplitude: 0.5, // Drive into saturation
                                duration: 0.05,
                                label: Some("saturated".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd { fundamental: 440.0 },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS 1.1dB / Peak 1.4dB,
                            // saturated RMS 1.1dB / Peak 1.3dB.
                            // WDF PNP Gummel-Poon vs AC128 SPICE model: ~1dB amplitude offset.
                            // ENGINE GAP: positive RMS/peak — WDF output is louder than SPICE.
                            // Honest gate: WDF must stay within 4dB of reference (measured + 3dB).
                            // This will fail until BJT bias point / Gummel-Poon calibration is fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // THD: clean 34.8dB, saturated 63.7dB. These are large because the
                            // PNP bias point differs from SPICE — harmonic spectrum misaligned.
                            // Gate at 40dB (clean + 6dB margin). Saturated is a known gap.
                            thd_error_db: Some(40.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // BEHAVIORAL SMOKE CHECK: the DSL fixture uses a pentode pair plus
                // transformer, while the SPICE fixture is a simplified resistive
                // plate-load/differential-output model. Tight equivalence requires an
                // aligned reference topology and is tracked by pedalkernel-z57z.
                tests.insert(
                    "push_pull_6l6".to_string(),
                    TestCase {
                        circuit: "active/push_pull_6l6.pedal".to_string(),
                        description: "Push-pull 6L6GC pentode output stage".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 440.0,
                            amplitude: 1.0,
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -0.0dB / Peak -0.0dB.
                            // WDF output matches reference almost exactly in amplitude.
                            // Previous +45dB threshold was ~178x error allowance — completely inverted.
                            // Honest gate: threshold = measured + 1dB margin = 1.0dB.
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(1.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Phase all-pass stage (single stage from Phase 90)
                // Tests JFET variable resistance + op-amp buffer
                tests.insert(
                    "phase_allpass_stage".to_string(),
                    TestCase {
                        circuit: "active/phase_allpass_stage.pedal".to_string(),
                        description: "Single JFET all-pass stage (phaser building block)"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.05,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 100.0,
                                f_end: 10000.0,
                                amplitude: 0.5,
                                duration: 0.5,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS 0.0dB / Peak 0.0dB (passes),
                            // sweep RMS 0.0dB / Peak 0.0dB (passes on time-domain).
                            // Time-domain match is excellent. Threshold = measured + 1dB = 1.0dB.
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(1.0),
                            // Spectral: sine 238.5dB, sweep 280.5dB. The 280.5dB figure is
                            // a numerical artifact from the Blackman-windowed FFT on a pure
                            // swept sine — the spectral metric is not meaningful for a sweep
                            // signal and should not gate this test. Gate at 300dB (pass-through).
                            // TODO: disable spectral metric for sweep signals.
                            spectral_error_db: Some(300.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Optical attenuator (VTL5C3 photocoupler)
                // Tests photocoupler LDR behavior
                tests.insert(
                    "optical_attenuator".to_string(),
                    TestCase {
                        circuit: "active/optical_attenuator.pedal".to_string(),
                        description: "VTL5C3 photocoupler optical attenuator".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -48.0dB / Peak -16.7dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-45.0),
                            peak_error_db: Some(-13.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // NMOS common source amplifier (2N7000)
                // Tests enhancement-mode MOSFET modeling
                tests.insert(
                    "nmos_common_source".to_string(),
                    TestCase {
                        circuit: "active/nmos_common_source.pedal".to_string(),
                        description: "2N7000 NMOS common source amplifier".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.1, // Small signal for linear operation
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -0.3dB / Peak -0.2dB.
                            // Threshold = measured + 2dB margin = 1.7dB/1.8dB → round to 2.0dB.
                            normalized_rms_error_db: Some(2.0),
                            peak_error_db: Some(2.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // PMOS source follower (BS250)
                // Tests P-channel enhancement-mode MOSFET modeling
                tests.insert(
                    "pmos_source_follower".to_string(),
                    TestCase {
                        circuit: "active/pmos_source_follower.pedal".to_string(),
                        description: "BS250 PMOS source follower buffer".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.5,
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS 0.0dB / Peak 0.7dB.
                            // Peak slightly positive — PMOS Vgs model differs from SPICE by ~0.7dB.
                            // Threshold = measured + 2dB margin = 2.0dB/2.7dB → 3.0dB peak.
                            normalized_rms_error_db: Some(2.0),
                            peak_error_db: Some(3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // NPN common emitter amplifier (2N3904)
                // Tests NPN BJT modeling - complements the PNP fuzz face test
                tests.insert(
                    "npn_common_emitter".to_string(),
                    TestCase {
                        circuit: "active/npn_common_emitter.pedal".to_string(),
                        description: "2N3904 NPN common emitter gain stage".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.05, // Small signal for linear operation
                                duration: 0.05,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.3, // Drive harder
                                duration: 0.05,
                                label: Some("driven".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS -0.1dB / Peak -0.1dB,
                            // driven RMS -0.5dB / Peak -0.3dB. All near-zero — engine matches well.
                            // Threshold = worst measured + 2dB margin → 1.9dB, round to 2.0dB.
                            normalized_rms_error_db: Some(2.0),
                            peak_error_db: Some(2.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Silicon 2-BJT shunt-feedback amp ("silicon fuzz") — co-solve reference.
                // Two DC-coupled 2N3904 common-emitter stages with GLOBAL DEGENERATIVE
                // feedback (Q2 emitter -> Rf -> Q1 base). The feedback resistor Rf forces
                // BOTH transistors into ONE grouped-Newton MultiNl group (4 NL ports), the
                // trustworthy stable-mid-rail co-solve vehicle that replaces the bistable
                // xref_feedback_amp. ngspice .op: nout ~4.35 V mid-rail, both BJTs active,
                // holds flat. Any level gap is the separate input-impedance investigation.
                tests.insert(
                    "si_fb_amp".to_string(),
                    TestCase {
                        circuit: "active/si_fb_amp.pedal".to_string(),
                        description: "2N3904 2-BJT global shunt-feedback amp (co-solve reference)"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.01, // small signal — linear co-solve region
                                duration: 0.05,
                                label: Some("clean".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Generous bounds: the point of this reference is a CLEAN, STABLE
                            // co-solving bias, not a tight level match. There IS a large level
                            // gap here — ngspice small-signal gain is ~+49 dB (277x), WDF is
                            // ~0 dB (unity), i.e. ~49 dB low. That is the banked adapted-input-
                            // port-impedance investigation (hardcoded 1000 Ohm input port; same
                            // family as the ba283 -49.5 dB gap), NOT a bias error.
                            //
                            // NOTE on the metric: normalized_rms_error_db = rms(wdf-ref)/rms(ref).
                            // Because the WDF output is ~49 dB BELOW the ngspice golden, wdf-ref
                            // ~= -ref, so the ratio ~= 1 and the metric reads ~0 dB. This ~0 dB is
                            // the DEGENERATE "WDF ~silent vs reference" reading, NOT a waveform
                            // match. The trustworthy comparison is the explicit gain measurement
                            // in tests/si_fb_amp_cosolve.rs (WDF ~0 dB vs ngspice +49 dB).
                            normalized_rms_error_db: Some(12.0),
                            peak_error_db: Some(12.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // PNP common emitter amplifier (2N3906)
                // Tests PNP BJT modeling - essential for Fuzz Face, vintage fuzzes
                tests.insert(
                    "pnp_common_emitter".to_string(),
                    TestCase {
                        circuit: "active/pnp_common_emitter.pedal".to_string(),
                        description: "2N3906 PNP common emitter gain stage".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.05, // Small signal for linear operation
                                duration: 0.05,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.3, // Drive harder
                                duration: 0.05,
                                label: Some("driven".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS 0.0dB / Peak 0.1dB,
                            // driven RMS 0.0dB / Peak 0.4dB. Near-zero — engine matches well.
                            // Threshold = worst measured + 2dB margin = 2.0/2.4dB → 2.5dB.
                            normalized_rms_error_db: Some(2.0),
                            peak_error_db: Some(2.5),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // OTA (CA3080) voltage-controlled amplifier — tanh transconductance
                // Tests nonlinear soft-clip saturation for compressors/VCAs.
                // SPICE deck: Bota behavioral B-source (tanh), Iabc=100uA, Vt=26mV.
                // clean (5mV): tanh(5mV/52mV)=0.096 — linear region (<1% THD).
                // hot  (0.5V): tanh(500mV/52mV)≈1.0 — fully saturated.
                // Goldens regenerated 2026-06-16 with nonlinear deck (Phase A).
                // pending_reference: true — WDF engine uses linear VCCS, so
                // clean/hot WDF vs SPICE comparison is tracked in Phase B.
                tests.insert(
                    "ota_ca3080".to_string(),
                    TestCase {
                        circuit: "active/ota_ca3080.pedal".to_string(),
                        description: "CA3080 OTA: tanh soft-clip, clean vs hot drive".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.005, // 5mV — near-linear region
                                duration: 0.05,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5, // 500mV — fully saturated
                                duration: 0.05,
                                label: Some("hot".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd { fundamental: 1000.0 },
                        ],
                        pass_criteria: PassCriteria {
                            // Goldens are SPICE tanh deck. WDF engine (Phase B) will close this gap.
                            // Wide gate: WDF uses linear model — large divergence expected on hot.
                            normalized_rms_error_db: Some(40.0),
                            peak_error_db: Some(40.0),
                            thd_error_db: Some(40.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: true,
                        pro_circuit_path: None,
                    },
                );

                // ── HOT variants — drive each FET/MOSFET device into its nonlinear region ──
                //
                // Each _hot TestCase reuses the SAME circuit deck as the clean variant.
                // Amplitude is chosen to push the device beyond its linear operating region:
                //   jfet_source_follower_hot : 2.0V — large gate swing forcing Vgs near
                //     VTO=-2.0V; source follower compresses/saturates.
                //   nmos_common_source_hot   : 0.5V — ~5-15x gain → drain clips on 9V rail.
                //   pmos_source_follower_hot : 0.6V — just above the 0.5V clean; PMOS
                //     enters partial cutoff on negative half-cycle (hard asymmetric clip).
                //
                // Part B (dcy4.4) will set honest thresholds after measuring the WDF gap.
                // The gated distortion metrics (thd_plus_n_error_db, harmonic_mag_error_db,
                // even_odd_ratio_error_db) are filled in by Part B once goldens exist.
                // pending_reference=true so a missing ngspice golden is PENDING, not FAIL.
                tests.insert(
                    "jfet_source_follower_hot".to_string(),
                    TestCase {
                        circuit: "active/jfet_source_follower.pedal".to_string(),
                        description:
                            "JFET source follower (2N5457) driven hot — 2.0V pushes Vgs near VTO=-2.0V"
                                .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            // 2.0V: large enough to saturate the source follower; VDD=9V,
                            // VTO=-2.0V, source resistor 2.2k — gate swing exceeds Vgs
                            // linear range on negative half-cycle.
                            amplitude: 2.0,
                            duration: 0.05,
                            label: Some("hot".to_string()),
                        }],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd { fundamental: 1000.0 },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-16: RMS -1.8dB / Peak 1.0dB / THD_err 3.59dB /
                            // THD+N_err 1.89dB / HarmMag 24.47dB / EO_ratio_err 0.58dB.
                            // WDF JFET square-law model vs SPICE: amplitude close but harmonic
                            // spectrum diverges in nonlinear region (HarmMag 24dB gap expected).
                            // Threshold = measured + 3–5dB margin.
                            normalized_rms_error_db: Some(4.0),
                            peak_error_db: Some(4.0),
                            thd_error_db: Some(7.0),
                            thd_plus_n_error_db: Some(5.0),
                            harmonic_mag_error_db: Some(30.0),
                            even_odd_ratio_error_db: Some(4.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: true,
                        pro_circuit_path: None,
                    },
                );

                tests.insert(
                    "nmos_common_source_hot".to_string(),
                    TestCase {
                        circuit: "active/nmos_common_source.pedal".to_string(),
                        description:
                            "2N7000 NMOS common source driven hot — 0.5V input clips on 9V rail"
                                .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            // 0.5V: gain ~5-15x means drain clips on 9V rail.  VDD=9V,
                            // VTO=2.1V, gate biased ~3.6V — 0.5V swing drives transistor
                            // between subthreshold and hard saturation.
                            amplitude: 0.5,
                            duration: 0.05,
                            label: Some("hot".to_string()),
                        }],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd { fundamental: 1000.0 },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-16: RMS 7.1dB / Peak 10.2dB / THD_err 8.90dB /
                            // THD+N_err 9.06dB / HarmMag 30.62dB / EO_ratio_err 1.92dB.
                            // KnownGap: WDF NMOS Level-1 square-law model cannot reproduce the
                            // rail-clipping harmonic spectrum that SPICE generates in saturation.
                            // Amplitude offset (+7dB RMS) reflects different operating point.
                            // Threshold = measured + 3–5dB margin.
                            normalized_rms_error_db: Some(10.5),
                            peak_error_db: Some(13.5),
                            thd_error_db: Some(12.0),
                            thd_plus_n_error_db: Some(12.5),
                            harmonic_mag_error_db: Some(36.0),
                            even_odd_ratio_error_db: Some(5.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: true,
                        pro_circuit_path: None,
                    },
                );

                tests.insert(
                    "pmos_source_follower_hot".to_string(),
                    TestCase {
                        circuit: "active/pmos_source_follower.pedal".to_string(),
                        description:
                            "BS250 PMOS source follower driven hot — 0.6V into cutoff region"
                                .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            // 0.6V: VDD=9V, BS250 VTO=-3.5V, source follower. Clean at 0.5V
                            // already shows -6.4 dB THD (asymmetric source swing). 0.6V
                            // pushes PMOS into partial cutoff on negative half-cycle, creating
                            // hard asymmetric clipping. Larger amplitudes (0.8V+) cause
                            // near-total cutoff, making the THD metric undefined.
                            amplitude: 0.6,
                            duration: 0.05,
                            label: Some("hot".to_string()),
                        }],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd { fundamental: 1000.0 },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-16: RMS -16.8dB / Peak -10.4dB / THD_err 6.72dB /
                            // THD+N_err 29.78dB / HarmMag 0.00dB / EO_ratio_err 3.71dB.
                            // WDF square-law PMOS model: output is linear (no cutoff) while ngspice
                            // clamps to ~6.25V DC floor (PMOS enters cutoff at 0.6V input).
                            // Large THD+N error because ngspice output has near-zero fundamental
                            // (signal disappears in cutoff); WDF outputs coherent sine instead.
                            // KnownGap: PMOS cutoff modeling is not implemented in WDF Level-1.
                            // Threshold = measured + 3–5dB margin.
                            normalized_rms_error_db: Some(-14.0),
                            peak_error_db: Some(-8.0),
                            thd_error_db: Some(12.0),
                            thd_plus_n_error_db: Some(35.0),
                            harmonic_mag_error_db: Some(5.0),
                            even_odd_ratio_error_db: Some(7.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: true,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Stress suite
    suites.insert(
        "stress".to_string(),
        TestSuite {
            description: "Edge cases and stress conditions".to_string(),
            tests: {
                let mut tests = BTreeMap::new();
                tests.insert(
                    "dc_stability".to_string(),
                    TestCase {
                        circuit: "nonlinear/diode_clipper.pedal".to_string(),
                        description: "DC offset accumulation over long run".to_string(),
                        signals: vec![SignalConfig::Silence {
                            duration: 10.0,
                            label: Some("silence".to_string()),
                        }],
                        metrics: vec![MetricConfig::DcDrift],
                        pass_criteria: PassCriteria {
                            max_dc_drift_mv: Some(1.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );
                tests
            },
        },
    );

    // Reactive components suite (transformers, delay lines, LC filters)
    suites.insert(
        "reactive".to_string(),
        TestSuite {
            description: "Reactive component validation (transformers, delay, LC)".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // Transformer step-down (10:1)
                // Note: SPICE uses coupled inductors (k=0.99) which has frequency-dependent
                // behavior. Our model uses ideal voltage scaling. 5dB tolerance accounts for
                // coupling coefficient and frequency response differences at low frequencies.
                tests.insert(
                    "transformer_stepdown".to_string(),
                    TestCase {
                        circuit: "reactive/transformer_stepdown.pedal".to_string(),
                        description: "10:1 step-down transformer, expect 0.1x voltage".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-58.1), // Allow 5dB for coupling/freq effects
                            peak_error_db: Some(-45.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Transformer step-up (1:4)
                // Note: Same coupling coefficient tolerance as step-down.
                tests.insert(
                    "transformer_stepup".to_string(),
                    TestCase {
                        circuit: "reactive/transformer_stepup.pedal".to_string(),
                        description: "1:4 step-up transformer, expect 4x voltage".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.25,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-89.7), // Allow 5dB for coupling/freq effects
                            peak_error_db: Some(-89.2),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Simple delay line (10ms) with 50/50 wet/dry mix
                tests.insert(
                    "delay_simple".to_string(),
                    TestCase {
                        circuit: "reactive/delay_simple.pedal".to_string(),
                        description: "10ms delay line with wet/dry mix, tests time-domain accuracy"
                            .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("impulse".to_string()),
                        }],
                        metrics: vec![],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: impulse RMS 0.0dB / Peak 0.0dB.
                            // Delay line is exact — the WDF delay element matches reference perfectly.
                            // Threshold = measured + 1dB margin. 0.0 + 1.0 = 1.0dB.
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(1.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // LC resonant filter
                // WDF LC resonators have Q-factor differences due to bilinear transform
                // frequency warping. Allow 5dB tolerance for gain differences at resonance.
                tests.insert(
                    "lc_resonant".to_string(),
                    TestCase {
                        circuit: "reactive/lc_resonant.pedal".to_string(),
                        description: "Series LC bandpass at ~1.6kHz".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1592.0, // Resonant frequency
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("resonant".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 100.0,
                                f_end: 10000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: resonant RMS -44.9dB / Peak -23.4dB,
                            // sweep RMS -5.3dB / Peak +5.4dB.
                            // Peak on sweep is positive — bilinear-transform frequency warping at
                            // resonance causes peak gain offset vs SPICE. Engine gap.
                            // Honest gate: RMS within 3dB of reference (negative threshold).
                            // Peak intentionally negative; sweep peak failure expected until BLT
                            // pre-warping at resonance is fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Op-amp configuration suite
    suites.insert(
        "opamp".to_string(),
        TestSuite {
            description: "Op-amp circuit configuration validation".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // Inverting amplifier with gain = -10 (Rf/Ri = 100k/10k)
                tests.insert(
                    "inverting_gain10".to_string(),
                    TestCase {
                        circuit: "opamp/inverting_gain10.pedal".to_string(),
                        description: "Inverting amplifier, Rf/Ri=10, expect gain=-10".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.1, // Small signal to avoid clipping
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -31.6dB / Peak -16.9dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-28.0),
                            peak_error_db: Some(-13.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Non-inverting amplifier with gain = 10 (1 + Rf/Ri = 1 + 90k/10k)
                tests.insert(
                    "noninverting_gain10".to_string(),
                    TestCase {
                        circuit: "opamp/noninverting_gain10.pedal".to_string(),
                        description: "Non-inverting amplifier, 1+Rf/Ri=10, expect gain=10"
                            .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.1, // Small signal to avoid clipping
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -31.6dB / Peak -16.9dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-28.0),
                            peak_error_db: Some(-13.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Unity gain buffer (voltage follower)
                tests.insert(
                    "unity_buffer".to_string(),
                    TestCase {
                        circuit: "opamp/unity_buffer.pedal".to_string(),
                        description: "Unity gain buffer (voltage follower), expect gain=1"
                            .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -49.8dB / Peak -16.7dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-46.0),
                            peak_error_db: Some(-13.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Inverting summing amplifier (single input test, gain = -1)
                tests.insert(
                    "summing_inverting".to_string(),
                    TestCase {
                        circuit: "opamp/summing_inverting.pedal".to_string(),
                        description: "Inverting summing amplifier, single input, gain=-1"
                            .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -31.6dB / Peak -16.7dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-28.0),
                            peak_error_db: Some(-13.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Difference amplifier (V2 grounded, so gain = 1)
                tests.insert(
                    "difference_amp".to_string(),
                    TestCase {
                        circuit: "opamp/difference_amp.pedal".to_string(),
                        description: "Difference amplifier, V2=0, expect gain=1".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS -31.6dB / Peak -16.7dB.
                            // Threshold = measured + 3dB margin.
                            normalized_rms_error_db: Some(-28.0),
                            peak_error_db: Some(-13.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Integrator (gain = 1 at 1kHz with R=10k, C=15.9nF)
                tests.insert(
                    "integrator".to_string(),
                    TestCase {
                        circuit: "opamp/integrator.pedal".to_string(),
                        description: "Integrator, RC gives gain~1 at 1kHz".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // Re-baselined 2026-07-21 (pedalkernel-foi, per kg3 investigation
                            // of PR #220): the ngspice golden is an IDEAL, railless VCVS
                            // integrator. The engine's real op-amp model has a small group-delay
                            // / phase difference vs that ideal golden, which the sample-aligned
                            // normalized_rms_error_db and peak_error_db metrics conflate with
                            // amplitude error — they are phase-sensitive. That made this
                            // circuit's pass/fail flip on PR #220 (a fix that moved rail
                            // saturation from per-state to output-only) even though #220 is
                            // MORE accurate on every physical axis (measured vs ngspice:
                            // main peak 0.72V/-2.84dB fund-gain/8.5% THD; #220 1.75V/-1.09dB/
                            // 5.2% THD; truth 1.99V/0dB/0.002% THD) — main only "passed" via
                            // lucky amplitude/phase cancellation in the sample-aligned diff.
                            //
                            // Switch to spectral_error_db: a phase-insensitive (FFT-magnitude,
                            // gated to significant bins) metric already used elsewhere in this
                            // config. Measured 2026-07-21: main=2.84dB, #220=1.09dB (#220 is
                            // BETTER). Threshold = worse-of-the-two (main, 2.84dB) + ~0.7dB
                            // margin = 3.5dB, so both the current engine and #220's fix pass
                            // honestly, and the metric no longer rewards phase-lucky output.
                            spectral_error_db: Some(3.5),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Extraction/control regression suite
    suites.insert(
        "extraction".to_string(),
        TestSuite {
            description: "Focused compiler extraction and control-routing regressions".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                tests.insert(
                    "active_feedback_treble_shelf".to_string(),
                    TestCase {
                        circuit: "extraction/active_feedback_treble_shelf.pedal".to_string(),
                        description: "Goldenrod-style op-amp feedback treble shelf with split pot"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 3000.0,
                                amplitude: 0.1,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 100.0,
                                f_end: 12000.0,
                                amplitude: 0.1,
                                duration: 0.1,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS 5.5dB / Peak 5.5dB,
                            // sweep RMS 5.2dB / Peak 5.0dB.
                            // ENGINE GAP: positive RMS/peak — treble shelf gain mismatch vs SPICE.
                            // Honest gate: WDF must be within 3dB of reference (negative threshold).
                            // Will fail until active-feedback treble shelf gain calibration fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // Spectral: sine 0.9dB, sweep 2.3dB. Gate at 3dB (1dB margin over sweep).
                            spectral_error_db: Some(3.3),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests.insert(
                    "passive_loaded_rc_lowpass".to_string(),
                    TestCase {
                        circuit: "extraction/passive_loaded_rc_lowpass.pedal".to_string(),
                        description: "Passive RC low-pass with explicit output load".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-35.0),
                            peak_error_db: Some(-25.0),
                            spectral_error_db: Some(1.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests.insert(
                    "output_wiper_divider".to_string(),
                    TestCase {
                        circuit: "extraction/output_wiper_divider.pedal".to_string(),
                        description: "Three-terminal output pot at default midpoint".to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 1.0,
                            duration: 0.1,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-50.0),
                            peak_error_db: Some(-40.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Unity-gain Sallen-Key low-pass (R=10k/10k, C=10n/10n, fc≈1.6 kHz).
                // Tracked by pedalkernel-ht0o; wired here so ngspice + WDF goldens
                // can be generated for the accuracy dashboard even while the
                // active-filter extraction work is in progress.
                tests.insert(
                    "sallen_key_lowpass".to_string(),
                    TestCase {
                        circuit: "extraction/sallen_key_lowpass.pedal".to_string(),
                        description: "Unity-gain Sallen-Key low-pass (R=10k/10k, C=10n/10n)"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 100.0,
                                f_end: 20000.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        // ENGINE GAP: Sallen-Key low-pass RMS 5.3dB / Peak 5.2dB (sine),
                        // sweep RMS 5.0dB / Peak 4.6dB. Active-filter extraction is broken —
                        // the op-amp feedback is not captured in the WDF tree.
                        // Honest gate: negative threshold; fails until active-filter fix lands.
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS 5.3dB / Peak 5.2dB,
                            // sweep RMS 5.0dB / Peak 4.6dB.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // Spectral: sine 1.5dB, sweep 2.9dB. Gate at 4dB.
                            spectral_error_db: Some(4.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Unity-gain Sallen-Key high-pass (C=10n/10n, R=10k/10k, fc≈1.6 kHz).
                tests.insert(
                    "sallen_key_highpass".to_string(),
                    TestCase {
                        circuit: "extraction/sallen_key_highpass.pedal".to_string(),
                        description: "Unity-gain Sallen-Key high-pass (C=10n/10n, R=10k/10k)"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 5000.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 100.0,
                                f_end: 20000.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS 9.4dB / Peak 9.4dB,
                            // sweep RMS 9.4dB / Peak 9.3dB. Large positive error — active-filter
                            // extraction gap (op-amp feedback not in WDF tree). Engine gap.
                            // Honest gate: negative threshold; fails until active-filter fix lands.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // Spectral: sine 5.8dB, sweep 27.9dB. Gate at 7dB (sine case).
                            // Sweep spectral fails (27.9dB measured). Honest gate here.
                            spectral_error_db: Some(7.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Rauch/MFB high-pass with controlled shunt leg.
                // Cutoff pot default 0.5 => position 0.525 => 52.5 kΩ shunt.
                tests.insert(
                    "mfb_highpass_controlled".to_string(),
                    TestCase {
                        circuit: "extraction/mfb_highpass_controlled.pedal".to_string(),
                        description:
                            "Rauch/MFB high-pass with controlled shunt (fc≈270 Hz at default)"
                                .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.1,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 100.0,
                                f_end: 20000.0,
                                amplitude: 0.1,
                                duration: 0.1,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine RMS 0.9dB / Peak 0.9dB,
                            // sweep RMS -0.0dB / Peak -0.0dB.
                            // ENGINE GAP: sweep spectral 40.1dB — MFB filter topology mismatch.
                            // RMS threshold = worst measured + 2dB = 2.9dB → 3.0dB.
                            normalized_rms_error_db: Some(3.0),
                            peak_error_db: Some(3.0),
                            // Spectral: sine 3.7dB, sweep 40.1dB. Gate at 5dB — sweep spectral FAILS
                            // honestly (40.1 > 5.0). Captures MFB spectral gap.
                            spectral_error_db: Some(5.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Classic pedals test suite
    suites.insert(
        "pedals".to_string(),
        TestSuite {
            description: "Classic pedal core circuit validation".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // Tube Screamer TS-808 core clipper
                // Op-amp with soft clipping diodes in feedback loop
                // NOTE: High tolerance until op-amp gain detection is implemented
                tests.insert(
                    "ts808_clipper".to_string(),
                    TestCase {
                        circuit: "pedals/ts808_clipper.pedal".to_string(),
                        description: "TS-808 core: op-amp with diode feedback clipping".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.1, // Low level - clean gain
                                duration: 0.1,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5, // Medium - soft clipping
                                duration: 0.1,
                                label: Some("clipping".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS 8.1dB / Peak 8.7dB,
                            // clipping RMS 7.6dB / Peak 8.4dB. Large positive error —
                            // op-amp gain not extracted, TS-808 drives at wrong level.
                            // ENGINE GAP: honest gate requires negative threshold; fails until
                            // op-amp gain detection (clipper feedback) is fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // THD: clean 2.12dB, clipping 0.93dB. Gate at 5dB (3dB margin).
                            thd_error_db: Some(5.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // ProCo RAT core clipper
                // Op-amp gain with hard clipping diodes to ground
                // NOTE: High tolerance until op-amp gain detection is implemented
                tests.insert(
                    "rat_clipper".to_string(),
                    TestCase {
                        circuit: "pedals/rat_clipper.pedal".to_string(),
                        description: "RAT core: op-amp with hard clipping to ground".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.05, // Low level - mostly clean
                                duration: 0.1,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.2, // Medium - hard clipping
                                duration: 0.1,
                                label: Some("clipping".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS 5.3dB / Peak 6.8dB,
                            // clipping RMS 3.4dB / Peak 6.1dB. Large positive error —
                            // op-amp gain not extracted, RAT drives at wrong level.
                            // ENGINE GAP: honest gate requires negative threshold; fails until
                            // op-amp gain detection (hard clipper) is fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // THD: clean 14.33dB, clipping 2.99dB. Gate at 18dB (clean + 4dB margin).
                            thd_error_db: Some(18.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Fuzz core - single transistor clipper
                // Common emitter driven into saturation
                // NOTE: High tolerance until BJT modeling is improved
                tests.insert(
                    "fuzz_core".to_string(),
                    TestCase {
                        circuit: "pedals/fuzz_core.pedal".to_string(),
                        description: "Fuzz core: transistor saturation clipping".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.01, // Very low - transistor linear region
                                duration: 0.1,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.1, // Push into saturation
                                duration: 0.1,
                                label: Some("saturated".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS 7.7dB / Peak 1.8dB,
                            // saturated RMS 26.8dB / Peak 12.4dB. Very large positive error —
                            // BJT single-transistor fuzz output amplitude massively wrong vs SPICE.
                            // ENGINE GAP: honest gate requires negative threshold; fails until
                            // BJT common-emitter bias point / saturation model is fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // THD: clean 110.65dB, saturated 58.39dB. Large because wrong operating
                            // point produces completely different harmonic spectrum. Gate at 115dB
                            // (clean + 5dB) to capture any regression vs the current error floor.
                            thd_error_db: Some(115.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // Big Muff single clipping stage
                // Transistor gain + diode clipping at collector
                // NOTE: High tolerance - 25dB error indicates gain mismatch
                tests.insert(
                    "bigmuff_stage".to_string(),
                    TestCase {
                        circuit: "pedals/bigmuff_stage.pedal".to_string(),
                        description: "Big Muff stage: transistor + diode clipping".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.01, // Low level
                                duration: 0.1,
                                label: Some("clean".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.1, // Clipping
                                duration: 0.1,
                                label: Some("clipping".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: clean RMS 70.2dB / Peak 50.7dB,
                            // clipping RMS 90.2dB / Peak 70.7dB. Catastrophic — BJT stage output
                            // is at completely wrong amplitude vs SPICE (likely gain mismatch ×1000).
                            // ENGINE GAP: honest gate requires negative threshold; fails loudly
                            // until BJT common-emitter + collector diode bias is fixed.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            // THD: clean 94.49dB, clipping 69.05dB. Wrong operating point means
                            // harmonic content is meaningless vs reference. Gate at 100dB (clean + 6dB).
                            thd_error_db: Some(100.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Canonical validation suite — 8 circuits systematically covering every WDF failure mode
    suites.insert(
        "canonical".to_string(),
        TestSuite {
            description: "Canonical circuits covering all WDF failure modes".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // 1. RC Lowpass — baseline bilinear-transform discretization
                tests.insert(
                    "rc_lowpass".to_string(),
                    TestCase {
                        circuit: "canonical/rc_lowpass.pedal".to_string(),
                        description: "RC lowpass baseline (R=10k, C=10n, fc≈1591Hz) — exact BLT match"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Impulse {
                                amplitude: 1.0,
                                label: Some("impulse".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-50.0),
                            peak_error_db: Some(-40.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // 2. RC Highpass — dual of lowpass, verify highpass discretization
                tests.insert(
                    "rc_highpass".to_string(),
                    TestCase {
                        circuit: "canonical/rc_highpass.pedal".to_string(),
                        description: "RC highpass (C=22n, R=33k, fc≈219Hz) — highpass BLT validation"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Impulse {
                                amplitude: 1.0,
                                label: Some("impulse".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-50.0),
                            peak_error_db: Some(-40.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // 3. Series RLC Bandpass — two reactive elements, series adaptor test
                tests.insert(
                    "series_rlc".to_string(),
                    TestCase {
                        circuit: "canonical/series_rlc.pedal".to_string(),
                        description:
                            "Series RLC bandpass (R=100, L=10mH, C=100nF, f0≈5033Hz) — inductor+capacitor"
                                .to_string(),
                        signals: vec![
                            SignalConfig::Impulse {
                                amplitude: 1.0,
                                label: Some("impulse".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 5000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-40.0),
                            peak_error_db: Some(-30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // 4. Twin-T Notch — 3+ reactive elements, adaptor scattering stress test
                tests.insert(
                    "twin_t_notch".to_string(),
                    TestCase {
                        circuit: "canonical/twin_t_notch.pedal".to_string(),
                        description:
                            "Twin-T notch (R=10k, C=10nF, f_notch≈1591Hz) — scattering accuracy"
                                .to_string(),
                        signals: vec![
                            SignalConfig::Impulse {
                                amplitude: 1.0,
                                label: Some("impulse".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1500.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-30.0),
                            peak_error_db: Some(-20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // 5. Transformer + Load — coupled inductors test
                tests.insert(
                    "transformer_load".to_string(),
                    TestCase {
                        circuit: "canonical/transformer_load.pedal".to_string(),
                        description:
                            "Transformer 1:2 + 1k load — coupled inductor WDF element"
                                .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 1.0,
                                duration: 0.1,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-20.0),
                            peak_error_db: Some(-15.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // 6. Single Diode Half-Wave Rectifier — basic NR convergence
                // THD tolerance is loose (200dB) because THD comparison is not
                // meaningful at low signal levels. Tighten when SPICE golden refs
                // are generated with `generate-spice --suite canonical`.
                tests.insert(
                    "single_diode".to_string(),
                    TestCase {
                        circuit: "canonical/single_diode.pedal".to_string(),
                        description:
                            "Single diode rectifier (R=4.7k, D=1N4148, RL=47k) — NR convergence"
                                .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.05,
                                label: Some("mild_clipping".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 2.0,
                                duration: 0.05,
                                label: Some("hard_clipping".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 1.0,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: mild_clipping RMS -25.6dB / Peak -26.9dB,
                            // hard_clipping RMS -40.1dB / Peak -40.7dB, sweep RMS -5.2dB / Peak +0.2dB.
                            // Worst RMS: -5.2dB (sweep). Threshold = -5.2 + 2dB = -3.2dB → -3.0dB.
                            // Sweep peak: +0.2dB. Threshold = 0.2 + 2dB = 2.2dB → 2.5dB.
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(2.5),
                            // THD: mild_clipping 0.15dB, hard_clipping 0.04dB. Excellent match.
                            // Gate at 2dB (1.85dB margin over worst measured).
                            thd_error_db: Some(2.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // 7. Op-Amp Feedback Diode Clipper — gain-stage + NR interaction
                // THD tolerance is loose (200dB) because THD comparison is not
                // meaningful at low signal levels. Tighten when SPICE golden refs
                // are generated with `generate-spice --suite canonical`.
                tests.insert(
                    "opamp_diode_clipper".to_string(),
                    TestCase {
                        circuit: "canonical/opamp_diode_clipper.pedal".to_string(),
                        description:
                            "Op-amp diode clipper (Rin=10k, Rfb=100k, gain=-10) — feedback NL interaction"
                                .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.05,
                                duration: 0.1,
                                label: Some("linear".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("clipping".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 0.2,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: linear RMS 0.0dB / Peak 0.8dB,
                            // clipping RMS 0.1dB / Peak 1.2dB, sweep RMS 0.1dB / Peak 1.2dB.
                            // Near-zero RMS, ~1dB peak offset from op-amp gain scaling.
                            // Threshold = worst measured + 2dB margin = 2.1dB/3.2dB → 3.5dB peak.
                            normalized_rms_error_db: Some(2.5),
                            peak_error_db: Some(3.5),
                            // THD: linear 7.82dB, clipping 22.2dB.
                            // Clipping THD 22.2dB is a known op-amp feedback NL solver gap.
                            // Gate at 25dB (clipping + 3dB margin) — covers both signals.
                            thd_error_db: Some(25.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // 8. BJT Differential Pair — multi-NL coupled transistors
                // THD tolerance is loose (200dB) because at 10mV input the signal
                // is near the noise floor and THD comparison is meaningless.
                // Tighten when SPICE golden refs are available.
                tests.insert(
                    "bjt_diff_pair".to_string(),
                    TestCase {
                        circuit: "canonical/bjt_diff_pair.pedal".to_string(),
                        description:
                            "BJT diff pair (2x 2N3904, RC=10k, R_tail=10k, 12V) — coupled NL solver"
                                .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.01,
                                duration: 0.05,
                                label: Some("linear".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.1,
                                duration: 0.05,
                                label: Some("soft_clipping".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 0.05,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: linear RMS -0.0dB / Peak -0.0dB,
                            // soft_clipping RMS -0.0dB / Peak -0.0dB, sweep RMS 0.1dB / Peak -0.1dB.
                            // Excellent match — coupled BJT solver is working well.
                            // Threshold = worst measured + 2dB margin = 2.1dB/1.9dB → 2.5dB.
                            normalized_rms_error_db: Some(2.5),
                            peak_error_db: Some(2.5),
                            // THD: linear 114dB (near noise floor, signal too small for meaningful THD),
                            // soft_clipping 91.5dB. Gate at 120dB — THD not meaningful at 10mV input.
                            thd_error_db: Some(120.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Tape suite — voltage-driven Jiles-Atherton tape-head saturation.
    //
    // The tape head is a J-A magnetics element (same family as the magnetics_
    // external transformer-core validation), but voltage-driven so it saturates
    // at line level. It gets its own `tape` suite to keep the magnetics J-A
    // *core* validation (current-driven, external LTspice CHAN golden) distinct
    // from the *head* validation (voltage-driven, ngspice behavioural golden).
    suites.insert(
        "tape".to_string(),
        TestSuite {
            description: "Tape-head Jiles-Atherton saturation validation".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // Validated against the committed ngspice behavioural J-A golden
                // (see spice-circuits/tape/tape_head_saturation.spice and
                // docs/tape-head-validation.md). Active in the gate (not pending).
                //
                // PASSES at the real match tolerances below. The earlier "known
                // divergence" (clean RMS -4.1dB / saturated spectral 33dB) was NOT
                // an engine/model defect: bead pedalkernel-x0mv Phase 0 traced it
                // to a NETLIST topology mismatch — the .pedal wired the head in
                // SERIES while this golden deck models it as a SHUNT at v_out.
                // Rewiring the .pedal to the shunt topology the deck documents
                // makes the WDF output match the golden to ~70 dB on both labels;
                // the J-A element itself is unchanged.
                tests.insert(
                    "tape_head_saturation".to_string(),
                    TestCase {
                        circuit: "tape/tape_head_saturation.pedal".to_string(),
                        description:
                            "Voltage-driven J-A tape head: clean->saturated vs ngspice (shunt topology, matches reference)"
                                .to_string(),
                        signals: vec![
                            // Clean: well below the ~1 V J-A knee.
                            SignalConfig::Sine {
                                frequency: 120.0,
                                amplitude: 0.1,
                                duration: 0.05,
                                label: Some("clean".to_string()),
                            },
                            // Hot: into saturation, several * the knee.
                            SignalConfig::Sine {
                                frequency: 120.0,
                                amplitude: 2.0,
                                duration: 0.05,
                                label: Some("saturated".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd { fundamental: 120.0 },
                        ],
                        pass_criteria: PassCriteria {
                            // Real match targets vs the ngspice J-A golden. The WDF
                            // tape head PASSES these comfortably once the .pedal is
                            // wired in the shunt topology the golden deck models
                            // (measured 2026-06-15 after the netlist fix: clean RMS
                            // -72dB/peak -73dB/spectral 0.2dB/THD 0.01dB, saturated
                            // RMS -70dB/peak -70dB/spectral 0.0dB/THD 0.0dB). The
                            // criteria are intentionally NOT loosened — the element
                            // matches the reference with ~64 dB of margin.
                            normalized_rms_error_db: Some(-6.0),
                            peak_error_db: Some(-6.0),
                            thd_error_db: Some(3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        // Golden generated from ngspice (2026-06-15). Active in the
                        // gate; not hidden behind pending_reference.
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Passive EQ suite — Pultec EQP-1A passive section (pedalkernel-hcpb.1 baseline)
    //
    // Five configs covering the key control states.  Goldens generated via ngspice
    // (generate-spice --suite eq).  The EXPECTED outcome is RED — the current WDF
    // engine does not render the passive RLC path correctly, and these tests quantify
    // how far off it is.  Do NOT loosen criteria to make them green; the gap IS the
    // deliverable.
    //
    // Pass criteria are intentionally tight (spectral -6dB, RMS -20dB) so any real
    // engine improvement registers as a tightening, not a no-op.  A failing test here
    // is correct and expected until the engine children (hcpb.2+) land.
    suites.insert(
        "eq".to_string(),
        TestSuite {
            description: "Pultec EQP-1A passive EQ section — ngspice baseline gap measurement"
                .to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // ── 1. FLAT ─────────────────────────────────────────────────────────
                // All controls off (position 0.0).  Establishes insertion-loss baseline.
                tests.insert(
                    "pultec_passive_flat".to_string(),
                    TestCase {
                        circuit: "eq/pultec_eqp1a_passive_flat.pedal".to_string(),
                        pending_reference: false,
                        pro_circuit_path: None,
                        description: "Pultec EQP-1A passive, flat (all controls off)".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("sine_1k".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 0.5,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        // Measured 2026-06-15: sine_1k RMS -76.9dB / Peak -76.8dB / spectral 0.0dB,
                        // sweep RMS -48.3dB / Peak -46.0dB / spectral 1.1dB.
                        // Passive RLC path matches reference well. Honest gate = worst + 3dB margin.
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-45.0),
                            peak_error_db: Some(-43.0),
                            spectral_error_db: Some(3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(50.0),
                    },
                );

                // ── 2. LF BOOST ─────────────────────────────────────────────────────
                // LF_Boost=1.0; measures whether L_lf shelving lift appears.
                tests.insert(
                    "pultec_passive_lf_boost".to_string(),
                    TestCase {
                        circuit: "eq/pultec_eqp1a_passive_lf_boost.pedal".to_string(),
                        pending_reference: false,
                        pro_circuit_path: None,
                        description: "Pultec EQP-1A passive, LF boost on (LF_Boost=1.0)".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 60.0,
                                amplitude: 0.5,
                                duration: 0.5,
                                label: Some("sine_60".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 0.5,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine_60 RMS -103.7dB / Peak -102.8dB / spectral 0.0dB,
                            // sweep RMS -48.3dB / Peak -46.0dB / spectral 1.1dB.
                            // Threshold = worst measured + 3dB margin.
                            normalized_rms_error_db: Some(-45.0),
                            peak_error_db: Some(-43.0),
                            spectral_error_db: Some(3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(100.0),
                    },
                );

                // ── 3. LF TRICK ─────────────────────────────────────────────────────
                // LF_Boost=1.0 + LF_Atten=1.0; the famous boost-below/dip-above shape.
                tests.insert(
                    "pultec_passive_lf_trick".to_string(),
                    TestCase {
                        circuit: "eq/pultec_eqp1a_passive_lf_trick.pedal".to_string(),
                        pending_reference: false,
                        pro_circuit_path: None,
                        description: "Pultec EQP-1A passive, LF trick (Boost+Atten=1.0)".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 60.0,
                                amplitude: 0.5,
                                duration: 0.5,
                                label: Some("sine_60".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 0.5,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine_60 RMS -103.7dB / Peak -102.0dB / spectral 0.0dB,
                            // sweep RMS -47.8dB / Peak -46.1dB / spectral 2.2dB.
                            // Threshold = worst measured + 3dB margin.
                            normalized_rms_error_db: Some(-44.0),
                            peak_error_db: Some(-43.0),
                            spectral_error_db: Some(5.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(100.0),
                    },
                );

                // ── 4. HF BOOST ─────────────────────────────────────────────────────
                // HF_Boost=1.0; measures whether the L_hf||KCS tank resonant peak forms.
                // Resonance at f0 = 1/(2π√(47m·5.6n)) ≈ 3.1 kHz.
                tests.insert(
                    "pultec_passive_hf_boost".to_string(),
                    TestCase {
                        circuit: "eq/pultec_eqp1a_passive_hf_boost.pedal".to_string(),
                        pending_reference: false,
                        pro_circuit_path: None,
                        description: "Pultec EQP-1A passive, HF boost on (HF_Boost=1.0, f0≈3.1kHz)".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 3100.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("sine_3k1".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 0.5,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine_3k1 RMS -68.3dB / Peak -68.0dB / spectral 0.0dB,
                            // sweep RMS -65.4dB / Peak -55.3dB / spectral 0.1dB.
                            // Threshold = worst measured + 3dB margin.
                            normalized_rms_error_db: Some(-62.0),
                            peak_error_db: Some(-52.0),
                            spectral_error_db: Some(2.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(50.0),
                    },
                );

                // ── 5. HF ATTEN ─────────────────────────────────────────────────────
                // HF_Atten=1.0; measures HFA_sel cap shelf cut.
                tests.insert(
                    "pultec_passive_hf_atten".to_string(),
                    TestCase {
                        circuit: "eq/pultec_eqp1a_passive_hf_atten.pedal".to_string(),
                        pending_reference: false,
                        pro_circuit_path: None,
                        description: "Pultec EQP-1A passive, HF atten on (HF_Atten=1.0)".to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 10000.0,
                                amplitude: 0.5,
                                duration: 0.1,
                                label: Some("sine_10k".to_string()),
                            },
                            SignalConfig::ExpSweep {
                                f_start: 20.0,
                                f_end: 20000.0,
                                amplitude: 0.5,
                                duration: 1.0,
                                label: Some("sweep".to_string()),
                            },
                        ],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-15: sine_10k RMS -46.5dB / Peak -46.4dB / spectral 0.0dB,
                            // sweep RMS -49.9dB / Peak -48.2dB / spectral 0.5dB.
                            // Threshold = worst measured + 3dB margin.
                            normalized_rms_error_db: Some(-43.0),
                            peak_error_db: Some(-43.0),
                            spectral_error_db: Some(2.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(50.0),
                    },
                );

                tests
            },
        },
    );

    // Compressor suite — FET Leveler (1176-style) ngspice gap measurement.
    //
    // Two stimuli characterize the feedback-compression path:
    //   1. LevelSweep  — static gain/GR curve (9 levels, -40..0 dBVU)
    //   2. ToneBurst   — attack/release timing (500 ms burst @ -6 dBVU)
    //
    // The EXPECTED outcome is an illuminating gap: ngspice shows ~4.2 dB GR
    // and real attack/release ballistics; the WDF engine produces ~0 dB GR
    // because the feedback compressor path is broken (audit gap G5 family,
    // see reports/outboard-gear-audit-2026-06-12.md §6).
    //
    // Pass criteria are intentionally tight (time_domain only) so the gap
    // registers as a delta, not a hidden pass.  A failing test here is correct
    // and expected until the engine's makeup-gain/feedback-detector fixes land.
    suites.insert(
        "compressor".to_string(),
        TestSuite {
            description:
                "FET Leveler (1176-style) — ngspice dynamics baseline vs WDF engine gap".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // ── 1. LEVEL SWEEP ──────────────────────────────────────────
                // 9 input levels from -40 to 0 dBVU at 1 kHz, 0.5 s each.
                // Measures static gain/GR curve; ngspice ~4.2 dB GR over
                // the sweep; WDF engine currently ~0 dB GR.
                tests.insert(
                    "fet_leveler_level_sweep".to_string(),
                    TestCase {
                        pending_reference: false,
                        pro_circuit_path: None,
                        circuit: "compressor/fet_leveler.pedal".to_string(),
                        description:
                            "FET Leveler 1176-style: static gain curve (-40..0 dBVU, 9 levels)"
                                .to_string(),
                        signals: vec![SignalConfig::LevelSweep {
                            frequency: 1000.0,
                            levels_dbvu: (-40..=0)
                                .step_by(5)
                                .map(|l| l as f64)
                                .collect(),
                            duration_per_level: 0.5,
                            label: Some("level_sweep".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        // ENGINE GAP: measured 2026-06-15: level_sweep RMS 0.0dB / Peak 0.0dB.
                        // WDF produces no gain reduction — compressor feedback detector broken.
                        // Honest gate: WDF must match reference within 3dB (negative threshold).
                        // This FAILS until the BJT makeup-gain + FET feedback detector is fixed.
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(200.0),
                    },
                );

                // ── 2. TONE BURST ──────────────────────────────────────────
                // 500 ms on / 2000 ms off, -6 dBVU, 1 repetition.
                // Measures attack/release transient shape.  ngspice: attack
                // ~5-10 ms (25k×220n=5.5 ms RC), release ~1-2 s (5M×220n=1.1 s).
                // WDF engine: no compression means attack/release are ~0 ms.
                tests.insert(
                    "fet_leveler_tone_burst".to_string(),
                    TestCase {
                        pending_reference: false,
                        pro_circuit_path: None,
                        circuit: "compressor/fet_leveler.pedal".to_string(),
                        description:
                            "FET Leveler 1176-style: attack/release timing via tone burst"
                                .to_string(),
                        signals: vec![SignalConfig::ToneBurst {
                            frequency: 1000.0,
                            amplitude_dbvu: Some(-6.0),
                            amplitude: 0.5,    // fallback (unused when amplitude_dbvu set)
                            on_ms: 500.0,
                            off_ms: 2000.0,
                            repetitions: 1,
                            label: Some("tone_burst".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        // ENGINE GAP: measured 2026-06-15: tone_burst RMS 0.0dB / Peak 0.1dB.
                        // WDF produces no gain reduction transient. Peak 0.1dB means the WDF
                        // output amplitude is identical to input — no compression.
                        // Honest gate: requires match within 3dB; FAILS until GR fixed.
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(-3.0),
                            peak_error_db: Some(-3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(100.0),
                    },
                );

                // ── 3. DYNA COMP (MXR CA3080 OTA) ──────────────────────────
                // pending_reference: true until goldens land from generate-spice.
                // Pass criteria are PLACEHOLDERS — reconcile with kyem.1 honest
                // values once that bead lands and the engine dyna_comp is wired.
                // KNOWN CONFLICT: this entry will need a rebase when kyem.1 lands.
                tests.insert(
                    "dyna_comp_level_sweep".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/dyna_comp.pedal".to_string(),
                        description:
                            "Dyna Comp (CA3080 OTA): static gain curve (-40..0 dBVU, 9 levels)"
                                .to_string(),
                        signals: vec![SignalConfig::LevelSweep {
                            frequency: 1000.0,
                            levels_dbvu: (-40..=0)
                                .step_by(5)
                                .map(|l| l as f64)
                                .collect(),
                            duration_per_level: 0.5,
                            label: Some("level_sweep".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(200.0),
                    },
                );

                tests.insert(
                    "dyna_comp_tone_burst".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/dyna_comp.pedal".to_string(),
                        description:
                            "Dyna Comp (CA3080 OTA): attack/release timing via tone burst"
                                .to_string(),
                        signals: vec![SignalConfig::ToneBurst {
                            frequency: 1000.0,
                            amplitude_dbvu: Some(-6.0),
                            amplitude: 0.5,
                            on_ms: 500.0,
                            off_ms: 2000.0,
                            repetitions: 1,
                            label: Some("tone_burst".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(100.0),
                    },
                );

                // ── 4. VCA BUS COMP (SSL/dbx-style SSM2164) ────────────────
                tests.insert(
                    "vca_bus_comp_level_sweep".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/vca_bus_comp.pedal".to_string(),
                        description:
                            "VCA Bus Comp (SSM2164): static gain curve (-40..0 dBVU, 9 levels)"
                                .to_string(),
                        signals: vec![SignalConfig::LevelSweep {
                            frequency: 1000.0,
                            levels_dbvu: (-40..=0)
                                .step_by(5)
                                .map(|l| l as f64)
                                .collect(),
                            duration_per_level: 0.5,
                            label: Some("level_sweep".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(200.0),
                    },
                );

                tests.insert(
                    "vca_bus_comp_tone_burst".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/vca_bus_comp.pedal".to_string(),
                        description:
                            "VCA Bus Comp (SSM2164): attack/release timing via tone burst"
                                .to_string(),
                        signals: vec![SignalConfig::ToneBurst {
                            frequency: 1000.0,
                            amplitude_dbvu: Some(-6.0),
                            amplitude: 0.5,
                            on_ms: 500.0,
                            off_ms: 2000.0,
                            repetitions: 1,
                            label: Some("tone_burst".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(100.0),
                    },
                );

                // ── 5. LA-2A (T4B two-rate opto, 3 makeup triodes + 2 sidechain tubes) ──
                // NOTE: LA-2A has slow T4B opto tau (500ms fast / slow up to 500ms).
                // The LevelSweep uses 0.5s/level — the last few levels will be settling.
                // A ToneBurst with 2.5s settle is provided for attack/release timing.
                tests.insert(
                    "la2a_level_sweep".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/la2a.pedal".to_string(),
                        description:
                            "LA-2A T4B opto leveler: static gain curve (-40..0 dBVU, 9 levels)"
                                .to_string(),
                        signals: vec![SignalConfig::LevelSweep {
                            frequency: 1000.0,
                            levels_dbvu: (-40..=0)
                                .step_by(5)
                                .map(|l| l as f64)
                                .collect(),
                            duration_per_level: 0.5,
                            label: Some("level_sweep".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(200.0),
                    },
                );

                tests.insert(
                    "la2a_tone_burst".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/la2a.pedal".to_string(),
                        description:
                            "LA-2A T4B opto leveler: attack/release timing via tone burst"
                                .to_string(),
                        signals: vec![SignalConfig::ToneBurst {
                            frequency: 1000.0,
                            amplitude_dbvu: Some(-6.0),
                            amplitude: 0.5,
                            on_ms: 500.0,
                            off_ms: 2500.0,
                            repetitions: 1,
                            label: Some("tone_burst".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(100.0),
                    },
                );

                // ── 6. OPTO LEVELER (single 12AX7, T4B opto, feed-forward) ──
                // NOTE: opto_leveler has EF release tau 2.2s — slow settling.
                // ToneBurst uses 3000ms off to allow the EF to mostly settle.
                tests.insert(
                    "opto_leveler_level_sweep".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/opto_leveler.pedal".to_string(),
                        description:
                            "Opto Leveler (T4B, single 12AX7): static gain curve (-40..0 dBVU, 9 levels)"
                                .to_string(),
                        signals: vec![SignalConfig::LevelSweep {
                            frequency: 1000.0,
                            levels_dbvu: (-40..=0)
                                .step_by(5)
                                .map(|l| l as f64)
                                .collect(),
                            duration_per_level: 0.5,
                            label: Some("level_sweep".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(200.0),
                    },
                );

                tests.insert(
                    "opto_leveler_tone_burst".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/opto_leveler.pedal".to_string(),
                        description:
                            "Opto Leveler (T4B, single 12AX7): attack/release timing via tone burst"
                                .to_string(),
                        signals: vec![SignalConfig::ToneBurst {
                            frequency: 1000.0,
                            amplitude_dbvu: Some(-6.0),
                            amplitude: 0.5,
                            on_ms: 500.0,
                            off_ms: 3000.0,
                            repetitions: 1,
                            label: Some("tone_burst".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        pass_criteria: PassCriteria {
                            // PLACEHOLDER: tighten when kyem.1 lands with honest thresholds.
                            normalized_rms_error_db: Some(30.0),
                            peak_error_db: Some(30.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(100.0),
                    },
                );

                // ── HOT variant — FET Leveler driven hard to produce measurable compression ──
                //
                // Reuses the SAME compressor/fet_leveler.pedal deck as the level_sweep/
                // tone_burst tests above.  A fixed 2.0V sine at 1 kHz drives the input
                // well above the existing sweep max (0 dBVU ≈ 0.894 Vpk) so the feedback
                // detector envelope charges and the JFET attenuator enters deep gain
                // reduction in ngspice.  VCC=30V, so 2.0V is well within the rail.
                //
                // Purpose: verify that ngspice shows materially higher THD in the hot case
                // vs the clean level_sweep; the WDF engine gap (no GR) is the measured
                // delta for Part B honest thresholds.
                //
                // pending_reference=true: golden generated by Part A generate-spice run.
                tests.insert(
                    "fet_leveler_hot".to_string(),
                    TestCase {
                        pending_reference: true,
                        pro_circuit_path: None,
                        circuit: "compressor/fet_leveler.pedal".to_string(),
                        description:
                            "FET Leveler 1176-style driven hot — 2.0V sine, deep compression region"
                                .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            // 2.0V: well above 0 dBVU (0.894 Vpk); feedback detector envelope
                            // charges to full compression (VCC=30V, so no rail clip).  Drives
                            // JFET shunt from near-off into hard attenuation.
                            amplitude: 2.0,
                            duration: 0.5,
                            label: Some("hot".to_string()),
                        }],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd { fundamental: 1000.0 },
                        ],
                        pass_criteria: PassCriteria {
                            // Measured 2026-06-16: RMS 0.0dB / Peak 0.0dB / THD_err 76.24dB /
                            // THD+N_err 27.24dB / HarmMag 19.49dB / EO_ratio_err 18.20dB.
                            // KnownGap: WDF FET leveler produces no compression (feedback
                            // detector broken — no GR); ngspice shows full 1176-style GR at 2.0V.
                            // WDF matches ngspice amplitude (0.0dB) only because both output
                            // roughly equal level before compression settles in warmup window.
                            // THD error is massive because ngspice compresses while WDF doesn't
                            // (harmonic content of a compressed vs uncompressed signal diverges).
                            // Threshold = measured + 3–5dB margin.
                            normalized_rms_error_db: Some(3.0),
                            peak_error_db: Some(3.0),
                            thd_error_db: Some(82.0),
                            thd_plus_n_error_db: Some(33.0),
                            harmonic_mag_error_db: Some(25.0),
                            even_odd_ratio_error_db: Some(24.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(200.0),
                    },
                );

                tests
            },
        },
    );

    // ── Tubes suite — new triode/pentode/vari-mu reference circuits ─────────
    // Additive: separate region from the compressor suite above.
    // Each circuit has both an ngspice SPICE golden and a WDF golden so the
    // dual-golden accuracy matrix shows SPICE-vs-WDF gaps per circuit.
    //
    // NOTE: The GE 6386 vari-mu WDF will show a known GAP vs ngspice (engine
    // comp≈0.17 issue / sidechain CV-swing problem). This is DESIRED — the gap
    // is visible on the matrix. The Raffensperger model itself is correct.
    //
    // pass_criteria are marked // Measured <date>: and updated after goldens are
    // generated by `generate-spice --suite tubes` + `bootstrap --suite tubes`.
    suites.insert(
        "tubes".to_string(),
        TestSuite {
            description: "Tube amplifier stage validation — triodes, pentode, vari-mu"
                .to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // ── 12AU7 common cathode ──────────────────────────────────────
                // Medium-mu triode (mu≈21.5), gain ≈ -14.
                // Same one-port TriodeRoot topology as the 12AX7 smoke check.
                tests.insert(
                    "common_cathode_12au7".to_string(),
                    TestCase {
                        circuit: "nonlinear/common_cathode_12au7.pedal".to_string(),
                        description: "Single 12AU7 triode, common cathode (mu≈21.5, gain≈-14)"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.1,
                                duration: 0.05,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.5,
                                duration: 0.05,
                                label: Some("driven".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        // Measured 2026-06-15: sine RMS=-0.0dB Peak=-0.4dB THD=0.18dB
                        //                      driven RMS=-0.1dB Peak=-1.1dB THD=0.11dB
                        // Honest gate: 20% headroom above measured worst-case.
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(2.0),
                            thd_error_db: Some(1.5),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // ── 12AT7 common cathode ──────────────────────────────────────
                // Medium-high mu triode (mu≈60), gain ≈ -40.
                tests.insert(
                    "common_cathode_12at7".to_string(),
                    TestCase {
                        circuit: "nonlinear/common_cathode_12at7.pedal".to_string(),
                        description: "Single 12AT7 triode, common cathode (mu≈60, gain≈-40)"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.05,
                                duration: 0.05,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.2,
                                duration: 0.05,
                                label: Some("driven".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        // Measured 2026-06-15: sine RMS=-0.0dB Peak=-0.7dB THD=0.34dB
                        //                      driven RMS=-0.1dB Peak=-1.3dB THD=0.33dB
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(2.0),
                            thd_error_db: Some(1.5),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // ── 12BH7 common cathode ──────────────────────────────────────
                // Low-mu high-current triode (mu≈17), gain ≈ -11.
                tests.insert(
                    "common_cathode_12bh7".to_string(),
                    TestCase {
                        circuit: "nonlinear/common_cathode_12bh7.pedal".to_string(),
                        description: "Single 12BH7 triode, common cathode (mu≈17, gain≈-11)"
                            .to_string(),
                        signals: vec![
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.05,
                                duration: 0.05,
                                label: Some("sine".to_string()),
                            },
                            SignalConfig::Sine {
                                frequency: 1000.0,
                                amplitude: 0.1,
                                duration: 0.05,
                                label: Some("driven".to_string()),
                            },
                        ],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        // Measured 2026-06-15: sine RMS=-0.1dB Peak=-0.5dB THD=0.17dB
                        //                      driven RMS=-0.1dB Peak=-0.5dB THD=0.14dB
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(2.0),
                            thd_error_db: Some(1.5),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // ── 12AX7 cathode follower ────────────────────────────────────
                // High-mu triode (mu≈100), non-inverting, gain ≈ 0.97.
                // Contrasts common-cathode; plate tied to B+, output from cathode.
                tests.insert(
                    "cathode_follower_12ax7".to_string(),
                    TestCase {
                        circuit: "nonlinear/cathode_follower_12ax7.pedal".to_string(),
                        description: "12AX7 cathode follower (mu≈100, gain≈0.97, non-inverting)"
                            .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.5,
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![
                            MetricConfig::TimeDomain,
                            MetricConfig::Thd {
                                fundamental: 1000.0,
                            },
                        ],
                        // Measured 2026-06-15: sine RMS=-0.3dB Peak=-1.6dB THD=1.12dB
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(1.0),
                            peak_error_db: Some(3.0),
                            thd_error_db: Some(2.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: None,
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // ── EL34 single-ended pentode ─────────────────────────────────
                // Class-A single-ended power stage. SPICE uses fixed bias (Vg1=-33V);
                // engine uses auto-bias (Rk). Topology mismatch → expect larger gap.
                // BEHAVIORAL SMOKE CHECK: surfaces operating-point gap on matrix.
                tests.insert(
                    "single_ended_el34".to_string(),
                    TestCase {
                        circuit: "nonlinear/single_ended_el34.pedal".to_string(),
                        description:
                            "EL34 single-ended pentode, class-A (auto-bias vs SPICE fixed-bias)"
                                .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.5,
                            duration: 0.05,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        // Re-baselined 2026-07-13 (pedalkernel-ko5g.5, pentode DC solver):
                        // the engine now SOLVES the self-bias op — Vg1k=-30.52V /
                        // Ia=64.9mA / Vpk=222.7V / Vg2=450V, matching the deck's
                        // documented op (Vg1=-33V fixed / Ip~65mA / Vp~225V) within 8%.
                        // Steady-state error vs ngspice: RMS 2.5dB / Peak 6.1dB
                        // (pre-solver the engine idled hot+plate-saturated: output RMS
                        // 0.876 vs golden 7.45 — ~19dB dead — and "passed" only because
                        // a 100%-relative-error output reads as 0.0dB on the
                        // rms(err)/rms(ref) metric; THD error 37.5dB, now 16.4dB).
                        // warmup_trim 30ms: the engine does not seed the OUTPUT coupling
                        // cap (C_out 100n into 100k, tau=10ms) so the first ~3 tau is the
                        // COUT charge transient; the deck sidesteps it with
                        // `.IC V(COUT)=225`. Residual steady-state gap = acknowledged
                        // netlist-vs-deck topology mismatch (auto-bias Rk + circuit
                        // Vg2=450 vs deck fixed -33V + Vg2=470) + engine atan(KVB=24)
                        // vs deck atan(KVB2=18). Smoke check only.
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(3.0),
                            peak_error_db: Some(8.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(30.0),
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                // ── GE 6386 variable-mu triode ────────────────────────────────
                // Remote-cutoff triode (Fairchild 670 compression element).
                // ENGINE GAP EXPECTED: comp≈0.17 issue means WDF gain will not track
                // ngspice across bias points. Both goldens committed so the gap is
                // visible on the matrix. Do NOT hide the gap.
                tests.insert(
                    "varimu_6386".to_string(),
                    TestCase {
                        circuit: "active/varimu_6386.pedal".to_string(),
                        description:
                            "GE 6386 variable-mu triode, common cathode (Raffensperger model)"
                                .to_string(),
                        signals: vec![SignalConfig::Sine {
                            frequency: 1000.0,
                            amplitude: 0.01,
                            duration: 0.2,
                            label: Some("sine".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain],
                        // The output-coupling cap has a long visible startup transient in both
                        // engines. Measure only the settled tail so the 1kHz tone, not the cap
                        // discharge, drives the comparison.
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(3.0),
                            peak_error_db: Some(3.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(150.0),
                        pending_reference: false,
                        pro_circuit_path: None,
                    },
                );

                tests
            },
        },
    );

    // Drums suite — TR-808/909 voice validation
    //
    // WDF circuit: loaded from pedalkernel-pro at bootstrap/run time via the
    // `circuit` path (bootstrap skips gracefully if the pro repo is absent; the
    // validate runner's load path similarly skips).  The .pedal files are
    // proprietary and must never be committed to this public repo.
    //
    // SPICE golden: spice-circuits/drums/<name>.spice (already committed).
    // Generate with: cargo run -p pedalkernel-validate -- generate-spice --suite drums
    //
    // Profile: `KnownGap` — the WDF 808 kick is known-broken per lq6.1
    // (f0 appears at Nyquist, no pitch sweep in the WDF layer).  Thresholds
    // are intentionally loose (20 dB) so the gate correctly reports RED and
    // the gap is visible on the accuracy dashboard without blocking CI.
    suites.insert(
        "drums".to_string(),
        TestSuite {
            description: "TR-808/909 drum voice resonator validation (SPICE vs WDF)".to_string(),
            tests: {
                let mut tests = BTreeMap::new();

                // 808 kick — bridged-T Sallen-Key resonator
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_kick.pedal
                // SPICE model: behavioral state-space equivalent (f0=56 Hz, Q≈30 — TR-808 manual).
                //
                // Signal: 2 ms gate trigger → 500 ms decay window.
                // Label "trigger" matches the existing golden path convention in
                // drums_spice.rs (golden/drums/808_kick/trigger.npy).
                //
                // Known failure: WDF f0 at Nyquist (engine bug, lq6.1 backlog).
                // Thresholds set loose (20 dB) → KnownGap profile.  The point is
                // to surface the gap on the dashboard, not to gate CI.
                tests.insert(
                    "808_kick".to_string(),
                    TestCase {
                        circuit: "drums/808_kick.pedal".to_string(),
                        description: "TR-808 kick: bridged-T resonator, f0=56 Hz (manual), Q≈30"
                            .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            // Single-sample impulse excites the resonator.
                            // The SPICE model and WDF engine both receive the same
                            // impulse, so compare-goldens measures the same response.
                            // Label "trigger" matches the golden path convention
                            // established in drums_spice.rs (golden/drums/808_kick/trigger.npy).
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF kick is broken (f0 at Nyquist, lq6.1).
                            // Thresholds loose enough that the test registers but
                            // reports RED honestly on the accuracy dashboard.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        // No warmup trim — the kick is all transient; trimming the
                        // head would discard the trigger onset and ring-up.
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        // Private circuit: bootstrap falls back to pedalkernel-pro.
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_kick.pedal".to_string(),
                        ),
                    },
                );

                // 808 snare — dual bridged-T resonator (lo ~154 Hz + hi ~339 Hz)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_snare.pedal
                // SPICE model: two state-space resonators summed; noise burst NOT modeled
                //   (tonal-body-only gap is documented in 808_snare.spice header).
                //
                // Lo body: f0=238 Hz (TR-808 manual), Q=2.5
                // Hi body: f0=476 Hz (TR-808 manual), Q=5.0
                //
                // Known failure: same WDF resonator bug as kick (lq6.1).
                // Thresholds loose (20 dB) → KnownGap profile.
                tests.insert(
                    "808_snare".to_string(),
                    TestCase {
                        circuit: "drums/808_snare.pedal".to_string(),
                        description:
                            "TR-808 snare: dual bridged-T (lo 238 Hz Q=2.5 + hi 476 Hz Q=5.0 — manual), tonal bodies only"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_snare.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 tom (lo-tom) — single bridged-T resonator
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_tom.pedal
                // SPICE model: state-space resonator, f0=90 Hz (TR-808 manual), Q=8.33
                //
                // NOTE: 808_tom.pedal is internally labelled "808 Mid Tom" but is the
                // lo-tom voice in the three-voice hierarchy.  See 808_tom.spice header.
                //
                // Known failure: same WDF resonator bug as kick (lq6.1).
                // Thresholds loose (20 dB) → KnownGap profile.
                tests.insert(
                    "808_tom".to_string(),
                    TestCase {
                        circuit: "drums/808_tom.pedal".to_string(),
                        description:
                            "TR-808 tom (lo-tom): bridged-T resonator, f0=90 Hz (manual), Q=8.33"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_tom.pedal".to_string(),
                        ),
                    },
                );

                // 808 mid tom — single bridged-T resonator
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_mid_tom.pedal
                // SPICE model: state-space resonator, f0=135 Hz (TR-808 manual), Q=9.1
                //
                // Known failure: same WDF resonator bug as kick (lq6.1).
                // Thresholds loose (20 dB) → KnownGap profile.
                tests.insert(
                    "808_mid_tom".to_string(),
                    TestCase {
                        circuit: "drums/808_mid_tom.pedal".to_string(),
                        description:
                            "TR-808 mid tom: bridged-T resonator, f0=135 Hz (manual), Q=9.1".to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_mid_tom.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 hi tom — single bridged-T resonator
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_hi_tom.pedal
                // SPICE model: state-space resonator, f0=185 Hz (TR-808 manual), Q=8.33
                //
                // REANCHOR: Previously f0=153.8 Hz (RC textbook). Now anchored to TR-808
                // service manual hi-tom target (185 Hz). Q preserved from .pedal component values.
                //
                // Known failure: same WDF resonator bug as kick (lq6.1).
                // Thresholds loose (20 dB) → KnownGap profile.
                tests.insert(
                    "808_hi_tom".to_string(),
                    TestCase {
                        circuit: "drums/808_hi_tom.pedal".to_string(),
                        description:
                            "TR-808 hi tom: bridged-T resonator, f0=185 Hz (manual), Q=8.33".to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_hi_tom.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 claves — single high-Q bridged-T resonator (~2.25 kHz, Q≈23.5)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_claves.pedal
                // SPICE model: state-space resonator, f0=2500 Hz (TR-808 manual), Q=23.5
                //
                // Short percussive click with brief ring. Same WDF resonator bug as other voices (lq6.1).
                tests.insert(
                    "808_claves".to_string(),
                    TestCase {
                        circuit: "drums/808_claves.pedal".to_string(),
                        description:
                            "TR-808 claves: single bridged-T resonator, f0=2500 Hz (manual), Q=23.5"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator is broken (f0 at Nyquist, lq6.1).
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_claves.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 rimshot — single low-Q bridged-T resonator (1667 Hz, Q≈2.78)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_rimshot.pedal
                // SPICE model: state-space resonator, f0=1667 Hz (TR-808 manual), Q=2.78
                //
                // Very short click (τ≈0.53ms). Same WDF resonator bug as other voices (lq6.1).
                tests.insert(
                    "808_rimshot".to_string(),
                    TestCase {
                        circuit: "drums/808_rimshot.pedal".to_string(),
                        description:
                            "TR-808 rimshot: single bridged-T resonator, f0=1667 Hz (manual), Q=2.78, τ≈0.53ms"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + WDF loading shifts f0.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_rimshot.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 cowbell — dual bridged-T resonator (lo 540 Hz + hi 800 Hz) summed
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_cowbell.pedal
                // SPICE model: two state-space resonators summed (sinusoidal approximation).
                //
                // Authentic TR-808 uses two square-wave oscillators (~560/845 Hz). SPICE deck
                // anchored to TR-808 service manual targets (540/800 Hz). Q preserved from
                // .pedal component ratios (lo Q=2.09, hi Q=1.98).
                // Square-wave harmonic content is a documented gap.
                tests.insert(
                    "808_cowbell".to_string(),
                    TestCase {
                        circuit: "drums/808_cowbell.pedal".to_string(),
                        description:
                            "TR-808 cowbell: dual bridged-T (lo 540 Hz Q=2.09 + hi 800 Hz Q=1.98 — manual), sinusoidal approx"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + square-wave harmonic gap.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_cowbell.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 maracas — high-freq bridged-T click resonator (~4823 Hz, Q=34)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_maracas.pedal
                // SPICE model: state-space resonator, f0=4822.9Hz, Q=34
                //
                // The .pedal provides a brief click at attack; the actual maracas character
                // is DSP noise (VoiceNoise at ~6 kHz bandpass) outside the WDF model.
                // SPICE deck captures tonal body only; noise component is a documented gap.
                tests.insert(
                    "808_maracas".to_string(),
                    TestCase {
                        circuit: "drums/808_maracas.pedal".to_string(),
                        description:
                            "TR-808 maracas: high-freq bridged-T click, f0=4822.9 Hz, Q=34; noise component not modeled"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + noise component not modeled.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_maracas.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 clap — bandpass body resonator (~1539 Hz, Q=1.43); burst envelope not modeled
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_clap.pedal
                // SPICE model: state-space resonator, f0=1539.2Hz, Q=1.43
                //
                // The authentic 808 clap has 3-4 retriggered noise bursts (reverb effect).
                // The multi-burst envelope is a DSP block (ClapEnvelope in drummerboy-core);
                // the .pedal provides only the bandpass resonator body. Two documented gaps:
                // (1) multi-burst envelope not in WDF path; (2) noise source not modeled.
                tests.insert(
                    "808_clap".to_string(),
                    TestCase {
                        circuit: "drums/808_clap.pedal".to_string(),
                        description:
                            "TR-808 clap body: bridged-T resonator, f0=1539.2 Hz, Q=1.43; multi-burst envelope + noise not modeled"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + multi-burst envelope gap
                            // + noise source gap. Three stacked modeling limitations.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_clap.pedal".to_string(),
                        ),
                    },
                );

                // 808 closed hat — damped high-freq resonator (~7074 Hz, Q_eff≈5 approx)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_closed_hat.pedal
                // SPICE model: state-space resonator, f0=7073.6Hz, Q_eff=5 (approximation).
                //
                // Authentic TR-808: 6 square-wave oscillators (~205–800 Hz) + 7kHz HPF.
                // The .pedal approximates this as a single 7kHz bridged-T with sub-critical
                // feedback (R_fb=47k < r_crit=450k → highly damped, very short ring).
                // Q_eff=5 is an approximation; the exact Q is not derivable from the
                // sub-critical R_fb formula. Two documented gaps: 6-osc metallic source +
                // sub-critical Q approximation.
                tests.insert(
                    "808_closed_hat".to_string(),
                    TestCase {
                        circuit: "drums/808_closed_hat.pedal".to_string(),
                        description:
                            "TR-808 closed hat: 7074 Hz resonator approx (Q_eff=5); 6-osc metallic source not modeled"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + 6-osc metallic gap
                            // + Q_eff approximation (R_fb < r_crit, sub-critical feedback).
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_closed_hat.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 808 open hat — high-Q high-freq resonator (~7074 Hz, Q=23.5)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/808_open_hat.pedal
                // SPICE model: state-space resonator, f0=7073.6Hz, Q=23.5
                //
                // Same resonator body as closed hat (identical R/C values) but with
                // R_fb=470k > r_crit=450k → above critical: longer ring than closed hat.
                // Same 6-osc metallic source gap as closed hat. Authentic decay (~300ms)
                // is not achievable with this single-resonator .pedal topology.
                tests.insert(
                    "808_open_hat".to_string(),
                    TestCase {
                        circuit: "drums/808_open_hat.pedal".to_string(),
                        description:
                            "TR-808 open hat: 7074 Hz resonator (Q=23.5); 6-osc metallic source not modeled"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + 6-osc metallic gap.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/808_open_hat.pedal"
                                .to_string(),
                        ),
                    },
                );

                // ── B3 voices: 909 analog + 606 snare ────────────────────────────────────

                // 606 snare — dual bridged-T resonator (lo ~282 Hz + hi ~339 Hz)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/606_snare.pedal
                // SPICE model: two state-space resonators summed; noise burst NOT modeled
                //   (tonal-body-only gap documented in 606_snare.spice header).
                //
                // Lo body: R=120k, C=4.7n → f0=282.3Hz, Q=4.27 (R_fb=470k)
                // Hi body: R=100k, C=4.7n → f0=338.6Hz, Q=5.62 (R_fb=365k)
                //
                // NOTE: Hi-body R_fb was raised 330k→365k to balance oscillator energy
                // (fixes prior bug where hi-body was 10× louder than lo-body).
                //
                // Known failure: same WDF resonator bug as 808 voices (lq6.1).
                // Thresholds loose (20 dB) → KnownGap profile.
                tests.insert(
                    "606_snare".to_string(),
                    TestCase {
                        circuit: "drums/606_snare.pedal".to_string(),
                        description:
                            "TR-606 snare: dual bridged-T (lo 282 Hz Q=4.27 + hi 339 Hz Q=5.62), tonal bodies only"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/606_snare.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 909 lo tom — single bridged-T resonator (~80 Hz, Q=5.0)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/909_lo_tom.pedal
                // SPICE model: state-space resonator, f0=79.6Hz, Q=5.0
                //
                // Authentic TR-909 LT uses a UJT relaxation oscillator (~65 Hz target).
                // .pedal approximates with bridged-T + PitchEnvelope. SPICE models
                // the static body resonance; PitchEnvelope sweep not modeled in SPICE.
                //
                // Known failure: same WDF resonator bug as 808 voices (lq6.1).
                tests.insert(
                    "909_lo_tom".to_string(),
                    TestCase {
                        circuit: "drums/909_lo_tom.pedal".to_string(),
                        description:
                            "TR-909 lo tom: bridged-T resonator, f0=79.6 Hz, Q=5.0; PitchEnvelope sweep not in SPICE"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/909_lo_tom.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 909 mid tom — single bridged-T resonator (~125 Hz, Q=5.26)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/909_mid_tom.pedal
                // SPICE model: state-space resonator, f0=125.3Hz, Q=5.26
                //
                // Authentic TR-909 MT uses a UJT relaxation oscillator (~110-120 Hz target).
                // .pedal approximates with bridged-T + PitchEnvelope. SPICE models static body.
                tests.insert(
                    "909_mid_tom".to_string(),
                    TestCase {
                        circuit: "drums/909_mid_tom.pedal".to_string(),
                        description:
                            "TR-909 mid tom: bridged-T resonator, f0=125.3 Hz, Q=5.26; PitchEnvelope sweep not in SPICE"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/909_mid_tom.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 909 hi tom — single bridged-T resonator (~188 Hz, Q=4.86)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/909_hi_tom.pedal
                // SPICE model: state-space resonator, f0=188.4Hz, Q=4.86
                //
                // Authentic TR-909 HT uses a UJT relaxation oscillator (~140-160 Hz target).
                // .pedal approximates with bridged-T (WDF loading shifts peak to 190-210 Hz).
                // PitchEnvelope sweep not modeled in SPICE.
                tests.insert(
                    "909_hi_tom".to_string(),
                    TestCase {
                        circuit: "drums/909_hi_tom.pedal".to_string(),
                        description:
                            "TR-909 hi tom: bridged-T resonator, f0=188.4 Hz, Q=4.86; PitchEnvelope sweep not in SPICE"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/909_hi_tom.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 909 rim — single bridged-T resonator (~412 Hz, Q=5.56)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/909_rim.pedal
                // SPICE model: state-space resonator, f0=412.3Hz, Q=5.56 (unloaded, Decay=1.0)
                //
                // Default Decay=0.3 shunts the midpoint, reducing effective Q significantly.
                // SPICE models the unloaded Q=5.56 (Decay=1.0 position); WDF engine applies
                // pot damping internally. Same pitch range as 808 rimshot; character
                // differentiation comes from shorter decay (Decay=0.3 default), not pitch.
                //
                // Same WDF resonator bug as 808 voices (lq6.1). Also expects WDF
                // bias-loading shift (similar to 808 rimshot, see ENGINE_BUG_BRIDGED_T_BIAS_LOADING.md).
                tests.insert(
                    "909_rim".to_string(),
                    TestCase {
                        circuit: "drums/909_rim.pedal".to_string(),
                        description:
                            "TR-909 rim shot: bridged-T resonator, f0=412.3 Hz, Q=5.56 (unloaded); short click at Decay=0.3"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + WDF bias-loading shift.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/909_rim.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 909 snare — dual bridged-T resonator (lo ~339 Hz + hi ~452 Hz)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/909_snare.pedal
                // SPICE model: two state-space resonators summed; noise burst NOT modeled.
                //
                // Lo body: R=100k, C=4.7n → f0=338.6Hz, Q=5.0
                // Hi body: R=75k, C=4.7n  → f0=451.4Hz, Q=6.0
                //
                // Higher-pitched than 808 snare (~154+339 Hz) — characteristic 909 brightness.
                // Noise gap: VoiceNoise (6kHz, Q=2.5, decay=60ms, amount=0.7) not modeled.
                // Same WDF resonator bug as 808 voices (lq6.1).
                tests.insert(
                    "909_snare".to_string(),
                    TestCase {
                        circuit: "drums/909_snare.pedal".to_string(),
                        description:
                            "TR-909 snare: dual bridged-T (lo 339 Hz Q=5.0 + hi 452 Hz Q=6.0), tonal bodies only"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/909_snare.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 909 kick — bridged-T resonator body (~48 Hz, Q=5.71)
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/909_kick.pedal
                // SPICE model: state-space resonator, f0=48.2Hz, Q=5.71 (body resonance only)
                //
                // DOCUMENTED GAPS (three stacked):
                //   1. BJT oscillator topology: authentic TR-909 kick uses a 2SC1583 dual-NPN
                //      transistor multivibrator. This SPICE deck models the equivalent
                //      bridged-T state-space body from the .pedal approximation — NOT the
                //      transistor oscillator circuit. BJT transient convergence in the
                //      multivibrator topology is too stiff for the standard SPICE harness.
                //   2. PitchEnvelope sweep (190→45 Hz over 80ms, amount=3.2) not in SPICE.
                //   3. VoiceNoise (4kHz, Q=1.5, decay=8ms) + VoiceClick (decay=3ms) DSP
                //      layers not modeled (outside WDF path).
                //
                // Same WDF resonator bug as 808 voices (lq6.1).
                tests.insert(
                    "909_kick".to_string(),
                    TestCase {
                        circuit: "drums/909_kick.pedal".to_string(),
                        description:
                            "TR-909 kick: bridged-T body approx, f0=48.2 Hz, Q=5.71; BJT oscillator + pitch sweep + noise not modeled"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + BJT oscillator gap
                            // + PitchEnvelope sweep gap + noise/click DSP gaps.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/909_kick.pedal"
                                .to_string(),
                        ),
                    },
                );

                // 909 clap — bandpass body resonator (~1539 Hz, Q=1.43); 4-burst envelope not modeled
                //
                // Circuit (private): crates/drummerboy/drummerboy-core/pedals/909_clap.pedal
                // SPICE model: state-space resonator, f0=1538.5Hz, Q=1.43
                //
                // Same bandpass resonator as 808 clap (R=22k, C=4.7n, R_fb=220k).
                // The distinction between 808 and 909 clap is in the DSP burst pattern:
                //   808: 3 bursts (ClapEnvelope), 909: 4 bursts (ClapEnvelope909).
                // Both body resonators are identical in spectral character.
                //
                // DOCUMENTED GAPS (same as 808 clap):
                //   1. Multi-burst comb envelope (ClapEnvelope909 DSP block) not in WDF path.
                //   2. Noise source not modeled.
                //   3. SPICE models deterministic resonant body response only.
                //
                // Same WDF resonator bug as 808 voices (lq6.1).
                tests.insert(
                    "909_clap".to_string(),
                    TestCase {
                        circuit: "drums/909_clap.pedal".to_string(),
                        description:
                            "TR-909 clap body: bridged-T resonator, f0=1538.5 Hz, Q=1.43; 4-burst envelope + noise not modeled"
                                .to_string(),
                        signals: vec![SignalConfig::Impulse {
                            amplitude: 1.0,
                            label: Some("trigger".to_string()),
                        }],
                        metrics: vec![MetricConfig::TimeDomain, MetricConfig::Spectral],
                        pass_criteria: PassCriteria {
                            // KnownGap: WDF resonator bug (lq6.1) + 4-burst envelope gap
                            // + noise source gap.
                            normalized_rms_error_db: Some(20.0),
                            peak_error_db: Some(20.0),
                            spectral_error_db: Some(20.0),
                            ..Default::default()
                        },
                        warmup_trim_ms: Some(0.0),
                        pending_reference: false,
                        pro_circuit_path: Some(
                            "crates/drummerboy/drummerboy-core/pedals/909_clap.pedal"
                                .to_string(),
                        ),
                    },
                );

                tests
            },
        },
    );

    suites
}

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

    #[test]
    fn global_warmup_trim_default_is_10ms() {
        let cfg = GlobalConfig::default();
        assert_eq!(cfg.warmup_trim_ms, 10.0);
    }

    #[test]
    fn test_case_uses_global_trim_when_no_override() {
        let global = GlobalConfig::default();
        let tc = TestCase {
            circuit: String::new(),
            description: String::new(),
            signals: vec![],
            metrics: vec![],
            pass_criteria: PassCriteria::default(),
            warmup_trim_ms: None,
            pending_reference: false,
            pro_circuit_path: None,
        };
        assert_eq!(tc.effective_warmup_trim_ms(&global), 10.0);
    }

    #[test]
    fn test_case_override_takes_precedence_over_global() {
        let global = GlobalConfig::default(); // warmup_trim_ms = 10.0
        let tc = TestCase {
            circuit: String::new(),
            description: String::new(),
            signals: vec![],
            metrics: vec![],
            pass_criteria: PassCriteria::default(),
            warmup_trim_ms: Some(5.0),
            pending_reference: false,
            pro_circuit_path: None,
        };
        assert_eq!(tc.effective_warmup_trim_ms(&global), 5.0);
    }

    #[test]
    fn zero_trim_is_valid_override() {
        let global = GlobalConfig::default();
        let tc = TestCase {
            circuit: String::new(),
            description: String::new(),
            signals: vec![],
            metrics: vec![],
            pass_criteria: PassCriteria::default(),
            warmup_trim_ms: Some(0.0),
            pending_reference: false,
            pro_circuit_path: None,
        };
        assert_eq!(tc.effective_warmup_trim_ms(&global), 0.0);
    }

    #[test]
    fn test_case_profiles_classify_gate_intent() {
        let mut tc = TestCase {
            circuit: String::new(),
            description: String::new(),
            signals: vec![],
            metrics: vec![],
            pass_criteria: PassCriteria::default(),
            warmup_trim_ms: None,
            pending_reference: false,
            pro_circuit_path: None,
        };

        assert_eq!(
            tc.effective_profile("linear", "resistor_divider"),
            ValidationProfile::Strict
        );
        assert_eq!(
            tc.effective_profile("tubes", "single_ended_el34"),
            ValidationProfile::Smoke
        );
        assert_eq!(
            tc.effective_profile("compressor", "fet_leveler_level_sweep"),
            ValidationProfile::KnownGap
        );

        // _hot tests are always KnownGap — even with pending_reference=true and
        // even inside suites that would otherwise return a different bucket.
        // This ensures the expected model-gap bucket is visible from the moment
        // the test is added, not just after goldens are generated.
        assert_eq!(
            tc.effective_profile("active", "jfet_source_follower_hot"),
            ValidationProfile::KnownGap
        );
        assert_eq!(
            tc.effective_profile("active", "nmos_common_source_hot"),
            ValidationProfile::KnownGap
        );
        assert_eq!(
            tc.effective_profile("compressor", "fet_leveler_hot"),
            ValidationProfile::KnownGap
        );

        tc.pending_reference = true;
        assert_eq!(
            tc.effective_profile("compressor", "la2a_level_sweep"),
            ValidationProfile::Pending
        );
        // _hot overrides pending_reference
        assert_eq!(
            tc.effective_profile("active", "nmos_common_source_hot"),
            ValidationProfile::KnownGap
        );
    }
}