Add files using upload-large-folder tool

README.md

@@ -0,0 +1,362 @@
+# SPADE Limiter Recovery — Documentazione
+
+## Panoramica
+
+Due script che formano una pipeline completa per il recupero di dinamiche
+compresse da un brickwall limiter su materiale percussivo.
+
+| Script | Ruolo |
+|---|---|
+| `spade_declip_v12.py` | Algoritmo di recupero (SPADE solver + GPU) |
+| `run_smart_sweep.py` | Ottimizzazione bayesiana dei parametri (Optuna) |
+
+---
+
+## `spade_declip_v12.py`
+
+### Cosa fa
+
+Implementa S-SPADE e A-SPADE — algoritmi di audio declipping basati su
+ottimizzazione sparsa nel dominio trasformato (DCT/RDFT). In modalità `soft`
+il problema viene esteso dal declipping classico al **recupero di dinamiche
+compresse da un brickwall limiter**: i campioni sopra la soglia vengono
+trattati come lower-bound (non come equality), permettendo all'ADMM di
+recuperare valori superiori al segnale limitato.
+
+### Algoritmo
+
+Il solver risolve iterativamente:
+
+```
+minimizza  ||A(x)||₀   (L0 nel dominio trasformato)
+soggetto a  x ∈ Γ       (consistency set: vincoli dal segnale limitato)
+```
+
+tramite ADMM (Alternating Direction Method of Multipliers):
+- **Step 2** — hard thresholding H_k: mantiene i k coefficienti più grandi
+- **Step 3** — proiezione su Γ: impone i constraint del segnale limitato
+- **Step 7** — aggiornamento duale: accumula le correzioni residue
+
+### Struttura del processing
+
+```
+input limitato
+    ↓
+[DC removal]  →  [mask detection Ir/Icp/Icm]
+    ↓
+[macro_expand pre-pass]          ← opzionale, v11
+    ↓
+[_lr_split per banda]            ← opzionale multiband, v11
+    ↓
+[WOLA frame extraction]
+    ↓
+[SPADE su ogni frame]  ←  GPU batch (F, M) tensor / CPU ThreadPool
+    ↓
+[WOLA accumulation + normalizzazione]
+    ↓
+[safe-Ir RMS match]              ← v12: esclude campioni contaminati da WOLA
+    ↓
+output recuperato
+```
+
+### Versioni e feature principali
+
+**v10 — GPU acceleration**
+- Tutti i frame attivi impacchettati in un batch tensor `(F, M)` e processati
+  in un singolo kernel GPU
+- Supporto CUDA (NVIDIA) e ROCm (AMD, testato su RX 6700 XT)
+- Convergenza tracciata per-frame con maschera booleana: i frame convergenti
+  vengono "congelati" mentre gli altri continuano a iterare
+- Speedup tipico: 15–100× rispetto a CPU single-thread
+
+**v11 — Delimiting features** (tutte disabilitate di default)
+- `release_ms > 0` — Dilatazione maschere: i campioni nel range di release
+  del limiter vengono riclassificati da Ir a Icp/Icm, permettendo all'ADMM
+  di recuperare la coda del transiente
+- `max_gain_db > 0` — Upper bound sulla proiezione: previene transienti
+  artificiali causati da ADMM senza limite di guadagno
+- `multiband=True` — Split Linkwitz-Riley per banda con perfect reconstruction
+  (`hp = x - lp`): ogni banda viene processata indipendentemente con il suo
+  `delta_db`, poi sommata. I filtri sono IIR zero-phase (`sosfiltfilt`) —
+  nessuna distorsione di fase
+- `macro_expand=True` — Pre-pass di espansione macro-dinamica: recupera la
+  soppressione di livello (body compression) a lungo termine che SPADE non
+  può correggere per via della finestra WOLA corta (~21 ms)
+
+**v12 — LF recovery** (nuovo)
+- `hard_thresh_lf` / `_hard_thresh_lf_gpu` — Hard thresholding stratificato
+  per frequenza: garantisce un budget minimo di `lf_k_min` coefficienti nelle
+  bande sotto `lf_cutoff_hz`, indipendente dalla competizione con i bin HF.
+  Risolve il sistematico sotto-recupero LF (-3÷-8 dB su sub-bass) causato dal
+  fatto che il limiter attenuava i coefficienti LF rendendoli invisibili al
+  top-k globale nelle prime iterazioni ADMM
+- Safe-Ir RMS match: esclude dal calcolo RMS i campioni Ir entro
+  `window_length` campioni da qualsiasi boundary Icp/Icm, prevenendo che il
+  bleed WOLA dell'energia LF recuperata causasse un rescaling globale verso
+  il basso che annullava parzialmente il recupero stesso
+
+**Bug fix ereditati**
+- BUG-1: flip output (non input) nella sintesi DST dell'RDFT
+- BUG-2: variabile duale A-SPADE nel dominio coefficienti, non segnale
+- BUG-3: WOLA gain drift per canale in elaborazione stereo
+- BUG-4: DC offset che rompeva la rilevazione delle maschere a mezza onda
+
+### Nota sui filtri IIR
+
+Tutti i filtri nel codebase sono **zero-phase** (`sosfiltfilt`) eccetto il
+generatore di rumore rosa in `run_smart_sweep.py` (IIR causale, usato solo
+per la generazione del corpus, mai nel path critico). Nessun filtro introduce
+distorsione di fase nel segnale processato o nel residual usato per la metrica.
+
+### `DeclipParams` — parametri principali
+
+```python
+DeclipParams(
+    algo           = "sspade",      # "sspade" (default) | "aspade"
+    frame          = "rdft",        # "rdft" (default, P=2M) | "dct" (P=M)
+    mode           = "soft",        # "soft" = limiter recovery | "hard" = clipping
+    delta_db       = 2.5,           # dB dalla soglia del limiter a 0 dBFS
+    window_length  = 1024,          # campioni per frame WOLA
+    hop_length     = 256,           # hop WOLA (overlap = 1 - hop/win)
+    s              = 1,             # sparsity step (incremento k per iter)
+    r              = 1,             # sparsity rate (ogni r iter si incrementa k)
+    eps            = 0.1,           # criterio di convergenza ADMM
+    max_iter       = 1000,          # iterazioni massime per frame
+    sample_rate    = 44100,
+    # v11
+    release_ms     = 0.0,           # dilatazione maschere (0 = disabilitato)
+    max_gain_db    = 0.0,           # cap recupero dB (0 = disabilitato)
+    multiband      = False,
+    band_crossovers = (250, 4000),  # Hz, usati solo se multiband=True
+    band_delta_db  = (),            # per-band delta_db; vuoto = usa delta_db
+    macro_expand   = False,
+    macro_ratio    = 1.2,           # usato solo se macro_expand=True
+    # v12
+    lf_cutoff_hz   = 0.0,           # Hz soglia bin LF (0 = disabilitato)
+    lf_k_min       = 0,             # slot LF garantiti per iterazione ADMM
+    # GPU
+    use_gpu        = True,
+    gpu_device     = "auto",
+)
+```
+
+### Dipendenze
+
+```
+pip install numpy scipy soundfile
+pip install torch  # opzionale, per GPU
+```
+
+### CLI
+
+```bash
+python spade_declip_v12.py input.wav output.wav --mode soft --delta-db 2.5
+
+# Con feature v11/v12
+python spade_declip_v12.py input.wav output.wav \
+    --mode soft --delta-db 2.5 \
+    --release-ms 80 --max-gain-db 6 \
+    --lf-cutoff-hz 1000 --lf-k-min 8
+```
+
+---
+
+## `run_smart_sweep.py`
+
+### Cosa fa
+
+Ottimizzazione bayesiana degli iperparametri di `spade_declip_v12.py` su un
+corpus di drum sample. Usa Optuna TPE (Tree-structured Parzen Estimator) con
+MedianPruner per interrompere trial chiaramente sotto-performanti a metà corpus.
+
+### Pipeline di valutazione
+
+Per ogni trial Optuna:
+
+```
+1. Corpus costruito una volta sola all'avvio (build_corpus):
+   - Carica drum sample (Kicks / Snares / Perc / Tops)
+   - Normalizza a 0 dBFS peak
+   - Aggiunge rumore rosa a -20 dB (simula sottofondo musicale)
+   - Ri-normalizza a 0 dBFS
+   - Applica limiter sintetico (brickwall, attack=1 campione, release=80 ms)
+   - Calcola GT residual = originale − limitato
+   - Conserva GT_res (peak-normalizzato, per cosine sim) e
+     GT_res_raw (scala originale, per confronto energetico assoluto)
+
+2. Per ogni trial:
+   - Shuffle del corpus con seed = trial.number (riproducibile)
+   - Prima metà del corpus → GPU mega-batch → check pruning
+   - Seconda metà del corpus → GPU mega-batch → score finale
+   - Calcolo score_breakdown per ogni file
+   - Aggregazione e salvataggio user_attrs su Optuna
+```
+
+### Limiter sintetico
+
+```
+Soglia:   -3.0 dBFS  (LIMITER_THRESHOLD_DB)
+Release:  80 ms      (LIMITER_RELEASE_MS)
+Attack:   1 campione (brickwall vero)
+```
+
+La soglia è volutamente a 3 dB per creare un regime di limitazione
+significativo che metta alla prova il recupero LF. Il rumore rosa simula
+il contesto musicale su cui il limiter agisce, rendendo il training più
+rappresentativo dell'uso reale su full mix.
+
+### Score composito — `score_breakdown`
+
+Il best score riportato da Optuna è lo **score composito**, non la cosine
+similarity semplice. Questo perché la cosine sim è scale-invariant e non
+rileva il deficit energetico LF.
+
+Sette metriche calcolate per ogni file:
+
+| Campo | Cosa misura |
+|---|---|
+| `cosine` | Cosine sim TF globale (shape spettrale, 12 bande log) |
+| `cosine_lf` | Cosine sim in 20–500 Hz (shape corpo sub-bass/bass) |
+| `cosine_hf` | Cosine sim in 2k–20k Hz (shape attacco/brillantezza) |
+| `energy_lf_db` | `RMS_lf(SPADE) − RMS_lf(GT)` su scala originale, dB |
+| `energy_hf_db` | idem per HF |
+| `overrecovery` | 1 se energy_lf_db > +3 dB (artefatti LF) |
+| `composite` | Score composito usato come obiettivo Optuna |
+
+**Formula composite:**
+
+```
+pen_lf    = exp(min(0, energy_lf_db) / 6)    # penalità sub-recupero LF
+pen_hf    = exp(min(0, energy_hf_db) / 10)   # penalità sub-recupero HF (più morbida)
+composite = cosine × pen_lf^0.5 × pen_hf^0.2
+```
+
+La penalità LF è più aggressiva (esponente 0.5 vs 0.2, costante 6 vs 10)
+perché il problema di under-recovery LF era il deficit principale identificato
+a -3÷-8 dB su sub-bass. A -6 dB sotto GT, `pen_lf^0.5 ≈ 0.61` — lo score
+scende di ~39% rispetto alla cosine sim sola.
+
+L'energia è confrontata su **scala originale** (GT_res_raw, non normalizzato)
+per evitare che la peak-normalizzazione a RESIDUAL_DBFS mascheri il deficit
+assoluto.
+
+### GPU mega-batch
+
+Per minimizzare il costo di ogni trial su GPU AMD RX 6700 XT (RDNA2), tutti
+i frame attivi dell'intero corpus vengono impacchettati in un unico tensore
+`(F_total, M)` e processati con un singolo `_sspade_batch_gpu`. Con corpus da
+~50 file × ~350 frame ≈ 17500 frame, la GPU rimane a MCLK massimo per tutta
+la durata del kernel invece di ciclare tra idle e burst per ogni file.
+
+Il pruning rimane funzionale: il corpus viene diviso in due metà, la prima
+viene processata, lo score intermedio viene reportato a Optuna, e se il trial
+è chiaramente sotto-performante viene interrotto prima di processare la seconda.
+
+### Spazio di ricerca
+
+| Parametro | Range | Note |
+|---|---|---|
+| `delta_db` | 1.5 – 3.5 dB | Calibrato sulla soglia del limiter a 3 dB |
+| `window_length` | 512 / 1024 / 2048 | via `win_exp` ∈ {9,10,11} |
+| `hop_length` | win/4 o win/8 | overlap 75% o 87.5% |
+| `release_ms` | 10 – 200 ms | 0 = disabilitato |
+| `max_gain_db` | 2 – 12 dB | cap recupero |
+| `eps` | 0.03 / 0.05 / 0.1 | criterio convergenza ADMM |
+| `max_iter` | 250 / 500 / 1000 | iterazioni massime |
+| `multiband` | True/False | split LF/HF |
+| `lf_delta_db` | 0.5 – 2.0 dB | delta per banda LF (se multiband) |
+| `macro_expand` | True/False | pre-pass espansione |
+| `macro_ratio` | 1.1 – 2.0 | rapporto espansione |
+| `lf_cutoff_hz` | 0 / 500 / 1000 / 2000 Hz | soglia bin LF garantiti |
+| `lf_k_min` | 0 – 16 | slot LF per iterazione ADMM |
+
+Il corpus viene **shufflato** con seed deterministico pari al numero del trial
+(`trial.number`) per prevenire bias sull'ordine dei file — senza shuffle,
+i file all'inizio della lista avrebbero peso sistematicamente maggiore nel
+pruning.
+
+### `trial.set_user_attr` — diagnostica per trial
+
+Ogni trial completato salva nel database Optuna:
+
+```
+cosine_overall, cosine_lf, cosine_hf   → shape spettrale per banda
+energy_lf_db, energy_hf_db            → deficit/surplus energetico assoluto
+n_overrecovery                         → file con LF > +3 dB sopra GT
+score_std                              → consistenza cross-file
+n_files_scored                         → file processati
+```
+
+### Dipendenze
+
+```
+pip install numpy scipy soundfile optuna rich
+pip install torch  # per GPU
+```
+
+### CLI
+
+```bash
+# Sweep completo (200 trial di default)
+python run_smart_sweep.py
+
+# Test rapido
+python run_smart_sweep.py --trials 20
+
+# Riprende da database esistente
+python run_smart_sweep.py --resume
+
+# Solo report finale (no sweep)
+python run_smart_sweep.py --report
+
+# Cartella custom
+python run_smart_sweep.py --base-dir /path/to/samples
+```
+
+---
+
+## Stato e limitazioni note
+
+### Cosa funziona
+
+- Recupero HF (2k–20k Hz) robusto, +12÷+18 dB rispetto al limitato su kick
+- GPU mega-batch su AMD RX 6700 XT funzionante, speedup ~15–20×
+- Ottimizzazione bayesiana riprendibile, stabile dopo ~80 trial
+- Score composito con penalità energetica LF misura correttamente il deficit
+  che la cosine sim sola non rileva
+
+### Limitazioni attuali
+
+- Il corpus è composto da **sample percussivi isolati** con rumore rosa
+  sintetico. I parametri ottimali su sample isolati possono non generalizzare
+  a full mix musicali dove il limiter agisce su strati sovrapposti
+- Il limiter sintetico (threshold-based, release esponenziale fissa) è
+  un'approssimazione di limitatori commerciali come FabFilter Pro-L 2 che
+  usano curve di release adattive e lookahead
+- `A-SPADE` non ha ancora il path GPU (solo S-SPADE è accelerato)
+- I parametri SPADE sono **costanti per file**: il solver non si adatta
+  frame-per-frame alla struttura locale del segnale (onset vs. release vs.
+  silenzio). Questo è il limite strutturale principale rispetto a un approccio
+  di tipo SPADE Unrolled
+
+### Direzione di sviluppo: SPADE Unrolled
+
+L'evoluzione naturale del sistema è sostituire i parametri fissi con un
+**Context Encoder** (rete neurale piccola, ~100K parametri) che predice
+`λ_LF`, `λ_HF`, `delta_factor` e `gmax_factor` per ogni frame in base
+al contesto temporale dei K frame precedenti.
+
+Il solver SPADE viene trasformato in K layer fissi (unrolling), con
+`soft_thresh` stratificato al posto di `hard_thresh` per differenziabilità.
+Il gradiente della loss fluisce attraverso i K layer ADMM fino all'encoder.
+
+Il training è proposto in due fasi:
+1. **Fase 1** su sample isolati con rumore rosa (corpus attuale) — convergenza
+   rapida, ground truth esatto, encoder impara la firma della limitazione
+2. **Fase 2** su full mix con lo stesso limiter sintetico applicato a stems
+   sommati (Strategia A) — adattamento alla distribuzione reale, con mixed
+   batching per prevenire catastrophic forgetting della Fase 1
+
+La componente algoritmica di SPADE garantisce che il modello non possa
+inventare contenuto assente nel segnale limitato — solo i parametri del solver
+vengono appresi, non una mappatura arbitraria input→output.

extra_drum_dirs.csv

@@ -0,0 +1,39 @@
+Percorso Directory,Tipo
+"./Cymatics - Cratediggers Vol.1/Drum Fills","Drum Loop"
+"./Cymatics - Cratediggers Vol.1/Drum Loops","Drum Loop"
+"./Cymatics - Cratediggers Vol.1/Hihat Loops & MIDI","Drum Loop"
+"./Cymatics - Cratediggers Vol.1/Percussion Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Bassquake/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Commercial Deep House/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Commercial Deep House/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Deathstep Essentials 2/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Deathstep Essentials 2/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Deathstep Essentials 2/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Gaming Dubstep & Midtempo 2/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Gaming Dubstep & Midtempo 2/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Trap & Wave Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Trap & Wave Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Festival EDM Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Festival EDM Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Festival EDM Essentials/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Hardstyle Legends/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Hardstyle Legends/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Infinite - Liquid DnB Samples/Loops/Drums/Full Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Infinite - Liquid DnB Samples/Loops/Drums/Separated Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Melodic Techno Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Melodic Techno Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Melodic Techno Essentials/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Midtempo Meteor/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Midtempo Meteor/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Neo Rave Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Neo Rave Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Neo Rave Essentials/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Phonk Essentials/Loops/Drums/Full Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Phonk Essentials/Loops/Drums/Separated Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Vision - Outrun Synthwave/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Vision - Outrun Synthwave/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Vision - Outrun Synthwave/One-Shots/Drum Shots","Drum One Shot"
+"./Infinity Audio - Hugelism/Drum Loops","Drum Loop"
+"./Infinity Audio - Hugelism/Percussion Loops","Drum Loop"
+"./Sample.Tools.by.Cr2.Festival.Trap.3.MULTiFORMAT-DECiBEL/Festival_Trap_3/Audio_MIDI/Drum Loops","Drum Loop"
+"./The Producer School - Oasis/Sample Pack/Drumloops/Percussion Loops","Drum Loop"

login.py

@@ -0,0 +1,10 @@
+from huggingface_hub import HfApi
+
+api = HfApi()
+
+api.upload_large_folder(
+    folder_path=".",
+    repo_id="simone00/mymodel",
+    repo_type="dataset",         # "model", "dataset", or "space"
+    num_workers=4,             # parallel uploads — increase if you have good bandwidth
+)

nodrums.py

@@ -0,0 +1,82 @@
+import os
+import shutil
+import csv
+
+# --- CONFIGURAZIONE ---
+csv_file_path = 'percorsi.csv' 
+main_no_drums_folder = "No-Drums"
+# Estensioni file audio da spostare
+audio_extensions = ('.wav', '.mp3', '.aif', '.aiff', '.flac')
+# Parole chiave che indicano file/cartelle di batteria
+drum_keywords = ['drum', 'kick', 'snare', 'hihat', 'perc', 'clap', 'cymbal']
+
+def organize_by_pack_root():
+    if not os.path.exists(csv_file_path):
+        print(f"Errore: Il file {csv_file_path} non è stato trovato.")
+        return
+
+    # Crea la cartella No-Drums in root
+    if not os.path.exists(main_no_drums_folder):
+        os.makedirs(main_no_drums_folder)
+        print(f"Creata cartella principale: {main_no_drums_folder}")
+
+    with open(csv_file_path, mode='r', encoding='utf-8') as file:
+        reader = csv.DictReader(file)
+        
+        # Usiamo un set per non analizzare due volte la stessa cartella pack
+        processed_packs = set()
+        
+        for row in reader:
+            specific_folder = row['Percorso Directory']
+            
+            if not os.path.exists(specific_folder):
+                continue
+            
+            # --- LOGICA: Trovare la root del Pack ---
+            # Questo è un approccio euristico: supponiamo che la root del pack
+            # sia qualche livello sopra la cartella drum specificata.
+            # Esempio: .../PackName/Loops/Drum Loops -> Root è .../PackName/
+            
+            # Per sicurezza, analizziamo la cartella appena sopra quella specifica
+            pack_root = os.path.dirname(specific_folder)
+            
+            # Se la cartella è già stata elaborata, saltiamo
+            if pack_root in processed_packs:
+                continue
+            
+            processed_packs.add(pack_root)
+            print(f"\nAnalisi Root Pack: {pack_root}")
+
+            # --- Scansione ricorsiva della root del pack ---
+            for dirpath, dirnames, filenames in os.walk(pack_root):
+                
+                # Salta la cartella No-Drums stessa
+                if main_no_drums_folder in dirpath:
+                    continue
+
+                for filename in filenames:
+                    if filename.lower().endswith(audio_extensions):
+                        
+                        file_path_full = os.path.join(dirpath, filename)
+                        
+                        # --- CONTROLLO STRICT ---
+                        # Sposta se il file o la sua cartella NON contiene parole chiave
+                        if not any(keyword in file_path_full.lower() for keyword in drum_keywords):
+                            
+                            destination_path = os.path.join(main_no_drums_folder, filename)
+                            
+                            # Gestione duplicati
+                            if os.path.exists(destination_path):
+                                base, extension = os.path.splitext(filename)
+                                counter = 1
+                                while os.path.exists(os.path.join(main_no_drums_folder, f"{base}_{counter}{extension}")):
+                                    counter += 1
+                                destination_path = os.path.join(main_no_drums_folder, f"{base}_{counter}{extension}")
+
+                            print(f"  -> Sposto in root/No-Drums: {filename} (da {dirpath})")
+                            shutil.move(file_path_full, destination_path)
+
+    print("\nOrganizzazione completata.")
+
+if __name__ == "__main__":
+    organize_by_pack_root()

param_sweep_results.csv

@@ -0,0 +1,145 @@
+rank,sim_mean,sim_median,sim_p10,sim_p90,delta_db,window_length,hop_length,eps,max_iter,release_ms,max_gain_db
+1,0.92369,0.97345,0.78397,1.0,1.5,1024,256,0.05,500,100.0,6.0
+2,0.92342,0.97343,0.78386,1.0,1.5,1024,256,0.1,500,100.0,6.0
+3,0.92219,0.97457,0.7806,1.0,1.5,1024,256,0.1,500,100.0,4.0
+4,0.92205,0.97453,0.77916,1.0,1.5,1024,256,0.05,500,100.0,4.0
+5,0.92198,0.97042,0.78126,1.0,1.5,1024,256,0.05,500,250.0,6.0
+6,0.92169,0.97045,0.78135,1.0,1.5,1024,256,0.1,500,250.0,6.0
+7,0.92023,0.97141,0.77784,1.0,1.5,1024,256,0.1,500,250.0,4.0
+8,0.92005,0.97143,0.77696,1.0,1.5,1024,256,0.05,500,250.0,4.0
+9,0.91922,0.97758,0.76821,1.0,1.5,1024,256,0.05,500,0.0,0.0
+10,0.91922,0.97758,0.76821,1.0,1.5,1024,256,0.1,500,0.0,0.0
+11,0.91878,0.97799,0.76663,1.0,1.5,2048,256,0.05,500,0.0,0.0
+12,0.91878,0.97799,0.76663,1.0,1.5,2048,256,0.1,500,0.0,0.0
+13,0.91873,0.97799,0.76582,1.0,1.5,2048,256,0.05,500,0.0,6.0
+14,0.91873,0.97799,0.76582,1.0,1.5,2048,256,0.1,500,0.0,6.0
+15,0.91864,0.96349,0.77759,1.0,1.5,2048,256,0.05,500,100.0,6.0
+16,0.91863,0.96353,0.77746,1.0,1.5,2048,256,0.1,500,100.0,6.0
+17,0.91847,0.97741,0.76555,1.0,1.5,1024,256,0.05,500,0.0,6.0
+18,0.91847,0.97741,0.76555,1.0,1.5,1024,256,0.1,500,0.0,6.0
+19,0.91838,0.96648,0.77167,1.0,1.5,2048,256,0.05,500,100.0,0.0
+20,0.91837,0.96653,0.77156,1.0,1.5,2048,256,0.1,500,100.0,0.0
+21,0.91825,0.97757,0.76397,1.0,1.5,2048,256,0.05,500,0.0,4.0
+22,0.91825,0.97757,0.76397,1.0,1.5,2048,256,0.1,500,0.0,4.0
+23,0.91801,0.97732,0.76484,1.0,1.5,1024,256,0.05,500,0.0,4.0
+24,0.91801,0.97732,0.76484,1.0,1.5,1024,256,0.1,500,0.0,4.0
+25,0.91758,0.97644,0.76619,1.0,2.0,1024,256,0.05,500,0.0,0.0
+26,0.91758,0.97644,0.76619,1.0,2.0,1024,256,0.1,500,0.0,0.0
+27,0.91711,0.97653,0.76581,1.0,2.0,2048,256,0.05,500,0.0,0.0
+28,0.91711,0.97653,0.76581,1.0,2.0,2048,256,0.1,500,0.0,0.0
+29,0.91703,0.97619,0.76507,1.0,2.0,1024,256,0.05,500,0.0,6.0
+30,0.91703,0.97619,0.76507,1.0,2.0,1024,256,0.1,500,0.0,6.0
+31,0.9167,0.97627,0.76449,1.0,2.0,2048,256,0.05,500,0.0,6.0
+32,0.9167,0.97627,0.76449,1.0,2.0,2048,256,0.1,500,0.0,6.0
+33,0.91639,0.96321,0.77227,1.0,2.0,1024,256,0.05,500,100.0,6.0
+34,0.91613,0.96331,0.7717,1.0,2.0,1024,256,0.1,500,100.0,6.0
+35,0.91593,0.96273,0.77179,1.0,1.5,2048,256,0.05,500,100.0,4.0
+36,0.91593,0.96275,0.77184,1.0,1.5,2048,256,0.1,500,100.0,4.0
+37,0.91574,0.97556,0.76276,1.0,2.0,1024,256,0.05,500,0.0,4.0
+38,0.91574,0.97556,0.76276,1.0,2.0,1024,256,0.1,500,0.0,4.0
+39,0.91572,0.95651,0.77462,1.0,1.5,2048,256,0.05,500,250.0,6.0
+40,0.91568,0.95666,0.77449,1.0,1.5,2048,256,0.1,500,250.0,6.0
+41,0.9154,0.97562,0.76083,1.0,2.0,2048,256,0.05,500,0.0,4.0
+42,0.9154,0.97562,0.76083,1.0,2.0,2048,256,0.1,500,0.0,4.0
+43,0.91469,0.95932,0.76495,1.0,1.5,2048,256,0.1,500,250.0,0.0
+44,0.91469,0.9593,0.76508,1.0,1.5,2048,256,0.05,500,250.0,0.0
+45,0.91465,0.95919,0.76924,1.0,2.0,1024,256,0.05,500,250.0,6.0
+46,0.91461,0.97306,0.76395,1.0,2.5,1024,256,0.05,500,0.0,0.0
+47,0.9146,0.97306,0.76399,1.0,2.5,1024,256,0.1,500,0.0,0.0
+48,0.91457,0.97286,0.76053,1.0,2.5,2048,256,0.05,500,0.0,0.0
+49,0.91457,0.97286,0.76053,1.0,2.5,2048,256,0.1,500,0.0,0.0
+50,0.91439,0.95875,0.76926,1.0,2.0,1024,256,0.1,500,250.0,6.0
+51,0.91432,0.97273,0.76254,1.0,1.5,1024,256,0.05,500,100.0,0.0
+52,0.91432,0.97277,0.76266,1.0,1.5,1024,256,0.1,500,100.0,0.0
+53,0.91427,0.9643,0.76733,1.0,2.0,1024,256,0.1,500,100.0,4.0
+54,0.91403,0.96416,0.76684,1.0,2.0,1024,256,0.05,500,100.0,4.0
+55,0.91395,0.97289,0.76269,1.0,2.5,1024,256,0.1,500,0.0,6.0
+56,0.91395,0.97289,0.76269,1.0,2.5,1024,256,0.05,500,0.0,6.0
+57,0.91382,0.97246,0.76092,1.0,2.5,2048,256,0.05,500,0.0,6.0
+58,0.91382,0.97246,0.76092,1.0,2.5,2048,256,0.1,500,0.0,6.0
+59,0.9136,0.95773,0.76252,1.0,2.0,2048,256,0.05,500,100.0,0.0
+60,0.91359,0.95769,0.76231,1.0,2.0,2048,256,0.1,500,100.0,0.0
+61,0.91297,0.95294,0.76902,1.0,2.0,2048,256,0.05,500,100.0,6.0
+62,0.91292,0.95279,0.76913,1.0,2.0,2048,256,0.1,500,100.0,6.0
+63,0.91258,0.95586,0.76828,1.0,1.5,2048,256,0.05,500,250.0,4.0
+64,0.91253,0.95593,0.76831,1.0,1.5,2048,256,0.1,500,250.0,4.0
+65,0.91249,0.97205,0.75794,1.0,2.5,2048,256,0.05,500,0.0,4.0
+66,0.91249,0.97205,0.75794,1.0,2.5,2048,256,0.1,500,0.0,4.0
+67,0.91233,0.95976,0.7649,1.0,2.0,1024,256,0.1,500,250.0,4.0
+68,0.91217,0.9592,0.7643,1.0,2.0,1024,256,0.05,500,250.0,4.0
+69,0.9121,0.96997,0.75762,1.0,1.5,1024,256,0.1,500,250.0,0.0
+70,0.9121,0.96986,0.75765,1.0,1.5,1024,256,0.05,500,250.0,0.0
+71,0.91206,0.97182,0.75925,1.0,2.5,1024,256,0.05,500,0.0,4.0
+72,0.91206,0.97182,0.75925,1.0,2.5,1024,256,0.1,500,0.0,4.0
+73,0.91124,0.96795,0.75884,1.0,3.0,2048,256,0.05,500,0.0,0.0
+74,0.91124,0.96795,0.75884,1.0,3.0,2048,256,0.1,500,0.0,0.0
+75,0.91107,0.96722,0.76218,1.0,3.0,1024,256,0.1,500,0.0,0.0
+76,0.91107,0.96722,0.76218,1.0,3.0,1024,256,0.05,500,0.0,0.0
+77,0.90989,0.94994,0.7581,1.0,2.0,2048,256,0.05,500,250.0,0.0
+78,0.90988,0.94991,0.75799,1.0,2.0,2048,256,0.1,500,250.0,0.0
+79,0.9096,0.9453,0.76521,1.0,2.0,2048,256,0.05,500,250.0,6.0
+80,0.90959,0.96681,0.75597,1.0,3.0,2048,256,0.05,500,0.0,6.0
+81,0.90959,0.96681,0.75597,1.0,3.0,2048,256,0.1,500,0.0,6.0
+82,0.90953,0.95187,0.76256,1.0,2.0,2048,256,0.05,500,100.0,4.0
+83,0.90953,0.94477,0.76566,1.0,2.0,2048,256,0.1,500,250.0,6.0
+84,0.90942,0.95144,0.7625,1.0,2.0,2048,256,0.1,500,100.0,4.0
+85,0.9094,0.96561,0.75877,1.0,3.0,1024,256,0.1,500,0.0,6.0
+86,0.9094,0.96562,0.75877,1.0,3.0,1024,256,0.05,500,0.0,6.0
+87,0.909,0.9648,0.7527,1.0,2.0,1024,256,0.05,500,100.0,0.0
+88,0.909,0.96473,0.75285,1.0,2.0,1024,256,0.1,500,100.0,0.0
+89,0.90769,0.96556,0.75334,1.0,3.0,2048,256,0.05,500,0.0,4.0
+90,0.90769,0.96556,0.75334,1.0,3.0,2048,256,0.1,500,0.0,4.0
+91,0.90725,0.96353,0.75433,1.0,3.0,1024,256,0.1,500,0.0,4.0
+92,0.90724,0.96353,0.75433,1.0,3.0,1024,256,0.05,500,0.0,4.0
+93,0.90675,0.96053,0.7489,1.0,2.0,1024,256,0.05,500,250.0,0.0
+94,0.90674,0.96041,0.74865,1.0,2.0,1024,256,0.1,500,250.0,0.0
+95,0.90582,0.942,0.75865,1.0,2.0,2048,256,0.05,500,250.0,4.0
+96,0.9057,0.94166,0.75837,1.0,2.0,2048,256,0.1,500,250.0,4.0
+97,0.90492,0.93797,0.75779,1.0,2.5,1024,256,0.05,500,100.0,6.0
+98,0.90456,0.93718,0.75641,1.0,2.5,1024,256,0.1,500,100.0,6.0
+99,0.90441,0.9397,0.75007,1.0,2.5,2048,256,0.05,500,100.0,0.0
+100,0.9044,0.9397,0.75026,1.0,2.5,2048,256,0.1,500,100.0,0.0
+101,0.9031,0.93466,0.75453,1.0,2.5,1024,256,0.05,500,250.0,6.0
+102,0.90272,0.93341,0.75337,1.0,2.5,1024,256,0.1,500,250.0,6.0
+103,0.90139,0.93493,0.74938,1.0,2.5,1024,256,0.05,500,100.0,4.0
+104,0.90136,0.9344,0.74948,1.0,2.5,1024,256,0.1,500,100.0,4.0
+105,0.90081,0.93414,0.74536,1.0,2.5,2048,256,0.1,500,250.0,0.0
+106,0.90081,0.93417,0.74539,1.0,2.5,2048,256,0.05,500,250.0,0.0
+107,0.90046,0.92685,0.75308,1.0,2.5,2048,256,0.05,500,100.0,6.0
+108,0.90039,0.94467,0.74093,1.0,2.5,1024,256,0.05,500,100.0,0.0
+109,0.90038,0.92657,0.75307,1.0,2.5,2048,256,0.1,500,100.0,6.0
+110,0.90036,0.94461,0.74137,1.0,2.5,1024,256,0.1,500,100.0,0.0
+111,0.89947,0.93077,0.74637,1.0,2.5,1024,256,0.05,500,250.0,4.0
+112,0.89937,0.92996,0.74668,1.0,2.5,1024,256,0.1,500,250.0,4.0
+113,0.89814,0.92855,0.74274,1.0,3.0,2048,256,0.05,500,100.0,0.0
+114,0.89814,0.92844,0.74273,1.0,3.0,2048,256,0.1,500,100.0,0.0
+115,0.89796,0.94002,0.73704,1.0,2.5,1024,256,0.05,500,250.0,0.0
+116,0.89793,0.94004,0.73671,1.0,2.5,1024,256,0.1,500,250.0,0.0
+117,0.89738,0.92223,0.74875,1.0,2.5,2048,256,0.05,500,250.0,6.0
+118,0.89728,0.92212,0.74839,1.0,2.5,2048,256,0.1,500,250.0,6.0
+119,0.89589,0.91947,0.7463,1.0,2.5,2048,256,0.05,500,100.0,4.0
+120,0.89579,0.91925,0.74651,1.0,2.5,2048,256,0.1,500,100.0,4.0
+121,0.89559,0.92118,0.74407,1.0,3.0,1024,256,0.05,500,100.0,6.0
+122,0.89539,0.92554,0.73887,1.0,3.0,2048,256,0.1,500,250.0,0.0
+123,0.89539,0.92544,0.73897,1.0,3.0,2048,256,0.05,500,250.0,0.0
+124,0.89512,0.92,0.74294,1.0,3.0,1024,256,0.1,500,100.0,6.0
+125,0.8943,0.91902,0.7421,1.0,3.0,1024,256,0.05,500,250.0,6.0
+126,0.89379,0.91802,0.74069,1.0,3.0,1024,256,0.1,500,250.0,6.0
+127,0.89291,0.92852,0.72894,1.0,3.0,1024,256,0.05,500,100.0,0.0
+128,0.89288,0.92858,0.72881,1.0,3.0,1024,256,0.1,500,100.0,0.0
+129,0.89245,0.91347,0.74168,1.0,2.5,2048,256,0.05,500,250.0,4.0
+130,0.89235,0.91297,0.74183,1.0,2.5,2048,256,0.1,500,250.0,4.0
+131,0.89227,0.91352,0.74314,1.0,3.0,2048,256,0.05,500,100.0,6.0
+132,0.89219,0.91303,0.74303,1.0,3.0,2048,256,0.1,500,100.0,6.0
+133,0.89106,0.91559,0.73677,1.0,3.0,1024,256,0.05,500,100.0,4.0
+134,0.89105,0.91386,0.73688,1.0,3.0,1024,256,0.1,500,100.0,4.0
+135,0.89086,0.92475,0.72639,1.0,3.0,1024,256,0.05,500,250.0,0.0
+136,0.89083,0.92465,0.72637,1.0,3.0,1024,256,0.1,500,250.0,0.0
+137,0.88974,0.91353,0.73471,1.0,3.0,1024,256,0.05,500,250.0,4.0
+138,0.88974,0.90995,0.73926,1.0,3.0,2048,256,0.05,500,250.0,6.0
+139,0.88969,0.91178,0.73463,1.0,3.0,1024,256,0.1,500,250.0,4.0
+140,0.88965,0.9097,0.73974,1.0,3.0,2048,256,0.1,500,250.0,6.0
+141,0.88663,0.90265,0.73501,1.0,3.0,2048,256,0.05,500,100.0,4.0
+142,0.88655,0.9025,0.73544,1.0,3.0,2048,256,0.1,500,100.0,4.0
+143,0.88404,0.89986,0.73167,1.0,3.0,2048,256,0.05,500,250.0,4.0
+144,0.88395,0.89985,0.7318,1.0,3.0,2048,256,0.1,500,250.0,4.0

percorsi.csv

@@ -0,0 +1,39 @@
+Percorso Directory,Tipo
+"./Cymatics - Cratediggers Vol.1/Drum Fills","Drum Loop"
+"./Cymatics - Cratediggers Vol.1/Drum Loops","Drum Loop"
+"./Cymatics - Cratediggers Vol.1/Hihat Loops & MIDI","Drum Loop"
+"./Cymatics - Cratediggers Vol.1/Percussion Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Bassquake/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Commercial Deep House/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Commercial Deep House/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Deathstep Essentials 2/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Deathstep Essentials 2/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Deathstep Essentials 2/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Gaming Dubstep & Midtempo 2/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Gaming Dubstep & Midtempo 2/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Trap & Wave Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2024/Ghosthack - Trap & Wave Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Festival EDM Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Festival EDM Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Festival EDM Essentials/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Hardstyle Legends/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Hardstyle Legends/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Infinite - Liquid DnB Samples/Loops/Drums/Full Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Infinite - Liquid DnB Samples/Loops/Drums/Separated Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Melodic Techno Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Melodic Techno Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Melodic Techno Essentials/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Midtempo Meteor/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Midtempo Meteor/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Neo Rave Essentials/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Neo Rave Essentials/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Neo Rave Essentials/One-Shots/Drum Shots","Drum One Shot"
+"./Ghosthack - Ultimate Producer Bundle 2025/Phonk Essentials/Loops/Drums/Full Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Phonk Essentials/Loops/Drums/Separated Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Vision - Outrun Synthwave/Loops/Drum Fills","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Vision - Outrun Synthwave/Loops/Drum Loops","Drum Loop"
+"./Ghosthack - Ultimate Producer Bundle 2025/Vision - Outrun Synthwave/One-Shots/Drum Shots","Drum One Shot"
+"./Infinity Audio - Hugelism/Drum Loops","Drum Loop"
+"./Infinity Audio - Hugelism/Percussion Loops","Drum Loop"
+"./Sample.Tools.by.Cr2.Festival.Trap.3.MULTiFORMAT-DECiBEL/Festival_Trap_3/Audio_MIDI/Drum Loops","Drum Loop"
+"./The Producer School - Oasis/Sample Pack/Drumloops/Percussion Loops","Drum Loop"

run_param_sweep.py

@@ -0,0 +1,457 @@
+"""
+run_param_sweep.py  —  S-SPADE parameter sweep with residual similarity ranking
+================================================================================
+
+PIPELINE
+--------
+1. Carica test.flac  (limitato)  e  test__3db.flac  (versione +3 dB pre-limiter)
+2. Normalizza entrambi a -20 LUFS integrato con pyloudnorm
+3. Ground-truth residual  = somma in fase inversa dei due (= ciò che il limiter ha tolto)
+4. Normalizza il residual GT a -3 dBFS
+5. Per ogni combinazione di parametri:
+      a. Esegui declip su test.flac
+      b. Normalizza output a -20 LUFS
+      c. Calcola residual  = test_lufs + declipped_lufs * (-1)   (inv. di fase)
+      d. Normalizza a -3 dBFS
+      e. Confronta GT vs residual_iter con similarità coseno su micro-finestre
+         temporali + frequenziali
+6. Stampa ranking finale per similarity media e mediana
+
+DIPENDENZE
+----------
+    pip install numpy scipy soundfile pyloudnorm rich
+    (rich è opzionale ma dà una tabella bella)
+"""
+
+import sys
+import itertools
+import warnings
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+from typing import List, Tuple, Dict, Optional
+import traceback
+
+import numpy as np
+import scipy.signal as sig
+import soundfile as sf
+
+# ── pyloudnorm ───────────────────────────────────────────────────────────────
+try:
+    import pyloudnorm as pyln
+    _HAS_PYLN = True
+except ImportError:
+    _HAS_PYLN = False
+    warnings.warn("pyloudnorm non trovato — installa con: pip install pyloudnorm", stacklevel=1)
+
+# ── spade_declip ─────────────────────────────────────────────────────────────
+try:
+    from spade_declip_v11 import declip, DeclipParams
+    _HAS_SPADE = True
+except ImportError:
+    _HAS_SPADE = False
+    warnings.warn("spade_declip_v11 non trovato — metti il file nella stessa cartella", stacklevel=1)
+
+# ── rich (opzionale) ─────────────────────────────────────────────────────────
+try:
+    from rich.console import Console
+    from rich.table import Table
+    from rich import print as rprint
+    _console = Console()
+    _HAS_RICH = True
+except ImportError:
+    _HAS_RICH = False
+    _console = None
+
+# =============================================================================
+# FILE DI INPUT  — modifica qui se i nomi sono diversi
+# =============================================================================
+FILE_LIMITED  = "test.flac"        # traccia limitata (quella che elaboriamo)
+FILE_PLUS3DB  = "test_3db.flac"   # stessa traccia +3 dB (riferimento pre-limiter)
+LUFS_TARGET   = -20.0              # normalizzazione LUFS integrato per entrambe
+RESIDUAL_DBFS = -3.0               # normalizzazione peak del residual
+
+# =============================================================================
+# GRIGLIA DEI PARAMETRI DA ESPLORARE
+# =============================================================================
+# Ogni lista può avere uno o più valori.
+# Il prodotto cartesiano genera tutte le combinazioni da testare.
+
+PARAM_GRID = {
+    # ── parametri declipping ─────────────────────────────────────────────
+    "delta_db"       : [1.5, 2.0, 2.5, 3.0],
+    "window_length"  : [1024, 2048],
+    "hop_length"     : [256],           # di solito window//4
+    "eps"            : [0.05, 0.1],
+    "max_iter"       : [500],           # alza a 1000 se hai tempo
+    # ── v11 delimiting ───────────────────────────────────────────────────
+    "release_ms"     : [0.0, 100.0, 250.0],
+    "max_gain_db"    : [0.0, 4.0, 6.0],
+}
+
+# Parametri fissi (non cambiano tra le iterazioni)
+FIXED_PARAMS = dict(
+    algo         = "sspade",
+    frame        = "rdft",
+    s            = 1,
+    r            = 1,
+    mode         = "soft",
+    multiband    = False,
+    macro_expand = False,
+    n_jobs       = -1,
+    verbose      = False,
+    show_progress= False,
+)
+
+# Limita il numero massimo di combinazioni da testare (None = tutte)
+MAX_COMBINATIONS: Optional[int] = None   # es. 40 per un test rapido
+
+# =============================================================================
+# FUNZIONI DI SUPPORTO
+# =============================================================================
+
+def normalize_lufs(audio: np.ndarray, sr: int, target_lufs: float) -> np.ndarray:
+    """Normalizza audio (N,C) a target_lufs LUFS integrato."""
+    if not _HAS_PYLN:
+        raise RuntimeError("pyloudnorm richiesto per la normalizzazione LUFS")
+    meter = pyln.Meter(sr)
+    # pyloudnorm vuole (N,) mono o (N,2) stereo
+    loud = meter.integrated_loudness(audio if audio.shape[1] > 1 else audio[:, 0])
+    if np.isinf(loud):
+        return audio  # silenzio — lascia invariato
+    gain_lin = 10 ** ((target_lufs - loud) / 20.0)
+    return audio * gain_lin
+
+
+def normalize_peak_dbfs(audio: np.ndarray, target_dbfs: float) -> np.ndarray:
+    """Normalizza audio al target peak (dBFS)."""
+    peak = np.max(np.abs(audio))
+    if peak < 1e-12:
+        return audio
+    target_lin = 10 ** (target_dbfs / 20.0)
+    return audio * (target_lin / peak)
+
+
+def compute_residual(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """
+    Residual = a + (-b)  (inversione di fase di b).
+    Assicura stessa lunghezza troncando al minimo.
+    """
+    L = min(a.shape[0], b.shape[0])
+    return a[:L] - b[:L]   # equivalente a a + inv_phase(b)
+
+
+def stft_cosine_similarity(
+    gt: np.ndarray,
+    est: np.ndarray,
+    sr: int,
+    win_samples: int = 2048,
+    hop_samples: int = 512,
+    n_freq_bins: int = 16,   # numero di bande di frequenza (mel-like split)
+) -> Dict[str, float]:
+    """
+    Calcola la similarità coseno media tra GT e stima su micro-finestre
+    tempo-frequenziali.
+
+    Strategia:
+    - STFT di entrambi i residual
+    - Split dell'asse frequenze in `n_freq_bins` bande log-spaced
+    - Per ogni banda e ogni frame: cosine similarity vettoriale
+    - Restituisce mean, median, p10, p90
+
+    Input: audio mono 1-D.
+    """
+    def _stft(x):
+        _, _, Z = sig.stft(
+            x, fs=sr, window="hann",
+            nperseg=win_samples, noverlap=win_samples - hop_samples,
+            boundary=None, padded=False
+        )
+        return Z   # shape: (freqs, time)
+
+    # Usa solo il canale L se stereo
+    gt_m  = gt[:, 0]  if gt.ndim == 2 else gt
+    est_m = est[:, 0] if est.ndim == 2 else est
+
+    L = min(len(gt_m), len(est_m))
+    Z_gt  = _stft(gt_m[:L])
+    Z_est = _stft(est_m[:L])
+
+    n_freqs, n_frames = Z_gt.shape
+
+    # Suddividi in bande log-spaced
+    edges = np.unique(
+        np.round(np.logspace(0, np.log10(n_freqs), n_freq_bins + 1)).astype(int)
+    )
+    edges = np.clip(edges, 0, n_freqs)
+
+    similarities = []
+    for i in range(len(edges) - 1):
+        f0, f1 = edges[i], edges[i + 1]
+        if f1 <= f0:
+            continue
+        # Per ogni frame temporale: cosine similarity sul vettore di frequenze nella banda
+        g = np.abs(Z_gt[f0:f1, :])    # (band_size, frames)
+        e = np.abs(Z_est[f0:f1, :])
+
+        # Cosine similarity per ogni frame
+        dot   = np.sum(g * e, axis=0)
+        norm_g = np.sqrt(np.sum(g ** 2, axis=0)) + 1e-12
+        norm_e = np.sqrt(np.sum(e ** 2, axis=0)) + 1e-12
+        cos_frame = dot / (norm_g * norm_e)
+        similarities.extend(cos_frame.tolist())
+
+    arr = np.array(similarities)
+    return {
+        "mean"  : float(np.mean(arr)),
+        "median": float(np.median(arr)),
+        "p10"   : float(np.percentile(arr, 10)),
+        "p90"   : float(np.percentile(arr, 90)),
+    }
+
+
+# =============================================================================
+# PREPARAZIONE GROUND TRUTH
+# =============================================================================
+
+def prepare_ground_truth(sr_ref: int) -> Tuple[np.ndarray, int]:
+    """
+    Carica test.flac e test__3db.flac, normalizza a LUFS_TARGET,
+    calcola il residual GT e lo normalizza a RESIDUAL_DBFS.
+    Ritorna (residual_gt, sr).
+    """
+    print("\n" + "=" * 65)
+    print("CALCOLO GROUND-TRUTH RESIDUAL")
+    print("=" * 65)
+
+    # Carica
+    limited, sr_l = sf.read(FILE_LIMITED,  always_2d=True)
+    plus3db, sr_p = sf.read(FILE_PLUS3DB, always_2d=True)
+    assert sr_l == sr_p, f"Sample rate diversi: {sr_l} vs {sr_p}"
+    sr = sr_l
+
+    limited = limited.astype(float)
+    plus3db = plus3db.astype(float)
+
+    print(f"  {FILE_LIMITED}  : {limited.shape[0]} camp @ {sr} Hz  "
+          f"| peak={np.max(np.abs(limited)):.4f}")
+    print(f"  {FILE_PLUS3DB}: {plus3db.shape[0]} camp @ {sr} Hz  "
+          f"| peak={np.max(np.abs(plus3db)):.4f}")
+
+    # Normalizza LUFS
+    limited_lufs = normalize_lufs(limited, sr, LUFS_TARGET)
+    plus3db_lufs = normalize_lufs(plus3db, sr, LUFS_TARGET)
+    print(f"  Normalizzazione LUFS: target={LUFS_TARGET} dBLUFS")
+
+    # Residual
+    residual_gt = compute_residual(plus3db_lufs, limited_lufs)
+    residual_gt = normalize_peak_dbfs(residual_gt, RESIDUAL_DBFS)
+
+    peak_res = np.max(np.abs(residual_gt))
+    print(f"  Residual GT peak normalizzato: {20*np.log10(peak_res+1e-12):.2f} dBFS  "
+          f"({residual_gt.shape[0]} camp)")
+
+    return residual_gt, sr
+
+
+# =============================================================================
+# SINGOLA ITERAZIONE DECLIP + RESIDUAL
+# =============================================================================
+
+def run_iteration(
+    limited_raw: np.ndarray,
+    sr: int,
+    params_dict: dict,
+    residual_gt: np.ndarray,
+) -> Optional[Dict]:
+    """
+    Esegue una singola iterazione di declip con i params forniti,
+    calcola il residual e la similarità con il GT.
+    Ritorna un dizionario con i risultati, o None se fallisce.
+    """
+    try:
+        # DeclipParams
+        p = DeclipParams(
+            sample_rate = sr,
+            **{k: v for k, v in FIXED_PARAMS.items()},
+            **params_dict,
+        )
+
+        fixed, _ = declip(limited_raw.copy(), p)
+        fixed_2d = fixed[:, None] if fixed.ndim == 1 else fixed
+
+        # Normalizza output a LUFS_TARGET
+        fixed_lufs = normalize_lufs(fixed_2d, sr, LUFS_TARGET)
+
+        # Carica anche il limited normalizzato LUFS (ricalcola ogni volta per sicurezza)
+        limited_lufs = normalize_lufs(limited_raw, sr, LUFS_TARGET)
+
+        # Residual iterazione
+        residual_iter = compute_residual(fixed_lufs, limited_lufs)
+        residual_iter = normalize_peak_dbfs(residual_iter, RESIDUAL_DBFS)
+
+        # Similarità coseno su micro-finestre TF
+        sim = stft_cosine_similarity(residual_gt, residual_iter, sr)
+
+        return {
+            "params"  : params_dict,
+            "sim_mean"  : sim["mean"],
+            "sim_median": sim["median"],
+            "sim_p10"   : sim["p10"],
+            "sim_p90"   : sim["p90"],
+        }
+
+    except Exception as exc:
+        print(f"  [ERRORE] {exc}")
+        traceback.print_exc()
+        return None
+
+
+# =============================================================================
+# STAMPA RISULTATI
+# =============================================================================
+
+def print_results(results: List[Dict], top_n: int = 20):
+    """Stampa il ranking per sim_mean decrescente."""
+
+    results_sorted = sorted(results, key=lambda x: x["sim_mean"], reverse=True)
+
+    print("\n" + "=" * 65)
+    print(f"RANKING  (top {min(top_n, len(results_sorted))} / {len(results_sorted)} iterazioni)")
+    print(f"Metrica principale: similarità coseno media sulle micro-finestre TF")
+    print("=" * 65)
+
+    if _HAS_RICH:
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("#",           style="dim",   width=4)
+        table.add_column("mean",        justify="right", width=7)
+        table.add_column("median",      justify="right", width=7)
+        table.add_column("p10",         justify="right", width=7)
+        table.add_column("p90",         justify="right", width=7)
+        table.add_column("delta_db",    justify="right", width=8)
+        table.add_column("win",         justify="right", width=6)
+        table.add_column("hop",         justify="right", width=6)
+        table.add_column("eps",         justify="right", width=6)
+        table.add_column("max_iter",    justify="right", width=8)
+        table.add_column("release_ms",  justify="right", width=10)
+        table.add_column("max_gain_db", justify="right", width=11)
+
+        for rank, r in enumerate(results_sorted[:top_n], 1):
+            p = r["params"]
+            row_style = "green" if rank == 1 else ("yellow" if rank <= 3 else "")
+            table.add_row(
+                str(rank),
+                f"{r['sim_mean']:.4f}",
+                f"{r['sim_median']:.4f}",
+                f"{r['sim_p10']:.4f}",
+                f"{r['sim_p90']:.4f}",
+                str(p.get("delta_db", "—")),
+                str(p.get("window_length", "—")),
+                str(p.get("hop_length", "—")),
+                str(p.get("eps", "—")),
+                str(p.get("max_iter", "—")),
+                str(p.get("release_ms", "—")),
+                str(p.get("max_gain_db", "—")),
+                style=row_style,
+            )
+        _console.print(table)
+    else:
+        header = (
+            f"{'#':>3}  {'mean':>7}  {'med':>7}  {'p10':>7}  {'p90':>7}"
+            f"  {'Δdb':>5}  {'win':>5}  {'hop':>4}  {'eps':>5}  "
+            f"{'iter':>5}  {'rel_ms':>7}  {'gain_db':>8}"
+        )
+        print(header)
+        print("-" * len(header))
+        for rank, r in enumerate(results_sorted[:top_n], 1):
+            p = r["params"]
+            print(
+                f"{rank:>3}  {r['sim_mean']:>7.4f}  {r['sim_median']:>7.4f}"
+                f"  {r['sim_p10']:>7.4f}  {r['sim_p90']:>7.4f}"
+                f"  {p.get('delta_db',0):>5}  {p.get('window_length',0):>5}"
+                f"  {p.get('hop_length',0):>4}  {p.get('eps',0):>5}"
+                f"  {p.get('max_iter',0):>5}  {p.get('release_ms',0):>7}"
+                f"  {p.get('max_gain_db',0):>8}"
+            )
+
+    # Parametri migliori
+    best = results_sorted[0]
+    print("\n✓ PARAMETRI MIGLIORI:")
+    for k, v in best["params"].items():
+        print(f"    {k} = {v}")
+    print(f"  → sim_mean={best['sim_mean']:.4f}  "
+          f"sim_median={best['sim_median']:.4f}")
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def main():
+    if not _HAS_PYLN:
+        sys.exit("Installa pyloudnorm prima di eseguire:  pip install pyloudnorm")
+    if not _HAS_SPADE:
+        sys.exit("spade_declip_v11.py non trovato nella cartella corrente")
+
+    # ── Carica il file limitato una sola volta ────────────────────────────
+    limited_raw, sr = sf.read(FILE_LIMITED, always_2d=True)
+    limited_raw = limited_raw.astype(float)
+
+    # ── Ground-truth residual ─────────────────────────────────────────────
+    residual_gt, sr = prepare_ground_truth(sr)
+
+    # ── Genera griglia parametri ──────────────────────────────────────────
+    keys   = list(PARAM_GRID.keys())
+    values = list(PARAM_GRID.values())
+    combos = list(itertools.product(*values))
+
+    if MAX_COMBINATIONS and len(combos) > MAX_COMBINATIONS:
+        # Campionamento stratificato semplice (ogni N)
+        step   = len(combos) // MAX_COMBINATIONS
+        combos = combos[::step][:MAX_COMBINATIONS]
+        print(f"\n[INFO] Griglia ridotta a {len(combos)} combinazioni (MAX_COMBINATIONS={MAX_COMBINATIONS})")
+
+    print(f"\n{'='*65}")
+    print(f"PARAM SWEEP  —  {len(combos)} combinazioni da testare")
+    print(f"{'='*65}")
+
+    results = []
+    for i, combo in enumerate(combos):
+        params_dict = dict(zip(keys, combo))
+        label = "  ".join(f"{k}={v}" for k, v in params_dict.items())
+        print(f"\n[{i+1:>3}/{len(combos)}]  {label}")
+
+        res = run_iteration(limited_raw, sr, params_dict, residual_gt)
+        if res is not None:
+            print(f"        → sim_mean={res['sim_mean']:.4f}  "
+                  f"sim_median={res['sim_median']:.4f}")
+            results.append(res)
+        else:
+            print("        → SALTATO (errore)")
+
+    if not results:
+        print("\n[ERRORE] Nessuna iterazione completata.")
+        return
+
+    print_results(results, top_n=20)
+
+    # ── Salva CSV con tutti i risultati ───────────────────────────────────
+    import csv
+    csv_path = "param_sweep_results.csv"
+    fieldnames = ["rank", "sim_mean", "sim_median", "sim_p10", "sim_p90"] + keys
+    results_sorted = sorted(results, key=lambda x: x["sim_mean"], reverse=True)
+    with open(csv_path, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        for rank, r in enumerate(results_sorted, 1):
+            row = {"rank": rank,
+                   "sim_mean":   round(r["sim_mean"],   5),
+                   "sim_median": round(r["sim_median"], 5),
+                   "sim_p10":    round(r["sim_p10"],    5),
+                   "sim_p90":    round(r["sim_p90"],    5)}
+            row.update(r["params"])
+            w.writerow(row)
+    print(f"\n  📄 Risultati salvati in: {csv_path}")
+
+
+if __name__ == "__main__":
+    main()

run_smart_sweep.py

@@ -0,0 +1,1136 @@
+"""
+run_smart_sweep.py  —  Hybrid SPADE  (v11 HF + Unrolled LF)  ·  Bayesian sweep
+===============================================================================
+
+Architettura ibrida
+-------------------
+  segnale limitato
+       ↓
+  LR crossover split a BAND_CROSSOVER_HZ (default 8000 Hz)
+       ├── HF (> 8 kHz) → SPADE v11 S-SPADE  H_k  (hard thresh, identico, invariato)
+       └── LF (< 8 kHz) → SPADEUnrolled model       (soft thresh appreso, context GRU)
+       ↓
+  somma LF_rec + HF_rec  →  segnale recuperato
+
+Razionale
+---------
+SPADE v11 recupera bene i transienti HF (cymbal snap, hi-hat attack, snap):
+i coefficienti DCT sopra 8 kHz sono sparsi e H_k li trova in poche iterazioni.
+Sotto 8 kHz (corpo kick, fondamentale del basso) v11 sotto-recupera perché:
+  • il livello di sparsità k corretto è content-dipendente e il piano fisso
+    s/r/max_iter non lo indovina
+  • i contenuti tonali/sustain non sono globalmente sparsi → H_k spreca
+    budget su coefficienti HF irrilevanti
+Il modello appreso risolve entrambi i problemi via lambda_lf adattivo e g_max.
+
+Pipeline di valutazione (6 tracce, standard run_smart_sweep)
+-------------------------------------------------------------
+  01_orig_with_noise   drum + pink noise @0 dBFS (ingresso pipeline)
+  02_limited           uscita limiter (ingresso SPADE)  ≈ −LIMITER_THRESHOLD_DB dBFS
+  03_gt_residual       GT residual @RESIDUAL_DBFS       (include attenuazione noise)
+  04_spade_output      uscita ibrida (float32, può >0 dBFS)
+  05_res_iter          residual ibrido @RESIDUAL_DBFS    (solo componente sparsa)
+  06_diff_residuals    GT_res − res_iter @RESIDUAL_DBFS  (silenzio ideale)
+                       → annotato con cos_sim, diff/GT dB, noise_floor
+
+Sweep Bayesiano
+---------------
+Il modello ML è fisso (pesi caricati da checkpoint).
+Il TPE ottimizza i parametri classici indipendentemente per ogni banda:
+  LF: lf_delta_db, lf_max_gain_db, lf_release_ms
+  HF: hf_delta_db, hf_win, hf_hop, hf_release_ms, hf_max_gain_db, hf_eps, hf_max_iter
+
+USO
+---
+  python run_smart_sweep.py --model checkpoints/phase1_best.pt
+  python run_smart_sweep.py --model checkpoints/phase1_best.pt --trials 100
+  python run_smart_sweep.py --model checkpoints/phase1_best.pt --debug-export 5
+  python run_smart_sweep.py --model checkpoints/phase1_best.pt --resume
+  python run_smart_sweep.py --model checkpoints/phase1_best.pt --report
+
+  # baseline: solo v11 broadband (senza modello ML)
+  python run_smart_sweep.py --baseline-v11
+
+DIPENDENZE
+----------
+  pip install numpy scipy soundfile optuna rich torch
+  spade_declip_v11.py  — deve essere nel Python path
+  spade_unrolled.py    — deve essere nel Python path (per HybridSPADEInference)
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+import time
+import warnings
+from dataclasses import asdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import scipy.signal as sig
+import soundfile as sf
+
+logging.getLogger("optuna").setLevel(logging.WARNING)
+
+# ── optuna ───────────────────────────────────────────────────────────────────
+try:
+    import optuna
+    from optuna.samplers import TPESampler
+    from optuna.pruners  import MedianPruner
+    _HAS_OPTUNA = True
+except ImportError:
+    _HAS_OPTUNA = False
+    warnings.warn("optuna non trovato — pip install optuna")
+
+# ── rich ─────────────────────────────────────────────────────────────────────
+try:
+    from rich.console import Console
+    from rich.table   import Table
+    _console  = Console()
+    _HAS_RICH = True
+except ImportError:
+    _HAS_RICH = False
+    _console  = None
+
+# ── spade v11 ────────────────────────────────────────────────────────────────
+try:
+    from spade_declip_v11 import declip as _v11_declip, DeclipParams as _V11Params
+    _HAS_V11 = True
+except ImportError:
+    _HAS_V11 = False
+    warnings.warn("spade_declip_v11.py non trovato — processing HF non disponibile")
+
+# ── spade_unrolled ────────────────────────────────────────────────────────────
+try:
+    import torch
+    from spade_unrolled import (
+        SPADEUnrolled, UnrolledConfig, SPADEUnrolledInference,
+        HybridSPADEInference,
+    )
+    _HAS_UNROLLED = True
+except ImportError:
+    _HAS_UNROLLED = False
+    warnings.warn("spade_unrolled.py / torch non trovati — modello ML non disponibile")
+
+
+# =============================================================================
+# CONFIG
+# =============================================================================
+
+DRUM_DIRS = ["Kicks", "Snares", "Perc", "Tops"]
+
+# Limiter sintetico (identico a run_smart_sweep_old)
+LIMITER_THRESHOLD_DB = 1.5      # dB sotto il ceiling (positivo)
+LIMITER_RELEASE_MS   = 80.0     # release del limiter sintetico (ms)
+
+RESIDUAL_DBFS       = -3.0      # normalizzazione residual per comparabilità cross-file
+PINK_NOISE_LEVEL_DB = -20.0     # noise di sottofondo (dB rel. al peak del drum)
+
+# Crossover LF/HF: HF usa v11 invariato, LF usa modello appreso
+BAND_CROSSOVER_HZ = 8000.0
+
+# Parametri FISSI del solver v11 (HF)
+HF_FIXED = dict(
+    algo          = "sspade",
+    frame         = "rdft",
+    mode          = "soft",
+    n_jobs        = 1,
+    verbose       = False,
+    show_progress = False,
+    use_gpu       = True,
+)
+
+STUDY_NAME = "hybrid_spade_v1"
+OUT_CSV    = "hybrid_sweep_results.csv"
+
+# Parametri debug di default (usati da --debug-export senza sweep)
+DEBUG_HF = dict(
+    hf_delta_db      = 1.5,
+    hf_window_length = 2048,
+    hf_hop_length    = 512,
+    hf_release_ms    = 80.0,
+    hf_max_gain_db   = 9.0,
+    hf_eps           = 0.05,
+    hf_max_iter      = 500,
+)
+DEBUG_LF = dict(
+    lf_delta_db    = 1.5,
+    lf_max_gain_db = 9.0,
+    lf_release_ms  = 80.0,
+)
+
+
+# =============================================================================
+# HELPERS  (identici a run_smart_sweep_old)
+# =============================================================================
+
+def ensure_2d(a: np.ndarray) -> np.ndarray:
+    return a[:, None] if a.ndim == 1 else a
+
+
+def normalize_to_0dBFS(a: np.ndarray) -> np.ndarray:
+    pk = np.max(np.abs(a))
+    return a / pk if pk > 1e-12 else a
+
+
+def normalize_peak(a: np.ndarray, target_dbfs: float) -> np.ndarray:
+    pk = np.max(np.abs(a))
+    return a * (10 ** (target_dbfs / 20.0) / pk) if pk > 1e-12 else a
+
+
+def generate_pink_noise(
+    n_samples: int, n_channels: int, rng: np.random.Generator
+) -> np.ndarray:
+    b = np.array([0.049922035, -0.095993537,  0.050612699, -0.004408786])
+    a = np.array([1.0,         -2.494956002,  2.017265875, -0.522189400])
+    out = np.empty((n_samples, n_channels))
+    for c in range(n_channels):
+        white = rng.standard_normal(n_samples)
+        pink  = sig.lfilter(b, a, white)
+        rms   = np.sqrt(np.mean(pink ** 2))
+        out[:, c] = pink / (rms + 1e-12)
+    return out
+
+
+def mix_pink_noise(
+    audio_0dBFS: np.ndarray,
+    sr:          int,
+    level_db:    float,
+    rng:         np.random.Generator,
+) -> np.ndarray:
+    audio = ensure_2d(audio_0dBFS)
+    N, C  = audio.shape
+    noise = generate_pink_noise(N, C, rng)
+    peak  = np.max(np.abs(audio))
+    gain  = peak * (10 ** (level_db / 20.0))
+    mixed = audio + noise * gain
+    return mixed[:, 0] if audio_0dBFS.ndim == 1 else mixed
+
+
+def apply_brickwall_limiter(
+    audio_0dBFS:  np.ndarray,
+    sr:           int,
+    threshold_db: float = LIMITER_THRESHOLD_DB,
+    release_ms:   float = LIMITER_RELEASE_MS,
+) -> np.ndarray:
+    thr_lin = 10 ** (-abs(threshold_db) / 20.0)
+    rc      = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9))
+    audio   = ensure_2d(audio_0dBFS).copy()
+    N, C    = audio.shape
+    out     = np.empty_like(audio)
+    for c in range(C):
+        ch  = audio[:, c]
+        env = 1.0
+        g   = np.empty(N)
+        for n in range(N):
+            pk     = abs(ch[n])
+            target = thr_lin / pk if pk > thr_lin else 1.0
+            env    = target if target < env else rc * env + (1.0 - rc) * target
+            g[n]   = env
+        out[:, c] = ch * g
+    return out[:, 0] if audio_0dBFS.ndim == 1 else out
+
+
+def cosine_sim_tf(
+    gt:          np.ndarray,
+    est:         np.ndarray,
+    sr:          int,
+    win_samples: int = 1024,
+    hop_samples: int = 256,
+    n_bands:     int = 12,
+) -> float:
+    L = min(gt.shape[0], est.shape[0])
+    g = (gt[:L, 0]  if gt.ndim  == 2 else gt[:L]).copy()
+    e = (est[:L, 0] if est.ndim == 2 else est[:L]).copy()
+    win = min(win_samples, max(32, L // 4))
+    hop = min(hop_samples, win // 2)
+    if L < win or win < 32:
+        denom = np.linalg.norm(g) * np.linalg.norm(e) + 1e-12
+        return float(np.dot(g, e) / denom)
+    _, _, Zg = sig.stft(g, fs=sr, window="hann", nperseg=win,
+                        noverlap=win - hop, boundary=None, padded=False)
+    _, _, Ze = sig.stft(e, fs=sr, window="hann", nperseg=win,
+                        noverlap=win - hop, boundary=None, padded=False)
+    n_freqs, n_frames = Zg.shape
+    if n_frames == 0:
+        return float(np.dot(g, e) / (np.linalg.norm(g) * np.linalg.norm(e) + 1e-12))
+    edges = np.unique(np.round(
+        np.logspace(0, np.log10(max(n_freqs, 2)), min(n_bands, n_freqs) + 1)
+    ).astype(int))
+    edges = np.clip(edges, 0, n_freqs)
+    sims  = []
+    for i in range(len(edges) - 1):
+        f0, f1 = int(edges[i]), int(edges[i + 1])
+        if f1 <= f0: continue
+        Mg = np.abs(Zg[f0:f1, :])
+        Me = np.abs(Ze[f0:f1, :])
+        dot    = np.sum(Mg * Me, axis=0)
+        norm_g = np.sqrt(np.sum(Mg ** 2, axis=0)) + 1e-12
+        norm_e = np.sqrt(np.sum(Me ** 2, axis=0)) + 1e-12
+        sims.extend((dot / (norm_g * norm_e)).tolist())
+    return float(np.mean(sims)) if sims else 0.0
+
+
+def _pk_dbfs(a: np.ndarray) -> float:
+    pk = float(np.max(np.abs(a)))
+    return 20.0 * np.log10(pk) if pk > 1e-12 else -999.0
+
+
+def _rms_dbfs(a: np.ndarray) -> float:
+    rms = float(np.sqrt(np.mean(np.asarray(a).astype(float) ** 2)))
+    return 20.0 * np.log10(rms) if rms > 1e-12 else -999.0
+
+
+def _write_wav(path: Path, audio: np.ndarray, sr: int) -> None:
+    a2d = ensure_2d(audio).astype(np.float32)
+    pk  = float(np.max(np.abs(a2d)))
+    if pk > 1.0:
+        print(f"    [WARN] {path.name}: peak={pk:.4f} (+{20*np.log10(pk):.2f} dBFS) — float32")
+    sf.write(str(path), a2d, sr, subtype="FLOAT")
+
+
+# =============================================================================
+# CORPUS
+# =============================================================================
+
+def build_corpus(base_dir: Path, max_files: Optional[int] = None) -> List[Dict]:
+    """
+    Per ogni drum sample:
+      1. Carica e normalizza a 0 dBFS peak
+      2. Mixa rumore rosa a PINK_NOISE_LEVEL_DB
+      3. Normalizza il mix a 0 dBFS peak
+      4. Applica limiter sintetico → limited
+      5. GT_res_raw = orig_with_noise − limited
+      6. Scarta file dove il limiter non interviene
+      7. Normalizza GT_res a RESIDUAL_DBFS
+
+    Nuovo rispetto alla versione precedente:
+      • orig_with_noise viene salvato nel corpus (evita ricalcolo in debug_export)
+    """
+    corpus     = []
+    extensions = {".wav", ".flac", ".aif", ".aiff"}
+    file_index = 0
+
+    for folder in DRUM_DIRS:
+        d = base_dir / folder
+        if not d.exists():
+            print(f"  [WARN] Cartella non trovata: {d}")
+            continue
+        for f in sorted(d.glob("*")):
+            if f.suffix.lower() not in extensions:
+                continue
+            try:
+                audio, sr = sf.read(str(f), always_2d=True)
+                audio = audio.astype(float)
+            except Exception as exc:
+                print(f"  [WARN] {f.name}: {exc}")
+                continue
+            if audio.shape[0] < 64:
+                continue
+
+            orig  = normalize_to_0dBFS(audio)
+            rng   = np.random.default_rng(seed=file_index)
+            mixed = ensure_2d(mix_pink_noise(orig, sr, PINK_NOISE_LEVEL_DB, rng))
+            file_index += 1
+            orig_with_noise = ensure_2d(normalize_to_0dBFS(mixed))
+            limited         = ensure_2d(apply_brickwall_limiter(orig_with_noise, sr))
+            gt_res_raw      = orig_with_noise - limited
+
+            if np.max(np.abs(gt_res_raw)) < 1e-6:
+                print(f"  [SKIP] {f.name} — limiter inattivo")
+                continue
+
+            gt_res = normalize_peak(gt_res_raw, RESIDUAL_DBFS)
+
+            corpus.append({
+                "file":           f.name,
+                "sr":             sr,
+                "orig_with_noise": orig_with_noise,   # ← nuovo: già pronto
+                "limited":        limited,
+                "gt_res":         gt_res,
+                "gt_res_raw":     gt_res_raw,         # ← nuovo: scala assoluta
+            })
+            if max_files and len(corpus) >= max_files:
+                return corpus
+
+    return corpus
+
+
+# =============================================================================
+# HYBRID PROCESSOR
+# =============================================================================
+
+def _lr_split_np(x: np.ndarray, crossover_hz: float, sr: int
+                 ) -> Tuple[np.ndarray, np.ndarray]:
+    """Phase-perfect LR crossover.  lp + hp == x esattamente."""
+    from scipy.signal import butter, sosfiltfilt
+    fc  = float(np.clip(crossover_hz, 1.0, sr / 2.0 - 1.0))
+    sos = butter(2, fc, btype="low", fs=sr, output="sos")
+    lp  = sosfiltfilt(sos, x)
+    hp  = x - lp
+    return lp, hp
+
+
+def process_hybrid(
+    limited:       np.ndarray,    # (N,) o (N, C) — segnale limitato
+    sr:            int,
+    hf_params:     dict,           # parametri per v11 HF
+    lf_model:      Optional["HybridSPADEInference"],  # None = solo v11
+    lf_params:     dict,           # parametri per LF (delta_db, max_gain_db, …)
+    crossover_hz:  float = BAND_CROSSOVER_HZ,
+) -> np.ndarray:
+    """
+    Processa un segnale con la pipeline ibrida:
+      HF (> crossover_hz): v11 S-SPADE invariato
+      LF (< crossover_hz): SPADEUnrolled (o v11 se lf_model is None)
+
+    Se lf_model is None → usa v11 anche per LF (modalità baseline).
+
+    Restituisce lo stesso shape di limited.
+    """
+    if not _HAS_V11:
+        raise RuntimeError("spade_declip_v11.py non trovato — impossibile processare HF")
+
+    mono = limited.ndim == 1
+    if mono:
+        limited = limited[:, None]
+    _, C   = limited.shape
+    output = np.zeros_like(limited, dtype=np.float64)
+
+    for ch in range(C):
+        yc = limited[:, ch].astype(np.float64)
+
+        # ── LR split ────────────────────────────────────────────────────
+        lf_band, hf_band = _lr_split_np(yc, crossover_hz, sr)
+
+        # ── HF: v11 S-SPADE identico ─────────────────────────────────────
+        hf_win  = hf_params.get("hf_window_length", 2048)
+        hf_hop  = hf_params.get("hf_hop_length",    hf_win // 4)
+        hf_p = _V11Params(
+            sample_rate   = sr,
+            delta_db      = hf_params.get("hf_delta_db",    1.5),
+            window_length = hf_win,
+            hop_length    = hf_hop,
+            s             = hf_params.get("hf_s",           1),
+            r             = hf_params.get("hf_r",           1),
+            eps           = hf_params.get("hf_eps",         0.05),
+            max_iter      = hf_params.get("hf_max_iter",    500),
+            max_gain_db   = hf_params.get("hf_max_gain_db", 9.0),
+            release_ms    = hf_params.get("hf_release_ms",  0.0),
+            **HF_FIXED,
+        )
+        hf_rec, _ = _v11_declip(hf_band.astype(np.float32), hf_p)
+
+        # ── LF: modello appreso o v11 fallback ────────────────────────────
+        if lf_model is not None:
+            # Aggiorna i parametri LF nel wrapper (ricrea SPADEUnrolledInference)
+            lf_infer = SPADEUnrolledInference(
+                lf_model.model,
+                delta_db    = lf_params.get("lf_delta_db",    1.5),
+                max_gain_db = lf_params.get("lf_max_gain_db", 9.0),
+                device      = lf_model.device,
+            )
+            lf_rec = lf_infer.process(lf_band.astype(np.float32), sr)
+        else:
+            # Baseline: v11 anche per LF
+            lf_win = hf_params.get("hf_window_length", 2048)
+            lf_hop = lf_win // 4
+            lf_p = _V11Params(
+                sample_rate   = sr,
+                delta_db      = lf_params.get("lf_delta_db",    1.5),
+                window_length = lf_win,
+                hop_length    = lf_hop,
+                eps           = hf_params.get("hf_eps",         0.05),
+                max_iter      = hf_params.get("hf_max_iter",    500),
+                max_gain_db   = lf_params.get("lf_max_gain_db", 9.0),
+                release_ms    = lf_params.get("lf_release_ms",  0.0),
+                **HF_FIXED,
+            )
+            lf_rec, _ = _v11_declip(lf_band.astype(np.float32), lf_p)
+
+        # ── Somma ─────────────────────────────────────────────────────────
+        L = min(len(lf_rec), len(hf_rec))
+        output[:L, ch] = lf_rec[:L].astype(np.float64) + hf_rec[:L]
+
+    return output[:, 0] if mono else output
+
+
+# =============================================================================
+# VALUTAZIONE SINGOLO FILE
+# =============================================================================
+
+def evaluate_one(
+    item:         Dict,
+    hf_params:    dict,
+    lf_params:    dict,
+    lf_model:     Optional["HybridSPADEInference"],
+) -> Optional[float]:
+    """
+    Esegue la pipeline ibrida su un item del corpus e restituisce il punteggio
+    cosine_sim_tf(gt_res, res_iter) in [0, 1].  1.0 = recupero perfetto.
+    """
+    try:
+        sr      = item["sr"]
+        limited = item["limited"].copy()
+        gt_res  = item["gt_res"]
+
+        fixed_2d = ensure_2d(process_hybrid(limited, sr, hf_params, lf_model, lf_params))
+        res_raw  = fixed_2d - limited
+        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)
+
+        return cosine_sim_tf(gt_res, res_iter, sr)
+    except Exception as exc:
+        warnings.warn(f"evaluate_one ({item['file']}): {exc}")
+        return None
+
+
+# =============================================================================
+# OBIETTIVO OPTUNA
+# =============================================================================
+
+def make_objective(
+    corpus:   List[Dict],
+    lf_model: Optional["HybridSPADEInference"],
+):
+    def objective(trial: "optuna.Trial") -> float:
+
+        # ── Parametri HF (v11 S-SPADE) ───────────────────────────────────
+        hf_delta  = trial.suggest_float("hf_delta_db",    0.5,  3.0, step=0.1)
+        hf_win_e  = trial.suggest_int  ("hf_win_exp",     9,    11)
+        hf_hop_d  = trial.suggest_categorical("hf_hop_div", [4, 8])
+        hf_rel    = trial.suggest_float("hf_release_ms",  0.0, 150.0, step=5.0)
+        hf_gain   = trial.suggest_float("hf_max_gain_db", 2.0,  12.0, step=0.5)
+        hf_eps    = trial.suggest_categorical("hf_eps",   [0.03, 0.05, 0.1])
+        hf_iter   = trial.suggest_categorical("hf_max_iter", [250, 500, 1000])
+        hf_win    = 2 ** hf_win_e
+        hf_hop    = hf_win // hf_hop_d
+
+        # ── Parametri LF (SPADEUnrolled) ─────────────────────────────────
+        # Il modello è fisso; ottimizziamo soglia/gain per la banda LF.
+        lf_delta  = trial.suggest_float("lf_delta_db",    0.5,  3.0, step=0.1)
+        lf_gain   = trial.suggest_float("lf_max_gain_db", 3.0,  12.0, step=0.5)
+        lf_rel    = trial.suggest_float("lf_release_ms",  0.0, 150.0, step=5.0)
+
+        hf_params = dict(
+            hf_delta_db      = hf_delta,
+            hf_window_length = hf_win,
+            hf_hop_length    = hf_hop,
+            hf_release_ms    = hf_rel,
+            hf_max_gain_db   = hf_gain,
+            hf_eps           = hf_eps,
+            hf_max_iter      = hf_iter,
+        )
+        lf_params = dict(
+            lf_delta_db    = lf_delta,
+            lf_max_gain_db = lf_gain,
+            lf_release_ms  = lf_rel,
+        )
+
+        scores   = []
+        midpoint = len(corpus) // 2
+
+        for step, item in enumerate(corpus):
+            sc = evaluate_one(item, hf_params, lf_params, lf_model)
+            if sc is not None:
+                scores.append(sc)
+            if step == midpoint and scores:
+                trial.report(float(np.mean(scores)), step=step)
+                if trial.should_prune():
+                    raise optuna.TrialPruned()
+
+        if not scores:
+            return 0.0
+        mean_score = float(np.mean(scores))
+        trial.report(mean_score, step=len(corpus))
+        return mean_score
+
+    return objective
+
+
+# =============================================================================
+# DEBUG EXPORT  (6 tracce + analisi spettrale)
+# =============================================================================
+
+def debug_export(
+    corpus:    list,
+    base_dir:  Path,
+    out_dir:   Path,
+    n_files:   int,
+    hf_params: dict,
+    lf_params: dict,
+    lf_model:  Optional["HybridSPADEInference"],
+) -> None:
+    """
+    Esporta 6 WAV float32 per i primi n_files item del corpus.
+
+    Tracce esportate
+    ----------------
+    01_orig_with_noise  drum + pink noise @0 dBFS (prima del limiter)
+    02_limited          uscita limiter (ingresso SPADE)
+    03_gt_residual      GT residual @RESIDUAL_DBFS
+    04_spade_output     uscita ibrida (può >0 dBFS)
+    05_res_iter         residual ibrido @RESIDUAL_DBFS
+    06_diff_residuals   GT_res − res_iter @RESIDUAL_DBFS
+                        → annotato: cos_sim, diff/GT dB, noise_floor dB
+
+    Metrica ideale: 06 = silenzio (diff → −∞ dB)
+    Floor fisico  : ~ PINK_NOISE_LEVEL_DB + RESIDUAL_DBFS (rumore irrecuperabile)
+    """
+    out_dir.mkdir(parents=True, exist_ok=True)
+    items  = corpus[:n_files]
+    col_w  = max(len(it["file"]) for it in items) + 2
+
+    HDR = (f"  {'file':<{col_w}}  {'traccia':<22}"
+           f"  {'peak dBFS':>10}  {'RMS dBFS':>9}  note")
+    SEP = "  " + "─" * (len(HDR) - 2)
+
+    mode_str = "IBRIDO (v11 HF + ML LF)" if lf_model is not None else "BASELINE v11 broadband"
+
+    print()
+    if _HAS_RICH:
+        _console.rule(f"[bold cyan]DEBUG EXPORT — {mode_str}[/]")
+    else:
+        print("=" * 72)
+        print(f"DEBUG EXPORT — {mode_str}")
+        print("=" * 72)
+
+    print(f"  Output dir    : {out_dir}")
+    print(f"  Modalità      : {mode_str}")
+    print(f"  Crossover     : {BAND_CROSSOVER_HZ:.0f} Hz")
+    print(f"  HF params     : delta={hf_params.get('hf_delta_db',1.5):.2f}"
+          f"  win={hf_params.get('hf_window_length',2048)}"
+          f"  rel={hf_params.get('hf_release_ms',0):.0f}ms"
+          f"  gain={hf_params.get('hf_max_gain_db',9):.1f}dB"
+          f"  eps={hf_params.get('hf_eps',0.05)}"
+          f"  iter={hf_params.get('hf_max_iter',500)}")
+    print(f"  LF params     : delta={lf_params.get('lf_delta_db',1.5):.2f}"
+          f"  gain={lf_params.get('lf_max_gain_db',9):.1f}dB"
+          f"  rel={lf_params.get('lf_release_ms',0):.0f}ms")
+    print(f"  File esportati: {len(items)}")
+    print()
+    print(f"  Livelli attesi:")
+    print(f"    01  ≈   0.00 dBFS  (normalizzato prima del limiter)")
+    print(f"    02  ≈ {-LIMITER_THRESHOLD_DB:+.2f} dBFS  (uscita limiter)")
+    print(f"    03  = {RESIDUAL_DBFS:+.2f} dBFS  (GT residual normalizzato)")
+    print(f"    04  può >0 dBFS    (transiente recuperato)")
+    print(f"    05  = {RESIDUAL_DBFS:+.2f} dBFS  (residual ibrido normalizzato)")
+    print(f"    06  << 0 dBFS      (più basso = migliore)")
+    print()
+    print(HDR)
+
+    diff_stats = []
+
+    for file_idx, item in enumerate(items):
+        sr               = item["sr"]
+        limited          = item["limited"].copy()
+        gt_res           = item["gt_res"]
+        gt_res_raw       = item["gt_res_raw"]
+        orig_with_noise  = item["orig_with_noise"]
+        stem             = Path(item["file"]).stem
+
+        # ── Esegui pipeline ibrida ───────────────────────────────��────────
+        try:
+            fixed_2d = ensure_2d(
+                process_hybrid(limited.copy(), sr, hf_params, lf_model, lf_params)
+            )
+        except Exception as exc:
+            print(f"  [ERRORE] {item['file']}: {exc}")
+            continue
+
+        # ── Residual iterazione (scala assoluta) ─────────────────────────
+        res_raw = fixed_2d - limited
+
+        # ── Metriche sulla scala raw (non normalizzata) ───────────────────
+        gt_arr  = gt_res_raw
+        est_arr = res_raw
+        L       = min(gt_arr.shape[0], est_arr.shape[0])
+
+        # Cosine similarity temporale (canale L)
+        g_flat = gt_arr[:L, 0]  if gt_arr.ndim  == 2 else gt_arr[:L]
+        e_flat = est_arr[:L, 0] if est_arr.ndim == 2 else est_arr[:L]
+        cos_sim_td = float(
+            np.dot(g_flat, e_flat) /
+            (np.linalg.norm(g_flat) * np.linalg.norm(e_flat) + 1e-12)
+        )
+
+        # diff/GT dB: quanto il residuo dell'errore è grande rispetto al GT
+        diff_raw      = gt_arr[:L] - est_arr[:L]
+        diff_rms_db   = _rms_dbfs(diff_raw)
+        gt_rms_db     = _rms_dbfs(gt_arr[:L])
+        diff_vs_gt_db = diff_rms_db - gt_rms_db    # 0 dB = diff uguale a GT; << 0 = buono
+
+        # Floor teorico: il rumore rosa fa parte del GT_res ma è irrecuperabile
+        noise_floor_db = PINK_NOISE_LEVEL_DB + RESIDUAL_DBFS   # ≈ −23 dBFS
+
+        # ── Normalizza per l'export WAV ────────────────────────────────────
+        res_iter  = normalize_peak(res_raw, RESIDUAL_DBFS)
+        diff_norm = (normalize_peak(diff_raw, RESIDUAL_DBFS)
+                     if np.max(np.abs(diff_raw)) > 1e-12
+                     else diff_raw)
+
+        diff_stats.append((diff_vs_gt_db, cos_sim_td))
+
+        # ── Definizione tracce  (pipeline standard run_smart_sweep) ──────
+        tracks = [
+            ("01_orig_with_noise",
+             orig_with_noise,
+             f"drum+noise @0dBFS (input pipeline)"),
+            ("02_limited",
+             limited,
+             f"uscita limiter (input SPADE)  atteso: ~{-LIMITER_THRESHOLD_DB:+.2f}dBFS"),
+            ("03_gt_residual",
+             gt_res,
+             f"GT residual @{RESIDUAL_DBFS:.0f}dBFS  (include noise attenuation)"),
+            ("04_spade_output",
+             fixed_2d,
+             f"SPADE output (float32, puo' >0dBFS)"),
+            ("05_res_iter",
+             res_iter,
+             f"residual SPADE @{RESIDUAL_DBFS:.0f}dBFS  (solo componente sparsa)"),
+            ("06_diff_residuals",
+             diff_norm,
+             f"GT - iter @{RESIDUAL_DBFS:.0f}dBFS  "
+             f"cos_sim={cos_sim_td:.3f}  diff/GT={diff_vs_gt_db:+.1f}dB  "
+             f"noise_floor≈{noise_floor_db:+.1f}dB"),
+        ]
+
+        # ── Stampa tabella + scrivi WAV ────────────────────────────────────
+        print(SEP)
+        for track_name, audio, note in tracks:
+            pk  = _pk_dbfs(audio)
+            rms = _rms_dbfs(audio)
+            flag = ""
+            if track_name == "06_diff_residuals":
+                if   diff_vs_gt_db < -12: flag = "[OK]   buona convergenza"
+                elif diff_vs_gt_db <  -6: flag = "[~]    convergenza parziale"
+                else:                     flag = "[WARN] diff elevato rispetto al GT"
+            row = (f"  {item['file']:<{col_w}}  {track_name:<22}"
+                   f"  {pk:>+10.2f}  {rms:>+9.2f}  {note}  {flag}")
+            if _HAS_RICH:
+                color = ("green"  if "[OK]"   in flag else
+                         "yellow" if "[~]"    in flag else
+                         "red"    if "[WARN]" in flag else "")
+                _console.print(row.replace(flag, f"[{color or 'dim'}]{flag}[/]") if flag else row)
+            else:
+                print(row)
+            _write_wav(out_dir / f"{stem}__{track_name}.wav", audio, sr)
+
+        # ── Analisi spettrale per banda ────────────────────────────────────
+        BANDS_SPEC = [
+            ("Sub-bass ",   20,    80),
+            ("Bass     ",   80,   250),
+            ("Low-mid  ",  250,   800),
+            ("High-mid ",  800,  4000),
+            ("High <8k ",  4000, 8000),
+            ("High >8k ",  8000, 20000),
+        ]
+
+        def band_energy(audio_2d, sr, f_lo, f_hi):
+            mono  = audio_2d[:, 0] if audio_2d.ndim == 2 else audio_2d
+            N     = len(mono)
+            if N < 8: return -999.0
+            nyq = sr / 2.0
+            lo  = max(f_lo / nyq, 1e-4)
+            hi  = min(f_hi / nyq, 0.9999)
+            if lo >= hi: return -999.0
+            if lo < 1e-3:
+                b2, a2 = sig.butter(4, hi, btype="low")
+            else:
+                b2, a2 = sig.butter(4, [lo, hi], btype="band")
+            filtered = sig.filtfilt(b2, a2, mono)
+            return _rms_dbfs(filtered)
+
+        print()
+        band_hdr = (f"    {'banda':<12} {'GT_res RMS':>10}  {'iter rec RMS':>13}"
+                    f"  {'diff':>6}  {'stato'}")
+        print(f"  Analisi spettrale — {item['file']}  (LF/HF split @ {BAND_CROSSOVER_HZ:.0f} Hz)")
+        print(f"  {'─'*76}")
+        print(band_hdr)
+        print(f"  {'─'*76}")
+        for bname, f_lo, f_hi in BANDS_SPEC:
+            gt_db   = band_energy(gt_res_raw,  sr, f_lo, f_hi)
+            iter_db = band_energy(res_raw,      sr, f_lo, f_hi)
+            is_hf   = f_lo >= BAND_CROSSOVER_HZ
+            label   = "v11 HF →" if is_hf else "ML LF →"
+            if gt_db < -60:
+                rec_str = "  —    (silenzio)"
+                status  = ""
+            else:
+                d = iter_db - gt_db
+                status  = ("OK"         if d > -3 else
+                           "~ parziale" if d > -9 else
+                           "!! sotto")
+                rec_str = f"{d:>+6.1f} dB  {status}"
+            line = f"    {bname:<12} {gt_db:>+10.1f}  {iter_db:>+13.1f}  {rec_str}  [{label}]"
+            if _HAS_RICH:
+                color = ("green" if "OK" in rec_str else
+                         "yellow" if "~" in rec_str else
+                         "red" if "!!" in rec_str else "dim")
+                _console.print(f"[{color}]{line}[/]")
+            else:
+                print(line)
+        print()
+
+    # ── Riepilogo complessivo ─────────────────────────────────────────────
+    print(SEP)
+    if diff_stats:
+        vs_gt  = [d[0] for d in diff_stats]
+        cosims = [d[1] for d in diff_stats]
+        nf_db  = PINK_NOISE_LEVEL_DB + RESIDUAL_DBFS
+
+        print(f"\n  RIEPILOGO  ({len(diff_stats)} file):")
+        print(f"    diff/GT_rms   media   : {np.mean(vs_gt):>+7.2f} dB")
+        print(f"    diff/GT_rms   migliore: {np.min(vs_gt):>+7.2f} dB")
+        print(f"    diff/GT_rms   peggiore: {np.max(vs_gt):>+7.2f} dB")
+        print(f"    cos_sim TD    media   : {np.mean(cosims):>8.4f}  (1.0 = identici)")
+        print()
+        print(f"  Floor fisico (rumore irrecuperabile): ≈ {nf_db:+.1f} dBFS")
+        print(f"  Soglia 'buona convergenza':           diff/GT < −12 dB")
+        verdict = ("OK     eccellente" if np.mean(vs_gt) < -12 else
+                   "~      buona"      if np.mean(vs_gt) < -6  else
+                   "INFO   compatibile con noise floor")
+        print(f"  Verdetto: {verdict}")
+
+    print(f"\n  WAV → {out_dir}/")
+    print(f"  Formato: float32  (usa editor che supporta >0 dBFS)")
+    print(f"  Nome: <stem>__<N>_<traccia>.wav")
+
+
+# =============================================================================
+# REPORT + CSV
+# =============================================================================
+
+def print_report(study: "optuna.Study", top_n: int = 20):
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    if not trials:
+        print("Nessun trial completato.")
+        return
+
+    if _HAS_RICH:
+        _console.rule("[bold cyan]RISULTATI SWEEP BAYESIANO — HYBRID SPADE[/]")
+        tbl = Table(show_header=True, header_style="bold cyan", show_lines=False)
+        for col, w in [
+            ("#",4),("score",9),
+            ("HF_ddb",6),("HF_win",6),("HF_rel",6),("HF_gain",6),("HF_eps",5),("HF_iter",5),
+            ("LF_ddb",6),("LF_gain",6),("LF_rel",6),
+        ]:
+            tbl.add_column(col, justify="right", width=w)
+        for rank, t in enumerate(trials[:top_n], 1):
+            p    = t.params
+            win  = 2 ** p.get("hf_win_exp", 11)
+            hop  = win // p.get("hf_hop_div", 4)
+            sty  = "bold green" if rank == 1 else ("yellow" if rank <= 3 else "")
+            tbl.add_row(
+                str(rank), f"{t.value:.5f}",
+                f"{p['hf_delta_db']:.2f}",  str(win),
+                f"{p['hf_release_ms']:.0f}", f"{p['hf_max_gain_db']:.1f}",
+                str(p['hf_eps']),            str(p['hf_max_iter']),
+                f"{p['lf_delta_db']:.2f}",  f"{p['lf_max_gain_db']:.1f}",
+                f"{p['lf_release_ms']:.0f}",
+                style=sty,
+            )
+        _console.print(tbl)
+    else:
+        hdr = (f"{'#':>3}  {'score':>8}  {'HFddb':>5}  {'HFwin':>5}"
+               f"  {'HFrel':>5}  {'HFgain':>6}  {'HFeps':>5}  {'HFiter':>5}"
+               f"  {'LFddb':>5}  {'LFgain':>6}  {'LFrel':>5}")
+        print(hdr); print("─" * len(hdr))
+        for rank, t in enumerate(trials[:top_n], 1):
+            p   = t.params
+            win = 2 ** p.get("hf_win_exp", 11)
+            print(f"{rank:>3}  {t.value:>8.5f}  {p['hf_delta_db']:>5.2f}"
+                  f"  {win:>5}  {p['hf_release_ms']:>5.0f}"
+                  f"  {p['hf_max_gain_db']:>6.1f}  {str(p['hf_eps']):>5}"
+                  f"  {p['hf_max_iter']:>5}"
+                  f"  {p['lf_delta_db']:>5.2f}  {p['lf_max_gain_db']:>6.1f}"
+                  f"  {p['lf_release_ms']:>5.0f}")
+
+    best = trials[0]
+    p    = best.params
+    win  = 2 ** p.get("hf_win_exp", 11)
+    hop  = win // p.get("hf_hop_div", 4)
+    print("\n" + "═" * 60)
+    print("CONFIG OTTIMALE — HYBRID SPADE")
+    print("═" * 60)
+    print(f"""
+hf_params = dict(
+    hf_delta_db      = {p['hf_delta_db']:.2f},
+    hf_window_length = {win},
+    hf_hop_length    = {hop},
+    hf_release_ms    = {p['hf_release_ms']:.1f},
+    hf_max_gain_db   = {p['hf_max_gain_db']:.1f},
+    hf_eps           = {p['hf_eps']},
+    hf_max_iter      = {p['hf_max_iter']},
+)
+lf_params = dict(
+    lf_delta_db      = {p['lf_delta_db']:.2f},
+    lf_max_gain_db   = {p['lf_max_gain_db']:.1f},
+    lf_release_ms    = {p['lf_release_ms']:.1f},
+)
+""")
+    print(f"→ Best score : {best.value:.5f}")
+    n_pruned = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED)
+    print(f"   Completed : {len(trials)}   Pruned : {n_pruned}")
+
+
+def save_csv(study: "optuna.Study"):
+    import csv
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    if not trials:
+        return
+    fieldnames = ["rank", "score"] + list(trials[0].params.keys())
+    with open(OUT_CSV, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        for rank, t in enumerate(trials, 1):
+            row = {"rank": rank, "score": f"{t.value:.6f}"}
+            row.update({k: f"{v:.4f}" if isinstance(v, float) else v
+                        for k, v in t.params.items()})
+            w.writerow(row)
+    print(f"\n  CSV salvato: {OUT_CSV}")
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def main():
+    p = argparse.ArgumentParser(
+        description="Hybrid SPADE (v11 HF + Unrolled LF) — Bayesian sweep",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("--base-dir",        type=Path,  default=Path("./Samples"),
+                   help="Cartella radice contenente Kicks/, Snares/, ecc.")
+    p.add_argument("--model",           type=Path,  default=None,
+                   dest="model_ckpt",
+                   help="Checkpoint SPADEUnrolled (.pt).  Ometti per baseline v11.")
+    p.add_argument("--trials",          type=int,   default=200)
+    p.add_argument("--resume",          action="store_true",
+                   help="Riprende uno studio Optuna esistente")
+    p.add_argument("--report",          action="store_true",
+                   help="Stampa solo il report dal DB esistente")
+    p.add_argument("--debug-export",    type=int,   default=0,
+                   metavar="N",
+                   help="Esporta le 6 tracce WAV per i primi N file del corpus")
+    p.add_argument("--debug-out",       type=Path,  default=Path("debug_export"),
+                   help="Directory di output per --debug-export")
+    p.add_argument("--baseline-v11",    action="store_true",
+                   help="Usa solo v11 broadband (nessun modello ML) come baseline")
+    p.add_argument("--crossover-hz",    type=float, default=BAND_CROSSOVER_HZ,
+                   help="Frequenza di crossover LF/HF in Hz")
+    p.add_argument("--max-files",       type=int,   default=None,
+                   help="Limita il corpus ai primi N file (test rapido)")
+    p.add_argument("--top",             type=int,   default=20,
+                   help="Numero di trial da mostrare nel report")
+    p.add_argument("--db-path",         type=str,   default=f"sqlite:///{STUDY_NAME}.db",
+                   help="SQLite URI per Optuna (default: sqlite:///hybrid_spade_v1.db)")
+    args = p.parse_args()
+
+    if not _HAS_V11:
+        print("[ERRORE] spade_declip_v11.py non trovato — uscita.")
+        sys.exit(1)
+
+    # ── Carica corpus ─────────────────────────────────────────────────────
+    print(f"\n  Caricamento corpus da: {args.base_dir}")
+    corpus = build_corpus(args.base_dir, max_files=args.max_files)
+    if not corpus:
+        print("[ERRORE] Corpus vuoto — controlla --base-dir e le cartelle drum.")
+        sys.exit(1)
+    print(f"  Corpus: {len(corpus)} file\n")
+
+    # ── Carica modello ML (opzionale) ─────────────────────────────────────
+    lf_model = None
+    if args.model_ckpt is not None and not args.baseline_v11:
+        if not _HAS_UNROLLED:
+            print("[ERRORE] spade_unrolled.py / PyTorch non trovati.")
+            sys.exit(1)
+        ckpt = torch.load(args.model_ckpt, map_location="cpu")
+        cfg  = UnrolledConfig(**ckpt["cfg"])
+        model = SPADEUnrolled(cfg)
+        model.load_state_dict(ckpt["model"])
+        model.eval()
+        lf_model = HybridSPADEInference(
+            model,
+            crossover_hz   = args.crossover_hz,
+            lf_delta_db    = DEBUG_LF["lf_delta_db"],
+            lf_max_gain_db = DEBUG_LF["lf_max_gain_db"],
+            device         = "auto",
+        )
+        print(f"  Modello caricato: {args.model_ckpt}")
+        print(f"  Crossover:        {args.crossover_hz:.0f} Hz")
+        print(f"  Parametri:        {model.parameter_count():,} trainable\n")
+    else:
+        print(f"  Modalità: {'baseline v11 broadband' if args.baseline_v11 else 'baseline v11 (nessun modello specificato)'}\n")
+
+    # ── Optuna: report-only ────────────────────────────────────────────────
+    if args.report:
+        if not _HAS_OPTUNA:
+            print("[ERRORE] optuna non trovato.")
+            sys.exit(1)
+        study = optuna.load_study(study_name=STUDY_NAME, storage=args.db_path)
+        print_report(study, top_n=args.top)
+        save_csv(study)
+        return
+
+    # ── Debug export ───────────────────────────────────────────────────────
+    if args.debug_export > 0:
+        # Se abbiamo un DB Optuna con trial completati → usa il best
+        best_hf = dict(DEBUG_HF)
+        best_lf = dict(DEBUG_LF)
+        if _HAS_OPTUNA:
+            try:
+                study = optuna.load_study(study_name=STUDY_NAME, storage=args.db_path)
+                complete = [t for t in study.trials
+                            if t.state == optuna.trial.TrialState.COMPLETE]
+                if complete:
+                    bp = max(complete, key=lambda t: t.value or 0).params
+                    win = 2 ** bp.get("hf_win_exp", 11)
+                    hop = win // bp.get("hf_hop_div", 4)
+                    best_hf = dict(
+                        hf_delta_db      = bp.get("hf_delta_db",    1.5),
+                        hf_window_length = win,
+                        hf_hop_length    = hop,
+                        hf_release_ms    = bp.get("hf_release_ms",  0.0),
+                        hf_max_gain_db   = bp.get("hf_max_gain_db", 9.0),
+                        hf_eps           = bp.get("hf_eps",         0.05),
+                        hf_max_iter      = bp.get("hf_max_iter",    500),
+                    )
+                    best_lf = dict(
+                        lf_delta_db    = bp.get("lf_delta_db",    1.5),
+                        lf_max_gain_db = bp.get("lf_max_gain_db", 9.0),
+                        lf_release_ms  = bp.get("lf_release_ms",  0.0),
+                    )
+                    print(f"  Best trial caricato dal DB ({len(complete)} completati)")
+            except Exception:
+                pass
+
+        debug_export(corpus, args.base_dir, args.debug_out,
+                     args.debug_export, best_hf, best_lf, lf_model)
+        return
+
+    # ── Bayesian sweep ─────────────────────────────────────────────────────
+    if not _HAS_OPTUNA:
+        print("[ERRORE] optuna non trovato — pip install optuna")
+        sys.exit(1)
+
+    sampler = TPESampler(multivariate=True, seed=42)
+    pruner  = MedianPruner(n_startup_trials=10, n_warmup_steps=len(corpus)//2)
+
+    if args.resume:
+        study = optuna.load_study(
+            study_name=STUDY_NAME, storage=args.db_path,
+            sampler=sampler, pruner=pruner,
+        )
+        print(f"  Studio ripreso: {len(study.trials)} trial esistenti")
+    else:
+        study = optuna.create_study(
+            study_name=STUDY_NAME, storage=args.db_path,
+            direction="maximize",
+            sampler=sampler, pruner=pruner,
+            load_if_exists=True,
+        )
+
+    objective = make_objective(corpus, lf_model)
+
+    # Progress bar (rich → tqdm → plain)
+    _state = {
+        "done": 0, "pruned": 0,
+        "best": float("-inf"), "best_p": {}, "last": float("-inf"),
+        "t0": time.time(),
+    }
+
+    try:
+        from rich.progress import (
+            Progress, BarColumn, TextColumn,
+            TimeElapsedColumn, TimeRemainingColumn, MofNCompleteColumn,
+        )
+        _has_rich_p = True
+    except ImportError:
+        _has_rich_p = False
+
+    try:
+        import tqdm as _tqdm_mod
+        _has_tqdm = True
+    except ImportError:
+        _has_tqdm = False
+
+    def _on_trial_end(study, trial):
+        fin = trial.state == optuna.trial.TrialState.COMPLETE
+        prn = trial.state == optuna.trial.TrialState.PRUNED
+        if fin:
+            _state["done"]  += 1
+            _state["last"]   = trial.value or 0.0
+            if _state["last"] > _state["best"]:
+                _state["best"]   = _state["last"]
+                _state["best_p"] = dict(study.best_params)
+        elif prn:
+            _state["pruned"] += 1
+
+    t0 = time.time()
+    try:
+        if _has_rich_p:
+            progress = Progress(
+                TextColumn("[bold cyan]Trial[/] [cyan]{task.completed}/{task.total}[/]"),
+                BarColumn(bar_width=32),
+                MofNCompleteColumn(),
+                TextColumn("  score [green]{task.fields[last]:.5f}[/]"),
+                TextColumn("  best [bold green]{task.fields[best]:.5f}[/]"),
+                TextColumn("  [dim]pruned {task.fields[pruned]}[/]"),
+                TimeElapsedColumn(), TextColumn("ETA"), TimeRemainingColumn(),
+                refresh_per_second=4,
+            )
+            def _on_trial_rich(study, trial):
+                _on_trial_end(study, trial)
+                progress.update(task_id, advance=1,
+                                last=_state["last"],
+                                best=max(_state["best"], 0.0),
+                                pruned=_state["pruned"])
+            with progress:
+                task_id = progress.add_task(
+                    "sweep", total=args.trials,
+                    last=0.0, best=0.0, pruned=0,
+                )
+                study.optimize(objective, n_trials=args.trials,
+                               callbacks=[_on_trial_rich],
+                               show_progress_bar=False)
+        elif _has_tqdm:
+            import tqdm
+            pbar = tqdm.tqdm(total=args.trials, unit="trial")
+            def _on_trial_tqdm(study, trial):
+                _on_trial_end(study, trial)
+                pbar.update(1)
+                pbar.set_postfix(score=f"{_state['last']:.5f}",
+                                 best=f"{_state['best']:.5f}",
+                                 pruned=_state["pruned"])
+            study.optimize(objective, n_trials=args.trials,
+                           callbacks=[_on_trial_tqdm], show_progress_bar=False)
+            pbar.close()
+        else:
+            study.optimize(objective, n_trials=args.trials,
+                           callbacks=[_on_trial_end], show_progress_bar=False)
+    except KeyboardInterrupt:
+        print("\n[!] Interrotto — risultati parziali salvati.")
+
+    elapsed = time.time() - t0
+    n_done  = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE)
+    n_prune = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED)
+    print(f"\n  Completati: {n_done}  |  Pruned: {n_prune}"
+          f"  |  Tempo: {elapsed/60:.1f} min"
+          f"  |  Media: {elapsed/max(n_done+n_prune,1):.1f} s/trial")
+
+    print_report(study, top_n=args.top)
+    save_csv(study)
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()

run_smart_sweep_old.py

@@ -0,0 +1,1367 @@
+"""
+run_smart_sweep.py  —  S-SPADE  ·  Bayesian parameter search  (v2)
+===================================================================
+
+PIPELINE GROUND-TRUTH (Case 1 — threshold-based limiter)
+---------------------------------------------------------
+Il limiter sintetico è threshold-based:
+    - Originale normalizzato a 0 dBFS peak
+    - Limiter: attua solo sui picchi sopra la soglia → output max peak ≈ −threshold_db
+    - Il CORPO del segnale (loudness percepita) rimane invariato per definizione
+    - NON si applica nessun gain al segnale limitato dopo il processing
+
+Allineamento per il calcolo residual:
+    Originale e limited sono già sulla stessa scala (loudness uguale, picchi diversi).
+    Nessuna normalizzazione LUFS / RMS necessaria o corretta.
+
+    GT_res   = original_0dBFS  −  limited         (scale identiche)
+    res_iter = spade_output    −  limited          (idem)
+
+    Entrambi vengono poi normalizzati a RESIDUAL_DBFS peak SOLO per rendere
+    comparabili file con diversi livelli assoluti — non altera la logica.
+
+Metrica ideale:
+    GT_res ≡ res_iter  →  cosine_sim = 1.0  →  differenza = −∞ dB
+
+Ottimizzatore: Optuna TPE (Bayesian) + MedianPruner
+Storage:       SQLite (riprendibile con --resume)
+Corpus:        tutti i drum sample in Kicks / Snares / Perc / Tops
+
+DIPENDENZE
+----------
+    pip install numpy scipy soundfile optuna rich
+    (pyloudnorm NON necessario)
+
+USO
+---
+    python run_smart_sweep.py                          # 200 trial
+    python run_smart_sweep.py --trials 50              # test rapido
+    python run_smart_sweep.py --resume                 # riprende da DB
+    python run_smart_sweep.py --report                 # solo risultati
+    python run_smart_sweep.py --base-dir /path/SPADE   # cartella custom
+"""
+
+import argparse
+import logging
+import sys
+import time
+import warnings
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+import scipy.signal as sig
+import soundfile as sf
+
+logging.getLogger("optuna").setLevel(logging.WARNING)
+
+# ── optuna ───────────────────────────────────────────────────────────────────
+try:
+    import optuna
+    from optuna.samplers import TPESampler
+    from optuna.pruners  import MedianPruner
+    _HAS_OPTUNA = True
+except ImportError:
+    _HAS_OPTUNA = False
+    warnings.warn("optuna non trovato — pip install optuna")
+
+# ── rich ─────────────────────────────────────────────────────────────────────
+try:
+    from rich.console import Console
+    from rich.table   import Table
+    _console  = Console()
+    _HAS_RICH = True
+except ImportError:
+    _HAS_RICH = False
+    _console  = None
+
+# ── spade_declip ─────────────────────────────────────────────────────────────
+try:
+    from spade_declip_v11 import declip, DeclipParams
+    _HAS_SPADE = True
+except ImportError:
+    _HAS_SPADE = False
+    warnings.warn("spade_declip_v11.py non trovato")
+
+# =============================================================================
+# CONFIG
+# =============================================================================
+
+DRUM_DIRS = ["Kicks", "Snares", "Perc", "Tops"]
+
+# ── Limiter sintetico ─────────────────────────────────────────────────────────
+# Case 1: threshold-based.
+# Originale @ 0 dBFS peak → limiter attua sui picchi > soglia →
+# output max peak ≈ −LIMITER_THRESHOLD_DB dBFS, loudness invariata.
+# NON si tocca il segnale limitato con nessun gain dopo.
+LIMITER_THRESHOLD_DB = 1.5   # dB sotto il ceiling (positivo)
+LIMITER_RELEASE_MS   = 80.0  # release del limiter sintetico (ms)
+# attack = 1 campione → brickwall vero
+
+# Normalizzazione residual — SOLO per comparabilità cross-file.
+# Scala entrambi GT e iter identicamente, quindi non altera il confronto.
+RESIDUAL_DBFS = -3.0
+
+# ── Rumore rosa di sottofondo ─────────────────────────────────────────────────
+# Simula un sottofondo musicale sotto il transiente di batteria.
+# Viene mixato al sample (già a 0 dBFS peak) PRIMA del limiter.
+# Questo assicura che:
+#   - il limiter agisca sul segnale realistico  drum + music background
+#   - SPADE riceva lo stesso mix e debba lavorare in condizioni realistiche
+#   - GT_res = (drum+noise) − limiter(drum+noise)  rifletta la situazione reale
+# Livello relativo al peak del drum sample. −20 dB = sottofondo ben sotto
+# il transiente, udibile ma non dominante (come un kick su un loop di batteria).
+PINK_NOISE_LEVEL_DB = -20.0   # dB rel. al peak del drum (negativo = sotto)
+
+# Optuna
+STUDY_NAME = "spade_smart_v2"
+OUT_CSV    = "smart_sweep_results.csv"
+
+# Parametri FISSI del solver SPADE (invarianti tra tutti i trial)
+FIXED_SOLVER = dict(
+    algo          = "sspade",
+    frame         = "rdft",
+    mode          = "soft",
+    s             = 1,
+    r             = 1,
+    n_jobs        = 1,
+    verbose       = False,
+    show_progress = False,
+    use_gpu       = True,
+    # multiband e macro_expand sono nello spazio di ricerca
+)
+
+# Crossover multiband (fisso per comparabilita' tra trial)
+# 250 Hz separa: LF=corpo/punch del kick  |  HF=transiente/attacco
+BAND_CROSSOVER_HZ = 250.0
+
+# =============================================================================
+# HELPERS
+# =============================================================================
+
+def ensure_2d(a: np.ndarray) -> np.ndarray:
+    return a[:, None] if a.ndim == 1 else a
+
+
+def normalize_to_0dBFS(a: np.ndarray) -> np.ndarray:
+    """Scala a 0 dBFS peak — usato solo sull'originale come riferimento comune."""
+    pk = np.max(np.abs(a))
+    return a / pk if pk > 1e-12 else a
+
+
+def normalize_peak(a: np.ndarray, target_dbfs: float) -> np.ndarray:
+    """
+    Scala a target_dbfs dBFS peak.
+    Usato SOLO sui residual per comparabilità cross-file;
+    non altera la logica perché GT e iter vengono scalati identicamente.
+    """
+    pk = np.max(np.abs(a))
+    return a * (10 ** (target_dbfs / 20.0) / pk) if pk > 1e-12 else a
+
+
+def generate_pink_noise(n_samples: int, n_channels: int, rng: np.random.Generator) -> np.ndarray:
+    """
+    Genera rumore rosa (1/f) tramite filtro IIR di Voss-McCartney (approssimazione
+    a 5 poli, accurata entro ±1 dB nel range 20 Hz – 20 kHz).
+
+    Output: shape (n_samples, n_channels), RMS normalizzato a 1.0 (prima
+    del mix-in con PINK_NOISE_LEVEL_DB, che controlla il livello finale).
+
+    Algoritmo: rumore bianco filtrato con H(z) = 1 / A(z) dove i coefficienti
+    sono ottimizzati per approssimare una densità spettrale 1/f.
+    """
+    # Coefficienti del filtro IIR a 5 poli (Voss approssimazione)
+    # Poli reali, tutti stabili (|p| < 1)
+    b = np.array([0.049922035, -0.095993537,  0.050612699, -0.004408786])
+    a = np.array([1.0,         -2.494956002,  2.017265875, -0.522189400])
+
+    out = np.empty((n_samples, n_channels))
+    for c in range(n_channels):
+        white = rng.standard_normal(n_samples)
+        pink  = sig.lfilter(b, a, white)
+        rms   = np.sqrt(np.mean(pink ** 2))
+        out[:, c] = pink / (rms + 1e-12)   # RMS = 1.0
+
+    return out
+
+
+def mix_pink_noise(
+    audio_0dBFS: np.ndarray,
+    sr: int,
+    level_db: float,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """
+    Mixa rumore rosa nel segnale a un livello relativo al suo peak.
+
+    level_db < 0  →  il rumore è sotto il peak del drum (es. −20 dB)
+    Il rumore dura quanto il sample; se il sample è stereo, il rumore è stereo
+    (canali indipendenti → decorrelato come un vero fondo musicale).
+
+    Il segnale in uscita può superare 0 dBFS di qualche frazione di dB: è
+    corretto, il limiter che segue si occupa di riportarlo sotto la soglia.
+    """
+    audio = ensure_2d(audio_0dBFS)
+    N, C  = audio.shape
+
+    noise  = generate_pink_noise(N, C, rng)          # RMS = 1.0 per canale
+    # Scala il rumore al livello desiderato rispetto al peak del drum
+    peak   = np.max(np.abs(audio))
+    gain   = peak * (10 ** (level_db / 20.0))        # gain lineare assoluto
+    mixed  = audio + noise * gain
+    # NON normalizziamo qui: la normalizzazione a 0 dBFS avviene in build_corpus
+    # subito dopo, su tutto il mix (drum + noise), prima di qualsiasi altra op.
+    return mixed[:, 0] if audio_0dBFS.ndim == 1 else mixed
+
+
+# =============================================================================
+# LIMITER SINTETICO  (Case 1 — threshold-based, brickwall, 1-campione attack)
+# =============================================================================
+
+def apply_brickwall_limiter(
+    audio_0dBFS: np.ndarray,
+    sr: int,
+    threshold_db: float = LIMITER_THRESHOLD_DB,
+    release_ms:   float = LIMITER_RELEASE_MS,
+) -> np.ndarray:
+    """
+    Brickwall limiter threshold-based.
+
+    Input:  audio_0dBFS — già a 0 dBFS peak, shape (N,) o (N, C)
+    Output: segnale limitato, stessa shape — NON boosted, NON clippato
+
+    Gain envelope:
+        se |x[n]| > threshold_lin  →  target_gain = threshold_lin / |x[n]|
+        altrimenti                 →  target_gain = 1.0
+    Attack : istantaneo (1 campione, true brickwall)
+    Release: esponenziale con costante release_ms
+
+    Post-processing: NESSUNO.
+    Il segnale in uscita ha max peak ≈ −threshold_db dBFS.
+    La loudness percepita è invariata rispetto all'input.
+    """
+    thr_lin = 10 ** (-abs(threshold_db) / 20.0)
+    rc      = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9))
+
+    audio   = ensure_2d(audio_0dBFS).copy()
+    N, C    = audio.shape
+    out     = np.empty_like(audio)
+
+    for c in range(C):
+        ch  = audio[:, c]
+        env = 1.0
+        g   = np.empty(N)
+        for n in range(N):
+            pk     = abs(ch[n])
+            target = thr_lin / pk if pk > thr_lin else 1.0
+            # attack istantaneo se gain scende, release esponenziale se risale
+            env    = target if target < env else rc * env + (1.0 - rc) * target
+            g[n]   = env
+        out[:, c] = ch * g
+
+    # Restituisce stessa shape dell'input
+    return out[:, 0] if audio_0dBFS.ndim == 1 else out
+
+
+# =============================================================================
+# COSINE SIMILARITY TF
+# =============================================================================
+
+def cosine_sim_tf(
+    gt:          np.ndarray,
+    est:         np.ndarray,
+    sr:          int,
+    win_samples: int = 1024,
+    hop_samples: int = 256,
+    n_bands:     int = 12,
+) -> float:
+    """
+    Similarità coseno media su micro-finestre tempo-frequenziali.
+    Input: entrambi già a RESIDUAL_DBFS peak.
+    Output: scalare in [0, 1]. Target ideale = 1.0.
+    """
+    L = min(gt.shape[0], est.shape[0])
+    g = (gt[:L, 0]  if gt.ndim  == 2 else gt[:L]).copy()
+    e = (est[:L, 0] if est.ndim == 2 else est[:L]).copy()
+
+    win = min(win_samples, max(32, L // 4))
+    hop = min(hop_samples, win // 2)
+
+    if L < win or win < 32:
+        denom = np.linalg.norm(g) * np.linalg.norm(e) + 1e-12
+        return float(np.dot(g, e) / denom)
+
+    _, _, Zg = sig.stft(g, fs=sr, window="hann",
+                        nperseg=win, noverlap=win - hop,
+                        boundary=None, padded=False)
+    _, _, Ze = sig.stft(e, fs=sr, window="hann",
+                        nperseg=win, noverlap=win - hop,
+                        boundary=None, padded=False)
+
+    n_freqs, n_frames = Zg.shape
+    if n_frames == 0:
+        return float(np.dot(g, e) / (np.linalg.norm(g) * np.linalg.norm(e) + 1e-12))
+
+    edges = np.unique(np.round(
+        np.logspace(0, np.log10(max(n_freqs, 2)), min(n_bands, n_freqs) + 1)
+    ).astype(int))
+    edges = np.clip(edges, 0, n_freqs)
+
+    sims = []
+    for i in range(len(edges) - 1):
+        f0, f1 = int(edges[i]), int(edges[i + 1])
+        if f1 <= f0:
+            continue
+        Mg = np.abs(Zg[f0:f1, :])
+        Me = np.abs(Ze[f0:f1, :])
+        dot    = np.sum(Mg * Me, axis=0)
+        norm_g = np.sqrt(np.sum(Mg ** 2, axis=0)) + 1e-12
+        norm_e = np.sqrt(np.sum(Me ** 2, axis=0)) + 1e-12
+        sims.extend((dot / (norm_g * norm_e)).tolist())
+
+    return float(np.mean(sims)) if sims else 0.0
+
+
+# =============================================================================
+# CORPUS
+# =============================================================================
+
+def build_corpus(base_dir: Path, max_files: Optional[int] = None) -> List[Dict]:
+    """
+    Per ogni drum sample:
+      1. Carica e normalizza a 0 dBFS peak  (riferimento comune cross-file)
+      2. Mixa rumore rosa a PINK_NOISE_LEVEL_DB rel. al peak  ← NUOVO
+         Il mix avviene in float (può temporaneamente superare 0 dBFS)
+      3. Normalizza il mix (drum + noise) a 0 dBFS peak
+         Riferimento comune prima di tutta la pipeline successiva
+      4. Applica limiter sintetico su (drum + noise) normalizzato  →  limited
+      4. GT_res_raw = (drum + noise) − limited         (stessa scala, nessun gain)
+      5. Scarta file dove il limiter non interviene
+      6. Normalizza GT_res a RESIDUAL_DBFS  (solo comparabilità cross-file)
+
+    Il rumore è riproducibile: ogni file usa un seed deterministico derivato
+    dal suo indice nel corpus, così i trial sono comparabili tra loro.
+    """
+    corpus = []
+    extensions = {".wav", ".flac", ".aif", ".aiff"}
+    file_index = 0   # usato per seed deterministico del rumore
+
+    for folder in DRUM_DIRS:
+        d = base_dir / folder
+        if not d.exists():
+            print(f"  [WARN] Cartella non trovata: {d}")
+            continue
+        for f in sorted(d.glob("*")):
+            if f.suffix.lower() not in extensions:
+                continue
+            try:
+                audio, sr = sf.read(str(f), always_2d=True)
+                audio = audio.astype(float)
+            except Exception as exc:
+                print(f"  [WARN] {f.name}: {exc}")
+                continue
+
+            if audio.shape[0] < 64:
+                continue
+
+            # 1. 0 dBFS peak
+            orig = normalize_to_0dBFS(audio)
+
+            # 2. Mix rumore rosa — seed deterministico per riproducibilità
+            rng  = np.random.default_rng(seed=file_index)
+            orig_with_noise = ensure_2d(mix_pink_noise(orig, sr,
+                                                        PINK_NOISE_LEVEL_DB, rng))
+            file_index += 1
+
+            # 3. Normalizza il mix a 0 dBFS peak — riferimento comune prima
+            #    di tutta la pipeline. Il mix in float può aver superato 0 dBFS;
+            #    questa normalizzazione azzera il problema prima del limiter.
+            orig_with_noise = ensure_2d(normalize_to_0dBFS(orig_with_noise))
+
+            # 4. Limiter sintetico su (drum + noise) @0dBFS — nessun gain dopo
+            limited = ensure_2d(apply_brickwall_limiter(orig_with_noise, sr))
+
+            # 5. Residual grezzo — stessa scala, zero aggiustamenti
+            gt_res_raw = orig_with_noise - limited
+
+            # 6. Verifica attività del limiter
+            if np.max(np.abs(gt_res_raw)) < 1e-6:
+                print(f"  [SKIP] {f.name} — picco sotto la soglia, limiter inattivo")
+                continue
+
+            # 7. Normalizza a RESIDUAL_DBFS solo per comparabilità cross-file
+            gt_res = normalize_peak(gt_res_raw, RESIDUAL_DBFS)
+
+            corpus.append({
+                "file"    : f.name,
+                "sr"      : sr,
+                "limited" : limited,    # input a SPADE = drum + noise + limiter
+                "gt_res"  : gt_res,     # target residual
+            })
+
+            if max_files and len(corpus) >= max_files:
+                return corpus
+
+    return corpus
+
+
+# =============================================================================
+# VALUTAZIONE SINGOLO FILE
+# =============================================================================
+
+def evaluate_one(item: Dict, params: dict) -> Optional[float]:
+    """
+    Esegue SPADE su limited, calcola il residual e lo confronta con GT.
+
+    params contiene parametri SPADE puri + flag di alto livello:
+        multiband    (bool)  -- split LF/HF, elabora separatamente
+        macro_expand (bool)  -- envelope pre-pass per recupero corpo LF
+        macro_ratio  (float) -- rapporto espansione (1.0 = bypass)
+        lf_delta_db  (float) -- delta_db per banda LF (<= BAND_CROSSOVER_HZ)
+                                 il delta_db standard e' usato per la banda HF
+    """
+    try:
+        sr      = item["sr"]
+        limited = item["limited"].copy()
+        gt_res  = item["gt_res"]
+
+        # Estrai flag di alto livello (non sono parametri DeclipParams diretti)
+        p2      = dict(params)   # copia per non mutare l'originale
+        multiband    = p2.pop("multiband",    False)
+        macro_expand = p2.pop("macro_expand", False)
+        macro_ratio  = p2.pop("macro_ratio",  1.0)
+        lf_delta_db  = p2.pop("lf_delta_db",  p2.get("delta_db", 1.5))
+
+        spade_kw = dict(
+            multiband        = multiband,
+            macro_expand     = macro_expand,
+            macro_ratio      = macro_ratio if macro_expand else 1.0,
+            macro_release_ms = 200.0,
+            macro_attack_ms  = 10.0,
+        )
+        if multiband:
+            spade_kw["band_crossovers"] = (BAND_CROSSOVER_HZ,)
+            spade_kw["band_delta_db"]   = (lf_delta_db, p2["delta_db"])
+
+        p = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **p2, **spade_kw)
+        fixed, _ = declip(limited, p)
+        fixed_2d  = ensure_2d(fixed)
+
+        # Residual generato — stessa scala dell'input, nessun gain
+        res_raw  = fixed_2d - limited
+        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)
+
+        return cosine_sim_tf(gt_res, res_iter, sr)
+
+    except Exception as exc:
+        warnings.warn(f"evaluate_one ({item['file']}): {exc}")
+        return None
+
+
+# =============================================================================
+# OBIETTIVO OPTUNA
+# =============================================================================
+
+def make_objective(corpus: List[Dict]):
+    def objective(trial: "optuna.Trial") -> float:
+        # ── Parametri core ────────────────────────────────────────────────
+        delta_db = trial.suggest_float("delta_db",    1.0,  2.0,  step=0.05)
+        win_exp  = trial.suggest_int  ("win_exp",      9,   11)
+        win      = 2 ** win_exp
+        hop_div  = trial.suggest_categorical("hop_div", [4, 8])
+        hop      = win // hop_div
+        rel_ms   = trial.suggest_float("release_ms",  10.0, 200.0, step=5.0)
+        gain_db  = trial.suggest_float("max_gain_db",  2.0,  12.0, step=0.5)
+        eps      = trial.suggest_categorical("eps",    [0.03, 0.05, 0.1])
+        max_iter = trial.suggest_categorical("max_iter", [250, 500, 1000])
+
+        # ── Multiband + Macro expand ────────────────────────────────────────
+        # SPAZIO STATICO: lf_delta_db e macro_ratio vengono SEMPRE campionati
+        # dal TPE (spazio fisso) e poi usati condizionalmente a runtime.
+        # Questo elimina il fallback a RandomSampler che degradava le performance
+        # del TPE multivariate con spazi dinamici.
+        multiband    = trial.suggest_categorical("multiband",    [False, True])
+        macro_expand = trial.suggest_categorical("macro_expand", [False, True])
+
+        # Sempre campionati (range fisso), usati solo se il flag e' True:
+        lf_delta_db = trial.suggest_float("lf_delta_db", 0.5, 2.0, step=0.05)
+        macro_ratio  = trial.suggest_float("macro_ratio",  1.1, 2.0, step=0.05)
+
+        # Se multiband=False, lf_delta_db viene ignorato in evaluate_one.
+        # Se macro_expand=False, macro_ratio viene ignorato in evaluate_one.
+
+        params = dict(
+            delta_db      = delta_db,
+            window_length = win,
+            hop_length    = hop,
+            release_ms    = rel_ms,
+            max_gain_db   = gain_db,
+            eps           = eps,
+            max_iter      = max_iter,
+            # flag di alto livello (estratti in evaluate_one, non passati raw)
+            multiband     = multiband,
+            lf_delta_db   = lf_delta_db,
+            macro_expand  = macro_expand,
+            macro_ratio   = macro_ratio,
+        )
+
+        scores   = []
+        midpoint = len(corpus) // 2
+
+        for step, item in enumerate(corpus):
+            sc = evaluate_one(item, dict(params))   # dict() per non mutare params
+            if sc is not None:
+                scores.append(sc)
+            if step == midpoint and scores:
+                trial.report(float(np.mean(scores)), step=step)
+                if trial.should_prune():
+                    raise optuna.TrialPruned()
+
+        if not scores:
+            return 0.0
+        mean_score = float(np.mean(scores))
+        trial.report(mean_score, step=len(corpus))
+        return mean_score
+
+    return objective
+
+
+# =============================================================================
+# REPORT + CSV
+# =============================================================================
+
+def print_report(study: "optuna.Study", top_n: int = 20):
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    if not trials:
+        print("Nessun trial completato.")
+        return
+
+    if _HAS_RICH:
+        _console.rule("[bold cyan]RISULTATI SWEEP BAYESIANO[/]")
+        tbl = Table(show_header=True, header_style="bold cyan", show_lines=False)
+        for col, w in [("#",4),("score",9),("ddb",6),("LFd",5),("win",6),
+                       ("hop",4),("rel",6),("gain",6),("eps",5),("iter",5),
+                       ("MB",3),("ME",3),("MR",5)]:
+            tbl.add_column(col, justify="right", width=w)
+        for rank, t in enumerate(trials[:top_n], 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            mb  = "Y" if p.get("multiband")    else "n"
+            me  = "Y" if p.get("macro_expand") else "n"
+            sty = "bold green" if rank == 1 else ("yellow" if rank <= 3 else "")
+            tbl.add_row(
+                str(rank), f"{t.value:.5f}",
+                f"{p['delta_db']:.2f}",
+                f"{p.get('lf_delta_db', p['delta_db']):.2f}",
+                str(win), str(hop),
+                f"{p['release_ms']:.0f}", f"{p['max_gain_db']:.1f}",
+                str(p['eps']), str(p['max_iter']),
+                mb, me, f"{p.get('macro_ratio', 1.0):.2f}",
+                style=sty,
+            )
+        _console.print(tbl)
+    else:
+        hdr = (f"{'#':>3}  {'score':>8}  {'ddb':>5}  {'LFd':>5}  {'win':>5}"
+               f"  {'hop':>4}  {'rel':>6}  {'gain':>5}  {'eps':>5}  {'iter':>5}"
+               f"  {'MB':>3}  {'ME':>3}  {'MR':>5}")
+        print(hdr); print("-" * len(hdr))
+        for rank, t in enumerate(trials[:top_n], 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            mb  = "Y" if p.get("multiband")    else "n"
+            me  = "Y" if p.get("macro_expand") else "n"
+            print(f"{rank:>3}  {t.value:>8.5f}  {p['delta_db']:>5.2f}"
+                  f"  {p.get('lf_delta_db', p['delta_db']):>5.2f}  {win:>5}"
+                  f"  {hop:>4}  {p['release_ms']:>6.0f}  {p['max_gain_db']:>5.1f}"
+                  f"  {str(p['eps']):>5}  {p['max_iter']:>5}"
+                  f"  {mb:>3}  {me:>3}  {p.get('macro_ratio', 1.0):>5.2f}")
+
+    best = trials[0]
+    p    = best.params
+    win  = 2 ** p["win_exp"]
+    hop  = win // p["hop_div"]
+    n_pruned = sum(1 for t in study.trials
+                   if t.state == optuna.trial.TrialState.PRUNED)
+
+    print("\n" + "═" * 60)
+    print("CONFIG OTTIMALE")
+    print("═" * 60)
+    print(f"""
+params = DeclipParams(
+    algo          = "sspade",
+    frame         = "rdft",
+    mode          = "soft",
+    delta_db      = {p['delta_db']:.2f},
+    window_length = {win},
+    hop_length    = {hop},
+    release_ms    = {p['release_ms']:.1f},
+    max_gain_db   = {p['max_gain_db']:.1f},
+    eps           = {p['eps']},
+    max_iter      = {p['max_iter']},
+    sample_rate   = sr,
+    multiband     = {p.get('multiband', False)},
+    band_crossovers = ({BAND_CROSSOVER_HZ},),
+    band_delta_db   = ({p.get('lf_delta_db', p['delta_db']):.2f}, {p['delta_db']:.2f}),
+    macro_expand  = {p.get('macro_expand', False)},
+    macro_ratio   = {p.get('macro_ratio', 1.0):.2f},
+    n_jobs        = -1,
+    show_progress = True,
+)""")
+    print(f"\n→ Best score    : {best.value:.5f}")
+    print(f"   Trials done  : {len(trials)}")
+    print(f"   Pruned       : {n_pruned}")
+
+
+
+# =============================================================================
+# DEBUG EXPORT
+# =============================================================================
+
+# Parametri SPADE usati per il debug (best noti dal grid sweep precedente).
+# Se un DB Optuna esiste e ha trial completati, vengono sostituiti dal best.
+DEBUG_PARAMS = dict(
+    delta_db      = 1.5,
+    window_length = 1024,
+    hop_length    = 256,
+    release_ms    = 100.0,
+    max_gain_db   = 6.0,
+    eps           = 0.05,
+    max_iter      = 500,
+)
+
+
+def _pk_dbfs(a: np.ndarray) -> float:
+    pk = float(np.max(np.abs(a)))
+    return 20.0 * np.log10(pk) if pk > 1e-12 else -999.0
+
+
+def _rms_dbfs(a: np.ndarray) -> float:
+    rms = float(np.sqrt(np.mean(a.astype(float) ** 2)))
+    return 20.0 * np.log10(rms) if rms > 1e-12 else -999.0
+
+
+def _write_wav(path: Path, audio: np.ndarray, sr: int) -> None:
+    """Scrive WAV float32 senza clipping. Avvisa se peak > 1.0."""
+    a2d = ensure_2d(audio).astype(np.float32)
+    pk  = float(np.max(np.abs(a2d)))
+    if pk > 1.0:
+        print(f"    [WARN] {path.name}: peak={pk:.4f} > 1.0 "
+              f"(+{20*np.log10(pk):.2f} dBFS) — float32, non clippato")
+    sf.write(str(path), a2d, sr, subtype="FLOAT")
+
+
+def debug_export(
+    corpus:       list,
+    base_dir:     Path,
+    out_dir:      Path,
+    n_files:      int,
+    spade_params: dict,
+) -> None:
+    """
+    Esporta WAV di debug per i primi n_files item del corpus.
+
+    Per ogni file vengono scritti 6 WAV float32:
+      01_orig_with_noise  drum + pink noise, normalizzato a 0 dBFS peak
+                          (segnale prima del limiter)
+      02_limited          uscita del limiter sintetico (input a SPADE)
+      03_gt_residual      orig_with_noise - limited, @RESIDUAL_DBFS peak
+      04_spade_output     uscita SPADE (float32, puo' superare 0 dBFS)
+      05_res_iter         spade_output - limited, @RESIDUAL_DBFS peak
+      06_diff_residuals   gt_residual - res_iter
+                          ideale = silenzio = -inf dB
+
+    Stampa una tabella con peak dBFS e RMS dBFS per ogni traccia.
+
+    Livelli ATTESI:
+      01  peak =  0.00 dBFS   (normalizzato)
+      02  peak ~ -LIMITER_THRESHOLD_DB dBFS   (es. -1.5 dBFS)
+      03  peak = RESIDUAL_DBFS  (es. -3.0 dBFS)
+      04  peak puo' essere > 0 dBFS (transiente recuperato)
+      05  peak = RESIDUAL_DBFS  (es. -3.0 dBFS)
+      06  peak << 0 dBFS  (piu' basso = SPADE piu' vicino al GT)
+    """
+    out_dir.mkdir(parents=True, exist_ok=True)
+    items   = corpus[:n_files]
+    col_w   = max(len(it["file"]) for it in items) + 2
+
+    HDR = (f"  {'file':<{col_w}}  {'traccia':<22}"
+           f"  {'peak dBFS':>10}  {'RMS dBFS':>9}  note")
+    SEP = "  " + "-" * (len(HDR) - 2)
+
+    print()
+    if _HAS_RICH:
+        _console.rule("[bold cyan]DEBUG EXPORT[/]")
+    else:
+        print("=" * 65)
+        print("DEBUG EXPORT")
+        print("=" * 65)
+
+    print(f"  Output dir    : {out_dir}")
+    print(f"  SPADE params  : delta_db={spade_params['delta_db']}"
+          f"  win={spade_params['window_length']}"
+          f"  hop={spade_params['hop_length']}"
+          f"  rel={spade_params['release_ms']}ms"
+          f"  gain={spade_params['max_gain_db']}dB")
+    print(f"  File esportati: {len(items)}")
+    print()
+    print(f"  Livelli attesi:")
+    print(f"    01_orig_with_noise  : ~  0.00 dBFS  (normalizzato prima del limiter)")
+    print(f"    02_limited          : ~ {-LIMITER_THRESHOLD_DB:+.2f} dBFS  (uscita limiter)")
+    print(f"    03_gt_residual      : = {RESIDUAL_DBFS:+.2f} dBFS  (normalizzato)")
+    print(f"    04_spade_output     :  > 0 dBFS possibile  (transiente recuperato)")
+    print(f"    05_res_iter         : = {RESIDUAL_DBFS:+.2f} dBFS  (normalizzato)")
+    print(f"    06_diff_residuals   : << 0 dBFS  (piu' basso = pipeline piu' corretta)")
+    print()
+    print(HDR)
+
+    diff_peaks = []
+
+    for file_index, item in enumerate(items):
+        sr      = item["sr"]
+        limited = item["limited"].copy()
+        gt_res  = item["gt_res"]
+        stem    = Path(item["file"]).stem
+
+        # ── Ricostruisci orig_with_noise ──────────────────────────────────
+        # Riesegue la stessa pipeline di build_corpus con il seed identico
+        orig_with_noise = None
+        for folder in DRUM_DIRS:
+            candidate = base_dir / folder / item["file"]
+            if candidate.exists():
+                try:
+                    raw, _ = sf.read(str(candidate), always_2d=True)
+                    raw    = raw.astype(float)
+                    rng    = np.random.default_rng(seed=file_index)
+                    orig_0 = normalize_to_0dBFS(raw)
+                    mixed  = ensure_2d(mix_pink_noise(orig_0, sr,
+                                                      PINK_NOISE_LEVEL_DB, rng))
+                    orig_with_noise = ensure_2d(normalize_to_0dBFS(mixed))
+                except Exception:
+                    pass
+                break
+
+        if orig_with_noise is None:
+            # Fallback: ricostruiamo da limited + gt_res (approssimazione)
+            gt_scale  = 10 ** (RESIDUAL_DBFS / 20.0)           # peak di gt_res
+            lim_peak  = 10 ** (-LIMITER_THRESHOLD_DB / 20.0)   # peak atteso del limited
+            gt_raw    = gt_res * (lim_peak / (gt_scale + 1e-12))
+            orig_with_noise = ensure_2d(normalize_to_0dBFS(limited + gt_raw))
+
+        # ── Esegui SPADE ──────────────────────────────────────────────────
+        try:
+            p        = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **spade_params)
+            fixed, _ = declip(limited.copy(), p)
+            fixed_2d = ensure_2d(fixed)
+        except Exception as exc:
+            print(f"  [ERRORE SPADE] {item['file']}: {exc}")
+            continue
+
+        # ── Residual iterazione (scala RAW, senza normalizzazione) ───────────
+        # IMPORTANTE: il diff deve avvenire sulla scala comune PRIMA di
+        # normalizzare i due residual, altrimenti la normalizzazione
+        # indipendente rimuove l'informazione di ampiezza relativa.
+        #
+        # gt_res e res_raw sono entrambi derivati dallo stesso limited →
+        # hanno la stessa scala di riferimento.
+        # gt_res e' gia' stato normalizzato a RESIDUAL_DBFS in build_corpus;
+        # dobbiamo riportarlo alla scala raw per il confronto.
+        #
+        # Scala comune: usiamo il peak del limited come riferimento.
+        # limited peak ≈ 10^(-LIMITER_THRESHOLD_DB/20) → scala assoluta nota.
+        res_raw   = fixed_2d - limited    # residual SPADE in scala assoluta
+
+        # gt_res_raw: ricostruiamo dalla scala normalizzata
+        # gt_res = gt_res_raw / peak(gt_res_raw) * 10^(RESIDUAL_DBFS/20)
+        # → gt_res_raw = gt_res * peak(gt_res_raw) / 10^(RESIDUAL_DBFS/20)
+        # Poiche' peak(gt_res_raw) non e' salvato, lo stimiamo:
+        # gt_res_raw ≈ orig_with_noise - limited  (ricostruito)
+        gt_res_raw_approx = ensure_2d(orig_with_noise) - limited
+        L = min(gt_res_raw_approx.shape[0], res_raw.shape[0])
+
+        # ── Diff sulla scala comune (raw, non normalizzata) ───────────────
+        diff_raw  = gt_res_raw_approx[:L] - res_raw[:L]
+
+        # ── Cosine similarity temporale (scalare, sul canale L) ──────────
+        g_flat = gt_res_raw_approx[:L, 0] if gt_res_raw_approx.ndim == 2 else gt_res_raw_approx[:L]
+        e_flat = res_raw[:L, 0]           if res_raw.ndim == 2           else res_raw[:L]
+        cos_sim_td = float(
+            np.dot(g_flat, e_flat) /
+            (np.linalg.norm(g_flat) * np.linalg.norm(e_flat) + 1e-12)
+        )
+
+        # ── Stima floor teorico del diff dovuto al rumore rosa ────────────
+        # Il limiter attenue anche i picchi del rumore rosa → quella parte
+        # sta nel GT_res ma NON in res_iter (SPADE non la recupera).
+        # Stimiamo quanto rumore e' nel GT_res come proxy del floor.
+        noise_gain_lin = 10 ** (PINK_NOISE_LEVEL_DB / 20.0)
+        # Ampiezza del rumore rispetto al limited: noise_gain ≈ fraction
+        # del GT_res che e' irrecuperabile da SPADE.
+        noise_floor_db = 20 * np.log10(noise_gain_lin + 1e-12) + RESIDUAL_DBFS
+        # In pratica: diff non puo' essere < noise_floor per costruzione.
+
+        # ── diff dBFS relativo al GT_res (SNR-like) ───────────────────────
+        diff_rms_db = _rms_dbfs(diff_raw[:L])
+        gt_rms_db   = _rms_dbfs(gt_res_raw_approx[:L])
+        # diff_vs_gt: quanto e' grande il diff rispetto al GT (0 dB = diff = GT)
+        diff_vs_gt_db = diff_rms_db - gt_rms_db  # piu' negativo = meglio
+
+        # Normalizza per l'export WAV
+        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)
+        diff_norm = normalize_peak(diff_raw, RESIDUAL_DBFS) if np.max(np.abs(diff_raw)) > 1e-12 else diff_raw
+
+        diff_peaks.append((diff_vs_gt_db, cos_sim_td, diff_rms_db, gt_rms_db))
+
+        # ── Definizione tracce ────────────────────────────────────────────
+        tracks = [
+            ("01_orig_with_noise",
+             orig_with_noise,
+             f"drum+noise @0dBFS (input pipeline)"),
+            ("02_limited",
+             limited,
+             f"uscita limiter (input SPADE)  atteso: ~{-LIMITER_THRESHOLD_DB:+.2f}dBFS"),
+            ("03_gt_residual",
+             gt_res,
+             f"GT residual @{RESIDUAL_DBFS:.0f}dBFS  (include noise attenuation)"),
+            ("04_spade_output",
+             fixed_2d,
+             f"SPADE output (float32, puo' >0dBFS)"),
+            ("05_res_iter",
+             res_iter,
+             f"residual SPADE @{RESIDUAL_DBFS:.0f}dBFS  (solo componente sparsa)"),
+            ("06_diff_residuals",
+             diff_norm,
+             f"GT - iter @{RESIDUAL_DBFS:.0f}dBFS  "
+             f"cos_sim={cos_sim_td:.3f}  diff/GT={diff_vs_gt_db:+.1f}dB  "
+             f"noise_floor≈{noise_floor_db:+.1f}dB"),
+        ]
+
+        # ── Soglia realistica per il diff ─────────────────────────────────
+        # Il diff non puo' essere < noise_floor per costruzione del corpus.
+        # Calibriamo la soglia [OK] a noise_floor + 6 dB (margine).
+        ok_threshold  = noise_floor_db + 6.0   # tipicamente attorno a -17 dBFS
+        warn_threshold = ok_threshold + 10.0   # tutto sopra e' davvero anomalo
+
+        # ── Stampa tabella + scrivi WAV ───────────────────────────────────
+        print(SEP)
+        for track_name, audio, note in tracks:
+            pk  = _pk_dbfs(audio)
+            rms = _rms_dbfs(audio)
+
+            flag = ""
+            if track_name == "06_diff_residuals":
+                if   diff_vs_gt_db < -12: flag = "[OK]   buona convergenza"
+                elif diff_vs_gt_db <  -6: flag = "[~]    convergenza parziale"
+                else:                     flag = "[WARN] diff elevato rispetto al GT"
+
+            row = (f"  {item['file']:<{col_w}}  {track_name:<22}"
+                   f"  {pk:>+10.2f}  {rms:>+9.2f}  {note}  {flag}")
+
+            if _HAS_RICH:
+                color = ("green"  if "[OK]"   in flag else
+                         "yellow" if "[~]"    in flag else
+                         "red"    if "[WARN]" in flag else "")
+                colored_row = row.replace(flag, f"[{color or 'dim'}]{flag}[/]") if flag else row
+                _console.print(colored_row)
+            else:
+                print(row)
+
+            wav_path = out_dir / f"{stem}__{track_name}.wav"
+            _write_wav(wav_path, audio, sr)
+
+        # ── Analisi spettrale per banda: LF vs HF ─────────────────────────
+        # Risponde alla domanda: quanto residual c'e' nelle basse frequenze,
+        # e quanto ne recupera SPADE?
+        #
+        # Bands:
+        #   Sub-bass  :  20 –  80 Hz  (fondamentale kick, body)
+        #   Bass      :  80 – 250 Hz  (corpo kick, coda)
+        #   Low-mid   : 250 – 800 Hz  (presenza)
+        #   High-mid  : 800 – 4000 Hz (attacco, click)
+        #   High      : 4k  – 20k Hz  (aria, snap)
+        #
+        # Per ogni banda misura:
+        #   GT_energy   = energia del GT residual (quanto il limiter ha tolto)
+        #   iter_energy = energia recuperata da SPADE
+        #   recovery %  = iter_energy / GT_energy × 100
+
+        def band_energy(audio_2d, sr, f_lo, f_hi):
+            """RMS energy in dB di una banda passante [f_lo, f_hi] Hz."""
+            mono = audio_2d[:, 0] if audio_2d.ndim == 2 else audio_2d
+            N    = len(mono)
+            if N < 8:
+                return -999.0
+            # Butterworth bandpass (o lowpass/highpass ai bordi)
+            nyq = sr / 2.0
+            lo  = max(f_lo / nyq, 1e-4)
+            hi  = min(f_hi / nyq, 0.9999)
+            if lo >= hi:
+                return -999.0
+            if lo < 1e-3:
+                b, a = sig.butter(4, hi, btype="low")
+            else:
+                b, a = sig.butter(4, [lo, hi], btype="band")
+            filtered = sig.filtfilt(b, a, mono)
+            return _rms_dbfs(filtered)
+
+        BANDS = [
+            ("Sub-bass ",   20,   80),
+            ("Bass     ",   80,  250),
+            ("Low-mid  ",  250,  800),
+            ("High-mid ",  800, 4000),
+            ("High     ", 4000, 20000),
+        ]
+
+        gt_mono   = gt_res[:, 0]  if gt_res.ndim  == 2 else gt_res
+        ri_mono   = res_iter[:, 0] if res_iter.ndim == 2 else res_iter
+
+        # Normalizza GT e iter sulla stessa scala (rimuovi la normalizzazione
+        # a RESIDUAL_DBFS per confrontare energie assolute)
+        gt_raw_for_bands   = gt_res_raw_approx
+        iter_raw_for_bands = res_raw
+
+        print()
+        band_hdr = f"    {'banda':<12} {'GT_res RMS':>10}  {'SPADE rec RMS':>13}  {'recovery':>9}  {'limitato?'}"
+        print(f"  Analisi spettrale per banda — {item['file']}")
+        print(f"  {'─'*75}")
+        print(band_hdr)
+        print(f"  {'─'*75}")
+        for bname, f_lo, f_hi in BANDS:
+            gt_db   = band_energy(gt_raw_for_bands,   sr, f_lo, f_hi)
+            iter_db = band_energy(iter_raw_for_bands, sr, f_lo, f_hi)
+            if gt_db < -60:
+                recovery_str = "  —    (silenzio)"
+                flag_b = ""
+            else:
+                diff_b   = iter_db - gt_db       # positivo = SPADE supera GT (overrecovery)
+                # recovery: 0 dB diff = recupero perfetto, molto negativo = sotto-recupero
+                if diff_b > -3:
+                    flag_b = "OK"
+                elif diff_b > -9:
+                    flag_b = "~  parziale"
+                else:
+                    flag_b = "!! sotto-recupero"
+                recovery_str = f"{diff_b:>+7.1f} dB  {flag_b}"
+            line = f"    {bname:<12} {gt_db:>+10.1f}  {iter_db:>+13.1f}  {recovery_str}"
+            if _HAS_RICH:
+                color = "green" if "OK" in recovery_str else (
+                        "yellow" if "~" in recovery_str else (
+                        "red" if "!!" in recovery_str else "dim"))
+                _console.print(f"[{color}]{line}[/]")
+            else:
+                print(line)
+        print()
+
+    print(SEP)
+    print()
+    if diff_peaks:
+        vs_gt_vals  = [d[0] for d in diff_peaks]
+        cos_vals    = [d[1] for d in diff_peaks]
+        avg_vs_gt   = float(np.mean(vs_gt_vals))
+        best_vs_gt  = float(np.min(vs_gt_vals))
+        worst_vs_gt = float(np.max(vs_gt_vals))
+        avg_cos     = float(np.mean(cos_vals))
+
+        noise_floor_db = 20 * np.log10(10 ** (PINK_NOISE_LEVEL_DB / 20.0) + 1e-12) + RESIDUAL_DBFS
+
+        print(f"  RIEPILOGO  06_diff_residuals:")
+        print(f"    diff/GT_rms  media   : {avg_vs_gt:>+7.2f} dB  (0 dB = diff grande quanto GT)")
+        print(f"    diff/GT_rms  migliore: {best_vs_gt:>+7.2f} dB")
+        print(f"    diff/GT_rms  peggiore: {worst_vs_gt:>+7.2f} dB")
+        print(f"    cos_sim TD   media   : {avg_cos:>8.4f}  (1.0 = identici)")
+        print()
+        print(f"  NOTA IMPORTANTE:")
+        print(f"    Il rumore rosa ({PINK_NOISE_LEVEL_DB} dB) fa parte del GT_res ma")
+        print(f"    NON puo' essere recuperato da SPADE (non e' sparso).")
+        print(f"    Floor teorico del diff: ≈ {noise_floor_db:+.1f} dBFS — questo e' il")
+        print(f"    limite fisico massimo raggiungibile con questo corpus.")
+        print(f"    Un diff/GT < -6 dB indica buona convergenza di SPADE.")
+        print()
+        if worst_vs_gt < -12:
+            verdict = "OK     Convergenza eccellente — SPADE recupera bene i transienti"
+        elif worst_vs_gt < -6:
+            verdict = "~      Convergenza buona — residuo compatibile con il noise floor"
+        else:
+            verdict = "INFO   diff dominato dal rumore rosa — comportamento atteso e corretto"
+        print(f"    Verdetto: {verdict}")
+    print(f"\n  WAV scritti in : {out_dir}/")
+    print(f"  Formato        : float32, nessun clipping (usa un editor che supporta >0dBFS)")
+    print(f"  Nomenclatura   : <stem>__<N>_<traccia>.wav")
+
+
+def save_csv(study: "optuna.Study"):
+    import csv
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    with open(OUT_CSV, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["rank", "score", "delta_db", "lf_delta_db",
+                    "window_length", "hop_length", "release_ms", "max_gain_db",
+                    "eps", "max_iter", "multiband", "macro_expand", "macro_ratio"])
+        for rank, t in enumerate(trials, 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            w.writerow([
+                rank, round(t.value, 6),
+                p["delta_db"],
+                round(p.get("lf_delta_db", p["delta_db"]), 2),
+                win, hop,
+                p["release_ms"], p["max_gain_db"], p["eps"], p["max_iter"],
+                int(p.get("multiband",    False)),
+                int(p.get("macro_expand", False)),
+                round(p.get("macro_ratio", 1.0), 2),
+            ])
+    print(f"\n  📄 CSV: {OUT_CSV}")
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def parse_args():
+    ap = argparse.ArgumentParser(description="Smart Bayesian sweep per S-SPADE v2")
+    ap.add_argument("--trials",      type=int,  default=200,
+                    help="Numero di trial Optuna (default: 200)")
+    ap.add_argument("--resume",      action="store_true",
+                    help="Carica lo study esistente e aggiunge trial")
+    ap.add_argument("--report",      action="store_true",
+                    help="Solo report (nessun nuovo trial)")
+    ap.add_argument("--base-dir",    type=str,  default=".",
+                    help="Cartella radice con Kicks/Snares/Perc/Tops")
+    ap.add_argument("--corpus-size", type=int,  default=None,
+                    help="Limita il corpus a N file (None = tutti)")
+    ap.add_argument("--top",         type=int,  default=20,
+                    help="Quanti trial mostrare nel ranking (default: 20)")
+    ap.add_argument("--no-prune",    action="store_true",
+                    help="Disabilita MedianPruner (più lento ma completo)")
+    ap.add_argument("--debug-export", action="store_true",
+                    help="Esporta WAV di debug per i primi N file del corpus (no sweep)")
+    ap.add_argument("--debug-dir",   type=str,  default="debug_export",
+                    help="Cartella output WAV di debug (default: debug_export)")
+    ap.add_argument("--debug-n",     type=int,  default=10,
+                    help="Quanti file esportare in debug (default: 10)")
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    missing = []
+    if not _HAS_OPTUNA: missing.append("optuna")
+    if not _HAS_SPADE:  missing.append("spade_declip_v11.py (nella stessa dir)")
+    if missing:
+        pip  = [m for m in missing if not m.endswith(")")]
+        sys.exit("Mancante:\n  pip install " + " ".join(pip)
+                 + ("\n  " + "\n  ".join(m for m in missing if m.endswith(")")) if any(m.endswith(")") for m in missing) else ""))
+
+    base_dir = Path(args.base_dir).resolve()
+    storage  = f"sqlite:///{STUDY_NAME}.db"
+    sampler  = TPESampler(seed=42, multivariate=True, warn_independent_sampling=False)
+    pruner   = (MedianPruner(n_startup_trials=10, n_warmup_steps=3)
+                if not args.no_prune else optuna.pruners.NopPruner())
+
+    if args.report:
+        try:
+            study = optuna.load_study(study_name=STUDY_NAME, storage=storage,
+                                      sampler=sampler, pruner=pruner)
+        except Exception:
+            sys.exit(f"Nessuno study trovato in {STUDY_NAME}.db")
+        print_report(study, top_n=args.top)
+        save_csv(study)
+        return
+
+    # ── Debug export ──────────────────────────────────────────────────────────
+    if args.debug_export:
+        # Usa i parametri del best trial se esiste un DB, altrimenti DEBUG_PARAMS
+        spade_params = dict(DEBUG_PARAMS)
+        try:
+            study = optuna.load_study(study_name=STUDY_NAME, storage=storage,
+                                      sampler=sampler, pruner=pruner)
+            completed = [t for t in study.trials
+                         if t.state == optuna.trial.TrialState.COMPLETE]
+            if completed:
+                best_t = max(completed, key=lambda t: t.value or 0)
+                p      = best_t.params
+                win    = 2 ** p["win_exp"]
+                hop    = win // p["hop_div"]
+                spade_params = dict(
+                    delta_db      = p["delta_db"],
+                    window_length = win,
+                    hop_length    = hop,
+                    release_ms    = p["release_ms"],
+                    max_gain_db   = p["max_gain_db"],
+                    eps           = p["eps"],
+                    max_iter      = p["max_iter"],
+                )
+                print(f"  [DEBUG] Usando best trial #{best_t.number}"
+                      f" (score={best_t.value:.5f}) dal DB.")
+        except Exception:
+            print(f"  [DEBUG] DB non trovato — uso DEBUG_PARAMS di default.")
+
+        # Costruisci corpus (limitato a debug_n file per velocita')
+        corpus = build_corpus(base_dir, max_files=args.debug_n)
+        if not corpus:
+            sys.exit("Corpus vuoto. Controlla --base-dir.")
+        debug_export(
+            corpus       = corpus,
+            base_dir     = base_dir,
+            out_dir      = Path(args.debug_dir),
+            n_files      = args.debug_n,
+            spade_params = spade_params,
+        )
+        return
+
+    # ── Corpus ───────────────────────────────────────────────────────────────
+    print("\n" + "=" * 65)
+    print("CORPUS  +  LIMITER SINTETICO  (Case 1 — threshold-based)")
+    print("=" * 65)
+    print(f"  Base dir  : {base_dir}")
+    print(f"  Threshold : −{LIMITER_THRESHOLD_DB} dBFS")
+    print(f"  Release   : {LIMITER_RELEASE_MS} ms")
+    print(f"  Level align: NESSUNO — loudness invariata per costruzione")
+    print(f"  Rumore rosa: {PINK_NOISE_LEVEL_DB} dB rel. peak  "
+          f"(simula sottofondo musicale sotto il transiente)")
+
+    corpus = build_corpus(base_dir, max_files=args.corpus_size)
+    if not corpus:
+        sys.exit("Corpus vuoto. Controlla --base-dir e le cartelle.")
+
+    print(f"\n  ✓ {len(corpus)} file nel corpus\n")
+    col_w = max(len(item["file"]) for item in corpus) + 2
+    for item in corpus:
+        rms  = float(np.sqrt(np.mean(item["gt_res"] ** 2)))
+        peak = float(np.max(np.abs(item["gt_res"])))
+        print(f"    {item['file']:<{col_w}}  sr={item['sr']}  "
+              f"GT rms={rms:.4f}  peak={peak:.4f}")
+
+    # ── Study ─────────────────────────────────────────────────────────────────
+    print(f"\n{'='*65}")
+    print(f"OTTIMIZZAZIONE BAYESIANA  —  {args.trials} trial")
+    print(f"TPE (multivariate) + MedianPruner  |  storage: {STUDY_NAME}.db")
+    print(f"{'='*65}\n")
+
+    study = optuna.create_study(
+        study_name     = STUDY_NAME,
+        storage        = storage,
+        sampler        = sampler,
+        pruner         = pruner,
+        direction      = "maximize",
+        load_if_exists = True,
+    )
+
+    # ── Progress bar (rich → tqdm → plain fallback) ───────────────────────────
+    try:
+        from rich.progress import (
+            Progress, BarColumn, TextColumn,
+            TimeElapsedColumn, TimeRemainingColumn, MofNCompleteColumn,
+        )
+        _has_rich_progress = True
+    except ImportError:
+        _has_rich_progress = False
+
+    try:
+        import tqdm as _tqdm_mod
+        _has_tqdm = True
+    except ImportError:
+        _has_tqdm = False
+
+    # Stato condiviso aggiornato dal callback.
+    # Pre-popolato con i trial gia' nel DB in caso di --resume,
+    # cosi' la progress bar mostra il conteggio corretto dall'inizio.
+    _existing_complete = [t for t in study.trials
+                          if t.state == optuna.trial.TrialState.COMPLETE]
+    _existing_pruned   = [t for t in study.trials
+                          if t.state == optuna.trial.TrialState.PRUNED]
+
+    if _existing_complete:
+        _best_existing = max(_existing_complete, key=lambda t: t.value or 0)
+        _init_best     = _best_existing.value or 0.0
+        _init_best_p   = dict(_best_existing.params)
+        _init_last     = _init_best
+    else:
+        _init_best, _init_best_p, _init_last = float("-inf"), {}, float("-inf")
+
+    _state = {
+        "done":    len(_existing_complete),
+        "pruned":  len(_existing_pruned),
+        "best":    _init_best,
+        "best_p":  _init_best_p,
+        "last":    _init_last,
+        "t0":      time.time(),
+        "n_total": len(_existing_complete) + len(_existing_pruned) + args.trials,
+    }
+
+    def _fmt_best(state: dict) -> str:
+        """Stringa compatta con i parametri del best trial corrente."""
+        bp = state["best_p"]
+        if not bp:
+            return "—"
+        win = 2 ** bp.get("win_exp", 10)
+        hop = win // bp.get("hop_div", 4)
+        return (f"δ={bp.get('delta_db',0):.2f} "
+                f"win={win} hop={hop} "
+                f"rel={bp.get('release_ms',0):.0f}ms "
+                f"gain={bp.get('max_gain_db',0):.1f}dB")
+
+    # ── Rich progress bar ─────────────────────────────────────────────────────
+    if _has_rich_progress:
+        progress = Progress(
+            TextColumn("[bold cyan]Trial[/] [cyan]{task.completed}/{task.total}[/]"),
+            BarColumn(bar_width=32),
+            MofNCompleteColumn(),
+            TextColumn("  score [green]{task.fields[last]:.5f}[/]"),
+            TextColumn("  best [bold green]{task.fields[best]:.5f}[/]"),
+            TextColumn("  [dim]pruned {task.fields[pruned]}[/]"),
+            TimeElapsedColumn(),
+            TextColumn("ETA"),
+            TimeRemainingColumn(),
+            refresh_per_second=4,
+            transient=False,
+        )
+        task_id = None   # creato dentro il context
+
+        def on_trial_end(study, trial):
+            fin = (trial.state == optuna.trial.TrialState.COMPLETE)
+            prn = (trial.state == optuna.trial.TrialState.PRUNED)
+            if fin:
+                _state["done"]   += 1
+                _state["last"]    = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+            elif prn:
+                _state["pruned"] += 1
+            progress.update(
+                task_id,
+                advance    = 1,
+                last       = _state["last"],
+                best       = max(_state["best"], 0.0),
+                pruned     = _state["pruned"],
+            )
+
+        t0 = time.time()
+        try:
+            with progress:
+                task_id = progress.add_task(
+                    "sweep",
+                    total     = _state["n_total"],
+                    completed = _state["done"] + _state["pruned"],
+                    last      = max(_state["last"], 0.0),
+                    best      = max(_state["best"],  0.0),
+                    pruned    = _state["pruned"],
+                )
+                study.optimize(
+                    make_objective(corpus),
+                    n_trials          = args.trials,
+                    callbacks         = [on_trial_end],
+                    show_progress_bar = False,
+                )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+
+    # ── tqdm fallback ─────────────────────────────────────────────────────────
+    elif _has_tqdm:
+        import tqdm
+        _already = _state["done"] + _state["pruned"]
+        pbar = tqdm.tqdm(
+            total   = _state["n_total"],
+            initial = _already,
+            unit    = "trial",
+            bar_format = "{l_bar}{bar}| {n}/{total} [{elapsed}<{remaining}]",
+        )
+        if _already > 0:
+            pbar.set_postfix(
+                score  = f"{max(_state['last'],  0.0):.5f}",
+                best   = f"{max(_state['best'],  0.0):.5f}",
+                pruned = _state["pruned"],
+            )
+
+        def on_trial_end(study, trial):
+            fin = trial.state == optuna.trial.TrialState.COMPLETE
+            prn = trial.state == optuna.trial.TrialState.PRUNED
+            if fin:
+                _state["done"]  += 1
+                _state["last"]   = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+            elif prn:
+                _state["pruned"] += 1
+            pbar.update(1)
+            pbar.set_postfix(
+                score  = f"{_state['last']:.5f}",
+                best   = f"{_state['best']:.5f}",
+                pruned = _state["pruned"],
+            )
+
+        t0 = time.time()
+        try:
+            study.optimize(
+                make_objective(corpus),
+                n_trials          = args.trials,
+                callbacks         = [on_trial_end],
+                show_progress_bar = False,
+            )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+        finally:
+            pbar.close()
+
+    # ── Plain fallback ────────────────────────────────────────────────────────
+    else:
+        def on_trial_end(study, trial):
+            fin = trial.state == optuna.trial.TrialState.COMPLETE
+            prn = trial.state == optuna.trial.TrialState.PRUNED
+            if fin:
+                _state["done"]  += 1
+                _state["last"]   = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+                elapsed  = time.time() - _state["t0"]
+                done_tot = _state["done"] + _state["pruned"]
+                eta_s    = (elapsed / done_tot) * (_state["n_total"] - done_tot) if done_tot else 0
+                is_best  = abs(_state["last"] - _state["best"]) < 1e-9
+                bar_n    = int(32 * done_tot / max(_state["n_total"], 1))
+                bar      = "█" * bar_n + "░" * (32 - bar_n)
+                print(f"\r[{bar}] {done_tot}/{_state['n_total']}"
+                      f"  {'★' if is_best else ' '}score={_state['last']:.5f}"
+                      f"  best={_state['best']:.5f}"
+                      f"  pruned={_state['pruned']}"
+                      f"  ETA {eta_s/60:.1f}min   ", end="", flush=True)
+            elif prn:
+                _state["pruned"] += 1
+
+        t0 = time.time()
+        try:
+            study.optimize(
+                make_objective(corpus),
+                n_trials          = args.trials,
+                callbacks         = [on_trial_end],
+                show_progress_bar = False,
+            )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+        print()   # newline dopo la riga \r
+
+    elapsed = time.time() - t0
+    n_done  = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE)
+    n_prune = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED)
+    print(f"\n  Completati: {n_done}  |  Pruned: {n_prune}"
+          f"  |  Tempo totale: {elapsed/60:.1f} min"
+          f"  |  Media: {elapsed/max(n_done+n_prune,1):.1f} s/trial")
+
+    print_report(study, top_n=args.top)
+    save_csv(study)
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()

run_smart_sweep_old2.py

@@ -0,0 +1,1400 @@
+"""
+run_smart_sweep.py  —  S-SPADE  ·  Bayesian parameter search  (v2)
+===================================================================
+
+PIPELINE GROUND-TRUTH (Case 1 — threshold-based limiter)
+---------------------------------------------------------
+Il limiter sintetico è threshold-based:
+    - Originale normalizzato a 0 dBFS peak
+    - Limiter: attua solo sui picchi sopra la soglia → output max peak ≈ −threshold_db
+    - Il CORPO del segnale (loudness percepita) rimane invariato per definizione
+    - NON si applica nessun gain al segnale limitato dopo il processing
+
+Allineamento per il calcolo residual:
+    Originale e limited sono già sulla stessa scala (loudness uguale, picchi diversi).
+    Nessuna normalizzazione LUFS / RMS necessaria o corretta.
+
+    GT_res   = original_0dBFS  −  limited         (scale identiche)
+    res_iter = spade_output    −  limited          (idem)
+
+    Entrambi vengono poi normalizzati a RESIDUAL_DBFS peak SOLO per rendere
+    comparabili file con diversi livelli assoluti — non altera la logica.
+
+Metrica ideale:
+    GT_res ≡ res_iter  →  cosine_sim = 1.0  →  differenza = −∞ dB
+
+Ottimizzatore: Optuna TPE (Bayesian) + MedianPruner
+Storage:       SQLite (riprendibile con --resume)
+Corpus:        tutti i drum sample in Kicks / Snares / Perc / Tops
+
+DIPENDENZE
+----------
+    pip install numpy scipy soundfile optuna rich
+    (pyloudnorm NON necessario)
+
+USO
+---
+    python run_smart_sweep.py                          # 200 trial
+    python run_smart_sweep.py --trials 50              # test rapido
+    python run_smart_sweep.py --resume                 # riprende da DB
+    python run_smart_sweep.py --report                 # solo risultati
+    python run_smart_sweep.py --base-dir /path/SPADE   # cartella custom
+"""
+
+import argparse
+import logging
+import sys
+import time
+import warnings
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+import scipy.signal as sig
+import soundfile as sf
+
+logging.getLogger("optuna").setLevel(logging.WARNING)
+
+# ── optuna ───────────────────────────────────────────────────────────────────
+try:
+    import optuna
+    from optuna.samplers import TPESampler
+    from optuna.pruners  import MedianPruner
+    _HAS_OPTUNA = True
+except ImportError:
+    _HAS_OPTUNA = False
+    warnings.warn("optuna non trovato — pip install optuna")
+
+# ── rich ─────────────────────────────────────────────────────────────────────
+try:
+    from rich.console import Console
+    from rich.table   import Table
+    _console  = Console()
+    _HAS_RICH = True
+except ImportError:
+    _HAS_RICH = False
+    _console  = None
+
+# ── spade_declip ─────────────────────────────────────────────────────────────
+try:
+    from spade_declip_v12 import declip, DeclipParams
+    _HAS_SPADE = True
+except ImportError:
+    _HAS_SPADE = False
+    warnings.warn("spade_declip_v12.py non trovato")
+
+# =============================================================================
+# CONFIG
+# =============================================================================
+
+DRUM_DIRS = ["Kicks", "Snares", "Perc", "Tops"]
+
+# ── Limiter sintetico ─────────────────────────────────────────────────────────
+# Case 1: threshold-based.
+# Originale @ 0 dBFS peak → limiter attua sui picchi > soglia →
+# output max peak ≈ −LIMITER_THRESHOLD_DB dBFS, loudness invariata.
+# NON si tocca il segnale limitato con nessun gain dopo.
+LIMITER_THRESHOLD_DB = 3.0   # dB sotto il ceiling (positivo)
+LIMITER_RELEASE_MS   = 80.0  # release del limiter sintetico (ms)
+# attack = 1 campione → brickwall vero
+
+# Normalizzazione residual — SOLO per comparabilità cross-file.
+# Scala entrambi GT e iter identicamente, quindi non altera il confronto.
+RESIDUAL_DBFS = -3.0
+
+# ── Rumore rosa di sottofondo ─────────────────────────────────────────────────
+# Simula un sottofondo musicale sotto il transiente di batteria.
+# Viene mixato al sample (già a 0 dBFS peak) PRIMA del limiter.
+# Questo assicura che:
+#   - il limiter agisca sul segnale realistico  drum + music background
+#   - SPADE riceva lo stesso mix e debba lavorare in condizioni realistiche
+#   - GT_res = (drum+noise) − limiter(drum+noise)  rifletta la situazione reale
+# Livello relativo al peak del drum sample. −20 dB = sottofondo ben sotto
+# il transiente, udibile ma non dominante (come un kick su un loop di batteria).
+PINK_NOISE_LEVEL_DB = -20.0   # dB rel. al peak del drum (negativo = sotto)
+
+# Optuna
+STUDY_NAME = "spade_smart_v2_thr3db"
+OUT_CSV    = "smart_sweep_results.csv"
+
+# Parametri FISSI del solver SPADE (invarianti tra tutti i trial)
+FIXED_SOLVER = dict(
+    algo          = "sspade",
+    frame         = "rdft",
+    mode          = "soft",
+    s             = 1,
+    r             = 1,
+    n_jobs        = 1,
+    verbose       = False,
+    show_progress = False,
+    use_gpu       = True,
+    # multiband e macro_expand sono nello spazio di ricerca
+)
+
+# Crossover multiband (fisso per comparabilita' tra trial)
+# 250 Hz separa: LF=corpo/punch del kick  |  HF=transiente/attacco
+BAND_CROSSOVER_HZ = 250.0
+
+# =============================================================================
+# HELPERS
+# =============================================================================
+
+def ensure_2d(a: np.ndarray) -> np.ndarray:
+    return a[:, None] if a.ndim == 1 else a
+
+
+def normalize_to_0dBFS(a: np.ndarray) -> np.ndarray:
+    """Scala a 0 dBFS peak — usato solo sull'originale come riferimento comune."""
+    pk = np.max(np.abs(a))
+    return a / pk if pk > 1e-12 else a
+
+
+def normalize_peak(a: np.ndarray, target_dbfs: float) -> np.ndarray:
+    """
+    Scala a target_dbfs dBFS peak.
+    Usato SOLO sui residual per comparabilità cross-file;
+    non altera la logica perché GT e iter vengono scalati identicamente.
+    """
+    pk = np.max(np.abs(a))
+    return a * (10 ** (target_dbfs / 20.0) / pk) if pk > 1e-12 else a
+
+
+def generate_pink_noise(n_samples: int, n_channels: int, rng: np.random.Generator) -> np.ndarray:
+    """
+    Genera rumore rosa (1/f) tramite filtro IIR di Voss-McCartney (approssimazione
+    a 5 poli, accurata entro ±1 dB nel range 20 Hz – 20 kHz).
+
+    Output: shape (n_samples, n_channels), RMS normalizzato a 1.0 (prima
+    del mix-in con PINK_NOISE_LEVEL_DB, che controlla il livello finale).
+
+    Algoritmo: rumore bianco filtrato con H(z) = 1 / A(z) dove i coefficienti
+    sono ottimizzati per approssimare una densità spettrale 1/f.
+    """
+    # Coefficienti del filtro IIR a 5 poli (Voss approssimazione)
+    # Poli reali, tutti stabili (|p| < 1)
+    b = np.array([0.049922035, -0.095993537,  0.050612699, -0.004408786])
+    a = np.array([1.0,         -2.494956002,  2.017265875, -0.522189400])
+
+    out = np.empty((n_samples, n_channels))
+    for c in range(n_channels):
+        white = rng.standard_normal(n_samples)
+        pink  = sig.lfilter(b, a, white)
+        rms   = np.sqrt(np.mean(pink ** 2))
+        out[:, c] = pink / (rms + 1e-12)   # RMS = 1.0
+
+    return out
+
+
+def mix_pink_noise(
+    audio_0dBFS: np.ndarray,
+    sr: int,
+    level_db: float,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """
+    Mixa rumore rosa nel segnale a un livello relativo al suo peak.
+
+    level_db < 0  →  il rumore è sotto il peak del drum (es. −20 dB)
+    Il rumore dura quanto il sample; se il sample è stereo, il rumore è stereo
+    (canali indipendenti → decorrelato come un vero fondo musicale).
+
+    Il segnale in uscita può superare 0 dBFS di qualche frazione di dB: è
+    corretto, il limiter che segue si occupa di riportarlo sotto la soglia.
+    """
+    audio = ensure_2d(audio_0dBFS)
+    N, C  = audio.shape
+
+    noise  = generate_pink_noise(N, C, rng)          # RMS = 1.0 per canale
+    # Scala il rumore al livello desiderato rispetto al peak del drum
+    peak   = np.max(np.abs(audio))
+    gain   = peak * (10 ** (level_db / 20.0))        # gain lineare assoluto
+    mixed  = audio + noise * gain
+    # NON normalizziamo qui: la normalizzazione a 0 dBFS avviene in build_corpus
+    # subito dopo, su tutto il mix (drum + noise), prima di qualsiasi altra op.
+    return mixed[:, 0] if audio_0dBFS.ndim == 1 else mixed
+
+
+# =============================================================================
+# LIMITER SINTETICO  (Case 1 — threshold-based, brickwall, 1-campione attack)
+# =============================================================================
+
+def apply_brickwall_limiter(
+    audio_0dBFS: np.ndarray,
+    sr: int,
+    threshold_db: float = LIMITER_THRESHOLD_DB,
+    release_ms:   float = LIMITER_RELEASE_MS,
+) -> np.ndarray:
+    """
+    Brickwall limiter threshold-based.
+
+    Input:  audio_0dBFS — già a 0 dBFS peak, shape (N,) o (N, C)
+    Output: segnale limitato, stessa shape — NON boosted, NON clippato
+
+    Gain envelope:
+        se |x[n]| > threshold_lin  →  target_gain = threshold_lin / |x[n]|
+        altrimenti                 →  target_gain = 1.0
+    Attack : istantaneo (1 campione, true brickwall)
+    Release: esponenziale con costante release_ms
+
+    Post-processing: NESSUNO.
+    Il segnale in uscita ha max peak ≈ −threshold_db dBFS.
+    La loudness percepita è invariata rispetto all'input.
+    """
+    thr_lin = 10 ** (-abs(threshold_db) / 20.0)
+    rc      = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9))
+
+    audio   = ensure_2d(audio_0dBFS).copy()
+    N, C    = audio.shape
+    out     = np.empty_like(audio)
+
+    for c in range(C):
+        ch  = audio[:, c]
+        env = 1.0
+        g   = np.empty(N)
+        for n in range(N):
+            pk     = abs(ch[n])
+            target = thr_lin / pk if pk > thr_lin else 1.0
+            # attack istantaneo se gain scende, release esponenziale se risale
+            env    = target if target < env else rc * env + (1.0 - rc) * target
+            g[n]   = env
+        out[:, c] = ch * g
+
+    # Restituisce stessa shape dell'input
+    return out[:, 0] if audio_0dBFS.ndim == 1 else out
+
+
+# =============================================================================
+# COSINE SIMILARITY TF
+# =============================================================================
+
+def cosine_sim_tf(
+    gt:          np.ndarray,
+    est:         np.ndarray,
+    sr:          int,
+    win_samples: int = 1024,
+    hop_samples: int = 256,
+    n_bands:     int = 12,
+) -> float:
+    """
+    Similarità coseno media su micro-finestre tempo-frequenziali.
+    Input: entrambi già a RESIDUAL_DBFS peak.
+    Output: scalare in [0, 1]. Target ideale = 1.0.
+    """
+    L = min(gt.shape[0], est.shape[0])
+    g = (gt[:L, 0]  if gt.ndim  == 2 else gt[:L]).copy()
+    e = (est[:L, 0] if est.ndim == 2 else est[:L]).copy()
+
+    win = min(win_samples, max(32, L // 4))
+    hop = min(hop_samples, win // 2)
+
+    if L < win or win < 32:
+        denom = np.linalg.norm(g) * np.linalg.norm(e) + 1e-12
+        return float(np.dot(g, e) / denom)
+
+    _, _, Zg = sig.stft(g, fs=sr, window="hann",
+                        nperseg=win, noverlap=win - hop,
+                        boundary=None, padded=False)
+    _, _, Ze = sig.stft(e, fs=sr, window="hann",
+                        nperseg=win, noverlap=win - hop,
+                        boundary=None, padded=False)
+
+    n_freqs, n_frames = Zg.shape
+    if n_frames == 0:
+        return float(np.dot(g, e) / (np.linalg.norm(g) * np.linalg.norm(e) + 1e-12))
+
+    edges = np.unique(np.round(
+        np.logspace(0, np.log10(max(n_freqs, 2)), min(n_bands, n_freqs) + 1)
+    ).astype(int))
+    edges = np.clip(edges, 0, n_freqs)
+
+    sims = []
+    for i in range(len(edges) - 1):
+        f0, f1 = int(edges[i]), int(edges[i + 1])
+        if f1 <= f0:
+            continue
+        Mg = np.abs(Zg[f0:f1, :])
+        Me = np.abs(Ze[f0:f1, :])
+        dot    = np.sum(Mg * Me, axis=0)
+        norm_g = np.sqrt(np.sum(Mg ** 2, axis=0)) + 1e-12
+        norm_e = np.sqrt(np.sum(Me ** 2, axis=0)) + 1e-12
+        sims.extend((dot / (norm_g * norm_e)).tolist())
+
+    return float(np.mean(sims)) if sims else 0.0
+
+
+# =============================================================================
+# CORPUS
+# =============================================================================
+
+def build_corpus(base_dir: Path, max_files: Optional[int] = None) -> List[Dict]:
+    """
+    Per ogni drum sample:
+      1. Carica e normalizza a 0 dBFS peak  (riferimento comune cross-file)
+      2. Mixa rumore rosa a PINK_NOISE_LEVEL_DB rel. al peak  ← NUOVO
+         Il mix avviene in float (può temporaneamente superare 0 dBFS)
+      3. Normalizza il mix (drum + noise) a 0 dBFS peak
+         Riferimento comune prima di tutta la pipeline successiva
+      4. Applica limiter sintetico su (drum + noise) normalizzato  →  limited
+      4. GT_res_raw = (drum + noise) − limited         (stessa scala, nessun gain)
+      5. Scarta file dove il limiter non interviene
+      6. Normalizza GT_res a RESIDUAL_DBFS  (solo comparabilità cross-file)
+
+    Il rumore è riproducibile: ogni file usa un seed deterministico derivato
+    dal suo indice nel corpus, così i trial sono comparabili tra loro.
+    """
+    corpus = []
+    extensions = {".wav", ".flac", ".aif", ".aiff"}
+    file_index = 0   # usato per seed deterministico del rumore
+
+    for folder in DRUM_DIRS:
+        d = base_dir / folder
+        if not d.exists():
+            print(f"  [WARN] Cartella non trovata: {d}")
+            continue
+        for f in sorted(d.glob("*")):
+            if f.suffix.lower() not in extensions:
+                continue
+            try:
+                audio, sr = sf.read(str(f), always_2d=True)
+                audio = audio.astype(float)
+            except Exception as exc:
+                print(f"  [WARN] {f.name}: {exc}")
+                continue
+
+            if audio.shape[0] < 64:
+                continue
+
+            # 1. 0 dBFS peak
+            orig = normalize_to_0dBFS(audio)
+
+            # 2. Mix rumore rosa — seed deterministico per riproducibilità
+            rng  = np.random.default_rng(seed=file_index)
+            orig_with_noise = ensure_2d(mix_pink_noise(orig, sr,
+                                                        PINK_NOISE_LEVEL_DB, rng))
+            file_index += 1
+
+            # 3. Normalizza il mix a 0 dBFS peak — riferimento comune prima
+            #    di tutta la pipeline. Il mix in float può aver superato 0 dBFS;
+            #    questa normalizzazione azzera il problema prima del limiter.
+            orig_with_noise = ensure_2d(normalize_to_0dBFS(orig_with_noise))
+
+            # 4. Limiter sintetico su (drum + noise) @0dBFS — nessun gain dopo
+            limited = ensure_2d(apply_brickwall_limiter(orig_with_noise, sr))
+
+            # 5. Residual grezzo — stessa scala, zero aggiustamenti
+            gt_res_raw = orig_with_noise - limited
+
+            # 6. Verifica attività del limiter
+            if np.max(np.abs(gt_res_raw)) < 1e-6:
+                print(f"  [SKIP] {f.name} — picco sotto la soglia, limiter inattivo")
+                continue
+
+            # 7. Normalizza a RESIDUAL_DBFS solo per comparabilità cross-file
+            gt_res = normalize_peak(gt_res_raw, RESIDUAL_DBFS)
+
+            corpus.append({
+                "file"    : f.name,
+                "sr"      : sr,
+                "limited" : limited,    # input a SPADE = drum + noise + limiter
+                "gt_res"  : gt_res,     # target residual
+            })
+
+            if max_files and len(corpus) >= max_files:
+                return corpus
+
+    return corpus
+
+
+# =============================================================================
+# VALUTAZIONE SINGOLO FILE
+# =============================================================================
+
+def evaluate_one(item: Dict, params: dict) -> Optional[float]:
+    """
+    Esegue SPADE su limited, calcola il residual e lo confronta con GT.
+
+    params contiene parametri SPADE puri + flag di alto livello:
+        multiband    (bool)  -- split LF/HF, elabora separatamente
+        macro_expand (bool)  -- envelope pre-pass per recupero corpo LF
+        macro_ratio  (float) -- rapporto espansione (1.0 = bypass)
+        lf_delta_db  (float) -- delta_db per banda LF (<= BAND_CROSSOVER_HZ)
+                                 il delta_db standard e' usato per la banda HF
+        lf_cutoff_hz (float) -- v12: Hz sotto cui riservare bin LF (0 = off)
+        lf_k_min     (int)   -- v12: slot LF garantiti per iterazione ADMM
+    """
+    try:
+        sr      = item["sr"]
+        limited = item["limited"].copy()
+        gt_res  = item["gt_res"]
+
+        # Estrai flag di alto livello (non sono parametri DeclipParams diretti)
+        p2      = dict(params)   # copia per non mutare l'originale
+        multiband    = p2.pop("multiband",    False)
+        macro_expand = p2.pop("macro_expand", False)
+        macro_ratio  = p2.pop("macro_ratio",  1.0)
+        lf_delta_db  = p2.pop("lf_delta_db",  p2.get("delta_db", 1.5))
+        # v12: stratified thresholding params — passati direttamente a DeclipParams
+        # (già nel dict p2, non richiedono pop separato)
+
+        spade_kw = dict(
+            multiband        = multiband,
+            macro_expand     = macro_expand,
+            macro_ratio      = macro_ratio if macro_expand else 1.0,
+            macro_release_ms = 200.0,
+            macro_attack_ms  = 10.0,
+        )
+        if multiband:
+            spade_kw["band_crossovers"] = (BAND_CROSSOVER_HZ,)
+            spade_kw["band_delta_db"]   = (lf_delta_db, p2["delta_db"])
+
+        p = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **p2, **spade_kw)
+        fixed, _ = declip(limited, p)
+        fixed_2d  = ensure_2d(fixed)
+
+        # Residual generato — stessa scala dell'input, nessun gain
+        res_raw  = fixed_2d - limited
+        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)
+
+        return cosine_sim_tf(gt_res, res_iter, sr)
+
+    except Exception as exc:
+        warnings.warn(f"evaluate_one ({item['file']}): {exc}")
+        return None
+
+
+# =============================================================================
+# OBIETTIVO OPTUNA
+# =============================================================================
+
+def make_objective(corpus: List[Dict]):
+    def objective(trial: "optuna.Trial") -> float:
+        # ── Parametri core ────────────────────────────────────────────────
+        delta_db = trial.suggest_float("delta_db",    1.5,  3.5,  step=0.05)
+        win_exp  = trial.suggest_int  ("win_exp",      9,   11)
+        win      = 2 ** win_exp
+        hop_div  = trial.suggest_categorical("hop_div", [4, 8])
+        hop      = win // hop_div
+        rel_ms   = trial.suggest_float("release_ms",  10.0, 200.0, step=5.0)
+        gain_db  = trial.suggest_float("max_gain_db",  2.0,  12.0, step=0.5)
+        eps      = trial.suggest_categorical("eps",    [0.03, 0.05, 0.1])
+        max_iter = trial.suggest_categorical("max_iter", [250, 500, 1000])
+
+        # ── Multiband + Macro expand ────────────────────────────────────────
+        # SPAZIO STATICO: lf_delta_db e macro_ratio vengono SEMPRE campionati
+        # dal TPE (spazio fisso) e poi usati condizionalmente a runtime.
+        # Questo elimina il fallback a RandomSampler che degradava le performance
+        # del TPE multivariate con spazi dinamici.
+        multiband    = trial.suggest_categorical("multiband",    [False, True])
+        macro_expand = trial.suggest_categorical("macro_expand", [False, True])
+
+        # Sempre campionati (range fisso), usati solo se il flag e' True:
+        lf_delta_db = trial.suggest_float("lf_delta_db", 0.5, 2.0, step=0.05)
+        macro_ratio  = trial.suggest_float("macro_ratio",  1.1, 2.0, step=0.05)
+
+        # ── v12: frequency-stratified thresholding ─────────────────────────
+        # lf_cutoff_hz: soglia in Hz che separa i bin "LF garantiti" dagli HF.
+        # Con M=512, sr=44100: bin_k = k * sr / (2M) → lf_cutoff=1000Hz → 23 bin LF.
+        # lf_k_min: quanti di quei bin sono garantiti per ogni iterazione ADMM.
+        # 0 = disabilitato (comportamento identico a v11).
+        lf_cutoff_hz = trial.suggest_categorical("lf_cutoff_hz", [0.0, 500.0, 1000.0, 2000.0])
+        lf_k_min     = trial.suggest_int("lf_k_min", 0, 16)
+        # Nota: quando lf_cutoff_hz=0 oppure lf_k_min=0, la feature e' disabilitata.
+        # Il TPE impara autonomamente quando conviene attivarla.
+
+        # Se multiband=False, lf_delta_db viene ignorato in evaluate_one.
+        # Se macro_expand=False, macro_ratio viene ignorato in evaluate_one.
+
+        params = dict(
+            delta_db      = delta_db,
+            window_length = win,
+            hop_length    = hop,
+            release_ms    = rel_ms,
+            max_gain_db   = gain_db,
+            eps           = eps,
+            max_iter      = max_iter,
+            # flag di alto livello (estratti in evaluate_one, non passati raw)
+            multiband     = multiband,
+            lf_delta_db   = lf_delta_db,
+            macro_expand  = macro_expand,
+            macro_ratio   = macro_ratio,
+            # v12: passati direttamente a DeclipParams (non estratti in evaluate_one)
+            lf_cutoff_hz  = lf_cutoff_hz,
+            lf_k_min      = lf_k_min,
+        )
+
+        scores   = []
+        # ── Shuffle per-trial con seed riproducibile ──────────────────────
+        # Ogni trial vede il corpus in ordine diverso per evitare che i file
+        # in coda siano sistematicamente ignorati dal pruner (che valuta al
+        # midpoint) e che l'ottimizzatore sviluppi un bias sull'ordine fisso.
+        # Il seed è deterministico (trial.number) → riproducibile con --resume.
+        rng_shuffle = np.random.default_rng(trial.number)
+        shuffled_corpus = rng_shuffle.permutation(len(corpus)).tolist()
+        midpoint = len(corpus) // 2
+
+        for step, idx in enumerate(shuffled_corpus):
+            item = corpus[idx]
+            sc = evaluate_one(item, dict(params))   # dict() per non mutare params
+            if sc is not None:
+                scores.append(sc)
+            if step == midpoint and scores:
+                trial.report(float(np.mean(scores)), step=step)
+                if trial.should_prune():
+                    raise optuna.TrialPruned()
+
+        if not scores:
+            return 0.0
+        mean_score = float(np.mean(scores))
+        trial.report(mean_score, step=len(corpus))
+        return mean_score
+
+    return objective
+
+
+# =============================================================================
+# REPORT + CSV
+# =============================================================================
+
+def print_report(study: "optuna.Study", top_n: int = 20):
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    if not trials:
+        print("Nessun trial completato.")
+        return
+
+    if _HAS_RICH:
+        _console.rule("[bold cyan]RISULTATI SWEEP BAYESIANO[/]")
+        tbl = Table(show_header=True, header_style="bold cyan", show_lines=False)
+        for col, w in [("#",4),("score",9),("ddb",6),("LFd",5),("win",6),
+                       ("hop",4),("rel",6),("gain",6),("eps",5),("iter",5),
+                       ("MB",3),("ME",3),("MR",5),("LFcut",6),("LFk",4)]:
+            tbl.add_column(col, justify="right", width=w)
+        for rank, t in enumerate(trials[:top_n], 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            mb  = "Y" if p.get("multiband")    else "n"
+            me  = "Y" if p.get("macro_expand") else "n"
+            lfc = p.get("lf_cutoff_hz", 0.0)
+            lfk = p.get("lf_k_min", 0)
+            sty = "bold green" if rank == 1 else ("yellow" if rank <= 3 else "")
+            tbl.add_row(
+                str(rank), f"{t.value:.5f}",
+                f"{p['delta_db']:.2f}",
+                f"{p.get('lf_delta_db', p['delta_db']):.2f}",
+                str(win), str(hop),
+                f"{p['release_ms']:.0f}", f"{p['max_gain_db']:.1f}",
+                str(p['eps']), str(p['max_iter']),
+                mb, me, f"{p.get('macro_ratio', 1.0):.2f}",
+                f"{lfc:.0f}", str(lfk),
+                style=sty,
+            )
+        _console.print(tbl)
+    else:
+        hdr = (f"{'#':>3}  {'score':>8}  {'ddb':>5}  {'LFd':>5}  {'win':>5}"
+               f"  {'hop':>4}  {'rel':>6}  {'gain':>5}  {'eps':>5}  {'iter':>5}"
+               f"  {'MB':>3}  {'ME':>3}  {'MR':>5}  {'LFcut':>6}  {'LFk':>4}")
+        print(hdr); print("-" * len(hdr))
+        for rank, t in enumerate(trials[:top_n], 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            mb  = "Y" if p.get("multiband")    else "n"
+            me  = "Y" if p.get("macro_expand") else "n"
+            lfc = p.get("lf_cutoff_hz", 0.0)
+            lfk = p.get("lf_k_min", 0)
+            print(f"{rank:>3}  {t.value:>8.5f}  {p['delta_db']:>5.2f}"
+                  f"  {p.get('lf_delta_db', p['delta_db']):>5.2f}  {win:>5}"
+                  f"  {hop:>4}  {p['release_ms']:>6.0f}  {p['max_gain_db']:>5.1f}"
+                  f"  {str(p['eps']):>5}  {p['max_iter']:>5}"
+                  f"  {mb:>3}  {me:>3}  {p.get('macro_ratio', 1.0):>5.2f}"
+                  f"  {lfc:>6.0f}  {lfk:>4}")
+
+    best = trials[0]
+    p    = best.params
+    win  = 2 ** p["win_exp"]
+    hop  = win // p["hop_div"]
+    n_pruned = sum(1 for t in study.trials
+                   if t.state == optuna.trial.TrialState.PRUNED)
+
+    print("\n" + "═" * 60)
+    print("CONFIG OTTIMALE")
+    print("═" * 60)
+    print(f"""
+params = DeclipParams(
+    algo          = "sspade",
+    frame         = "rdft",
+    mode          = "soft",
+    delta_db      = {p['delta_db']:.2f},
+    window_length = {win},
+    hop_length    = {hop},
+    release_ms    = {p['release_ms']:.1f},
+    max_gain_db   = {p['max_gain_db']:.1f},
+    eps           = {p['eps']},
+    max_iter      = {p['max_iter']},
+    sample_rate   = sr,
+    multiband     = {p.get('multiband', False)},
+    band_crossovers = ({BAND_CROSSOVER_HZ},),
+    band_delta_db   = ({p.get('lf_delta_db', p['delta_db']):.2f}, {p['delta_db']:.2f}),
+    macro_expand  = {p.get('macro_expand', False)},
+    macro_ratio   = {p.get('macro_ratio', 1.0):.2f},
+    lf_cutoff_hz  = {p.get('lf_cutoff_hz', 0.0):.1f},   # v12
+    lf_k_min      = {p.get('lf_k_min', 0)},               # v12
+    n_jobs        = -1,
+    show_progress = True,
+)""")
+    print(f"\n→ Best score    : {best.value:.5f}")
+    print(f"   Trials done  : {len(trials)}")
+    print(f"   Pruned       : {n_pruned}")
+
+
+
+# =============================================================================
+# DEBUG EXPORT
+# =============================================================================
+
+# Parametri SPADE usati per il debug (best noti dal grid sweep precedente).
+# Se un DB Optuna esiste e ha trial completati, vengono sostituiti dal best.
+DEBUG_PARAMS = dict(
+    delta_db      = 1.5,
+    window_length = 1024,
+    hop_length    = 256,
+    release_ms    = 100.0,
+    max_gain_db   = 6.0,
+    eps           = 0.05,
+    max_iter      = 500,
+)
+
+
+def _pk_dbfs(a: np.ndarray) -> float:
+    pk = float(np.max(np.abs(a)))
+    return 20.0 * np.log10(pk) if pk > 1e-12 else -999.0
+
+
+def _rms_dbfs(a: np.ndarray) -> float:
+    rms = float(np.sqrt(np.mean(a.astype(float) ** 2)))
+    return 20.0 * np.log10(rms) if rms > 1e-12 else -999.0
+
+
+def _write_wav(path: Path, audio: np.ndarray, sr: int) -> None:
+    """Scrive WAV float32 senza clipping. Avvisa se peak > 1.0."""
+    a2d = ensure_2d(audio).astype(np.float32)
+    pk  = float(np.max(np.abs(a2d)))
+    if pk > 1.0:
+        print(f"    [WARN] {path.name}: peak={pk:.4f} > 1.0 "
+              f"(+{20*np.log10(pk):.2f} dBFS) — float32, non clippato")
+    sf.write(str(path), a2d, sr, subtype="FLOAT")
+
+
+def debug_export(
+    corpus:       list,
+    base_dir:     Path,
+    out_dir:      Path,
+    n_files:      int,
+    spade_params: dict,
+) -> None:
+    """
+    Esporta WAV di debug per i primi n_files item del corpus.
+
+    Per ogni file vengono scritti 6 WAV float32:
+      01_orig_with_noise  drum + pink noise, normalizzato a 0 dBFS peak
+                          (segnale prima del limiter)
+      02_limited          uscita del limiter sintetico (input a SPADE)
+      03_gt_residual      orig_with_noise - limited, @RESIDUAL_DBFS peak
+      04_spade_output     uscita SPADE (float32, puo' superare 0 dBFS)
+      05_res_iter         spade_output - limited, @RESIDUAL_DBFS peak
+      06_diff_residuals   gt_residual - res_iter
+                          ideale = silenzio = -inf dB
+
+    Stampa una tabella con peak dBFS e RMS dBFS per ogni traccia.
+
+    Livelli ATTESI:
+      01  peak =  0.00 dBFS   (normalizzato)
+      02  peak ~ -LIMITER_THRESHOLD_DB dBFS   (es. -1.5 dBFS)
+      03  peak = RESIDUAL_DBFS  (es. -3.0 dBFS)
+      04  peak puo' essere > 0 dBFS (transiente recuperato)
+      05  peak = RESIDUAL_DBFS  (es. -3.0 dBFS)
+      06  peak << 0 dBFS  (piu' basso = SPADE piu' vicino al GT)
+    """
+    out_dir.mkdir(parents=True, exist_ok=True)
+    items   = corpus[:n_files]
+    col_w   = max(len(it["file"]) for it in items) + 2
+
+    HDR = (f"  {'file':<{col_w}}  {'traccia':<22}"
+           f"  {'peak dBFS':>10}  {'RMS dBFS':>9}  note")
+    SEP = "  " + "-" * (len(HDR) - 2)
+
+    print()
+    if _HAS_RICH:
+        _console.rule("[bold cyan]DEBUG EXPORT[/]")
+    else:
+        print("=" * 65)
+        print("DEBUG EXPORT")
+        print("=" * 65)
+
+    print(f"  Output dir    : {out_dir}")
+    print(f"  SPADE params  : delta_db={spade_params['delta_db']}"
+          f"  win={spade_params['window_length']}"
+          f"  hop={spade_params['hop_length']}"
+          f"  rel={spade_params['release_ms']}ms"
+          f"  gain={spade_params['max_gain_db']}dB")
+    print(f"  File esportati: {len(items)}")
+    print()
+    print(f"  Livelli attesi:")
+    print(f"    01_orig_with_noise  : ~  0.00 dBFS  (normalizzato prima del limiter)")
+    print(f"    02_limited          : ~ {-LIMITER_THRESHOLD_DB:+.2f} dBFS  (uscita limiter)")
+    print(f"    03_gt_residual      : = {RESIDUAL_DBFS:+.2f} dBFS  (normalizzato)")
+    print(f"    04_spade_output     :  > 0 dBFS possibile  (transiente recuperato)")
+    print(f"    05_res_iter         : = {RESIDUAL_DBFS:+.2f} dBFS  (normalizzato)")
+    print(f"    06_diff_residuals   : << 0 dBFS  (piu' basso = pipeline piu' corretta)")
+    print()
+    print(HDR)
+
+    diff_peaks = []
+
+    for file_index, item in enumerate(items):
+        sr      = item["sr"]
+        limited = item["limited"].copy()
+        gt_res  = item["gt_res"]
+        stem    = Path(item["file"]).stem
+
+        # ── Ricostruisci orig_with_noise ──────────────────────────────────
+        # Riesegue la stessa pipeline di build_corpus con il seed identico
+        orig_with_noise = None
+        for folder in DRUM_DIRS:
+            candidate = base_dir / folder / item["file"]
+            if candidate.exists():
+                try:
+                    raw, _ = sf.read(str(candidate), always_2d=True)
+                    raw    = raw.astype(float)
+                    rng    = np.random.default_rng(seed=file_index)
+                    orig_0 = normalize_to_0dBFS(raw)
+                    mixed  = ensure_2d(mix_pink_noise(orig_0, sr,
+                                                      PINK_NOISE_LEVEL_DB, rng))
+                    orig_with_noise = ensure_2d(normalize_to_0dBFS(mixed))
+                except Exception:
+                    pass
+                break
+
+        if orig_with_noise is None:
+            # Fallback: ricostruiamo da limited + gt_res (approssimazione)
+            gt_scale  = 10 ** (RESIDUAL_DBFS / 20.0)           # peak di gt_res
+            lim_peak  = 10 ** (-LIMITER_THRESHOLD_DB / 20.0)   # peak atteso del limited
+            gt_raw    = gt_res * (lim_peak / (gt_scale + 1e-12))
+            orig_with_noise = ensure_2d(normalize_to_0dBFS(limited + gt_raw))
+
+        # ── Esegui SPADE ──────────────────────────────────────────────────
+        try:
+            p        = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **spade_params)
+            fixed, _ = declip(limited.copy(), p)
+            fixed_2d = ensure_2d(fixed)
+        except Exception as exc:
+            print(f"  [ERRORE SPADE] {item['file']}: {exc}")
+            continue
+
+        # ── Residual iterazione (scala RAW, senza normalizzazione) ───────────
+        # IMPORTANTE: il diff deve avvenire sulla scala comune PRIMA di
+        # normalizzare i due residual, altrimenti la normalizzazione
+        # indipendente rimuove l'informazione di ampiezza relativa.
+        #
+        # gt_res e res_raw sono entrambi derivati dallo stesso limited →
+        # hanno la stessa scala di riferimento.
+        # gt_res e' gia' stato normalizzato a RESIDUAL_DBFS in build_corpus;
+        # dobbiamo riportarlo alla scala raw per il confronto.
+        #
+        # Scala comune: usiamo il peak del limited come riferimento.
+        # limited peak ≈ 10^(-LIMITER_THRESHOLD_DB/20) → scala assoluta nota.
+        res_raw   = fixed_2d - limited    # residual SPADE in scala assoluta
+
+        # gt_res_raw: ricostruiamo dalla scala normalizzata
+        # gt_res = gt_res_raw / peak(gt_res_raw) * 10^(RESIDUAL_DBFS/20)
+        # → gt_res_raw = gt_res * peak(gt_res_raw) / 10^(RESIDUAL_DBFS/20)
+        # Poiche' peak(gt_res_raw) non e' salvato, lo stimiamo:
+        # gt_res_raw ≈ orig_with_noise - limited  (ricostruito)
+        gt_res_raw_approx = ensure_2d(orig_with_noise) - limited
+        L = min(gt_res_raw_approx.shape[0], res_raw.shape[0])
+
+        # ── Diff sulla scala comune (raw, non normalizzata) ───────────────
+        diff_raw  = gt_res_raw_approx[:L] - res_raw[:L]
+
+        # ── Cosine similarity temporale (scalare, sul canale L) ──────────
+        g_flat = gt_res_raw_approx[:L, 0] if gt_res_raw_approx.ndim == 2 else gt_res_raw_approx[:L]
+        e_flat = res_raw[:L, 0]           if res_raw.ndim == 2           else res_raw[:L]
+        cos_sim_td = float(
+            np.dot(g_flat, e_flat) /
+            (np.linalg.norm(g_flat) * np.linalg.norm(e_flat) + 1e-12)
+        )
+
+        # ── Stima floor teorico del diff dovuto al rumore rosa ────────────
+        # Il limiter attenue anche i picchi del rumore rosa → quella parte
+        # sta nel GT_res ma NON in res_iter (SPADE non la recupera).
+        # Stimiamo quanto rumore e' nel GT_res come proxy del floor.
+        noise_gain_lin = 10 ** (PINK_NOISE_LEVEL_DB / 20.0)
+        # Ampiezza del rumore rispetto al limited: noise_gain ≈ fraction
+        # del GT_res che e' irrecuperabile da SPADE.
+        noise_floor_db = 20 * np.log10(noise_gain_lin + 1e-12) + RESIDUAL_DBFS
+        # In pratica: diff non puo' essere < noise_floor per costruzione.
+
+        # ── diff dBFS relativo al GT_res (SNR-like) ───────────────────────
+        diff_rms_db = _rms_dbfs(diff_raw[:L])
+        gt_rms_db   = _rms_dbfs(gt_res_raw_approx[:L])
+        # diff_vs_gt: quanto e' grande il diff rispetto al GT (0 dB = diff = GT)
+        diff_vs_gt_db = diff_rms_db - gt_rms_db  # piu' negativo = meglio
+
+        # Normalizza per l'export WAV
+        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)
+        diff_norm = normalize_peak(diff_raw, RESIDUAL_DBFS) if np.max(np.abs(diff_raw)) > 1e-12 else diff_raw
+
+        diff_peaks.append((diff_vs_gt_db, cos_sim_td, diff_rms_db, gt_rms_db))
+
+        # ── Definizione tracce ────────────────────────────────────────────
+        tracks = [
+            ("01_orig_with_noise",
+             orig_with_noise,
+             f"drum+noise @0dBFS (input pipeline)"),
+            ("02_limited",
+             limited,
+             f"uscita limiter (input SPADE)  atteso: ~{-LIMITER_THRESHOLD_DB:+.2f}dBFS"),
+            ("03_gt_residual",
+             gt_res,
+             f"GT residual @{RESIDUAL_DBFS:.0f}dBFS  (include noise attenuation)"),
+            ("04_spade_output",
+             fixed_2d,
+             f"SPADE output (float32, puo' >0dBFS)"),
+            ("05_res_iter",
+             res_iter,
+             f"residual SPADE @{RESIDUAL_DBFS:.0f}dBFS  (solo componente sparsa)"),
+            ("06_diff_residuals",
+             diff_norm,
+             f"GT - iter @{RESIDUAL_DBFS:.0f}dBFS  "
+             f"cos_sim={cos_sim_td:.3f}  diff/GT={diff_vs_gt_db:+.1f}dB  "
+             f"noise_floor≈{noise_floor_db:+.1f}dB"),
+        ]
+
+        # ── Soglia realistica per il diff ─────────────────────────────────
+        # Il diff non puo' essere < noise_floor per costruzione del corpus.
+        # Calibriamo la soglia [OK] a noise_floor + 6 dB (margine).
+        ok_threshold  = noise_floor_db + 6.0   # tipicamente attorno a -17 dBFS
+        warn_threshold = ok_threshold + 10.0   # tutto sopra e' davvero anomalo
+
+        # ── Stampa tabella + scrivi WAV ───────────────────────────────────
+        print(SEP)
+        for track_name, audio, note in tracks:
+            pk  = _pk_dbfs(audio)
+            rms = _rms_dbfs(audio)
+
+            flag = ""
+            if track_name == "06_diff_residuals":
+                if   diff_vs_gt_db < -12: flag = "[OK]   buona convergenza"
+                elif diff_vs_gt_db <  -6: flag = "[~]    convergenza parziale"
+                else:                     flag = "[WARN] diff elevato rispetto al GT"
+
+            row = (f"  {item['file']:<{col_w}}  {track_name:<22}"
+                   f"  {pk:>+10.2f}  {rms:>+9.2f}  {note}  {flag}")
+
+            if _HAS_RICH:
+                color = ("green"  if "[OK]"   in flag else
+                         "yellow" if "[~]"    in flag else
+                         "red"    if "[WARN]" in flag else "")
+                colored_row = row.replace(flag, f"[{color or 'dim'}]{flag}[/]") if flag else row
+                _console.print(colored_row)
+            else:
+                print(row)
+
+            wav_path = out_dir / f"{stem}__{track_name}.wav"
+            _write_wav(wav_path, audio, sr)
+
+        # ── Analisi spettrale per banda: LF vs HF ─────────────────────────
+        # Risponde alla domanda: quanto residual c'e' nelle basse frequenze,
+        # e quanto ne recupera SPADE?
+        #
+        # Bands:
+        #   Sub-bass  :  20 –  80 Hz  (fondamentale kick, body)
+        #   Bass      :  80 – 250 Hz  (corpo kick, coda)
+        #   Low-mid   : 250 – 800 Hz  (presenza)
+        #   High-mid  : 800 – 4000 Hz (attacco, click)
+        #   High      : 4k  – 20k Hz  (aria, snap)
+        #
+        # Per ogni banda misura:
+        #   GT_energy   = energia del GT residual (quanto il limiter ha tolto)
+        #   iter_energy = energia recuperata da SPADE
+        #   recovery %  = iter_energy / GT_energy × 100
+
+        def band_energy(audio_2d, sr, f_lo, f_hi):
+            """RMS energy in dB di una banda passante [f_lo, f_hi] Hz."""
+            mono = audio_2d[:, 0] if audio_2d.ndim == 2 else audio_2d
+            N    = len(mono)
+            if N < 8:
+                return -999.0
+            # Butterworth bandpass (o lowpass/highpass ai bordi)
+            nyq = sr / 2.0
+            lo  = max(f_lo / nyq, 1e-4)
+            hi  = min(f_hi / nyq, 0.9999)
+            if lo >= hi:
+                return -999.0
+            if lo < 1e-3:
+                b, a = sig.butter(4, hi, btype="low")
+            else:
+                b, a = sig.butter(4, [lo, hi], btype="band")
+            filtered = sig.filtfilt(b, a, mono)
+            return _rms_dbfs(filtered)
+
+        BANDS = [
+            ("Sub-bass ",   20,   80),
+            ("Bass     ",   80,  250),
+            ("Low-mid  ",  250,  800),
+            ("High-mid ",  800, 4000),
+            ("High     ", 4000, 20000),
+        ]
+
+        gt_mono   = gt_res[:, 0]  if gt_res.ndim  == 2 else gt_res
+        ri_mono   = res_iter[:, 0] if res_iter.ndim == 2 else res_iter
+
+        # Normalizza GT e iter sulla stessa scala (rimuovi la normalizzazione
+        # a RESIDUAL_DBFS per confrontare energie assolute)
+        gt_raw_for_bands   = gt_res_raw_approx
+        iter_raw_for_bands = res_raw
+
+        print()
+        band_hdr = f"    {'banda':<12} {'GT_res RMS':>10}  {'SPADE rec RMS':>13}  {'recovery':>9}  {'limitato?'}"
+        print(f"  Analisi spettrale per banda — {item['file']}")
+        print(f"  {'─'*75}")
+        print(band_hdr)
+        print(f"  {'─'*75}")
+        for bname, f_lo, f_hi in BANDS:
+            gt_db   = band_energy(gt_raw_for_bands,   sr, f_lo, f_hi)
+            iter_db = band_energy(iter_raw_for_bands, sr, f_lo, f_hi)
+            if gt_db < -60:
+                recovery_str = "  —    (silenzio)"
+                flag_b = ""
+            else:
+                diff_b   = iter_db - gt_db       # positivo = SPADE supera GT (overrecovery)
+                # recovery: 0 dB diff = recupero perfetto, molto negativo = sotto-recupero
+                if diff_b > -3:
+                    flag_b = "OK"
+                elif diff_b > -9:
+                    flag_b = "~  parziale"
+                else:
+                    flag_b = "!! sotto-recupero"
+                recovery_str = f"{diff_b:>+7.1f} dB  {flag_b}"
+            line = f"    {bname:<12} {gt_db:>+10.1f}  {iter_db:>+13.1f}  {recovery_str}"
+            if _HAS_RICH:
+                color = "green" if "OK" in recovery_str else (
+                        "yellow" if "~" in recovery_str else (
+                        "red" if "!!" in recovery_str else "dim"))
+                _console.print(f"[{color}]{line}[/]")
+            else:
+                print(line)
+        print()
+
+    print(SEP)
+    print()
+    if diff_peaks:
+        vs_gt_vals  = [d[0] for d in diff_peaks]
+        cos_vals    = [d[1] for d in diff_peaks]
+        avg_vs_gt   = float(np.mean(vs_gt_vals))
+        best_vs_gt  = float(np.min(vs_gt_vals))
+        worst_vs_gt = float(np.max(vs_gt_vals))
+        avg_cos     = float(np.mean(cos_vals))
+
+        noise_floor_db = 20 * np.log10(10 ** (PINK_NOISE_LEVEL_DB / 20.0) + 1e-12) + RESIDUAL_DBFS
+
+        print(f"  RIEPILOGO  06_diff_residuals:")
+        print(f"    diff/GT_rms  media   : {avg_vs_gt:>+7.2f} dB  (0 dB = diff grande quanto GT)")
+        print(f"    diff/GT_rms  migliore: {best_vs_gt:>+7.2f} dB")
+        print(f"    diff/GT_rms  peggiore: {worst_vs_gt:>+7.2f} dB")
+        print(f"    cos_sim TD   media   : {avg_cos:>8.4f}  (1.0 = identici)")
+        print()
+        print(f"  NOTA IMPORTANTE:")
+        print(f"    Il rumore rosa ({PINK_NOISE_LEVEL_DB} dB) fa parte del GT_res ma")
+        print(f"    NON puo' essere recuperato da SPADE (non e' sparso).")
+        print(f"    Floor teorico del diff: ≈ {noise_floor_db:+.1f} dBFS — questo e' il")
+        print(f"    limite fisico massimo raggiungibile con questo corpus.")
+        print(f"    Un diff/GT < -6 dB indica buona convergenza di SPADE.")
+        print()
+        if worst_vs_gt < -12:
+            verdict = "OK     Convergenza eccellente — SPADE recupera bene i transienti"
+        elif worst_vs_gt < -6:
+            verdict = "~      Convergenza buona — residuo compatibile con il noise floor"
+        else:
+            verdict = "INFO   diff dominato dal rumore rosa — comportamento atteso e corretto"
+        print(f"    Verdetto: {verdict}")
+    print(f"\n  WAV scritti in : {out_dir}/")
+    print(f"  Formato        : float32, nessun clipping (usa un editor che supporta >0dBFS)")
+    print(f"  Nomenclatura   : <stem>__<N>_<traccia>.wav")
+
+
+def save_csv(study: "optuna.Study"):
+    import csv
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    with open(OUT_CSV, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["rank", "score", "delta_db", "lf_delta_db",
+                    "window_length", "hop_length", "release_ms", "max_gain_db",
+                    "eps", "max_iter", "multiband", "macro_expand", "macro_ratio"])
+        for rank, t in enumerate(trials, 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            w.writerow([
+                rank, round(t.value, 6),
+                p["delta_db"],
+                round(p.get("lf_delta_db", p["delta_db"]), 2),
+                win, hop,
+                p["release_ms"], p["max_gain_db"], p["eps"], p["max_iter"],
+                int(p.get("multiband",    False)),
+                int(p.get("macro_expand", False)),
+                round(p.get("macro_ratio", 1.0), 2),
+            ])
+    print(f"\n  📄 CSV: {OUT_CSV}")
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def parse_args():
+    ap = argparse.ArgumentParser(description="Smart Bayesian sweep per S-SPADE v2")
+    ap.add_argument("--trials",      type=int,  default=200,
+                    help="Numero di trial Optuna (default: 200)")
+    ap.add_argument("--resume",      action="store_true",
+                    help="Carica lo study esistente e aggiunge trial")
+    ap.add_argument("--report",      action="store_true",
+                    help="Solo report (nessun nuovo trial)")
+    ap.add_argument("--base-dir",    type=str,  default=".",
+                    help="Cartella radice con Kicks/Snares/Perc/Tops")
+    ap.add_argument("--corpus-size", type=int,  default=None,
+                    help="Limita il corpus a N file (None = tutti)")
+    ap.add_argument("--top",         type=int,  default=20,
+                    help="Quanti trial mostrare nel ranking (default: 20)")
+    ap.add_argument("--no-prune",    action="store_true",
+                    help="Disabilita MedianPruner (più lento ma completo)")
+    ap.add_argument("--debug-export", action="store_true",
+                    help="Esporta WAV di debug per i primi N file del corpus (no sweep)")
+    ap.add_argument("--debug-dir",   type=str,  default="debug_export",
+                    help="Cartella output WAV di debug (default: debug_export)")
+    ap.add_argument("--debug-n",     type=int,  default=10,
+                    help="Quanti file esportare in debug (default: 10)")
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    missing = []
+    if not _HAS_OPTUNA: missing.append("optuna")
+    if not _HAS_SPADE:  missing.append("spade_declip_v11.py (nella stessa dir)")
+    if missing:
+        pip  = [m for m in missing if not m.endswith(")")]
+        sys.exit("Mancante:\n  pip install " + " ".join(pip)
+                 + ("\n  " + "\n  ".join(m for m in missing if m.endswith(")")) if any(m.endswith(")") for m in missing) else ""))
+
+    base_dir = Path(args.base_dir).resolve()
+    storage  = f"sqlite:///{STUDY_NAME}.db"
+    sampler  = TPESampler(seed=42, multivariate=True, warn_independent_sampling=False)
+    pruner   = (MedianPruner(n_startup_trials=10, n_warmup_steps=3)
+                if not args.no_prune else optuna.pruners.NopPruner())
+
+    if args.report:
+        try:
+            study = optuna.load_study(study_name=STUDY_NAME, storage=storage,
+                                      sampler=sampler, pruner=pruner)
+        except Exception:
+            sys.exit(f"Nessuno study trovato in {STUDY_NAME}.db")
+        print_report(study, top_n=args.top)
+        save_csv(study)
+        return
+
+    # ── Debug export ──────────────────────────────────────────────────────────
+    if args.debug_export:
+        # Usa i parametri del best trial se esiste un DB, altrimenti DEBUG_PARAMS
+        spade_params = dict(DEBUG_PARAMS)
+        try:
+            study = optuna.load_study(study_name=STUDY_NAME, storage=storage,
+                                      sampler=sampler, pruner=pruner)
+            completed = [t for t in study.trials
+                         if t.state == optuna.trial.TrialState.COMPLETE]
+            if completed:
+                best_t = max(completed, key=lambda t: t.value or 0)
+                p      = best_t.params
+                win    = 2 ** p["win_exp"]
+                hop    = win // p["hop_div"]
+                spade_params = dict(
+                    delta_db      = p["delta_db"],
+                    window_length = win,
+                    hop_length    = hop,
+                    release_ms    = p["release_ms"],
+                    max_gain_db   = p["max_gain_db"],
+                    eps           = p["eps"],
+                    max_iter      = p["max_iter"],
+                )
+                print(f"  [DEBUG] Usando best trial #{best_t.number}"
+                      f" (score={best_t.value:.5f}) dal DB.")
+        except Exception:
+            print(f"  [DEBUG] DB non trovato — uso DEBUG_PARAMS di default.")
+
+        # Costruisci corpus (limitato a debug_n file per velocita')
+        corpus = build_corpus(base_dir, max_files=args.debug_n)
+        if not corpus:
+            sys.exit("Corpus vuoto. Controlla --base-dir.")
+        debug_export(
+            corpus       = corpus,
+            base_dir     = base_dir,
+            out_dir      = Path(args.debug_dir),
+            n_files      = args.debug_n,
+            spade_params = spade_params,
+        )
+        return
+
+    # ── Corpus ───────────────────────────────────────────────────────────────
+    print("\n" + "=" * 65)
+    print("CORPUS  +  LIMITER SINTETICO  (Case 1 — threshold-based)")
+    print("=" * 65)
+    print(f"  Base dir  : {base_dir}")
+    print(f"  Threshold : −{LIMITER_THRESHOLD_DB} dBFS")
+    print(f"  Release   : {LIMITER_RELEASE_MS} ms")
+    print(f"  Level align: NESSUNO — loudness invariata per costruzione")
+    print(f"  Rumore rosa: {PINK_NOISE_LEVEL_DB} dB rel. peak  "
+          f"(simula sottofondo musicale sotto il transiente)")
+
+    corpus = build_corpus(base_dir, max_files=args.corpus_size)
+    if not corpus:
+        sys.exit("Corpus vuoto. Controlla --base-dir e le cartelle.")
+
+    print(f"\n  ✓ {len(corpus)} file nel corpus\n")
+    col_w = max(len(item["file"]) for item in corpus) + 2
+    for item in corpus:
+        rms  = float(np.sqrt(np.mean(item["gt_res"] ** 2)))
+        peak = float(np.max(np.abs(item["gt_res"])))
+        print(f"    {item['file']:<{col_w}}  sr={item['sr']}  "
+              f"GT rms={rms:.4f}  peak={peak:.4f}")
+
+    # ── Study ─────────────────────────────────────────────────────────────────
+    print(f"\n{'='*65}")
+    print(f"OTTIMIZZAZIONE BAYESIANA  —  {args.trials} trial")
+    print(f"TPE (multivariate) + MedianPruner  |  storage: {STUDY_NAME}.db")
+    print(f"{'='*65}\n")
+
+    study = optuna.create_study(
+        study_name     = STUDY_NAME,
+        storage        = storage,
+        sampler        = sampler,
+        pruner         = pruner,
+        direction      = "maximize",
+        load_if_exists = True,
+    )
+
+    # ── Progress bar (rich → tqdm → plain fallback) ───────────────────────────
+    try:
+        from rich.progress import (
+            Progress, BarColumn, TextColumn,
+            TimeElapsedColumn, TimeRemainingColumn, MofNCompleteColumn,
+        )
+        _has_rich_progress = True
+    except ImportError:
+        _has_rich_progress = False
+
+    try:
+        import tqdm as _tqdm_mod
+        _has_tqdm = True
+    except ImportError:
+        _has_tqdm = False
+
+    # Stato condiviso aggiornato dal callback.
+    # Pre-popolato con i trial gia' nel DB in caso di --resume,
+    # cosi' la progress bar mostra il conteggio corretto dall'inizio.
+    _existing_complete = [t for t in study.trials
+                          if t.state == optuna.trial.TrialState.COMPLETE]
+    _existing_pruned   = [t for t in study.trials
+                          if t.state == optuna.trial.TrialState.PRUNED]
+
+    if _existing_complete:
+        _best_existing = max(_existing_complete, key=lambda t: t.value or 0)
+        _init_best     = _best_existing.value or 0.0
+        _init_best_p   = dict(_best_existing.params)
+        _init_last     = _init_best
+    else:
+        _init_best, _init_best_p, _init_last = float("-inf"), {}, float("-inf")
+
+    _state = {
+        "done":    len(_existing_complete),
+        "pruned":  len(_existing_pruned),
+        "best":    _init_best,
+        "best_p":  _init_best_p,
+        "last":    _init_last,
+        "t0":      time.time(),
+        "n_total": len(_existing_complete) + len(_existing_pruned) + args.trials,
+    }
+
+    def _fmt_best(state: dict) -> str:
+        """Stringa compatta con i parametri del best trial corrente."""
+        bp = state["best_p"]
+        if not bp:
+            return "—"
+        win = 2 ** bp.get("win_exp", 10)
+        hop = win // bp.get("hop_div", 4)
+        return (f"δ={bp.get('delta_db',0):.2f} "
+                f"win={win} hop={hop} "
+                f"rel={bp.get('release_ms',0):.0f}ms "
+                f"gain={bp.get('max_gain_db',0):.1f}dB")
+
+    # ── Rich progress bar ─────────────────────────────────────────────────────
+    if _has_rich_progress:
+        progress = Progress(
+            TextColumn("[bold cyan]Trial[/] [cyan]{task.completed}/{task.total}[/]"),
+            BarColumn(bar_width=32),
+            MofNCompleteColumn(),
+            TextColumn("  score [green]{task.fields[last]:.5f}[/]"),
+            TextColumn("  best [bold green]{task.fields[best]:.5f}[/]"),
+            TextColumn("  [dim]pruned {task.fields[pruned]}[/]"),
+            TimeElapsedColumn(),
+            TextColumn("ETA"),
+            TimeRemainingColumn(),
+            refresh_per_second=4,
+            transient=False,
+        )
+        task_id = None   # creato dentro il context
+
+        def on_trial_end(study, trial):
+            fin = (trial.state == optuna.trial.TrialState.COMPLETE)
+            prn = (trial.state == optuna.trial.TrialState.PRUNED)
+            if fin:
+                _state["done"]   += 1
+                _state["last"]    = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+            elif prn:
+                _state["pruned"] += 1
+            progress.update(
+                task_id,
+                advance    = 1,
+                last       = _state["last"],
+                best       = max(_state["best"], 0.0),
+                pruned     = _state["pruned"],
+            )
+
+        t0 = time.time()
+        try:
+            with progress:
+                task_id = progress.add_task(
+                    "sweep",
+                    total     = _state["n_total"],
+                    completed = _state["done"] + _state["pruned"],
+                    last      = max(_state["last"], 0.0),
+                    best      = max(_state["best"],  0.0),
+                    pruned    = _state["pruned"],
+                )
+                study.optimize(
+                    make_objective(corpus),
+                    n_trials          = args.trials,
+                    callbacks         = [on_trial_end],
+                    show_progress_bar = False,
+                )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+
+    # ── tqdm fallback ─────────────────────────────────────────────────────────
+    elif _has_tqdm:
+        import tqdm
+        _already = _state["done"] + _state["pruned"]
+        pbar = tqdm.tqdm(
+            total   = _state["n_total"],
+            initial = _already,
+            unit    = "trial",
+            bar_format = "{l_bar}{bar}| {n}/{total} [{elapsed}<{remaining}]",
+        )
+        if _already > 0:
+            pbar.set_postfix(
+                score  = f"{max(_state['last'],  0.0):.5f}",
+                best   = f"{max(_state['best'],  0.0):.5f}",
+                pruned = _state["pruned"],
+            )
+
+        def on_trial_end(study, trial):
+            fin = trial.state == optuna.trial.TrialState.COMPLETE
+            prn = trial.state == optuna.trial.TrialState.PRUNED
+            if fin:
+                _state["done"]  += 1
+                _state["last"]   = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+            elif prn:
+                _state["pruned"] += 1
+            pbar.update(1)
+            pbar.set_postfix(
+                score  = f"{_state['last']:.5f}",
+                best   = f"{_state['best']:.5f}",
+                pruned = _state["pruned"],
+            )
+
+        t0 = time.time()
+        try:
+            study.optimize(
+                make_objective(corpus),
+                n_trials          = args.trials,
+                callbacks         = [on_trial_end],
+                show_progress_bar = False,
+            )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+        finally:
+            pbar.close()
+
+    # ── Plain fallback ────────────────────────────────────────────────────────
+    else:
+        def on_trial_end(study, trial):
+            fin = trial.state == optuna.trial.TrialState.COMPLETE
+            prn = trial.state == optuna.trial.TrialState.PRUNED
+            if fin:
+                _state["done"]  += 1
+                _state["last"]   = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+                elapsed  = time.time() - _state["t0"]
+                done_tot = _state["done"] + _state["pruned"]
+                eta_s    = (elapsed / done_tot) * (_state["n_total"] - done_tot) if done_tot else 0
+                is_best  = abs(_state["last"] - _state["best"]) < 1e-9
+                bar_n    = int(32 * done_tot / max(_state["n_total"], 1))
+                bar      = "█" * bar_n + "░" * (32 - bar_n)
+                print(f"\r[{bar}] {done_tot}/{_state['n_total']}"
+                      f"  {'★' if is_best else ' '}score={_state['last']:.5f}"
+                      f"  best={_state['best']:.5f}"
+                      f"  pruned={_state['pruned']}"
+                      f"  ETA {eta_s/60:.1f}min   ", end="", flush=True)
+            elif prn:
+                _state["pruned"] += 1
+
+        t0 = time.time()
+        try:
+            study.optimize(
+                make_objective(corpus),
+                n_trials          = args.trials,
+                callbacks         = [on_trial_end],
+                show_progress_bar = False,
+            )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+        print()   # newline dopo la riga \r
+
+    elapsed = time.time() - t0
+    n_done  = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE)
+    n_prune = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED)
+    print(f"\n  Completati: {n_done}  |  Pruned: {n_prune}"
+          f"  |  Tempo totale: {elapsed/60:.1f} min"
+          f"  |  Media: {elapsed/max(n_done+n_prune,1):.1f} s/trial")
+
+    print_report(study, top_n=args.top)
+    save_csv(study)
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()

run_smart_sweep_old3.py

@@ -0,0 +1,2086 @@
+"""
+run_smart_sweep.py  —  S-SPADE  ·  Bayesian parameter search  (v2)
+===================================================================
+
+PIPELINE GROUND-TRUTH (Case 1 — threshold-based limiter)
+---------------------------------------------------------
+Il limiter sintetico è threshold-based:
+    - Originale normalizzato a 0 dBFS peak
+    - Limiter: attua solo sui picchi sopra la soglia → output max peak ≈ −threshold_db
+    - Il CORPO del segnale (loudness percepita) rimane invariato per definizione
+    - NON si applica nessun gain al segnale limitato dopo il processing
+
+Allineamento per il calcolo residual:
+    Originale e limited sono già sulla stessa scala (loudness uguale, picchi diversi).
+    Nessuna normalizzazione LUFS / RMS necessaria o corretta.
+
+    GT_res   = original_0dBFS  −  limited         (scale identiche)
+    res_iter = spade_output    −  limited          (idem)
+
+    Entrambi vengono poi normalizzati a RESIDUAL_DBFS peak SOLO per rendere
+    comparabili file con diversi livelli assoluti — non altera la logica.
+
+Metrica ideale:
+    GT_res ≡ res_iter  →  cosine_sim = 1.0  →  differenza = −∞ dB
+
+Ottimizzatore: Optuna TPE (Bayesian) + MedianPruner
+Storage:       SQLite (riprendibile con --resume)
+Corpus:        tutti i drum sample in Kicks / Snares / Perc / Tops
+
+DIPENDENZE
+----------
+    pip install numpy scipy soundfile optuna rich
+    (pyloudnorm NON necessario)
+
+USO
+---
+    python run_smart_sweep.py                          # 200 trial
+    python run_smart_sweep.py --trials 50              # test rapido
+    python run_smart_sweep.py --resume                 # riprende da DB
+    python run_smart_sweep.py --report                 # solo risultati
+    python run_smart_sweep.py --base-dir /path/SPADE   # cartella custom
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+import warnings
+from pathlib import Path
+from typing import Dict, List, Optional
+
+# ── AMD ROCm performance tuning ───────────────────────────────────────────────
+# Must be set BEFORE any torch/ROCm import.
+#
+# HSA_ENABLE_SDMA=0: disabilita il DMA engine per i trasferimenti host↔device.
+#   Su RDNA (RX 6700 XT e simili) l'SDMA engine ha latenza elevata per batch
+#   piccoli (<1 MB). Usando compute-shader blits invece, il primo trasferimento
+#   è 3-5× più veloce. Nessun effetto su batch grandi.
+#
+# GPU_MAX_HW_QUEUES=4: limita le hardware queue a 4 (default=8 su RDNA).
+#   Con 8 queue e un singolo dispatch stream, il driver distribuisce le wave
+#   su queue diverse causando serializzazione. Con 4 si concentrano sullo stesso
+#   ring buffer e si riduce la latenza di scheduling.
+#
+# HSA_OVERRIDE_GFX_VERSION: solo se necessario (RX 6700 XT = gfx1031 → OK as-is).
+os.environ.setdefault("HSA_ENABLE_SDMA",    "0")
+os.environ.setdefault("GPU_MAX_HW_QUEUES",  "4")
+
+import numpy as np
+import scipy.signal as sig
+import soundfile as sf
+
+logging.getLogger("optuna").setLevel(logging.WARNING)
+
+# ── optuna ───────────────────────────────────────────────────────────────────
+try:
+    import optuna
+    from optuna.samplers import TPESampler
+    from optuna.pruners  import MedianPruner
+    _HAS_OPTUNA = True
+except ImportError:
+    _HAS_OPTUNA = False
+    warnings.warn("optuna non trovato — pip install optuna")
+
+# ── rich ─────────────────────────────────────────────────────────────────────
+try:
+    from rich.console import Console
+    from rich.table   import Table
+    _console  = Console()
+    _HAS_RICH = True
+except ImportError:
+    _HAS_RICH = False
+    _console  = None
+
+# ── spade_declip ─────────────────────────────────────────────────────────────
+try:
+    from spade_declip_v12 import (
+        declip, DeclipParams,
+        # Internals needed for the GPU mega-batch path in evaluate_corpus_gpu_mega:
+        _compute_masks, _dilate_masks_soft, _macro_expand_pass,
+        _build_lf_mask, _sspade_batch_gpu,
+        ClippingMasks,
+    )
+    _HAS_SPADE = True
+except ImportError:
+    _HAS_SPADE = False
+    warnings.warn("spade_declip_v12.py non trovato")
+
+# =============================================================================
+# CONFIG
+# =============================================================================
+
+DRUM_DIRS = ["Kicks", "Snares", "Perc", "Tops"]
+
+# ── Limiter sintetico ─────────────────────────────────────────────────────────
+# Case 1: threshold-based.
+# Originale @ 0 dBFS peak → limiter attua sui picchi > soglia →
+# output max peak ≈ −LIMITER_THRESHOLD_DB dBFS, loudness invariata.
+# NON si tocca il segnale limitato con nessun gain dopo.
+LIMITER_THRESHOLD_DB = 3.0   # dB sotto il ceiling (positivo)
+LIMITER_RELEASE_MS   = 80.0  # release del limiter sintetico (ms)
+# attack = 1 campione → brickwall vero
+
+# Normalizzazione residual — SOLO per comparabilità cross-file.
+# Scala entrambi GT e iter identicamente, quindi non altera il confronto.
+RESIDUAL_DBFS = -3.0
+
+# ── Rumore rosa di sottofondo ─────────────────────────────────────────────────
+# Simula un sottofondo musicale sotto il transiente di batteria.
+# Viene mixato al sample (già a 0 dBFS peak) PRIMA del limiter.
+# Questo assicura che:
+#   - il limiter agisca sul segnale realistico  drum + music background
+#   - SPADE riceva lo stesso mix e debba lavorare in condizioni realistiche
+#   - GT_res = (drum+noise) − limiter(drum+noise)  rifletta la situazione reale
+# Livello relativo al peak del drum sample. −20 dB = sottofondo ben sotto
+# il transiente, udibile ma non dominante (come un kick su un loop di batteria).
+PINK_NOISE_LEVEL_DB = -20.0   # dB rel. al peak del drum (negativo = sotto)
+
+# Optuna
+STUDY_NAME = "spade_smart_v2_thr3db"
+OUT_CSV    = "smart_sweep_results.csv"
+
+# Parametri FISSI del solver SPADE (invarianti tra tutti i trial)
+FIXED_SOLVER = dict(
+    algo          = "sspade",
+    frame         = "rdft",
+    mode          = "soft",
+    s             = 1,
+    r             = 1,
+    n_jobs        = 1,
+    verbose       = False,
+    show_progress = False,
+    use_gpu       = True,
+    # multiband e macro_expand sono nello spazio di ricerca
+)
+
+# Crossover multiband (fisso per comparabilita' tra trial)
+# 250 Hz separa: LF=corpo/punch del kick  |  HF=transiente/attacco
+BAND_CROSSOVER_HZ = 250.0
+
+# =============================================================================
+# HELPERS
+# =============================================================================
+
+def ensure_2d(a: np.ndarray) -> np.ndarray:
+    return a[:, None] if a.ndim == 1 else a
+
+
+def normalize_to_0dBFS(a: np.ndarray) -> np.ndarray:
+    """Scala a 0 dBFS peak — usato solo sull'originale come riferimento comune."""
+    pk = np.max(np.abs(a))
+    return a / pk if pk > 1e-12 else a
+
+
+def normalize_peak(a: np.ndarray, target_dbfs: float) -> np.ndarray:
+    """
+    Scala a target_dbfs dBFS peak.
+    Usato SOLO sui residual per comparabilità cross-file;
+    non altera la logica perché GT e iter vengono scalati identicamente.
+    """
+    pk = np.max(np.abs(a))
+    return a * (10 ** (target_dbfs / 20.0) / pk) if pk > 1e-12 else a
+
+
+def generate_pink_noise(n_samples: int, n_channels: int, rng: np.random.Generator) -> np.ndarray:
+    """
+    Genera rumore rosa (1/f) tramite filtro IIR di Voss-McCartney (approssimazione
+    a 5 poli, accurata entro ±1 dB nel range 20 Hz – 20 kHz).
+
+    Output: shape (n_samples, n_channels), RMS normalizzato a 1.0 (prima
+    del mix-in con PINK_NOISE_LEVEL_DB, che controlla il livello finale).
+
+    Algoritmo: rumore bianco filtrato con H(z) = 1 / A(z) dove i coefficienti
+    sono ottimizzati per approssimare una densità spettrale 1/f.
+    """
+    # Coefficienti del filtro IIR a 5 poli (Voss approssimazione)
+    # Poli reali, tutti stabili (|p| < 1)
+    b = np.array([0.049922035, -0.095993537,  0.050612699, -0.004408786])
+    a = np.array([1.0,         -2.494956002,  2.017265875, -0.522189400])
+
+    out = np.empty((n_samples, n_channels))
+    for c in range(n_channels):
+        white = rng.standard_normal(n_samples)
+        pink  = sig.lfilter(b, a, white)
+        rms   = np.sqrt(np.mean(pink ** 2))
+        out[:, c] = pink / (rms + 1e-12)   # RMS = 1.0
+
+    return out
+
+
+def mix_pink_noise(
+    audio_0dBFS: np.ndarray,
+    sr: int,
+    level_db: float,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """
+    Mixa rumore rosa nel segnale a un livello relativo al suo peak.
+
+    level_db < 0  →  il rumore è sotto il peak del drum (es. −20 dB)
+    Il rumore dura quanto il sample; se il sample è stereo, il rumore è stereo
+    (canali indipendenti → decorrelato come un vero fondo musicale).
+
+    Il segnale in uscita può superare 0 dBFS di qualche frazione di dB: è
+    corretto, il limiter che segue si occupa di riportarlo sotto la soglia.
+    """
+    audio = ensure_2d(audio_0dBFS)
+    N, C  = audio.shape
+
+    noise  = generate_pink_noise(N, C, rng)          # RMS = 1.0 per canale
+    # Scala il rumore al livello desiderato rispetto al peak del drum
+    peak   = np.max(np.abs(audio))
+    gain   = peak * (10 ** (level_db / 20.0))        # gain lineare assoluto
+    mixed  = audio + noise * gain
+    # NON normalizziamo qui: la normalizzazione a 0 dBFS avviene in build_corpus
+    # subito dopo, su tutto il mix (drum + noise), prima di qualsiasi altra op.
+    return mixed[:, 0] if audio_0dBFS.ndim == 1 else mixed
+
+
+# =============================================================================
+# LIMITER SINTETICO  (Case 1 — threshold-based, brickwall, 1-campione attack)
+# =============================================================================
+
+def apply_brickwall_limiter(
+    audio_0dBFS: np.ndarray,
+    sr: int,
+    threshold_db: float = LIMITER_THRESHOLD_DB,
+    release_ms:   float = LIMITER_RELEASE_MS,
+) -> np.ndarray:
+    """
+    Brickwall limiter threshold-based.
+
+    Tenta la GPU (Hillis-Steele parallel prefix scan, O(log N) depth) se
+    PyTorch + CUDA/ROCm sono disponibili, altrimenti Numba JIT, altrimenti
+    loop numpy ottimizzato.
+
+    Input:  audio_0dBFS — già a 0 dBFS peak, shape (N,) o (N, C)
+    Output: segnale limitato, stessa shape — NON boosted, NON clippato
+    """
+    thr_lin = 10 ** (-abs(threshold_db) / 20.0)
+    rc      = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9))
+
+    audio = ensure_2d(audio_0dBFS).copy().astype(np.float32)
+    N, C  = audio.shape
+
+    # ── GPU path (preferred) ──────────────────────────────────────────────
+    try:
+        import torch
+        if torch.cuda.is_available():
+            dev = "cuda"
+            out = np.empty_like(audio)
+            for c in range(C):
+                x_t = torch.from_numpy(audio[:, c]).to(device=dev)
+                y_t = _brickwall_limiter_gpu(x_t, thr_lin, rc)
+                out[:, c] = y_t.cpu().numpy()
+            return out[:, 0] if audio_0dBFS.ndim == 1 else out
+    except Exception:
+        pass   # fall through to CPU paths
+
+    # ── Numba JIT path ────────────────────────────────────────────────────
+    try:
+        from numba import njit
+
+        @njit(cache=True)
+        def _limiter_loop_nb(ch: np.ndarray, thr: float, rc: float,
+                              g_out: np.ndarray) -> None:
+            env = 1.0
+            for n in range(len(ch)):
+                pk     = abs(ch[n])
+                target = thr / pk if pk > thr else 1.0
+                env    = target if target < env else rc * env + (1.0 - rc) * target
+                g_out[n] = env
+
+        out = np.empty(audio.shape, dtype=np.float32)
+        for c in range(C):
+            g = np.empty(N, dtype=np.float32)
+            _limiter_loop_nb(audio[:, c].astype(np.float64), thr_lin, rc, g)
+            out[:, c] = audio[:, c] * g
+        return out[:, 0] if audio_0dBFS.ndim == 1 else out
+
+    except ImportError:
+        pass
+
+    # ── Pure-numpy fallback ───────────────────────────────────────────────
+    out = np.empty_like(audio)
+    for c in range(C):
+        ch = audio[:, c].astype(np.float64)
+        pk = np.abs(ch)
+        g_instant = np.where(pk > thr_lin, thr_lin / np.maximum(pk, 1e-12), 1.0)
+        g   = np.empty(N)
+        env = 1.0
+        gi  = g_instant
+        for n in range(N):
+            t   = gi[n]
+            env = t if t < env else rc * env + (1.0 - rc) * t
+            g[n] = env
+        out[:, c] = ch * g
+    return out[:, 0] if audio_0dBFS.ndim == 1 else out
+
+
+# =============================================================================
+# COSINE SIMILARITY TF
+# =============================================================================
+
+def cosine_sim_tf(
+    gt:          np.ndarray,
+    est:         np.ndarray,
+    sr:          int,
+    win_samples: int = 1024,
+    hop_samples: int = 256,
+    n_bands:     int = 12,
+) -> float:
+    """
+    Similarità coseno media su micro-finestre tempo-frequenziali.
+    Input: entrambi già a RESIDUAL_DBFS peak.
+    Output: scalare in [0, 1]. Target ideale = 1.0.
+    """
+    L = min(gt.shape[0], est.shape[0])
+    g = (gt[:L, 0]  if gt.ndim  == 2 else gt[:L]).copy()
+    e = (est[:L, 0] if est.ndim == 2 else est[:L]).copy()
+
+    win = min(win_samples, max(32, L // 4))
+    hop = min(hop_samples, win // 2)
+
+    if L < win or win < 32:
+        denom = np.linalg.norm(g) * np.linalg.norm(e) + 1e-12
+        return float(np.dot(g, e) / denom)
+
+    _, _, Zg = sig.stft(g, fs=sr, window="hann",
+                        nperseg=win, noverlap=win - hop,
+                        boundary=None, padded=False)
+    _, _, Ze = sig.stft(e, fs=sr, window="hann",
+                        nperseg=win, noverlap=win - hop,
+                        boundary=None, padded=False)
+
+    n_freqs, n_frames = Zg.shape
+    if n_frames == 0:
+        return float(np.dot(g, e) / (np.linalg.norm(g) * np.linalg.norm(e) + 1e-12))
+
+    edges = np.unique(np.round(
+        np.logspace(0, np.log10(max(n_freqs, 2)), min(n_bands, n_freqs) + 1)
+    ).astype(int))
+    edges = np.clip(edges, 0, n_freqs)
+
+    sims = []
+    for i in range(len(edges) - 1):
+        f0, f1 = int(edges[i]), int(edges[i + 1])
+        if f1 <= f0:
+            continue
+        Mg = np.abs(Zg[f0:f1, :])
+        Me = np.abs(Ze[f0:f1, :])
+        dot    = np.sum(Mg * Me, axis=0)
+        norm_g = np.sqrt(np.sum(Mg ** 2, axis=0)) + 1e-12
+        norm_e = np.sqrt(np.sum(Me ** 2, axis=0)) + 1e-12
+        sims.extend((dot / (norm_g * norm_e)).tolist())
+
+    return float(np.mean(sims)) if sims else 0.0
+
+
+# =============================================================================
+# CORPUS
+# =============================================================================
+
+def build_corpus(base_dir: Path, max_files: Optional[int] = None) -> List[Dict]:
+    """
+    Per ogni drum sample:
+      1. Carica e normalizza a 0 dBFS peak  (riferimento comune cross-file)
+      2. Mixa rumore rosa a PINK_NOISE_LEVEL_DB rel. al peak  ← NUOVO
+         Il mix avviene in float (può temporaneamente superare 0 dBFS)
+      3. Normalizza il mix (drum + noise) a 0 dBFS peak
+         Riferimento comune prima di tutta la pipeline successiva
+      4. Applica limiter sintetico su (drum + noise) normalizzato  →  limited
+      4. GT_res_raw = (drum + noise) − limited         (stessa scala, nessun gain)
+      5. Scarta file dove il limiter non interviene
+      6. Normalizza GT_res a RESIDUAL_DBFS  (solo comparabilità cross-file)
+
+    Il rumore è riproducibile: ogni file usa un seed deterministico derivato
+    dal suo indice nel corpus, così i trial sono comparabili tra loro.
+    """
+    corpus = []
+    extensions = {".wav", ".flac", ".aif", ".aiff"}
+    file_index = 0   # usato per seed deterministico del rumore
+
+    for folder in DRUM_DIRS:
+        d = base_dir / folder
+        if not d.exists():
+            print(f"  [WARN] Cartella non trovata: {d}")
+            continue
+        for f in sorted(d.glob("*")):
+            if f.suffix.lower() not in extensions:
+                continue
+            try:
+                audio, sr = sf.read(str(f), always_2d=True)
+                audio = audio.astype(float)
+            except Exception as exc:
+                print(f"  [WARN] {f.name}: {exc}")
+                continue
+
+            if audio.shape[0] < 64:
+                continue
+
+            # 1. 0 dBFS peak
+            orig = normalize_to_0dBFS(audio)
+
+            # 2. Mix rumore rosa — seed deterministico per riproducibilità
+            rng  = np.random.default_rng(seed=file_index)
+            orig_with_noise = ensure_2d(mix_pink_noise(orig, sr,
+                                                        PINK_NOISE_LEVEL_DB, rng))
+            file_index += 1
+
+            # 3. Normalizza il mix a 0 dBFS peak — riferimento comune prima
+            #    di tutta la pipeline. Il mix in float può aver superato 0 dBFS;
+            #    questa normalizzazione azzera il problema prima del limiter.
+            orig_with_noise = ensure_2d(normalize_to_0dBFS(orig_with_noise))
+
+            # 4. Limiter sintetico su (drum + noise) @0dBFS — nessun gain dopo
+            limited = ensure_2d(apply_brickwall_limiter(orig_with_noise, sr))
+
+            # 5. Residual grezzo — stessa scala, zero aggiustamenti
+            gt_res_raw = orig_with_noise - limited
+
+            # 6. Verifica attività del limiter
+            if np.max(np.abs(gt_res_raw)) < 1e-6:
+                print(f"  [SKIP] {f.name} — picco sotto la soglia, limiter inattivo")
+                continue
+
+            # 7. Normalizza a RESIDUAL_DBFS solo per comparabilità cross-file
+            gt_res = normalize_peak(gt_res_raw, RESIDUAL_DBFS)
+
+            corpus.append({
+                "file"    : f.name,
+                "sr"      : sr,
+                "limited" : limited,    # input a SPADE = drum + noise + limiter
+                "gt_res"  : gt_res,     # target residual
+            })
+
+            if max_files and len(corpus) >= max_files:
+                return corpus
+
+    return corpus
+
+
+# =============================================================================
+# VALUTAZIONE SINGOLO FILE
+# =============================================================================
+
+def evaluate_one(item: Dict, params: dict) -> Optional[float]:
+    """
+    Esegue SPADE su limited, calcola il residual e lo confronta con GT.
+
+    params contiene parametri SPADE puri + flag di alto livello:
+        multiband    (bool)  -- split LF/HF, elabora separatamente
+        macro_expand (bool)  -- envelope pre-pass per recupero corpo LF
+        macro_ratio  (float) -- rapporto espansione (1.0 = bypass)
+        lf_delta_db  (float) -- delta_db per banda LF (<= BAND_CROSSOVER_HZ)
+                                 il delta_db standard e' usato per la banda HF
+        lf_cutoff_hz (float) -- v12: Hz sotto cui riservare bin LF (0 = off)
+        lf_k_min     (int)   -- v12: slot LF garantiti per iterazione ADMM
+    """
+    try:
+        sr      = item["sr"]
+        limited = item["limited"].copy()
+        gt_res  = item["gt_res"]
+
+        # Estrai flag di alto livello (non sono parametri DeclipParams diretti)
+        p2      = dict(params)   # copia per non mutare l'originale
+        multiband    = p2.pop("multiband",    False)
+        macro_expand = p2.pop("macro_expand", False)
+        macro_ratio  = p2.pop("macro_ratio",  1.0)
+        lf_delta_db  = p2.pop("lf_delta_db",  p2.get("delta_db", 1.5))
+        # v12: stratified thresholding params — passati direttamente a DeclipParams
+        # (già nel dict p2, non richiedono pop separato)
+
+        spade_kw = dict(
+            multiband        = multiband,
+            macro_expand     = macro_expand,
+            macro_ratio      = macro_ratio if macro_expand else 1.0,
+            macro_release_ms = 200.0,
+            macro_attack_ms  = 10.0,
+        )
+        if multiband:
+            spade_kw["band_crossovers"] = (BAND_CROSSOVER_HZ,)
+            spade_kw["band_delta_db"]   = (lf_delta_db, p2["delta_db"])
+
+        p = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **p2, **spade_kw)
+        fixed, _ = declip(limited, p)
+        fixed_2d  = ensure_2d(fixed)
+
+        # Residual generato — stessa scala dell'input, nessun gain
+        res_raw  = fixed_2d - limited
+        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)
+
+        # GPU cosine sim when available, CPU fallback otherwise
+        try:
+            import torch
+            g = gt_res[:, 0] if gt_res.ndim == 2 else gt_res
+            e = (res_iter[:, 0] if res_iter.ndim == 2 else res_iter).astype(np.float32)
+            dev = "cuda" if torch.cuda.is_available() else "cpu"
+            g_t = torch.from_numpy(g.astype(np.float32)).to(dev)
+            e_t = torch.from_numpy(e).to(dev)
+            Lmin = min(g_t.shape[0], e_t.shape[0])
+            return _cosine_sim_gpu(g_t[:Lmin], e_t[:Lmin])
+        except Exception:
+            return cosine_sim_tf(gt_res, res_iter, sr)
+
+    except Exception as exc:
+        warnings.warn(f"evaluate_one ({item['file']}): {exc}")
+        return None
+
+
+# =============================================================================
+# GPU MEGA-BATCH  (v12 — AMD RX 6700 XT optimisation)
+# =============================================================================
+
+
+# =============================================================================
+# GPU PIPELINE — tutti i pass su GPU  (v13)
+# =============================================================================
+#
+# Architettura
+# ------------
+# _brickwall_limiter_gpu   : limiter con Hillis-Steele parallel prefix scan
+# _compute_masks_gpu       : boolean tensor ops
+# _dilate_masks_gpu        : F.max_pool1d invece di np.convolve
+# _extract_frames_gpu      : tensor.unfold → frame batch senza loop Python
+# _wola_gpu                : scatter_add_ → overlap-add senza loop Python
+# _rms_match_gpu           : F.max_pool1d per near-clip + ops tensore
+# _cosine_sim_gpu          : torch.stft → cosine sim senza scipy
+# evaluate_corpus_gpu_mega : pipeline completa — zero numpy nel hot-path
+# =============================================================================
+
+def _brickwall_limiter_gpu(
+    audio_t:   "torch.Tensor",   # (L,) o (C, L) float32
+    thr_lin:   float,
+    rc:        float,
+) -> "torch.Tensor":
+    """
+    Brickwall limiter su GPU tramite Hillis-Steele parallel prefix scan.
+
+    Recurrence (causal):
+        env[n] = min(target[n], rc * env[n-1] + (1-rc) * target[n])
+
+    Rappresentazione funzione clamp-lineare  f(y) = min(t, r*y + c):
+        - r_n = rc,  c_n = (1-rc)*target[n],  t_n = target[n]
+
+    Operatore di composizione  h_a ⋆ h_b  (applica h_a prima, poi h_b):
+        r_ab = r_a * r_b
+        c_ab = r_b * c_a + c_b
+        t_ab = min(t_b, r_b * t_a + c_b)
+
+    Hillis-Steele inclusive prefix scan con ⋆ → O(log N) depth.
+    Risultato: scan[n] = f_0 ⋆ f_1 ⋆ ... ⋆ f_n
+    env[n] = scan[n](env_init=1.0) = min(t_prefix[n], r_prefix[n] + c_prefix[n])
+    """
+    import torch, math as _m
+    squeeze = audio_t.dim() == 1
+    if squeeze:
+        audio_t = audio_t.unsqueeze(0)          # (1, L)
+    C, L = audio_t.shape
+    dev  = audio_t.device
+    dt   = audio_t.dtype
+
+    # ── Step 1: instantaneous gain target (fully parallel) ────────────────
+    pk     = audio_t.abs().clamp(min=1e-12)
+    target = (thr_lin / pk).clamp(max=1.0)      # (C, L)
+
+    # ── Step 2: Hillis-Steele prefix scan ─────────────────────────────────
+    inv_rc = 1.0 - rc
+    # Each position n represents f_n: (r=rc, c=(1-rc)*target[n], t=target[n])
+    r = torch.full((C, L), rc,  device=dev, dtype=dt)
+    c = target * inv_rc                          # (C, L)
+    t = target.clone()                           # (C, L)
+
+    d = 1
+    while d < L:
+        # Clone previous step (Hillis-Steele requires read-before-write)
+        r_p = r.clone()
+        c_p = c.clone()
+        t_p = t.clone()
+        # For positions i >= d: scan[i] = scan_prev[i-d] ⋆ scan_prev[i]
+        r_l = r_p[:, :-d];  c_l = c_p[:, :-d];  t_l = t_p[:, :-d]
+        r_r = r_p[:, d:];   c_r = c_p[:, d:];   t_r = t_p[:, d:]
+        r[:, d:] = r_l * r_r
+        c[:, d:] = r_r * c_l + c_r
+        t[:, d:] = torch.minimum(t_r, r_r * t_l + c_r)
+        d *= 2
+
+    # ── Step 3: evaluate at env_init = 1.0 ───────────────────────────────
+    env = torch.minimum(t, r + c)               # (C, L)
+
+    out = audio_t * env
+    return out.squeeze(0) if squeeze else out
+
+
+def _compute_masks_gpu(
+    yc_t:   "torch.Tensor",   # (L,) float
+    thresh: float,
+) -> "tuple[torch.Tensor, torch.Tensor, torch.Tensor]":
+    """GPU version of _compute_masks. Returns (Ir, Icp, Icm) bool tensors."""
+    Icp = yc_t >= thresh
+    Icm = yc_t <= -thresh
+    Ir  = ~(Icp | Icm)
+    return Ir, Icp, Icm
+
+
+def _dilate_masks_gpu(
+    Icp_t:      "torch.Tensor",   # (L,) bool
+    Icm_t:      "torch.Tensor",   # (L,) bool
+    yc_t:       "torch.Tensor",   # (L,) float
+    rel_samp:   int,
+) -> "tuple[torch.Tensor, torch.Tensor, torch.Tensor]":
+    """
+    GPU forward morphological dilation of soft-mode masks.
+
+    Replaces np.convolve(..., ones(rel_samp+1))[:N] > 0  with
+    F.max_pool1d(causal_pad, kernel=rel_samp+1, stride=1).
+
+    Causal dilation: each True in Icp/Icm infects the next rel_samp positions.
+    Equivalent to convolving with a boxcar of length rel_samp+1 (causal).
+    max_pool1d with left-padding of rel_samp achieves this.
+    """
+    import torch.nn.functional as F
+    if rel_samp <= 0:
+        return ~(Icp_t | Icm_t), Icp_t, Icm_t
+
+    L = yc_t.shape[0]
+    k = rel_samp + 1   # kernel size matching np.ones(rel_samp + 1)
+
+    def _dilate(mask_t):
+        # (1, 1, L) → pad left by rel_samp → max_pool(kernel=k, stride=1) → (1,1,L)
+        x = mask_t.float().unsqueeze(0).unsqueeze(0)   # (1, 1, L)
+        x = F.pad(x, (rel_samp, 0), value=0.0)         # left-pad for causality
+        x = F.max_pool1d(x, kernel_size=k, stride=1)   # (1, 1, L)
+        return x.squeeze().bool()[:L]
+
+    dil_union = _dilate(Icp_t | Icm_t)     # any clipped → forward dilation
+    new_Icp   = dil_union & (yc_t >= 0)
+    new_Icm   = dil_union & (yc_t <  0)
+    new_Ir    = ~(new_Icp | new_Icm)
+    return new_Ir, new_Icp, new_Icm
+
+
+def _extract_frames_gpu(
+    yc_t:   "torch.Tensor",   # (L,) float — DC-removed, normalised
+    Ir_t:   "torch.Tensor",   # (L,) bool
+    Icp_t:  "torch.Tensor",   # (L,) bool
+    Icm_t:  "torch.Tensor",   # (L,) bool
+    M:      int,
+    a:      int,
+    win_t:  "torch.Tensor",   # (M,) float
+    thresh: float,
+) -> "tuple":
+    """
+    GPU frame extraction using tensor.unfold — zero Python loops.
+
+    Returns
+    -------
+    yc_active  : (n_active, M) float  — windowed frames for SPADE
+    Ir_active  : (n_active, M) bool
+    Icp_active : (n_active, M) bool
+    Icm_active : (n_active, M) bool
+    is_active  : (N,) bool            — bypass mask for ALL N frames
+    N          : int                  — total number of frames
+    idx1s_t    : (N,) long            — start indices for WOLA
+    """
+    import torch.nn.functional as F
+    L   = yc_t.shape[0]
+    import math
+    N   = math.ceil(L / a)
+    dev = yc_t.device
+
+    # Pad to N*a + M to ensure all frames are exactly M samples
+    pad_len = N * a + M - L
+    yc_pad  = F.pad(yc_t,         (0, pad_len), value=0.0)
+    Ir_pad  = F.pad(Ir_t.float(), (0, pad_len), value=1.0).bool()
+    Icp_pad = F.pad(Icp_t.float(),(0, pad_len), value=0.0).bool()
+    Icm_pad = F.pad(Icm_t.float(),(0, pad_len), value=0.0).bool()
+
+    # unfold: (L_padded,) → (N, M)  — zero-copy strided view
+    yc_frames  = yc_pad.unfold(0, M, a)    # (N, M)
+    Ir_frames  = Ir_pad.unfold(0, M, a)    # (N, M) bool
+    Icp_frames = Icp_pad.unfold(0, M, a)
+    Icm_frames = Icm_pad.unfold(0, M, a)
+
+    # Per-frame peak → bypass decision (fully parallel)
+    frame_peaks = yc_frames.abs().amax(dim=-1)   # (N,)
+    is_active   = frame_peaks >= thresh           # (N,) bool
+
+    # Active frames
+    yc_active  = yc_frames [is_active] * win_t   # (n_active, M) windowed
+    Ir_active  = Ir_frames [is_active]
+    Icp_active = Icp_frames[is_active]
+    Icm_active = Icm_frames[is_active]
+
+    idx1s_t = torch.arange(N, device=dev, dtype=torch.long) * a   # (N,)
+
+    return yc_active, Ir_active, Icp_active, Icm_active, is_active, N, idx1s_t
+
+
+def _wola_gpu(
+    x_active_t: "torch.Tensor",   # (n_active, M) float — SPADE output
+    is_active:  "torch.Tensor",   # (N,) bool
+    idx1s_t:    "torch.Tensor",   # (N,) long — frame start indices
+    yc_t:       "torch.Tensor",   # (L,) float — original signal (for bypass)
+    win_t:      "torch.Tensor",   # (M,) float
+    L:          int,
+    M:          int,
+) -> "torch.Tensor":
+    """
+    GPU WOLA overlap-add via scatter_add_ — zero Python loops.
+
+    Bypassed frames accumulate yc * win^2.
+    Active frames accumulate x_spade * win.
+    norm_win  accumulates win^2 for ALL frames.
+    """
+    import torch.nn.functional as F
+    dev  = x_active_t.device
+    dt   = x_active_t.dtype
+    win2 = win_t ** 2   # (M,)
+
+    N = idx1s_t.shape[0]
+
+    # Index matrix for ALL N frames: (N, M)
+    col    = torch.arange(M, device=dev, dtype=torch.long)
+    idx_mat = idx1s_t.unsqueeze(1) + col.unsqueeze(0)   # (N, M)
+
+    # Output buffers (L+M to avoid OOB)
+    x_out    = torch.zeros(L + M, device=dev, dtype=dt)
+    norm_out = torch.zeros(L + M, device=dev, dtype=dt)
+
+    # norm_win: all N frames contribute win^2
+    norm_vals = win2.unsqueeze(0).expand(N, -1)           # (N, M)
+    norm_out.scatter_add_(0, idx_mat.reshape(-1), norm_vals.reshape(-1))
+
+    # Bypassed frames: yc * win^2
+    byp_mask = ~is_active
+    if byp_mask.any():
+        byp_idx = idx_mat[byp_mask]                        # (n_byp, M)
+        yc_pad  = F.pad(yc_t, (0, M))                     # (L+M,)
+        byp_yc  = yc_pad[byp_idx]                         # (n_byp, M) — gather
+        byp_val = byp_yc * win2.unsqueeze(0)
+        x_out.scatter_add_(0, byp_idx.reshape(-1), byp_val.reshape(-1))
+
+    # Active frames: x_spade * win
+    if is_active.any():
+        act_idx = idx_mat[is_active]                       # (n_active, M)
+        act_val = x_active_t.to(dt) * win_t.unsqueeze(0)  # (n_active, M)
+        x_out.scatter_add_(0, act_idx.reshape(-1), act_val.reshape(-1))
+
+    norm_clamped = norm_out[:L].clamp(min=1e-12)
+    return x_out[:L] / norm_clamped
+
+
+def _rms_match_gpu(
+    x_t:   "torch.Tensor",   # (L,) float — reconstructed signal
+    yc_t:  "torch.Tensor",   # (L,) float — input (DC-removed)
+    Ir_t:  "torch.Tensor",   # (L,) bool  — reliable samples
+    M:     int,
+) -> "torch.Tensor":
+    """
+    GPU reliable-sample RMS match (v12 safe-Ir).
+
+    Replaces np.convolve(...) for near-clip detection with F.max_pool1d.
+    All ops stay on GPU — returns rescaled x_t tensor.
+    """
+    import torch.nn.functional as F
+    if Ir_t.sum() == 0:
+        return x_t
+
+    # Near-clip: any Ir sample within M of a clip boundary is "contaminated"
+    clip_f = (~Ir_t).float().unsqueeze(0).unsqueeze(0)   # (1, 1, L)
+    near   = F.max_pool1d(clip_f, M, stride=1,
+                          padding=M // 2).squeeze()[:len(Ir_t)] > 0
+
+    safe_Ir = Ir_t & ~near
+    use_Ir  = safe_Ir if safe_Ir.sum() >= 100 else Ir_t
+
+    rms_in  = yc_t[use_Ir].pow(2).mean().sqrt()
+    rms_out = x_t [use_Ir].pow(2).mean().sqrt()
+    if rms_out > 1e-12 and rms_in > 1e-12:
+        x_t = x_t * (rms_in / rms_out)
+    return x_t
+
+
+def _cosine_sim_gpu(
+    gt_t:        "torch.Tensor",   # (L,) float — GT residual
+    est_t:       "torch.Tensor",   # (L,) float — estimated residual
+    win_samples: int = 1024,
+    hop_samples: int = 256,
+) -> float:
+    """
+    GPU cosine similarity via torch.stft.
+
+    Replaces scipy.signal.stft + numpy band loops with a single GPU STFT
+    call and vectorised band computation. Returns float in [0, 1].
+    """
+    import torch
+    L = min(gt_t.shape[0], est_t.shape[0])
+    g = gt_t [:L].float()
+    e = est_t[:L].float()
+    dev = g.device
+
+    win_s = min(win_samples, max(32, L // 4))
+    hop_s = min(hop_samples, win_s // 2)
+
+    if L < win_s or win_s < 32:
+        denom = g.norm() * e.norm() + 1e-12
+        return (g * e).sum().item() / denom.item()
+
+    window = torch.hann_window(win_s, device=dev)
+    # torch.stft: input (L,) → (F, T) complex
+    Zg = torch.stft(g, win_s, hop_s, window=window,
+                    return_complex=True, normalized=False)   # (F, T)
+    Ze = torch.stft(e, win_s, hop_s, window=window,
+                    return_complex=True, normalized=False)
+
+    Mg = Zg.abs()   # (F, T)
+    Me = Ze.abs()   # (F, T)
+
+    dot    = (Mg * Me).sum(dim=0)               # (T,)
+    norm_g = Mg.norm(dim=0).clamp(min=1e-12)    # (T,)
+    norm_e = Me.norm(dim=0).clamp(min=1e-12)    # (T,)
+
+    return (dot / (norm_g * norm_e)).mean().item()
+
+
+# ── GPU corpus cache — upload limited arrays to GPU once per build_corpus ──
+# Keyed by (id(item), device_str). Cleared at program exit.
+_GPU_CORPUS_CACHE: dict = {}
+
+
+def evaluate_corpus_gpu_mega(
+    items:       List[Dict],
+    params_dict: dict,
+    device:      str,
+) -> List[Optional[float]]:
+    """
+    Pipeline interamente GPU — v13.
+
+    Pass 0  Carica i tensor GPU dal cache (upload one-time per corpus build).
+    Pass 1  Per ogni item: normalise + DC + masks + dilation + unfold (GPU).
+            Raccoglie i frame attivi nel mega-tensor.
+    Pass 2  _sspade_batch_gpu — invariato, già GPU.
+    Pass 3  Per ogni item: WOLA + RMS match + cosine sim (GPU).
+            Nessun trasferimento GPU→CPU fino ai punteggi finali.
+
+    Rispetto a v12:
+    - Eliminati tutti i loop Python nel hot-path
+    - ThreadPoolExecutor rimosso (serializzazione GPU è già il collo di bottiglia)
+    - numpy utilizzato SOLO per l'inizializzazione degli array corpus (build_corpus)
+      e per raccogliere i punteggi finali (una .item() per file)
+    """
+    try:
+        import torch
+        import torch.nn.functional as F
+        from scipy.signal import hann as _hann
+        import math as _m
+    except ImportError:
+        return [evaluate_one(item, dict(params_dict)) for item in items]
+
+    # ── Extract flags ─────────────────────────────────────────────────────
+    p2           = dict(params_dict)
+    multiband    = p2.pop("multiband",    False)
+    macro_expand = p2.pop("macro_expand", False)
+    macro_ratio  = p2.pop("macro_ratio",  1.0)
+    lf_delta_db  = p2.pop("lf_delta_db",  p2.get("delta_db", 1.5))
+
+    if multiband:
+        return [evaluate_one(item, dict(params_dict)) for item in items]
+
+    # ── Build DeclipParams ────────────────────────────────────────────────
+    sr_ref = items[0]["sr"]
+    spade_kw = dict(
+        macro_expand=macro_expand,
+        macro_ratio=macro_ratio if macro_expand else 1.0,
+        macro_release_ms=200.0,
+        macro_attack_ms=10.0,
+    )
+    try:
+        p = DeclipParams(sample_rate=sr_ref, **FIXED_SOLVER, **p2, **spade_kw)
+    except Exception as exc:
+        warnings.warn(f"evaluate_corpus_gpu_mega: DeclipParams error: {exc}")
+        return [None] * len(items)
+
+    M       = p.window_length
+    a       = p.hop_length
+    NORM_TGT = 0.9
+    win_np  = np.sqrt(_hann(M, sym=False)).astype(np.float32)
+    win_t   = torch.from_numpy(win_np).to(device=device)        # (M,) on GPU
+
+    # ── LF mask tensor ────────────────────────────────────────────────────
+    lf_mask_t = None
+    if p.lf_cutoff_hz > 0.0 and p.lf_k_min > 0:
+        lf_mask_np = _build_lf_mask(M, p.frame, sr_ref, p.lf_cutoff_hz)
+        lf_mask_t  = torch.tensor(lf_mask_np, dtype=torch.bool, device=device)
+
+    g_max = (10.0 ** (p.max_gain_db / 20.0) if p.max_gain_db > 0.0
+             else float("inf"))
+
+    # ── Pass 0: GPU corpus cache ──────────────────────────────────────────
+    # Upload item["limited"] to GPU once; reuse across trials.
+    limited_gpu: list = []
+    gt_res_gpu:  list = []
+    for item in items:
+        key = (id(item), device)
+        if key not in _GPU_CORPUS_CACHE:
+            ltd = np.asarray(item["limited"], dtype=np.float32)
+            if ltd.ndim == 2:
+                ltd = ltd[:, 0]   # take L channel; corpus is mono-per-item
+            _GPU_CORPUS_CACHE[key] = torch.from_numpy(ltd).to(device=device)
+        limited_gpu.append(_GPU_CORPUS_CACHE[key])
+
+        gt_key = (id(item), device, "gt")
+        if gt_key not in _GPU_CORPUS_CACHE:
+            gt = np.asarray(item["gt_res"], dtype=np.float32)
+            if gt.ndim == 2:
+                gt = gt[:, 0]
+            _GPU_CORPUS_CACHE[gt_key] = torch.from_numpy(gt).to(device=device)
+        gt_res_gpu.append(_GPU_CORPUS_CACHE[gt_key])
+
+    # ── Pass 1: GPU preprocessing + frame extraction ──────────────────────
+    # Process items sequentially; each step is a GPU kernel (no Python per-sample).
+    item_states: list = []
+    all_yc_active:  list = []   # (n_i, M) tensors — will be cat'd
+    all_Ir_active:  list = []
+    all_Icp_active: list = []
+    all_Icm_active: list = []
+
+    for i, item in enumerate(items):
+        try:
+            sr      = item["sr"]
+            yc_orig = limited_gpu[i]                          # (L,) on GPU
+
+            # Normalise
+            gp = float(yc_orig.abs().max().item())
+            if gp > NORM_TGT:
+                scale = NORM_TGT / gp
+                yc    = yc_orig * scale
+            else:
+                scale = 1.0
+                yc    = yc_orig
+
+            # DC removal
+            dc = float(yc.mean().item())
+            yc = yc - dc
+
+            # Ceiling + threshold (GPU scalars)
+            ceiling = float(torch.maximum(yc.max(), (-yc).max()).item())
+            thresh  = ceiling * (10.0 ** (-p.delta_db / 20.0))
+            if thresh <= 0.0:
+                item_states.append(None)
+                continue
+
+            # Masks — GPU boolean ops
+            Ir_t, Icp_t, Icm_t = _compute_masks_gpu(yc, thresh)
+
+            # Mask dilation — GPU max_pool
+            if p.release_ms > 0.0:
+                rs = max(0, round(p.release_ms * sr / 1000.0))
+                if rs > 0:
+                    Ir_t, Icp_t, Icm_t = _dilate_masks_gpu(Icp_t, Icm_t, yc, rs)
+
+            # Macro expand — still CPU via imported function; runs on numpy
+            if macro_expand and macro_ratio > 1.0:
+                yc_np = yc.cpu().numpy().astype(float)
+                yc_np = _macro_expand_pass(yc_np, sr,
+                                           attack_ms=p.macro_attack_ms,
+                                           release_ms=p.macro_release_ms,
+                                           ratio=macro_ratio)
+                yc = torch.from_numpy(yc_np.astype(np.float32)).to(device=device)
+                Ir_t, Icp_t, Icm_t = _compute_masks_gpu(yc, thresh)
+                if p.release_ms > 0.0 and rs > 0:
+                    Ir_t, Icp_t, Icm_t = _dilate_masks_gpu(Icp_t, Icm_t, yc, rs)
+
+            L = yc.shape[0]
+
+            # Frame extraction — GPU unfold
+            yc_act, Ir_act, Icp_act, Icm_act, is_active, N, idx1s_t = \
+                _extract_frames_gpu(yc, Ir_t, Icp_t, Icm_t, M, a, win_t, thresh)
+
+            frame_offset = sum(s["n_active"] for s in item_states if s is not None)
+            n_active     = int(is_active.sum().item())
+
+            item_states.append({
+                "yc":          yc,
+                "scale":       scale,
+                "Ir_t":        Ir_t,
+                "L":           L,
+                "is_active":   is_active,
+                "N":           N,
+                "idx1s_t":     idx1s_t,
+                "frame_offset":frame_offset,
+                "n_active":    n_active,
+                "gt_t":        gt_res_gpu[i],
+                "limited_t":   limited_gpu[i],
+                "sr":          sr,
+            })
+
+            if n_active > 0:
+                all_yc_active .append(yc_act)
+                all_Ir_active .append(Ir_act)
+                all_Icp_active.append(Icp_act)
+                all_Icm_active.append(Icm_act)
+
+        except Exception as exc:
+            warnings.warn(f"evaluate_corpus_gpu_mega preprocess ({item['file']}): {exc}")
+            item_states.append(None)
+
+    if not all_yc_active:
+        return [None] * len(items)
+
+    # Concatenate into mega-batch — single GPU allocation
+    yc_mega  = torch.cat(all_yc_active,  dim=0)   # (total_active, M)
+    Ir_mega  = torch.cat(all_Ir_active,  dim=0)
+    Icp_mega = torch.cat(all_Icp_active, dim=0)
+    Icm_mega = torch.cat(all_Icm_active, dim=0)
+
+    total_frames  = yc_mega.shape[0]
+    total_meta    = sum(s["N"]        for s in item_states if s is not None)
+    bypass_frames = total_meta - total_frames
+    vram_mb       = total_frames * M * 4 * 4 / 1024 ** 2
+    print(f"  [mega-batch] {total_frames} active / {total_meta} total frames "
+          f"({100*bypass_frames/max(total_meta,1):.0f}% bypassed)  "
+          f"≈{vram_mb:.0f} MB GPU")
+
+    # ── Pass 2 (GPU): _sspade_batch_gpu — unchanged ───────────────────────
+    try:
+        x_mega, _ = _sspade_batch_gpu(
+            yc_mega, Ir_mega, Icp_mega, Icm_mega,
+            p.frame, p.s, p.r, p.eps, p.max_iter,
+            g_max=g_max, lf_mask_t=lf_mask_t, k_lf_min=p.lf_k_min,
+            gpu_dtype=getattr(p, "gpu_dtype", "float32"),
+        )
+    except Exception as exc:
+        warnings.warn(f"evaluate_corpus_gpu_mega GPU pass: {exc}")
+        return [None] * len(items)
+    finally:
+        del yc_mega, Ir_mega, Icp_mega, Icm_mega
+
+    # ── Pass 3 (GPU): WOLA + RMS match + cosine sim ───────────────────────
+    # All operations stay on GPU. Only .item() at the very end to get the score.
+    scores: List[Optional[float]] = []
+    NORM_LIN = 10.0 ** (RESIDUAL_DBFS / 20.0)
+
+    for state in item_states:
+        if state is None:
+            scores.append(None)
+            continue
+        try:
+            yc       = state["yc"]           # (L,) float GPU
+            scale    = state["scale"]
+            L        = state["L"]
+            Ir_t     = state["Ir_t"]
+            is_active= state["is_active"]    # (N,) bool
+            idx1s_t  = state["idx1s_t"]      # (N,) long
+            f_off    = state["frame_offset"]
+            n_act    = state["n_active"]
+            gt_t     = state["gt_t"]         # (L_gt,) float GPU
+            ltd_t    = state["limited_t"]    # (L,) float GPU
+            sr       = state["sr"]
+
+            # Slice active frames for this item
+            x_item = x_mega[f_off:f_off + n_act] if n_act > 0 \
+                     else torch.empty((0, M), device=device)
+
+            # GPU WOLA
+            x_t = _wola_gpu(x_item, is_active, idx1s_t, yc, win_t, L, M)
+
+            # GPU RMS match
+            x_t = _rms_match_gpu(x_t, yc, Ir_t, M)
+
+            # Un-scale
+            x_t = x_t / scale
+
+            # Residual — GPU subtraction
+            ltd_ch = ltd_t[:L]   # align lengths
+            res_raw = x_t - ltd_ch
+
+            # Normalise to RESIDUAL_DBFS (GPU)
+            pk = res_raw.abs().max().clamp(min=1e-12)
+            res_norm = res_raw * (NORM_LIN / pk)
+
+            # Align with gt_t
+            gt_ch  = gt_t[:, 0] if gt_t.dim() == 2 else gt_t
+            Lmin   = min(res_norm.shape[0], gt_ch.shape[0])
+
+            # GPU cosine sim via torch.stft
+            sc = _cosine_sim_gpu(gt_ch[:Lmin], res_norm[:Lmin],
+                                 win_samples=1024, hop_samples=256)
+            scores.append(sc)
+
+        except Exception as exc:
+            warnings.warn(f"evaluate_corpus_gpu_mega WOLA/score ({item['file']}): {exc}")
+            scores.append(None)
+
+    return scores
+
+
+# OBIETTIVO OPTUNA
+# =============================================================================
+
+def make_objective(corpus: List[Dict]):
+    def objective(trial: "optuna.Trial") -> float:
+        # ── Parametri core ────────────────────────────────────────────────
+        delta_db = trial.suggest_float("delta_db",    1.5,  3.5,  step=0.05)
+        win_exp  = trial.suggest_int  ("win_exp",      9,   11)
+        win      = 2 ** win_exp
+        hop_div  = trial.suggest_categorical("hop_div", [4, 8])
+        hop      = win // hop_div
+        rel_ms   = trial.suggest_float("release_ms",  10.0, 200.0, step=5.0)
+        gain_db  = trial.suggest_float("max_gain_db",  2.0,  12.0, step=0.5)
+        eps      = trial.suggest_categorical("eps",    [0.03, 0.05, 0.1])
+        max_iter = trial.suggest_categorical("max_iter", [250, 500, 1000])
+
+        # ── Multiband + Macro expand ────────────────────────────────────────
+        # SPAZIO STATICO: lf_delta_db e macro_ratio vengono SEMPRE campionati
+        # dal TPE (spazio fisso) e poi usati condizionalmente a runtime.
+        # Questo elimina il fallback a RandomSampler che degradava le performance
+        # del TPE multivariate con spazi dinamici.
+        multiband    = trial.suggest_categorical("multiband",    [False, True])
+        macro_expand = trial.suggest_categorical("macro_expand", [False, True])
+
+        # Sempre campionati (range fisso), usati solo se il flag e' True:
+        lf_delta_db = trial.suggest_float("lf_delta_db", 0.5, 2.0, step=0.05)
+        macro_ratio  = trial.suggest_float("macro_ratio",  1.1, 2.0, step=0.05)
+
+        # ── v12: frequency-stratified thresholding ─────────────────────────
+        # lf_cutoff_hz: soglia in Hz che separa i bin "LF garantiti" dagli HF.
+        # Con M=512, sr=44100: bin_k = k * sr / (2M) → lf_cutoff=1000Hz → 23 bin LF.
+        # lf_k_min: quanti di quei bin sono garantiti per ogni iterazione ADMM.
+        # 0 = disabilitato (comportamento identico a v11).
+        lf_cutoff_hz = trial.suggest_categorical("lf_cutoff_hz", [0.0, 500.0, 1000.0, 2000.0])
+        lf_k_min     = trial.suggest_int("lf_k_min", 0, 16)
+        # Nota: quando lf_cutoff_hz=0 oppure lf_k_min=0, la feature e' disabilitata.
+        # Il TPE impara autonomamente quando conviene attivarla.
+
+        # Se multiband=False, lf_delta_db viene ignorato in evaluate_one.
+        # Se macro_expand=False, macro_ratio viene ignorato in evaluate_one.
+
+        params = dict(
+            delta_db      = delta_db,
+            window_length = win,
+            hop_length    = hop,
+            release_ms    = rel_ms,
+            max_gain_db   = gain_db,
+            eps           = eps,
+            max_iter      = max_iter,
+            # flag di alto livello (estratti in evaluate_one, non passati raw)
+            multiband     = multiband,
+            lf_delta_db   = lf_delta_db,
+            macro_expand  = macro_expand,
+            macro_ratio   = macro_ratio,
+            # v12: passati direttamente a DeclipParams (non estratti in evaluate_one)
+            lf_cutoff_hz  = lf_cutoff_hz,
+            lf_k_min      = lf_k_min,
+        )
+
+        scores   = []
+        # ── Shuffle per-trial con seed riproducibile ──────────────────────
+        rng_shuffle     = np.random.default_rng(trial.number)
+        shuffled_corpus = rng_shuffle.permutation(len(corpus)).tolist()
+        midpoint        = len(corpus) // 2
+        ordered_items   = [corpus[idx] for idx in shuffled_corpus]
+
+        # ── GPU mega-batch: tutti i frame del corpus in un solo kernel ────
+        # Rileva il device GPU disponibile per questa chiamata.
+        # Se non disponibile, evaluate_corpus_gpu_mega ricade su evaluate_one.
+        _gpu_dev = "cpu"
+        try:
+            import torch
+            if torch.cuda.is_available():
+                _gpu_dev = "cuda"
+        except ImportError:
+            pass
+
+        # Primo metà del corpus → prune check → seconda metà
+        # (preserva il beneficio del MedianPruner senza N kernel separati)
+        first_half  = ordered_items[:midpoint + 1]
+        second_half = ordered_items[midpoint + 1:]
+
+        scores_first = evaluate_corpus_gpu_mega(first_half,  dict(params), _gpu_dev)
+        scores = [sc for sc in scores_first if sc is not None]
+
+        if scores:
+            trial.report(float(np.mean(scores)), step=midpoint)
+            if trial.should_prune():
+                raise optuna.TrialPruned()
+
+        if second_half:
+            scores_second = evaluate_corpus_gpu_mega(second_half, dict(params), _gpu_dev)
+            scores.extend(sc for sc in scores_second if sc is not None)
+
+        if not scores:
+            return 0.0
+        mean_score = float(np.mean(scores))
+        trial.report(mean_score, step=len(corpus))
+        return mean_score
+
+    return objective
+
+
+# =============================================================================
+# REPORT + CSV
+# =============================================================================
+
+def print_report(study: "optuna.Study", top_n: int = 20):
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    if not trials:
+        print("Nessun trial completato.")
+        return
+
+    if _HAS_RICH:
+        _console.rule("[bold cyan]RISULTATI SWEEP BAYESIANO[/]")
+        tbl = Table(show_header=True, header_style="bold cyan", show_lines=False)
+        for col, w in [("#",4),("score",9),("ddb",6),("LFd",5),("win",6),
+                       ("hop",4),("rel",6),("gain",6),("eps",5),("iter",5),
+                       ("MB",3),("ME",3),("MR",5),("LFcut",6),("LFk",4)]:
+            tbl.add_column(col, justify="right", width=w)
+        for rank, t in enumerate(trials[:top_n], 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            mb  = "Y" if p.get("multiband")    else "n"
+            me  = "Y" if p.get("macro_expand") else "n"
+            lfc = p.get("lf_cutoff_hz", 0.0)
+            lfk = p.get("lf_k_min", 0)
+            sty = "bold green" if rank == 1 else ("yellow" if rank <= 3 else "")
+            tbl.add_row(
+                str(rank), f"{t.value:.5f}",
+                f"{p['delta_db']:.2f}",
+                f"{p.get('lf_delta_db', p['delta_db']):.2f}",
+                str(win), str(hop),
+                f"{p['release_ms']:.0f}", f"{p['max_gain_db']:.1f}",
+                str(p['eps']), str(p['max_iter']),
+                mb, me, f"{p.get('macro_ratio', 1.0):.2f}",
+                f"{lfc:.0f}", str(lfk),
+                style=sty,
+            )
+        _console.print(tbl)
+    else:
+        hdr = (f"{'#':>3}  {'score':>8}  {'ddb':>5}  {'LFd':>5}  {'win':>5}"
+               f"  {'hop':>4}  {'rel':>6}  {'gain':>5}  {'eps':>5}  {'iter':>5}"
+               f"  {'MB':>3}  {'ME':>3}  {'MR':>5}  {'LFcut':>6}  {'LFk':>4}")
+        print(hdr); print("-" * len(hdr))
+        for rank, t in enumerate(trials[:top_n], 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            mb  = "Y" if p.get("multiband")    else "n"
+            me  = "Y" if p.get("macro_expand") else "n"
+            lfc = p.get("lf_cutoff_hz", 0.0)
+            lfk = p.get("lf_k_min", 0)
+            print(f"{rank:>3}  {t.value:>8.5f}  {p['delta_db']:>5.2f}"
+                  f"  {p.get('lf_delta_db', p['delta_db']):>5.2f}  {win:>5}"
+                  f"  {hop:>4}  {p['release_ms']:>6.0f}  {p['max_gain_db']:>5.1f}"
+                  f"  {str(p['eps']):>5}  {p['max_iter']:>5}"
+                  f"  {mb:>3}  {me:>3}  {p.get('macro_ratio', 1.0):>5.2f}"
+                  f"  {lfc:>6.0f}  {lfk:>4}")
+
+    best = trials[0]
+    p    = best.params
+    win  = 2 ** p["win_exp"]
+    hop  = win // p["hop_div"]
+    n_pruned = sum(1 for t in study.trials
+                   if t.state == optuna.trial.TrialState.PRUNED)
+
+    print("\n" + "═" * 60)
+    print("CONFIG OTTIMALE")
+    print("═" * 60)
+    print(f"""
+params = DeclipParams(
+    algo          = "sspade",
+    frame         = "rdft",
+    mode          = "soft",
+    delta_db      = {p['delta_db']:.2f},
+    window_length = {win},
+    hop_length    = {hop},
+    release_ms    = {p['release_ms']:.1f},
+    max_gain_db   = {p['max_gain_db']:.1f},
+    eps           = {p['eps']},
+    max_iter      = {p['max_iter']},
+    sample_rate   = sr,
+    multiband     = {p.get('multiband', False)},
+    band_crossovers = ({BAND_CROSSOVER_HZ},),
+    band_delta_db   = ({p.get('lf_delta_db', p['delta_db']):.2f}, {p['delta_db']:.2f}),
+    macro_expand  = {p.get('macro_expand', False)},
+    macro_ratio   = {p.get('macro_ratio', 1.0):.2f},
+    lf_cutoff_hz  = {p.get('lf_cutoff_hz', 0.0):.1f},   # v12
+    lf_k_min      = {p.get('lf_k_min', 0)},               # v12
+    n_jobs        = -1,
+    show_progress = True,
+)""")
+    print(f"\n→ Best score    : {best.value:.5f}")
+    print(f"   Trials done  : {len(trials)}")
+    print(f"   Pruned       : {n_pruned}")
+
+
+
+# =============================================================================
+# DEBUG EXPORT
+# =============================================================================
+
+# Parametri SPADE usati per il debug (best noti dal grid sweep precedente).
+# Se un DB Optuna esiste e ha trial completati, vengono sostituiti dal best.
+DEBUG_PARAMS = dict(
+    delta_db      = 1.5,
+    window_length = 1024,
+    hop_length    = 256,
+    release_ms    = 100.0,
+    max_gain_db   = 6.0,
+    eps           = 0.05,
+    max_iter      = 500,
+)
+
+
+def _pk_dbfs(a: np.ndarray) -> float:
+    pk = float(np.max(np.abs(a)))
+    return 20.0 * np.log10(pk) if pk > 1e-12 else -999.0
+
+
+def _rms_dbfs(a: np.ndarray) -> float:
+    rms = float(np.sqrt(np.mean(a.astype(float) ** 2)))
+    return 20.0 * np.log10(rms) if rms > 1e-12 else -999.0
+
+
+def _write_wav(path: Path, audio: np.ndarray, sr: int) -> None:
+    """Scrive WAV float32 senza clipping. Avvisa se peak > 1.0."""
+    a2d = ensure_2d(audio).astype(np.float32)
+    pk  = float(np.max(np.abs(a2d)))
+    if pk > 1.0:
+        print(f"    [WARN] {path.name}: peak={pk:.4f} > 1.0 "
+              f"(+{20*np.log10(pk):.2f} dBFS) — float32, non clippato")
+    sf.write(str(path), a2d, sr, subtype="FLOAT")
+
+
+def debug_export(
+    corpus:       list,
+    base_dir:     Path,
+    out_dir:      Path,
+    n_files:      int,
+    spade_params: dict,
+) -> None:
+    """
+    Esporta WAV di debug per i primi n_files item del corpus.
+
+    Per ogni file vengono scritti 6 WAV float32:
+      01_orig_with_noise  drum + pink noise, normalizzato a 0 dBFS peak
+                          (segnale prima del limiter)
+      02_limited          uscita del limiter sintetico (input a SPADE)
+      03_gt_residual      orig_with_noise - limited, @RESIDUAL_DBFS peak
+      04_spade_output     uscita SPADE (float32, puo' superare 0 dBFS)
+      05_res_iter         spade_output - limited, @RESIDUAL_DBFS peak
+      06_diff_residuals   gt_residual - res_iter
+                          ideale = silenzio = -inf dB
+
+    Stampa una tabella con peak dBFS e RMS dBFS per ogni traccia.
+
+    Livelli ATTESI:
+      01  peak =  0.00 dBFS   (normalizzato)
+      02  peak ~ -LIMITER_THRESHOLD_DB dBFS   (es. -1.5 dBFS)
+      03  peak = RESIDUAL_DBFS  (es. -3.0 dBFS)
+      04  peak puo' essere > 0 dBFS (transiente recuperato)
+      05  peak = RESIDUAL_DBFS  (es. -3.0 dBFS)
+      06  peak << 0 dBFS  (piu' basso = SPADE piu' vicino al GT)
+    """
+    out_dir.mkdir(parents=True, exist_ok=True)
+    items   = corpus[:n_files]
+    col_w   = max(len(it["file"]) for it in items) + 2
+
+    HDR = (f"  {'file':<{col_w}}  {'traccia':<22}"
+           f"  {'peak dBFS':>10}  {'RMS dBFS':>9}  note")
+    SEP = "  " + "-" * (len(HDR) - 2)
+
+    print()
+    if _HAS_RICH:
+        _console.rule("[bold cyan]DEBUG EXPORT[/]")
+    else:
+        print("=" * 65)
+        print("DEBUG EXPORT")
+        print("=" * 65)
+
+    print(f"  Output dir    : {out_dir}")
+    print(f"  SPADE params  : delta_db={spade_params['delta_db']}"
+          f"  win={spade_params['window_length']}"
+          f"  hop={spade_params['hop_length']}"
+          f"  rel={spade_params['release_ms']}ms"
+          f"  gain={spade_params['max_gain_db']}dB")
+    print(f"  File esportati: {len(items)}")
+    print()
+    print(f"  Livelli attesi:")
+    print(f"    01_orig_with_noise  : ~  0.00 dBFS  (normalizzato prima del limiter)")
+    print(f"    02_limited          : ~ {-LIMITER_THRESHOLD_DB:+.2f} dBFS  (uscita limiter)")
+    print(f"    03_gt_residual      : = {RESIDUAL_DBFS:+.2f} dBFS  (normalizzato)")
+    print(f"    04_spade_output     :  > 0 dBFS possibile  (transiente recuperato)")
+    print(f"    05_res_iter         : = {RESIDUAL_DBFS:+.2f} dBFS  (normalizzato)")
+    print(f"    06_diff_residuals   : << 0 dBFS  (piu' basso = pipeline piu' corretta)")
+    print()
+    print(HDR)
+
+    diff_peaks = []
+
+    for file_index, item in enumerate(items):
+        sr      = item["sr"]
+        limited = item["limited"].copy()
+        gt_res  = item["gt_res"]
+        stem    = Path(item["file"]).stem
+
+        # ── Ricostruisci orig_with_noise ──────────────────────────────────
+        # Riesegue la stessa pipeline di build_corpus con il seed identico
+        orig_with_noise = None
+        for folder in DRUM_DIRS:
+            candidate = base_dir / folder / item["file"]
+            if candidate.exists():
+                try:
+                    raw, _ = sf.read(str(candidate), always_2d=True)
+                    raw    = raw.astype(float)
+                    rng    = np.random.default_rng(seed=file_index)
+                    orig_0 = normalize_to_0dBFS(raw)
+                    mixed  = ensure_2d(mix_pink_noise(orig_0, sr,
+                                                      PINK_NOISE_LEVEL_DB, rng))
+                    orig_with_noise = ensure_2d(normalize_to_0dBFS(mixed))
+                except Exception:
+                    pass
+                break
+
+        if orig_with_noise is None:
+            # Fallback: ricostruiamo da limited + gt_res (approssimazione)
+            gt_scale  = 10 ** (RESIDUAL_DBFS / 20.0)           # peak di gt_res
+            lim_peak  = 10 ** (-LIMITER_THRESHOLD_DB / 20.0)   # peak atteso del limited
+            gt_raw    = gt_res * (lim_peak / (gt_scale + 1e-12))
+            orig_with_noise = ensure_2d(normalize_to_0dBFS(limited + gt_raw))
+
+        # ── Esegui SPADE ───────────────────────────────────────────��──────
+        try:
+            p        = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **spade_params)
+            fixed, _ = declip(limited.copy(), p)
+            fixed_2d = ensure_2d(fixed)
+        except Exception as exc:
+            print(f"  [ERRORE SPADE] {item['file']}: {exc}")
+            continue
+
+        # ── Residual iterazione (scala RAW, senza normalizzazione) ───────────
+        # IMPORTANTE: il diff deve avvenire sulla scala comune PRIMA di
+        # normalizzare i due residual, altrimenti la normalizzazione
+        # indipendente rimuove l'informazione di ampiezza relativa.
+        #
+        # gt_res e res_raw sono entrambi derivati dallo stesso limited →
+        # hanno la stessa scala di riferimento.
+        # gt_res e' gia' stato normalizzato a RESIDUAL_DBFS in build_corpus;
+        # dobbiamo riportarlo alla scala raw per il confronto.
+        #
+        # Scala comune: usiamo il peak del limited come riferimento.
+        # limited peak ≈ 10^(-LIMITER_THRESHOLD_DB/20) → scala assoluta nota.
+        res_raw   = fixed_2d - limited    # residual SPADE in scala assoluta
+
+        # gt_res_raw: ricostruiamo dalla scala normalizzata
+        # gt_res = gt_res_raw / peak(gt_res_raw) * 10^(RESIDUAL_DBFS/20)
+        # → gt_res_raw = gt_res * peak(gt_res_raw) / 10^(RESIDUAL_DBFS/20)
+        # Poiche' peak(gt_res_raw) non e' salvato, lo stimiamo:
+        # gt_res_raw ≈ orig_with_noise - limited  (ricostruito)
+        gt_res_raw_approx = ensure_2d(orig_with_noise) - limited
+        L = min(gt_res_raw_approx.shape[0], res_raw.shape[0])
+
+        # ── Diff sulla scala comune (raw, non normalizzata) ───────────────
+        diff_raw  = gt_res_raw_approx[:L] - res_raw[:L]
+
+        # ── Cosine similarity temporale (scalare, sul canale L) ──────────
+        g_flat = gt_res_raw_approx[:L, 0] if gt_res_raw_approx.ndim == 2 else gt_res_raw_approx[:L]
+        e_flat = res_raw[:L, 0]           if res_raw.ndim == 2           else res_raw[:L]
+        cos_sim_td = float(
+            np.dot(g_flat, e_flat) /
+            (np.linalg.norm(g_flat) * np.linalg.norm(e_flat) + 1e-12)
+        )
+
+        # ── Stima floor teorico del diff dovuto al rumore rosa ────────────
+        # Il limiter attenue anche i picchi del rumore rosa → quella parte
+        # sta nel GT_res ma NON in res_iter (SPADE non la recupera).
+        # Stimiamo quanto rumore e' nel GT_res come proxy del floor.
+        noise_gain_lin = 10 ** (PINK_NOISE_LEVEL_DB / 20.0)
+        # Ampiezza del rumore rispetto al limited: noise_gain ≈ fraction
+        # del GT_res che e' irrecuperabile da SPADE.
+        noise_floor_db = 20 * np.log10(noise_gain_lin + 1e-12) + RESIDUAL_DBFS
+        # In pratica: diff non puo' essere < noise_floor per costruzione.
+
+        # ── diff dBFS relativo al GT_res (SNR-like) ───────────────────────
+        diff_rms_db = _rms_dbfs(diff_raw[:L])
+        gt_rms_db   = _rms_dbfs(gt_res_raw_approx[:L])
+        # diff_vs_gt: quanto e' grande il diff rispetto al GT (0 dB = diff = GT)
+        diff_vs_gt_db = diff_rms_db - gt_rms_db  # piu' negativo = meglio
+
+        # Normalizza per l'export WAV
+        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)
+        diff_norm = normalize_peak(diff_raw, RESIDUAL_DBFS) if np.max(np.abs(diff_raw)) > 1e-12 else diff_raw
+
+        diff_peaks.append((diff_vs_gt_db, cos_sim_td, diff_rms_db, gt_rms_db))
+
+        # ── Definizione tracce ────────────────────────────────────────────
+        tracks = [
+            ("01_orig_with_noise",
+             orig_with_noise,
+             f"drum+noise @0dBFS (input pipeline)"),
+            ("02_limited",
+             limited,
+             f"uscita limiter (input SPADE)  atteso: ~{-LIMITER_THRESHOLD_DB:+.2f}dBFS"),
+            ("03_gt_residual",
+             gt_res,
+             f"GT residual @{RESIDUAL_DBFS:.0f}dBFS  (include noise attenuation)"),
+            ("04_spade_output",
+             fixed_2d,
+             f"SPADE output (float32, puo' >0dBFS)"),
+            ("05_res_iter",
+             res_iter,
+             f"residual SPADE @{RESIDUAL_DBFS:.0f}dBFS  (solo componente sparsa)"),
+            ("06_diff_residuals",
+             diff_norm,
+             f"GT - iter @{RESIDUAL_DBFS:.0f}dBFS  "
+             f"cos_sim={cos_sim_td:.3f}  diff/GT={diff_vs_gt_db:+.1f}dB  "
+             f"noise_floor≈{noise_floor_db:+.1f}dB"),
+        ]
+
+        # ── Soglia realistica per il diff ─────────────────────────────────
+        # Il diff non puo' essere < noise_floor per costruzione del corpus.
+        # Calibriamo la soglia [OK] a noise_floor + 6 dB (margine).
+        ok_threshold  = noise_floor_db + 6.0   # tipicamente attorno a -17 dBFS
+        warn_threshold = ok_threshold + 10.0   # tutto sopra e' davvero anomalo
+
+        # ── Stampa tabella + scrivi WAV ───────────────────────────────────
+        print(SEP)
+        for track_name, audio, note in tracks:
+            pk  = _pk_dbfs(audio)
+            rms = _rms_dbfs(audio)
+
+            flag = ""
+            if track_name == "06_diff_residuals":
+                if   diff_vs_gt_db < -12: flag = "[OK]   buona convergenza"
+                elif diff_vs_gt_db <  -6: flag = "[~]    convergenza parziale"
+                else:                     flag = "[WARN] diff elevato rispetto al GT"
+
+            row = (f"  {item['file']:<{col_w}}  {track_name:<22}"
+                   f"  {pk:>+10.2f}  {rms:>+9.2f}  {note}  {flag}")
+
+            if _HAS_RICH:
+                color = ("green"  if "[OK]"   in flag else
+                         "yellow" if "[~]"    in flag else
+                         "red"    if "[WARN]" in flag else "")
+                colored_row = row.replace(flag, f"[{color or 'dim'}]{flag}[/]") if flag else row
+                _console.print(colored_row)
+            else:
+                print(row)
+
+            wav_path = out_dir / f"{stem}__{track_name}.wav"
+            _write_wav(wav_path, audio, sr)
+
+        # ── Analisi spettrale per banda: LF vs HF ─────────────────────────
+        # Risponde alla domanda: quanto residual c'e' nelle basse frequenze,
+        # e quanto ne recupera SPADE?
+        #
+        # Bands:
+        #   Sub-bass  :  20 –  80 Hz  (fondamentale kick, body)
+        #   Bass      :  80 – 250 Hz  (corpo kick, coda)
+        #   Low-mid   : 250 – 800 Hz  (presenza)
+        #   High-mid  : 800 – 4000 Hz (attacco, click)
+        #   High      : 4k  – 20k Hz  (aria, snap)
+        #
+        # Per ogni banda misura:
+        #   GT_energy   = energia del GT residual (quanto il limiter ha tolto)
+        #   iter_energy = energia recuperata da SPADE
+        #   recovery %  = iter_energy / GT_energy × 100
+
+        def band_energy(audio_2d, sr, f_lo, f_hi):
+            """RMS energy in dB di una banda passante [f_lo, f_hi] Hz."""
+            mono = audio_2d[:, 0] if audio_2d.ndim == 2 else audio_2d
+            N    = len(mono)
+            if N < 8:
+                return -999.0
+            # Butterworth bandpass (o lowpass/highpass ai bordi)
+            nyq = sr / 2.0
+            lo  = max(f_lo / nyq, 1e-4)
+            hi  = min(f_hi / nyq, 0.9999)
+            if lo >= hi:
+                return -999.0
+            if lo < 1e-3:
+                b, a = sig.butter(4, hi, btype="low")
+            else:
+                b, a = sig.butter(4, [lo, hi], btype="band")
+            filtered = sig.filtfilt(b, a, mono)
+            return _rms_dbfs(filtered)
+
+        BANDS = [
+            ("Sub-bass ",   20,   80),
+            ("Bass     ",   80,  250),
+            ("Low-mid  ",  250,  800),
+            ("High-mid ",  800, 4000),
+            ("High     ", 4000, 20000),
+        ]
+
+        gt_mono   = gt_res[:, 0]  if gt_res.ndim  == 2 else gt_res
+        ri_mono   = res_iter[:, 0] if res_iter.ndim == 2 else res_iter
+
+        # Normalizza GT e iter sulla stessa scala (rimuovi la normalizzazione
+        # a RESIDUAL_DBFS per confrontare energie assolute)
+        gt_raw_for_bands   = gt_res_raw_approx
+        iter_raw_for_bands = res_raw
+
+        print()
+        band_hdr = f"    {'banda':<12} {'GT_res RMS':>10}  {'SPADE rec RMS':>13}  {'recovery':>9}  {'limitato?'}"
+        print(f"  Analisi spettrale per banda — {item['file']}")
+        print(f"  {'─'*75}")
+        print(band_hdr)
+        print(f"  {'─'*75}")
+        for bname, f_lo, f_hi in BANDS:
+            gt_db   = band_energy(gt_raw_for_bands,   sr, f_lo, f_hi)
+            iter_db = band_energy(iter_raw_for_bands, sr, f_lo, f_hi)
+            if gt_db < -60:
+                recovery_str = "  —    (silenzio)"
+                flag_b = ""
+            else:
+                diff_b   = iter_db - gt_db       # positivo = SPADE supera GT (overrecovery)
+                # recovery: 0 dB diff = recupero perfetto, molto negativo = sotto-recupero
+                if diff_b > -3:
+                    flag_b = "OK"
+                elif diff_b > -9:
+                    flag_b = "~  parziale"
+                else:
+                    flag_b = "!! sotto-recupero"
+                recovery_str = f"{diff_b:>+7.1f} dB  {flag_b}"
+            line = f"    {bname:<12} {gt_db:>+10.1f}  {iter_db:>+13.1f}  {recovery_str}"
+            if _HAS_RICH:
+                color = "green" if "OK" in recovery_str else (
+                        "yellow" if "~" in recovery_str else (
+                        "red" if "!!" in recovery_str else "dim"))
+                _console.print(f"[{color}]{line}[/]")
+            else:
+                print(line)
+        print()
+
+    print(SEP)
+    print()
+    if diff_peaks:
+        vs_gt_vals  = [d[0] for d in diff_peaks]
+        cos_vals    = [d[1] for d in diff_peaks]
+        avg_vs_gt   = float(np.mean(vs_gt_vals))
+        best_vs_gt  = float(np.min(vs_gt_vals))
+        worst_vs_gt = float(np.max(vs_gt_vals))
+        avg_cos     = float(np.mean(cos_vals))
+
+        noise_floor_db = 20 * np.log10(10 ** (PINK_NOISE_LEVEL_DB / 20.0) + 1e-12) + RESIDUAL_DBFS
+
+        print(f"  RIEPILOGO  06_diff_residuals:")
+        print(f"    diff/GT_rms  media   : {avg_vs_gt:>+7.2f} dB  (0 dB = diff grande quanto GT)")
+        print(f"    diff/GT_rms  migliore: {best_vs_gt:>+7.2f} dB")
+        print(f"    diff/GT_rms  peggiore: {worst_vs_gt:>+7.2f} dB")
+        print(f"    cos_sim TD   media   : {avg_cos:>8.4f}  (1.0 = identici)")
+        print()
+        print(f"  NOTA IMPORTANTE:")
+        print(f"    Il rumore rosa ({PINK_NOISE_LEVEL_DB} dB) fa parte del GT_res ma")
+        print(f"    NON puo' essere recuperato da SPADE (non e' sparso).")
+        print(f"    Floor teorico del diff: ≈ {noise_floor_db:+.1f} dBFS — questo e' il")
+        print(f"    limite fisico massimo raggiungibile con questo corpus.")
+        print(f"    Un diff/GT < -6 dB indica buona convergenza di SPADE.")
+        print()
+        if worst_vs_gt < -12:
+            verdict = "OK     Convergenza eccellente — SPADE recupera bene i transienti"
+        elif worst_vs_gt < -6:
+            verdict = "~      Convergenza buona — residuo compatibile con il noise floor"
+        else:
+            verdict = "INFO   diff dominato dal rumore rosa — comportamento atteso e corretto"
+        print(f"    Verdetto: {verdict}")
+    print(f"\n  WAV scritti in : {out_dir}/")
+    print(f"  Formato        : float32, nessun clipping (usa un editor che supporta >0dBFS)")
+    print(f"  Nomenclatura   : <stem>__<N>_<traccia>.wav")
+
+
+def save_csv(study: "optuna.Study"):
+    import csv
+    trials = sorted(
+        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
+        key=lambda t: t.value or 0, reverse=True,
+    )
+    with open(OUT_CSV, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["rank", "score", "delta_db", "lf_delta_db",
+                    "window_length", "hop_length", "release_ms", "max_gain_db",
+                    "eps", "max_iter", "multiband", "macro_expand", "macro_ratio"])
+        for rank, t in enumerate(trials, 1):
+            p   = t.params
+            win = 2 ** p["win_exp"]
+            hop = win // p["hop_div"]
+            w.writerow([
+                rank, round(t.value, 6),
+                p["delta_db"],
+                round(p.get("lf_delta_db", p["delta_db"]), 2),
+                win, hop,
+                p["release_ms"], p["max_gain_db"], p["eps"], p["max_iter"],
+                int(p.get("multiband",    False)),
+                int(p.get("macro_expand", False)),
+                round(p.get("macro_ratio", 1.0), 2),
+            ])
+    print(f"\n  📄 CSV: {OUT_CSV}")
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def parse_args():
+    ap = argparse.ArgumentParser(description="Smart Bayesian sweep per S-SPADE v2")
+    ap.add_argument("--trials",      type=int,  default=200,
+                    help="Numero di trial Optuna (default: 200)")
+    ap.add_argument("--resume",      action="store_true",
+                    help="Carica lo study esistente e aggiunge trial")
+    ap.add_argument("--report",      action="store_true",
+                    help="Solo report (nessun nuovo trial)")
+    ap.add_argument("--base-dir",    type=str,  default=".",
+                    help="Cartella radice con Kicks/Snares/Perc/Tops")
+    ap.add_argument("--corpus-size", type=int,  default=None,
+                    help="Limita il corpus a N file (None = tutti)")
+    ap.add_argument("--top",         type=int,  default=20,
+                    help="Quanti trial mostrare nel ranking (default: 20)")
+    ap.add_argument("--no-prune",    action="store_true",
+                    help="Disabilita MedianPruner (più lento ma completo)")
+    ap.add_argument("--debug-export", action="store_true",
+                    help="Esporta WAV di debug per i primi N file del corpus (no sweep)")
+    ap.add_argument("--debug-dir",   type=str,  default="debug_export",
+                    help="Cartella output WAV di debug (default: debug_export)")
+    ap.add_argument("--debug-n",     type=int,  default=10,
+                    help="Quanti file esportare in debug (default: 10)")
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    missing = []
+    if not _HAS_OPTUNA: missing.append("optuna")
+    if not _HAS_SPADE:  missing.append("spade_declip_v11.py (nella stessa dir)")
+    if missing:
+        pip  = [m for m in missing if not m.endswith(")")]
+        sys.exit("Mancante:\n  pip install " + " ".join(pip)
+                 + ("\n  " + "\n  ".join(m for m in missing if m.endswith(")")) if any(m.endswith(")") for m in missing) else ""))
+
+    base_dir = Path(args.base_dir).resolve()
+    storage  = f"sqlite:///{STUDY_NAME}.db"
+    sampler  = TPESampler(seed=42, multivariate=True, warn_independent_sampling=False)
+    pruner   = (MedianPruner(n_startup_trials=10, n_warmup_steps=3)
+                if not args.no_prune else optuna.pruners.NopPruner())
+
+    if args.report:
+        try:
+            study = optuna.load_study(study_name=STUDY_NAME, storage=storage,
+                                      sampler=sampler, pruner=pruner)
+        except Exception:
+            sys.exit(f"Nessuno study trovato in {STUDY_NAME}.db")
+        print_report(study, top_n=args.top)
+        save_csv(study)
+        return
+
+    # ── Debug export ──────────────────────────────────────────────────────────
+    if args.debug_export:
+        # Usa i parametri del best trial se esiste un DB, altrimenti DEBUG_PARAMS
+        spade_params = dict(DEBUG_PARAMS)
+        try:
+            study = optuna.load_study(study_name=STUDY_NAME, storage=storage,
+                                      sampler=sampler, pruner=pruner)
+            completed = [t for t in study.trials
+                         if t.state == optuna.trial.TrialState.COMPLETE]
+            if completed:
+                best_t = max(completed, key=lambda t: t.value or 0)
+                p      = best_t.params
+                win    = 2 ** p["win_exp"]
+                hop    = win // p["hop_div"]
+                spade_params = dict(
+                    delta_db      = p["delta_db"],
+                    window_length = win,
+                    hop_length    = hop,
+                    release_ms    = p["release_ms"],
+                    max_gain_db   = p["max_gain_db"],
+                    eps           = p["eps"],
+                    max_iter      = p["max_iter"],
+                )
+                print(f"  [DEBUG] Usando best trial #{best_t.number}"
+                      f" (score={best_t.value:.5f}) dal DB.")
+        except Exception:
+            print(f"  [DEBUG] DB non trovato — uso DEBUG_PARAMS di default.")
+
+        # Costruisci corpus (limitato a debug_n file per velocita')
+        corpus = build_corpus(base_dir, max_files=args.debug_n)
+        if not corpus:
+            sys.exit("Corpus vuoto. Controlla --base-dir.")
+        debug_export(
+            corpus       = corpus,
+            base_dir     = base_dir,
+            out_dir      = Path(args.debug_dir),
+            n_files      = args.debug_n,
+            spade_params = spade_params,
+        )
+        return
+
+    # ── Corpus ───────────────────────────────────────────────────────────────
+    print("\n" + "=" * 65)
+    print("CORPUS  +  LIMITER SINTETICO  (Case 1 — threshold-based)")
+    print("=" * 65)
+    print(f"  Base dir  : {base_dir}")
+    print(f"  Threshold : −{LIMITER_THRESHOLD_DB} dBFS")
+    print(f"  Release   : {LIMITER_RELEASE_MS} ms")
+    print(f"  Level align: NESSUNO — loudness invariata per costruzione")
+    print(f"  Rumore rosa: {PINK_NOISE_LEVEL_DB} dB rel. peak  "
+          f"(simula sottofondo musicale sotto il transiente)")
+
+    corpus = build_corpus(base_dir, max_files=args.corpus_size)
+    if not corpus:
+        sys.exit("Corpus vuoto. Controlla --base-dir e le cartelle.")
+
+    # ── GPU warm-up: forza MCLK al massimo prima del primo trial ─────────────
+    # Su RDNA2 (RX 6700 XT) il memory clock parte da 96 MHz (idle) e impiega
+    # ~200ms per salire a 1750 MHz. Un primo batch piccolo lascia MCLK basso
+    # per tutto il trial. Questo dummy dispatch forza il ramp-up in anticipo.
+    try:
+        import torch
+        if torch.cuda.is_available():
+            _wd = "cuda"
+            _sz = 8192 * 1024     # 8 MB → sufficiente per trigger MCLK ramp
+            _dummy = torch.randn(_sz, device=_wd, dtype=torch.float32)
+            _dummy2 = _dummy * 2.0 + _dummy.roll(1)
+            torch.cuda.synchronize()
+            del _dummy, _dummy2
+            print("  ✓ GPU warm-up completato (MCLK ramp forzato)")
+    except Exception:
+        pass
+
+    print(f"\n  ✓ {len(corpus)} file nel corpus\n")
+    col_w = max(len(item["file"]) for item in corpus) + 2
+    for item in corpus:
+        rms  = float(np.sqrt(np.mean(item["gt_res"] ** 2)))
+        peak = float(np.max(np.abs(item["gt_res"])))
+        print(f"    {item['file']:<{col_w}}  sr={item['sr']}  "
+              f"GT rms={rms:.4f}  peak={peak:.4f}")
+
+    # ── Study ─────────────────────────────────────────────────────────────────
+    print(f"\n{'='*65}")
+    print(f"OTTIMIZZAZIONE BAYESIANA  —  {args.trials} trial")
+    print(f"TPE (multivariate) + MedianPruner  |  storage: {STUDY_NAME}.db")
+    print(f"{'='*65}\n")
+
+    study = optuna.create_study(
+        study_name     = STUDY_NAME,
+        storage        = storage,
+        sampler        = sampler,
+        pruner         = pruner,
+        direction      = "maximize",
+        load_if_exists = True,
+    )
+
+    # ── Progress bar (rich → tqdm → plain fallback) ───────────────────────────
+    try:
+        from rich.progress import (
+            Progress, BarColumn, TextColumn,
+            TimeElapsedColumn, TimeRemainingColumn, MofNCompleteColumn,
+        )
+        _has_rich_progress = True
+    except ImportError:
+        _has_rich_progress = False
+
+    try:
+        import tqdm as _tqdm_mod
+        _has_tqdm = True
+    except ImportError:
+        _has_tqdm = False
+
+    # Stato condiviso aggiornato dal callback.
+    # Pre-popolato con i trial gia' nel DB in caso di --resume,
+    # cosi' la progress bar mostra il conteggio corretto dall'inizio.
+    _existing_complete = [t for t in study.trials
+                          if t.state == optuna.trial.TrialState.COMPLETE]
+    _existing_pruned   = [t for t in study.trials
+                          if t.state == optuna.trial.TrialState.PRUNED]
+
+    if _existing_complete:
+        _best_existing = max(_existing_complete, key=lambda t: t.value or 0)
+        _init_best     = _best_existing.value or 0.0
+        _init_best_p   = dict(_best_existing.params)
+        _init_last     = _init_best
+    else:
+        _init_best, _init_best_p, _init_last = float("-inf"), {}, float("-inf")
+
+    _state = {
+        "done":    len(_existing_complete),
+        "pruned":  len(_existing_pruned),
+        "best":    _init_best,
+        "best_p":  _init_best_p,
+        "last":    _init_last,
+        "t0":      time.time(),
+        "n_total": len(_existing_complete) + len(_existing_pruned) + args.trials,
+    }
+
+    def _fmt_best(state: dict) -> str:
+        """Stringa compatta con i parametri del best trial corrente."""
+        bp = state["best_p"]
+        if not bp:
+            return "—"
+        win = 2 ** bp.get("win_exp", 10)
+        hop = win // bp.get("hop_div", 4)
+        return (f"δ={bp.get('delta_db',0):.2f} "
+                f"win={win} hop={hop} "
+                f"rel={bp.get('release_ms',0):.0f}ms "
+                f"gain={bp.get('max_gain_db',0):.1f}dB")
+
+    # ── Rich progress bar ─────────────────────────────────────────────────────
+    if _has_rich_progress:
+        progress = Progress(
+            TextColumn("[bold cyan]Trial[/] [cyan]{task.completed}/{task.total}[/]"),
+            BarColumn(bar_width=32),
+            MofNCompleteColumn(),
+            TextColumn("  score [green]{task.fields[last]:.5f}[/]"),
+            TextColumn("  best [bold green]{task.fields[best]:.5f}[/]"),
+            TextColumn("  [dim]pruned {task.fields[pruned]}[/]"),
+            TimeElapsedColumn(),
+            TextColumn("ETA"),
+            TimeRemainingColumn(),
+            refresh_per_second=4,
+            transient=False,
+        )
+        task_id = None   # creato dentro il context
+
+        def on_trial_end(study, trial):
+            fin = (trial.state == optuna.trial.TrialState.COMPLETE)
+            prn = (trial.state == optuna.trial.TrialState.PRUNED)
+            if fin:
+                _state["done"]   += 1
+                _state["last"]    = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+            elif prn:
+                _state["pruned"] += 1
+            progress.update(
+                task_id,
+                advance    = 1,
+                last       = _state["last"],
+                best       = max(_state["best"], 0.0),
+                pruned     = _state["pruned"],
+            )
+
+        t0 = time.time()
+        try:
+            with progress:
+                task_id = progress.add_task(
+                    "sweep",
+                    total     = _state["n_total"],
+                    completed = _state["done"] + _state["pruned"],
+                    last      = max(_state["last"], 0.0),
+                    best      = max(_state["best"],  0.0),
+                    pruned    = _state["pruned"],
+                )
+                study.optimize(
+                    make_objective(corpus),
+                    n_trials          = args.trials,
+                    callbacks         = [on_trial_end],
+                    show_progress_bar = False,
+                )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+
+    # ── tqdm fallback ─────────────────────────────────────────────────────────
+    elif _has_tqdm:
+        import tqdm
+        _already = _state["done"] + _state["pruned"]
+        pbar = tqdm.tqdm(
+            total   = _state["n_total"],
+            initial = _already,
+            unit    = "trial",
+            bar_format = "{l_bar}{bar}| {n}/{total} [{elapsed}<{remaining}]",
+        )
+        if _already > 0:
+            pbar.set_postfix(
+                score  = f"{max(_state['last'],  0.0):.5f}",
+                best   = f"{max(_state['best'],  0.0):.5f}",
+                pruned = _state["pruned"],
+            )
+
+        def on_trial_end(study, trial):
+            fin = trial.state == optuna.trial.TrialState.COMPLETE
+            prn = trial.state == optuna.trial.TrialState.PRUNED
+            if fin:
+                _state["done"]  += 1
+                _state["last"]   = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+            elif prn:
+                _state["pruned"] += 1
+            pbar.update(1)
+            pbar.set_postfix(
+                score  = f"{_state['last']:.5f}",
+                best   = f"{_state['best']:.5f}",
+                pruned = _state["pruned"],
+            )
+
+        t0 = time.time()
+        try:
+            study.optimize(
+                make_objective(corpus),
+                n_trials          = args.trials,
+                callbacks         = [on_trial_end],
+                show_progress_bar = False,
+            )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+        finally:
+            pbar.close()
+
+    # ── Plain fallback ────────────────────────────────────────────────────────
+    else:
+        def on_trial_end(study, trial):
+            fin = trial.state == optuna.trial.TrialState.COMPLETE
+            prn = trial.state == optuna.trial.TrialState.PRUNED
+            if fin:
+                _state["done"]  += 1
+                _state["last"]   = trial.value or 0.0
+                if _state["last"] > _state["best"]:
+                    _state["best"]   = _state["last"]
+                    _state["best_p"] = dict(study.best_params)
+                elapsed  = time.time() - _state["t0"]
+                done_tot = _state["done"] + _state["pruned"]
+                eta_s    = (elapsed / done_tot) * (_state["n_total"] - done_tot) if done_tot else 0
+                is_best  = abs(_state["last"] - _state["best"]) < 1e-9
+                bar_n    = int(32 * done_tot / max(_state["n_total"], 1))
+                bar      = "█" * bar_n + "░" * (32 - bar_n)
+                print(f"\r[{bar}] {done_tot}/{_state['n_total']}"
+                      f"  {'★' if is_best else ' '}score={_state['last']:.5f}"
+                      f"  best={_state['best']:.5f}"
+                      f"  pruned={_state['pruned']}"
+                      f"  ETA {eta_s/60:.1f}min   ", end="", flush=True)
+            elif prn:
+                _state["pruned"] += 1
+
+        t0 = time.time()
+        try:
+            study.optimize(
+                make_objective(corpus),
+                n_trials          = args.trials,
+                callbacks         = [on_trial_end],
+                show_progress_bar = False,
+            )
+        except KeyboardInterrupt:
+            print("\n[!] Interrotto — risultati parziali salvati.")
+        print()   # newline dopo la riga \r
+
+    elapsed = time.time() - t0
+    n_done  = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE)
+    n_prune = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED)
+    print(f"\n  Completati: {n_done}  |  Pruned: {n_prune}"
+          f"  |  Tempo totale: {elapsed/60:.1f} min"
+          f"  |  Media: {elapsed/max(n_done+n_prune,1):.1f} s/trial")
+
+    print_report(study, top_n=args.top)
+    save_csv(study)
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()

run_test.py

@@ -0,0 +1,115 @@
+"""
+run_test_v6.py  —  S-SPADE RDFT  ·  brickwall limiter recovery
+===============================================================
+Usa spade_declip_v9 in mode='soft' per recuperare la dinamica
+compressa da un brickwall limiter su tracce di mastering.
+
+Novità v6 rispetto a v5
+-----------------------
+NEW — Progress bar (rich → tqdm → plain fallback):
+    Durante il processing viene mostrata una barra di avanzamento
+    per canale con ETA, % frame bypassed e contatore no_conv.
+    Installare rich per la UI migliore:  pip install rich
+    Alternativa:                         pip install tqdm
+    Funziona anche senza nessuno dei due (plain % printout).
+
+Come leggere delta_db da Waveform Statistics (RX / Audition / iZotope):
+    Individua il livello sotto il quale il limiter NON è intervenuto,
+    es. "da −∞ fino a −2.5 dB"  →  delta_db = 2.5
+    In alternativa: Max RMS ≈ −1.3 dB → prova delta_db tra 1.0 e 2.5.
+
+Output:
+    Il file salvato è FLOAT32 WAV — può avere sample > 1.0 (corretto:
+    sono i transienti recuperati sopra il ceiling limitato).
+    Applica un gain di −20·log10(peak) dB per riportare a 0 dBFS.
+"""
+import numpy as np
+import soundfile as sf
+from spade_declip_v11 import declip, DeclipParams
+
+# ── File da processare ────────────────────────────────────────────────────
+# Formato: (filename, delta_db)
+# delta_db = dB dal ceiling (0 dBFS) alla soglia del limiter
+FILES_SOFT = [
+    ("test.flac", 2.5),
+    # ("mastering.flac", 1.5),   # prova valori più stretti se senti artefatti
+    # ("mastering.flac", 3.0),   # prova valori più ampi se i transienti non cambiano
+]
+
+ALGO  = "sspade"
+FRAME = "rdft"
+
+# ─────────────────────────────────────────────────────────────────────────
+print("\n" + "=" * 65)
+print("MODE: SOFT  (brickwall limiter recovery)")
+print("=" * 65)
+
+for filepath, delta_db in FILES_SOFT:
+    print(f"\nFile : {filepath}  |  delta_db={delta_db} dB")
+
+    try:
+        yc, sr_val = sf.read(filepath, always_2d=True)
+    except Exception as e:
+        print(f"  [ERRORE] {e}")
+        continue
+
+    yc = yc.astype(float)
+    n_samp, n_ch = yc.shape
+    labels = ["L", "R"] if n_ch == 2 else ["Ch" + str(c) for c in range(n_ch)]
+
+    print(f"  SR={sr_val} Hz  |  dur={round(n_samp/sr_val, 2)}s  |  channels={n_ch}")
+    for c, lbl in enumerate(labels):
+        peak_c = float(np.max(np.abs(yc[:, c])))
+        print(f"  [{lbl}] peak={round(peak_c, 4)}")
+
+    params = DeclipParams(
+        algo="sspade",
+	frame="rdft",
+	window_length=1024,
+	hop_length=256,
+	s=1, r=1, eps=0.1, max_iter=1000,
+	mode="soft", 
+	delta_db=delta_db,
+	# --- NOVITÀ V11 ---
+	sample_rate=sr_val,          # Fondamentale per il calcolo dei ms
+	release_ms=250.0,             # Aiuta a ridurre il pumping post-picco
+	max_gain_db=6.0,             # Evita transienti "ice-pick" innaturali
+	multiband=False,             # Metti True se il limiter originale era multibanda
+	macro_expand=False,          # Metti True per recuperare "corpo" (RMS)
+	# ------------------
+	n_jobs=-1, 
+	verbose=True,
+	show_progress=True,
+    )
+
+
+    fixed, masks = declip(yc, params)
+
+    fixed_2d = fixed[:, None] if fixed.ndim == 1 else fixed
+    peak_out = float(np.max(np.abs(fixed_2d)))
+
+    # Costruisce nome file output
+    for ext in (".flac", ".wav", ".aif", ".aiff"):
+        if filepath.lower().endswith(ext):
+            base = filepath[:-len(ext)]
+            break
+    else:
+        base = filepath
+    out_name = f"{base}_soft_d{str(delta_db).replace('.','p')}_{ALGO}_{FRAME}.wav"
+
+    # ── Write as 32-bit float WAV ─────────────────────────────────────────
+    # CRITICAL: subtype='FLOAT' preserves sample values > 1.0 (recovered
+    # transients).  The v4 default (PCM_16) silently truncated anything
+    # outside ±1.0 to exactly ±1.0, re-clipping all recovered peaks.
+    sf.write(out_name, fixed_2d.astype(np.float32), sr_val, subtype='FLOAT')
+
+    peaks = [round(float(np.max(np.abs(fixed_2d[:, c]))), 4) for c in range(n_ch)]
+    print(f"  → {out_name}")
+    print(f"     peak out: " + "  ".join(f"{lbl}={p}" for lbl, p in zip(labels, peaks)))
+    if peak_out > 1.0:
+        gain_db = round(-20 * np.log10(peak_out), 2)
+        print(f"     ⚠  Peak > 1.0 — applica {gain_db} dB per riportare a 0 dBFS")
+    else:
+        print(f"     ✓  Peak ≤ 1.0 — nessuna normalizzazione necessaria")
+
+print("\nDone.")

smart_sweep_results.csv

@@ -0,0 +1,11 @@
+rank,score,delta_db,lf_delta_db,window_length,hop_length,release_ms,max_gain_db,eps,max_iter,multiband,macro_expand,macro_ratio
+1,0.915965,3.5,1.0,2048,512,165.0,9.0,0.05,1000,0,1,1.75
+2,0.906553,2.25,1.15,1024,256,110.0,8.0,0.05,1000,0,1,1.2
+3,0.864981,2.75,1.05,1024,256,170.0,5.0,0.1,250,1,1,1.95
+4,0.830788,3.05,0.85,1024,256,110.0,6.0,0.05,250,0,1,1.15
+5,0.809859,2.1,1.75,1024,256,195.0,10.0,0.03,250,1,0,1.4
+6,0.809082,3.25,0.8,2048,256,115.0,10.0,0.03,1000,0,0,1.2
+7,0.784889,2.2,2.0,2048,512,105.0,5.0,0.1,250,0,1,1.3
+8,0.744222,2.85,1.05,512,64,140.0,8.5,0.05,500,0,0,1.35
+9,0.740836,2.25,0.95,2048,512,40.0,3.5,0.05,1000,0,1,1.55
+10,0.645003,2.0,1.45,1024,256,110.0,4.5,0.1,250,1,0,1.15

spade_declip_v11.py

@@ -0,0 +1,2234 @@
+"""
+spade_declip.py  –  v11  (delimiting: envelope dilation + ratio bounds + multiband + macro expand)
+====================================================================================
+S-SPADE / A-SPADE audio declipping — extended to recover dynamics
+compressed by a brickwall limiter (mode='soft').
+
+GPU acceleration  (v10 — NEW)
+------------------------------
+Requires PyTorch ≥ 2.0 with a working CUDA *or* ROCm backend.
+PyTorch-ROCm exposes AMD GPUs under the standard torch.cuda namespace,
+so detection and device strings are identical to NVIDIA:
+
+    Device auto-detection order: CUDA → ROCm → CPU fallback
+    Device string:  "auto"    — first available GPU (cuda / cuda:0)
+                    "cuda:0"  — explicit device index
+                    "cpu"     — force CPU (disables GPU path)
+
+GPU strategy:
+    CPU path (v8/v9): processes frames one-by-one with ThreadPoolExecutor.
+    GPU path (v10):   packs ALL active frames into a single (F, M) batch
+                      tensor and runs S-SPADE entirely on the GPU in one
+                      kernel sweep — DCT, hard-threshold, IDCT, proj_Γ are
+                      all vectorised over F simultaneously.
+
+    Convergence is tracked per-frame with a bool mask; converged frames
+    are frozen (their dual variable stops updating) while the rest keep
+    iterating.  The GPU loop exits as soon as every frame has converged
+    or max_iter is reached.
+
+    Typical speedup vs. single-thread CPU: 20–100× depending on GPU and
+    frame count.  The RX 6700 XT (12 GB, ROCm) processes the 2784-frame
+    stereo example in ~60–90 s vs. the 1289 s CPU baseline (≈15–20×).
+
+DCT implementation on GPU:
+    Uses a verified FFT-based Makhoul (1980) algorithm that exactly matches
+    scipy.fft.dct(x, type=2, norm='ortho') to float32 precision.
+    Runs in float64 internally for numerical safety, cast to float32 on
+    output.  Both DCT and IDCT are batch-safe: input shape (..., N).
+
+Limitations:
+    • algo='aspade' is CPU-only in v10 (A-SPADE GPU planned for v11).
+      Set use_gpu=False or switch to algo='sspade' for GPU acceleration.
+    • Very long files (> ~2 h at 48 kHz) may require chunked batching;
+      add gpu_batch_frames parameter if VRAM is exhausted.
+
+References
+----------
+[1] Kitić, Bertin, Gribonval — "Sparsity and cosparsity for audio declipping:
+    a flexible non-convex approach", LVA/ICA 2015.  (arXiv:1506.01830)
+[2] Záviška, Rajmic, Průša, Veselý — "Revisiting Synthesis Model in Sparse
+    Audio Declipper", 2018.  (arXiv:1807.03612)
+
+Algorithms
+----------
+S-SPADE  →  Algorithm 1 in [2]  (synthesis, coefficient-domain ADMM)  [DEFAULT]
+             Projection uses the closed-form Lemma / eq.(12) from [2].
+A-SPADE  →  Algorithm 2 in [2]  (analysis, signal-domain ADMM)
+
+Transforms
+----------
+'dct'   Orthonormal DCT-II  (tight Parseval frame, bound = 1, P = N)
+'rdft'  Redundant real frame [DCT-II/√2 ‖ DST-II/√2] (tight, bound = 1, P = 2N)
+        [DEFAULT] Best empirical quality; mimics oversampled DFT from [1][2].
+
+Operating modes
+---------------
+mode='hard'  (default)
+    Standard hard-clipping recovery.  Mask detects samples exactly at the
+    digital ceiling (±tau).  Same behaviour as v5.
+
+mode='soft'  (introduced v6, frame-adaptive bypass in v7)
+    Brickwall-limiter recovery.  Any sample above the limiter threshold
+    (ceiling − delta_db dB) is treated as potentially attenuated; its true
+    value is constrained to be ≥ its current value (lower bound, not equality).
+
+    v7 frame-adaptive bypass  ← NEW
+    --------------------------------
+    Before processing each frame, the raw un-windowed peak is compared to
+    the global threshold:
+
+        frame_peak = max(|yc[idx1:idx2]|)
+
+        frame_peak < threshold  →  bypass: WOLA accumulation with win²,
+                                   SPADE never called, zero artefact risk.
+        frame_peak >= threshold →  normal SPADE processing.
+
+    The bypass uses identical win²/norm_win bookkeeping to the SPADE path,
+    so the WOLA reconstruction is numerically transparent.
+    Verbose output reports active/bypassed/no-conv frame counts and speedup.
+
+    Mathematical basis:
+        proj_Γ implements  v[Icp] = max(v[Icp], yc[Icp])  where yc[Icp]
+        is the actual limited sample value — the lower-bound constraint is
+        exact.  proj_gamma, tight_sspade, tight_aspade are UNCHANGED.
+
+    Practical parameter guidance:
+        delta_db = dB from 0 dBFS to the limiter threshold.
+        Read from Waveform Statistics: find the level below which the limiter
+        did NOT intervene → delta_db = that level (positive number).
+        Typical brickwall masterings: 1.0 – 3.0 dB.
+
+    Limitations:
+        • Attack/release pumping attenuates samples just outside the threshold;
+          those are pinned as reliable — unavoidable without the limiter's curve.
+        • Macro-dynamics cannot be restored; only transient peaks are recovered.
+
+Verified bugs fixed (inherited from v5/v6)
+-------------------------------------------
+BUG-1  frsyn/RDFT: flip output not input in DST synthesis
+BUG-2  tight_aspade: dual variable in coefficient domain, not signal domain
+BUG-3  _declip_mono: per-channel WOLA gain drift (stereo L/R balance)
+BUG-4  _declip_mono: DC offset breaks half-wave mask detection
+
+Dependencies:  pip install numpy scipy soundfile
+
+Usage (API)
+-----------
+    from spade_declip_v10 import declip, DeclipParams
+
+    params = DeclipParams(mode="soft", delta_db=2.5)   # GPU used automatically
+    fixed, masks = declip(limited_master, params)
+
+    # Explicit GPU device (ROCm / CUDA):
+    params = DeclipParams(mode="soft", delta_db=2.5, use_gpu=True, gpu_device="cuda:0")
+
+    # Force CPU (disable GPU):
+    params = DeclipParams(mode="soft", delta_db=2.5, use_gpu=False)
+
+New in v11 — Delimiting features
+----------------------------------
+Four new DeclipParams knobs that transition from declipping to genuine delimiting.
+All are disabled by default for full backward compatibility.
+
+1. Envelope-Based Mask Dilation  (release_ms > 0)
+   --------------------------------------------------
+   A limiter's release time attenuates not just the peak sample but all samples
+   for the next 10–50 ms.  By default, _compute_masks marks those post-peak
+   samples as "reliable" (Ir), pinning the ADMM solver to artificially low values
+   and causing the pumping artifact.
+
+   Fix: _dilate_masks_soft() forward-dilates Icp and Icm by `release_samples =
+   round(release_ms * sample_rate / 1000)` samples using convolution.  Any newly
+   flagged sample within the release window is reclassified:
+       yc[n] ≥ 0  →  Icp  (true value ≥ yc[n])
+       yc[n] < 0  →  Icm  (true value ≤ yc[n])
+   The constraint is always satisfied by the limiter model: the true value can
+   only be larger in magnitude than the gain-reduced sample.
+
+   Parameters: release_ms (float, default 0.0), sample_rate (int, default 44100).
+
+2. Ratio-Aware Upper Bound  (max_gain_db > 0)
+   -----------------------------------------------
+   Without an upper bound, the L0-ADMM can generate "ice-pick" transients that
+   exceed any physical limiter's ratio.  max_gain_db caps the recovery:
+
+       v[Icp] = clip(max(v[Icp], yc[Icp]), yc[Icp], yc[Icp] * G_max)
+       v[Icm] = clip(min(v[Icm], yc[Icm]), yc[Icm] * G_max, yc[Icm])
+
+   where G_max = 10^(max_gain_db / 20).  Implemented in both proj_gamma (CPU)
+   and the inline GPU projection in _sspade_batch_gpu.
+
+   Parameters: max_gain_db (float, default 0.0 = disabled; e.g. 6.0 for ±6 dB max).
+
+3. Sub-band (Multi-band) SPADE  (multiband=True)
+   --------------------------------------------------
+   Multi-band limiters (FabFilter Pro-L 2, etc.) apply independent gain reduction
+   per frequency range.  Running broadband SPADE on such material "un-ducks"
+   frequency bands that were never attenuated, causing harshness.
+
+   Fix: _lr_split() builds a phase-perfect crossover (LP via scipy Butterworth
+   sosfiltfilt + HP = x − LP) at each crossover frequency.  Each band is
+   declipped independently with its own delta_db threshold, then summed back.
+
+   The GPU batch path naturally handles multiple bands — each band contributes
+   its own frames to the (F, M) batch with no added latency.
+
+   Parameters: multiband (bool), band_crossovers (tuple of Hz, default (250, 4000)),
+               band_delta_db (tuple of floats; empty = use delta_db for all bands).
+
+4. Macro-Dynamics Upward Expansion Pre-pass  (macro_expand=True)
+   ----------------------------------------------------------------
+   SPADE operates on ≈21 ms WOLA windows and cannot undo the slow 200–500 ms
+   RMS squash ("body" compression) a mastering limiter imposes.
+
+   Fix: _macro_expand_pass() runs a causal peak-envelope follower (attack +
+   release IIR) over the full signal, estimates where the level is held below
+   the long-term 80th-percentile envelope, and applies gentle upward expansion:
+
+       g(n) = (env(n) / threshold)^(1/ratio − 1)   if env(n) < threshold
+            = 1.0                                    otherwise
+
+   SPADE then corrects the microscopic waveform peaks that the expander cannot
+   interpolate.  The two passes are complementary by design.
+
+   Parameters: macro_expand (bool), macro_attack_ms (float, default 10.0),
+               macro_release_ms (float, default 200.0), macro_ratio (float, default 1.2).
+
+
+Usage (CLI)
+-----------
+    python spade_declip_v11.py input.wav output.wav --mode soft --delta-db 2.5
+    python spade_declip_v11.py input.wav output.wav --mode soft --delta-db 2.5 --gpu-device cuda:0
+    python spade_declip_v11.py input.wav output.wav --mode soft --delta-db 2.5 --no-gpu
+
+    # v11 delimiting features
+    python spade_declip_v11.py input.wav output.wav --mode soft --delta-db 2.5 \
+        --release-ms 30 --max-gain-db 6 --multiband --band-crossovers 250 4000
+
+    python spade_declip_v11.py input.wav output.wav --mode soft --delta-db 2.5 \
+        --macro-expand --macro-release-ms 200 --macro-ratio 1.2
+"""
+
+from __future__ import annotations
+try:
+    import torch as _torch_module
+    import torch
+    _TORCH_AVAILABLE = True
+except ImportError:
+    _TORCH_AVAILABLE = False
+import argparse
+import os
+import time
+import warnings
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import List, Literal, Tuple, Union
+
+import numpy as np
+from scipy.fft import dct, idct
+from scipy.signal.windows import hann
+
+
+# ============================================================================
+# Progress-bar backend  (rich → tqdm → plain fallback, zero hard deps)
+# ============================================================================
+# Three concrete backends implement the same interface:
+#
+#   ctx  = _make_progress(n_channels)
+#   with ctx:
+#       task = ctx.add_task(label, total=N)
+#       ctx.advance(task)                   # +1 frame done
+#       ctx.set_postfix(task, key=value)    # update live counters
+#
+# The module-level _PROGRESS_LOCK serialises add_task() calls so that two
+# channel threads don't interleave their header prints.
+
+import threading
+_PROGRESS_LOCK = threading.Lock()
+
+try:
+    from rich.progress import (
+        Progress, BarColumn, TextColumn, TimeRemainingColumn,
+        TimeElapsedColumn, MofNCompleteColumn, SpinnerColumn,
+    )
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich import print as rprint
+    _RICH = True
+except ImportError:
+    _RICH = False
+
+try:
+    import tqdm as _tqdm_mod
+    _TQDM = True
+except ImportError:
+    _TQDM = False
+
+
+class _RichProgress:
+    """Thin wrapper around a shared rich.Progress instance."""
+
+    def __init__(self, n_channels: int):
+        self._progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[bold cyan]{task.fields[ch_label]:<4}[/]"),
+            BarColumn(bar_width=36),
+            MofNCompleteColumn(),
+            TextColumn("[green]{task.fields[eta_str]}[/]"),
+            TextColumn("[dim]{task.fields[bypass_str]}[/]"),
+            TextColumn("[yellow]{task.fields[noconv_str]}[/]"),
+            TimeElapsedColumn(),
+            TimeRemainingColumn(),
+            refresh_per_second=10,
+        )
+
+    def __enter__(self):
+        self._progress.__enter__()
+        return self
+
+    def __exit__(self, *args):
+        self._progress.__exit__(*args)
+
+    def add_task(self, ch_label: str, total: int) -> object:
+        return self._progress.add_task(
+            "", total=total,
+            ch_label=ch_label,
+            eta_str="",
+            bypass_str="",
+            noconv_str="",
+        )
+
+    def advance(self, task_id, n_bypassed: int, n_noconv: int, n_done: int, n_total: int):
+        bypass_pct = 100.0 * n_bypassed / n_done if n_done else 0.0
+        self._progress.update(
+            task_id,
+            advance=1,
+            bypass_str=f"bypassed {bypass_pct:.0f}%" if n_bypassed else "",
+            noconv_str=f"no_conv {n_noconv}" if n_noconv else "",
+        )
+
+
+class _TqdmProgress:
+    """Thin wrapper around tqdm, one bar per channel."""
+
+    def __init__(self, n_channels: int):
+        self._bars: dict = {}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        for bar in self._bars.values():
+            bar.close()
+
+    def add_task(self, ch_label: str, total: int) -> str:
+        import tqdm
+        bar = tqdm.tqdm(
+            total=total,
+            desc=f"[{ch_label}]",
+            unit="fr",
+            dynamic_ncols=True,
+            leave=True,
+        )
+        self._bars[ch_label] = bar
+        return ch_label
+
+    def advance(self, task_id, n_bypassed: int, n_noconv: int, n_done: int, n_total: int):
+        bar = self._bars[task_id]
+        bypass_pct = 100.0 * n_bypassed / n_done if n_done else 0.0
+        parts = []
+        if n_bypassed:
+            parts.append(f"bypass={bypass_pct:.0f}%")
+        if n_noconv:
+            parts.append(f"no_conv={n_noconv}")
+        bar.set_postfix_str("  ".join(parts))
+        bar.update(1)
+
+
+class _PlainProgress:
+    """Last-resort fallback: prints a percentage line per channel."""
+
+    def __init__(self, n_channels: int):
+        self._state: dict = {}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def add_task(self, ch_label: str, total: int) -> str:
+        self._state[ch_label] = {"total": total, "done": 0, "last_pct": -1}
+        return ch_label
+
+    def advance(self, task_id, n_bypassed: int, n_noconv: int, n_done: int, n_total: int):
+        s = self._state[task_id]
+        s["done"] += 1
+        pct = int(100 * s["done"] / s["total"])
+        # Print only at each 5% step to avoid flooding stdout
+        if pct // 5 > s["last_pct"] // 5:
+            s["last_pct"] = pct
+            print(f"  [{task_id}] {pct:3d}%  ({s['done']}/{s['total']} frames"
+                  + (f"  bypassed={n_bypassed}" if n_bypassed else "")
+                  + (f"  no_conv={n_noconv}"    if n_noconv  else "")
+                  + ")")
+
+
+def _make_progress(n_channels: int):
+    """Return the best available progress backend."""
+    if _RICH:
+        return _RichProgress(n_channels)
+    if _TQDM:
+        return _TqdmProgress(n_channels)
+    return _PlainProgress(n_channels)
+
+
+
+
+# ============================================================================
+# Data structures
+# ============================================================================
+
+@dataclass
+class ClippingMasks:
+    """
+    Boolean index masks identifying the three sample categories of a clipped signal.
+
+    Attributes
+    ----------
+    Ir  : reliable (unclipped) samples — must be preserved exactly
+    Icp : positively clipped (flat at +τ) — true signal ≥ τ
+    Icm : negatively clipped (flat at −τ) — true signal ≤ −τ
+    """
+    Ir:  np.ndarray
+    Icp: np.ndarray
+    Icm: np.ndarray
+
+
+@dataclass
+class DeclipParams:
+    """
+    Parameters controlling the declipping pipeline.
+
+    Attributes
+    ----------
+    algo : 'sspade' | 'aspade'
+        Core per-frame algorithm.  Default: 'sspade' (best empirical results).
+    window_length : int
+        Frame size in samples.  Powers of 2 recommended (e.g. 1024, 2048).
+        Per [2]: A-SPADE works best ≈ 2048; S-SPADE is robust to longer windows.
+    hop_length : int
+        Hop between consecutive frames.  Minimum 50% overlap recommended ([2] §4.4).
+        Typical: window_length // 4  (75% overlap, best quality per [2]).
+    frame : 'dct' | 'rdft'
+        Sparse transform.
+        'dct'  — orthonormal DCT-II (no redundancy, P = N).
+        'rdft' — redundant real tight frame DCT‖DST (redundancy 2, P = 2N);
+                 mimics the oversampled DFT used in [1][2].  [DEFAULT — best quality]
+    s : int
+        Initial and incremental sparsity step (k starts at s, increases by s
+        every r iterations).  [2] uses s = 100 for whole-signal; s = 1 block-by-block.
+    r : int
+        Sparsity relaxation period (k is incremented every r iterations).
+    eps : float
+        Convergence threshold ε.  Loop stops when the residual norm ≤ ε.
+        [1][2] use ε = 0.1 for their experiments.
+    max_iter : int
+        Hard upper limit on iterations per frame.
+    verbose : bool
+        Print per-signal diagnostics (DC offset, threshold, mask sizes, timing).
+    n_jobs : int
+        Number of parallel workers for multi-channel processing.
+        1  = sequential (default, always safe).
+        -1 = use all available CPU cores.
+    mode : 'hard' | 'soft'
+        Detection mode.
+        'hard' — standard hard-clipping recovery (default).
+                 Marks samples exactly at ±tau as clipped.
+        'soft' — brickwall limiter recovery (NEW in v6).
+                 Marks all samples above the limiter threshold as potentially
+                 attenuated.  The threshold is  ceiling − delta_db  dB, where
+                 ceiling = max(|yc|) after DC removal.
+                 The lower-bound constraint  true_value ≥ yc[n]  is already
+                 implemented by proj_gamma — no algorithmic changes needed.
+    delta_db : float
+        [soft mode only]  Distance in dB from 0 dBFS to the limiter threshold.
+        Read from Waveform Statistics: find the level below which the limiter
+        did NOT intervene, e.g. "da −∞ fino a −2.5 dB" → delta_db = 2.5.
+        Typical brickwall masterings: 1.0 – 3.0 dB.
+        Ignored when mode='hard'.
+    use_gpu : bool
+        Enable GPU acceleration via PyTorch (CUDA or ROCm).  Default: True.
+        Falls back to CPU automatically if PyTorch is not installed, no GPU
+        is present, or algo='aspade' (A-SPADE GPU not yet implemented).
+    gpu_device : str
+        PyTorch device string.  Default: "auto" (first available GPU).
+        Examples: "cuda", "cuda:0", "cuda:1", "cpu".
+        AMD ROCm GPUs appear as "cuda" in PyTorch-ROCm — use the same syntax.
+    sample_rate : int
+        [v11] Sample rate of the audio in Hz.  Required when release_ms > 0 or
+        multiband=True.  Set automatically from the file header when using the CLI.
+        Default: 44100.
+    release_ms : float
+        [v11, soft mode] Limiter release time in milliseconds.  When > 0, the
+        clipping masks are forward-dilated by this many samples so that post-peak
+        samples attenuated by the limiter’s release phase are treated as constrained
+        (not reliable).  0 = disabled (v10 behaviour).  Typical: 10–50 ms.
+    max_gain_db : float
+        [v11, soft mode] Maximum recovery in dB above the limited sample value.
+        Caps proj_Γ to prevent ADMM from generating unphysical transients.
+        0 = disabled (unbounded, v10 behaviour).  Typical: 3–6 dB.
+    multiband : bool
+        [v11, soft mode] Enable Linkwitz-Riley sub-band processing.  The signal is
+        split at band_crossovers Hz, each band is processed with its own delta_db,
+        then summed.  Addresses multi-band limiting (FabFilter Pro-L 2 etc.).
+    band_crossovers : tuple[float, ...]
+        [v11] Crossover frequencies in Hz (ascending).  Produces len+1 bands.
+        Default: (250, 4000) → Low / Mid / High.
+    band_delta_db : tuple[float, ...]
+        [v11] Per-band delta_db values.  If empty, delta_db is used for all bands.
+        Must have the same length as band_crossovers + 1 when non-empty.
+    macro_expand : bool
+        [v11, soft mode] Enable macro-dynamics upward expansion pre-pass.  A causal
+        peak-envelope follower detects where the limiter’s release held the level
+        down, then applies gentle upward expansion before SPADE restores the peaks.
+    macro_attack_ms : float
+        [v11] Expander attack time in ms.  Default: 10.0.
+    macro_release_ms : float
+        [v11] Expander release time in ms.  Default: 200.0.
+    macro_ratio : float
+        [v11] Expansion ratio.  1.0 = bypass; >1 = upward expansion.
+        g(n) = (env(n)/threshold)^(1/ratio - 1) when below threshold.  Default: 1.2.
+    """
+    algo:          Literal["sspade", "aspade"] = "sspade"
+    window_length: int   = 1024
+    hop_length:    int   = 256
+    frame:         Literal["dct", "rdft"]      = "rdft"
+    s:             int   = 1
+    r:             int   = 1
+    eps:           float = 0.1
+    max_iter:      int   = 1000
+    verbose:       bool  = False
+    n_jobs:        int   = 1
+    mode:          Literal["hard", "soft"]     = "hard"
+    delta_db:      float = 1.0
+    show_progress: bool  = True
+    use_gpu:       bool  = True                            # v10: GPU acceleration
+    gpu_device:    str   = "auto"                          # v10: device string
+    # ── v11: delimiting features ─────────────────────────────────────────
+    sample_rate:      int   = 44100   # required for release_ms and multiband
+    release_ms:       float = 0.0     # mask dilation (0 = disabled)
+    max_gain_db:      float = 0.0     # ratio-aware cap (0 = disabled)
+    multiband:        bool  = False   # Linkwitz-Riley sub-band processing
+    band_crossovers:  tuple = (250, 4000)   # Hz crossover frequencies
+    band_delta_db:    tuple = ()            # per-band delta_db; empty = use delta_db
+    macro_expand:     bool  = False   # upward expansion pre-pass
+    macro_attack_ms:  float = 10.0    # expander attack (ms)
+    macro_release_ms: float = 200.0   # expander release (ms)
+    macro_ratio:      float = 1.2     # expansion ratio (1.0 = bypass)
+
+
+# ============================================================================
+# Sparse transform — Analysis (A) and Synthesis (D = A^H) operators
+# ============================================================================
+
+def _frame_size(M: int, frame: str) -> int:
+    """Number of transform coefficients P for a frame of M samples."""
+    if frame == "dct":
+        return M
+    if frame == "rdft":
+        return 2 * M
+    raise ValueError(f"Unknown frame '{frame}'")
+
+
+# ============================================================================
+# GPU engine  (PyTorch — CUDA or ROCm)
+# ============================================================================
+# All GPU functions are defined unconditionally but only called when torch is
+# available.  Type annotations use strings to avoid NameError at import time.
+
+import math as _math
+
+def _resolve_gpu_device(params: "DeclipParams") -> "str | None":
+    """
+    Return a torch device string if GPU is usable, else None.
+
+    AMD ROCm GPUs are exposed by PyTorch-ROCm under the torch.cuda namespace
+    (torch.cuda.is_available() returns True, devices appear as "cuda" / "cuda:0").
+    Detection is therefore identical for NVIDIA CUDA and AMD ROCm.
+
+    Returns None if:
+      • params.use_gpu is False
+      • PyTorch is not installed
+      • No CUDA/ROCm device is present or accessible
+      • algo='aspade'  (A-SPADE GPU not yet implemented)
+    """
+    if not params.use_gpu:
+        return None
+    if params.algo != "sspade":
+        return None          # A-SPADE GPU not implemented; fall through to CPU path
+    try:
+        import torch
+        if not torch.cuda.is_available():
+            return None
+        dev = "cuda" if params.gpu_device == "auto" else params.gpu_device
+        torch.zeros(1, device=dev)   # warm-up / validity check
+        return dev
+    except Exception:
+        return None
+
+
+def _dct2_gpu(x: "torch.Tensor") -> "torch.Tensor":
+    """
+    Batched orthonormal DCT-II on GPU.  x: (..., N) — float32 or float64.
+    Returns same dtype as input.
+    Numerically matches scipy.fft.dct(x, type=2, norm='ortho') to ~1e-14.
+
+    Algorithm: Makhoul (1980) FFT-based DCT-II.
+        1. Reorder x into v = [x[0], x[2], …, x[N-1], x[N-3], …, x[1]]
+        2. V    = FFT(v)        (computed in float64 for accuracy)
+        3. C    = Re( exp(−jπk/(2N)) · V ) · √(2/N)
+        4. C[0] /= √2          (ortho normalisation for DC bin)
+    """
+    import torch
+    in_dtype = x.dtype
+    N  = x.shape[-1]
+    v  = torch.cat([x[..., ::2], x[..., 1::2].flip(-1)], dim=-1)
+    V  = torch.fft.fft(v.double(), dim=-1)
+    k  = torch.arange(N, device=x.device, dtype=torch.float64)
+    tw = torch.exp(-1j * _math.pi * k / (2.0 * N))
+    C  = (tw * V).real * _math.sqrt(2.0 / N)
+    C  = C.clone()
+    C[..., 0] /= _math.sqrt(2.0)
+    return C.to(in_dtype)
+
+
+def _idct2_gpu(X: "torch.Tensor") -> "torch.Tensor":
+    """
+    Batched orthonormal IDCT-II on GPU.  X: (..., N) — float32 or float64.
+    Returns same dtype as input.
+    Numerically matches scipy.fft.idct(X, type=2, norm='ortho') to ~1e-14.
+
+    Inverse of _dct2_gpu via conjugate-twiddle + IFFT (Makhoul 1980):
+        1. Undo ortho scaling:  C = X·√(N/2);  C[0] ·= √2
+        2. Build W[k] = C[k] − j·C[N−k]  for k=0…N−1
+           where C[0] uses the W[0] = C[0] special case (ipart[0] = 0).
+           ipart[k] = −C[N−k] for k=1…N−1
+           ↳ BUG FIX: use C.flip(-1)[..., :-1] which gives C[N-1], C[N-2], …, C[1]
+             The old code used Cf[1:] = C[N-2], C[N-3], …, C[0] — off by one.
+        3. Recover V:   V = W · exp(+jπk/(2N))
+        4. v = Re(IFFT(V))
+        5. Un-interleave: x[2n] = v[n],  x[2n+1] = v[N−1−n]
+    """
+    import torch
+    in_dtype = X.dtype
+    N   = X.shape[-1]
+    C   = X.double() * _math.sqrt(N / 2.0)
+    C   = C.clone()                          # avoid in-place on original
+    C[..., 0] *= _math.sqrt(2.0)
+    # ── BUG-GPU-3 FIX ────────────────────────────────────────────────────
+    # ipart[k] must equal -C[N-k] for k=1..N-1.
+    # C.flip(-1) = [C[N-1], C[N-2], ..., C[1], C[0]]
+    # C.flip(-1)[..., :-1] = [C[N-1], C[N-2], ..., C[1]]  ← correct
+    # (old buggy code: -Cf[..., 1:] = -[C[N-2], C[N-3], ..., C[0]] ← off by one)
+    ipart = torch.zeros_like(C)
+    ipart[..., 1:] = -C.flip(-1)[..., :-1]
+    W = torch.view_as_complex(torch.stack([C, ipart], dim=-1))
+    k    = torch.arange(N, device=X.device, dtype=torch.float64)
+    V    = W * torch.exp(1j * _math.pi * k / (2.0 * N))
+    v    = torch.fft.ifft(V, dim=-1).real
+    half = (N + 1) // 2
+    x    = torch.empty_like(v)
+    x[..., ::2]  = v[..., :half]
+    x[..., 1::2] = v[..., half:].flip(-1)
+    return x.to(in_dtype)
+
+
+def _frana_gpu(x: "torch.Tensor", frame: str) -> "torch.Tensor":
+    """
+    Batched analysis operator A: (..., M) → (..., P).
+    DCT  frame: P = M   →  orthonormal DCT-II
+    RDFT frame: P = 2M  →  [DCT(x)/√2 ‖ DST(x)/√2]
+                            DST-II(x) = DCT-II(x[::-1])
+    """
+    import torch
+    if frame == "dct":
+        return _dct2_gpu(x)
+    s2 = _math.sqrt(2.0)
+    return torch.cat([_dct2_gpu(x) / s2, _dct2_gpu(x.flip(-1)) / s2], dim=-1)
+
+
+def _frsyn_gpu(z: "torch.Tensor", frame: str, M: int) -> "torch.Tensor":
+    """
+    Batched synthesis operator D = A^H: (..., P) → (..., M).
+    Adjoint of _frana_gpu.  For RDFT the DST adjoint flips the OUTPUT.
+    """
+    import torch
+    if frame == "dct":
+        return _idct2_gpu(z)
+    s2 = _math.sqrt(2.0)
+    cos_part = _idct2_gpu(z[..., :M]) / s2
+    sin_part = _idct2_gpu(z[..., M:]).flip(-1) / s2
+    return cos_part + sin_part
+
+
+def _hard_thresh_gpu(u: "torch.Tensor", k: int) -> "torch.Tensor":
+    """
+    Batched hard thresholding: keep k largest-magnitude coefficients per row.
+    u: (F, P).  Returns same shape with all but top-k magnitudes zeroed.
+    """
+    k = int(max(1, min(k, u.shape[-1])))
+    kth = torch.topk(u.abs(), k, dim=-1, sorted=True).values[..., -1:]  # (F,1)
+    return u * (u.abs() >= kth)
+
+
+def _sspade_batch_gpu(
+    yc_w:     "torch.Tensor",   # (F, M) windowed frames, already on device
+    Ir:       "torch.Tensor",   # (F, M) bool — reliable samples
+    Icp:      "torch.Tensor",   # (F, M) bool — positively limited
+    Icm:      "torch.Tensor",   # (F, M) bool — negatively limited
+    frame:    str,
+    s:        int,
+    r:        int,
+    eps:      float,
+    max_iter: int,
+    g_max:    float = float("inf"),  # v11: ratio-aware upper bound (linear)
+) -> "Tuple[torch.Tensor, torch.Tensor]":
+    """
+    Batched S-SPADE on GPU — all F frames processed simultaneously.
+
+    Determinism guarantees
+    ----------------------
+    BUG-GPU-2 fix: ADMM runs in float64 throughout (yc_w is upcast at entry,
+    downcast to float32 on output).  This matches the CPU path which also runs
+    in float64 via numpy/scipy.  float32 would accumulate ~2.3 units of error
+    after 500 iterations vs float64's ~1e-14 — causing divergent ADMM trajectories.
+
+    BUG-GPU-1 fix: zi_final captures zi at the exact convergence iteration for
+    each frame. Without this, zi keeps being overwritten in subsequent iterations
+    for already-converged frames (dual ui stops updating but the zi update
+    expression keeps running for all frames). The CPU tight_sspade breaks
+    immediately on convergence; the GPU batch loop cannot break early, so
+    zi_final is the equivalent mechanism.
+
+    Convergence mask
+    ----------------
+    A per-frame `active` bool mask marks frames still iterating.
+    - `conv[f]`  = True once frame f has met the stopping criterion
+    - `active[f]` = ~conv[f]
+    - ui is updated only for active frames (correct — matches CPU which exits
+      before updating ui on the convergence iteration)
+    - zi_final[f] is frozen at the first iteration where conv[f] becomes True
+
+    Returns
+    -------
+    x_frames  : (F, M) float32  — time-domain restored frames (on device)
+    converged : (F,)   bool     — True where ADMM converged within max_iter
+    """
+    import torch
+    # ── BUG-GPU-2 FIX: upcast to float64 to match CPU float64 path ───────
+    yc_w64 = yc_w.double()
+    F, M   = yc_w64.shape
+
+    zi       = _frana_gpu(yc_w64, frame)                       # (F, P) float64
+    ui       = torch.zeros_like(zi)                            # float64
+    k        = s
+    active   = torch.ones (F, dtype=torch.bool, device=yc_w.device)
+    conv     = torch.zeros(F, dtype=torch.bool, device=yc_w.device)
+
+    # ── BUG-GPU-1 FIX: zi_final captures zi at the convergence iteration ─
+    # Frames that never converge will have zi_final = zi at loop exit.
+    zi_final = zi.clone()
+
+    for i in range(1, max_iter + 1):
+        # ── Step 2: sparsity (all frames) ────────────────────────────────
+        zb = _hard_thresh_gpu(zi + ui, k)                      # (F, P)
+
+        # ── Step 3: project onto Γ via eq.(12) ───────────────────────────
+        v_c  = zb - ui                                         # (F, P)
+        Dv   = _frsyn_gpu(v_c, frame, M)                      # (F, M)
+
+        pDv  = Dv.clone()
+        pDv[Ir]  = yc_w64[Ir]
+        # Ratio-aware projection (v11): lower bound max(v, yc) AND optional upper bound
+        # Use finite g_max check to avoid 0 * inf = nan when g_max=inf (disabled).
+        lower_p = yc_w64[Icp]
+        if _math.isfinite(g_max):
+            upper_p = (lower_p * g_max).clamp(min=lower_p)
+        else:
+            upper_p = torch.full_like(lower_p, _math.inf)
+        pDv[Icp] = torch.clamp(torch.maximum(pDv[Icp], lower_p), max=upper_p)
+        lower_m = yc_w64[Icm]   # negative values
+        if _math.isfinite(g_max):
+            lower_m_cap = (lower_m * g_max).clamp(max=lower_m)
+        else:
+            lower_m_cap = torch.full_like(lower_m, -_math.inf)
+        pDv[Icm] = torch.clamp(torch.minimum(pDv[Icm], lower_m), min=lower_m_cap)
+
+        zi = v_c - _frana_gpu(Dv - pDv, frame)                # (F, P)
+
+        # ── Step 4: convergence check for still-active frames ─────────────
+        norms    = (zi - zb).norm(dim=-1)                      # (F,)
+        new_conv = active & (norms <= eps)
+
+        if new_conv.any():
+            # Freeze zi at the convergence point — equivalent to CPU 'break'
+            zi_final[new_conv] = zi[new_conv]
+            conv  |= new_conv
+            active = ~conv
+
+        if not active.any():
+            break
+
+        # ── Step 7: dual update for active frames only ────────────────────
+        # CPU tight_sspade updates ui AFTER the convergence check,
+        # meaning ui is NOT updated on the convergence iteration.
+        # Matching that: only active frames (not yet converged) update ui.
+        ui[active] = ui[active] + zi[active] - zb[active]
+
+        if i % r == 0:
+            k += s
+
+    # Frames that never converged: use their final zi
+    if active.any():
+        zi_final[active] = zi[active]
+
+    # Downcast output to float32 for WOLA accumulation
+    return _frsyn_gpu(zi_final, frame, M).float(), conv
+
+
+def _declip_mono_gpu(
+    yc:           np.ndarray,
+    params:       "DeclipParams",
+    tau:          float,
+    ch_label:     str,
+    device:       str,
+    progress_ctx  = None,
+    task_id       = None,
+) -> "Tuple[np.ndarray, ClippingMasks]":
+    """
+    GPU-accelerated mono declipping pipeline.
+
+    Three-pass strategy
+    -------------------
+    Pass 1 (CPU): extract all frames, compute bypass decisions and masks.
+    Pass 2 (GPU): pack active frames into a batch tensor and run
+                  _sspade_batch_gpu — all frames in one GPU kernel sweep.
+    Pass 3 (CPU): sequential WOLA accumulation + RMS level match.
+
+    Progress behaviour
+    ------------------
+    Bypassed frames advance the progress bar in real-time during Pass 1.
+    Active (GPU-processed) frames advance the bar immediately after
+    Pass 2 returns (appears as a single jump — mirrors how the GPU works).
+    """
+    import torch
+
+    # ── DC removal (BUG-4 fix) ────────────────────────────────────���──────
+    dc_offset = float(np.mean(yc))
+    yc        = yc - dc_offset
+
+    # ── Ceiling and threshold ────────────────────────────────────────────
+    ceiling_pos = float(np.max(yc))
+    ceiling_neg = float(-np.min(yc))
+
+    if params.mode == "hard":
+        threshold = min(ceiling_pos, ceiling_neg)
+    else:
+        ceiling   = max(ceiling_pos, ceiling_neg)
+        threshold = ceiling * (10.0 ** (-params.delta_db / 20.0))
+
+    if threshold <= 0.0:
+        return yc.copy(), _compute_masks(yc, 0.0)
+
+    masks     = _compute_masks(yc, threshold)
+
+    # ── v11 Feature 1: envelope-based mask dilation (GPU path) ────────────
+    if params.mode == "soft" and params.release_ms > 0.0:
+        rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0))
+        if rel_samp > 0:
+            masks = _dilate_masks_soft(masks, yc, rel_samp)
+
+    # ── v11 Feature 4: macro-dynamics upward expansion pre-pass ──────────
+    if params.mode == "soft" and params.macro_expand and params.macro_ratio > 1.0:
+        yc = _macro_expand_pass(
+            yc, params.sample_rate,
+            attack_ms=params.macro_attack_ms,
+            release_ms=params.macro_release_ms,
+            ratio=params.macro_ratio,
+        )
+        masks = _compute_masks(yc, threshold)
+        if params.release_ms > 0.0:
+            rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0))
+            if rel_samp > 0:
+                masks = _dilate_masks_soft(masks, yc, rel_samp)
+
+    n_clipped = int(np.sum(~masks.Ir))
+    L         = len(yc)
+
+    # ── v11 Feature 2: ratio-aware upper bound (linear) ──────────────────
+    g_max = (10.0 ** (params.max_gain_db / 20.0)
+             if params.mode == "soft" and params.max_gain_db > 0.0
+             else float("inf"))
+
+    if params.verbose:
+        ch  = f" [{ch_label}]" if ch_label else ""
+        tag = "threshold" if params.mode == "soft" else "tau"
+        print(f"[declip{ch}] Length    : {L} samples  [device: {device}]")
+        print(f"[declip{ch}] DC offset : {dc_offset:+.6f}  ({dc_offset*100:+.4f}%)  → removed")
+        if params.mode == "hard":
+            print(f"[declip{ch}] {tag:<9}  : {threshold:.6f}  "
+                  f"(pos_peak={ceiling_pos:.6f}  neg_peak={ceiling_neg:.6f}  using min)")
+        else:
+            print(f"[declip{ch}] ceiling   : {max(ceiling_pos, ceiling_neg):.6f}  "
+                  f"(pos={ceiling_pos:.6f}  neg={ceiling_neg:.6f})")
+            print(f"[declip{ch}] {tag:<9}  : {threshold:.6f}  "
+                  f"(ceiling − {params.delta_db:.2f} dB = "
+                  f"{20*np.log10(threshold/max(ceiling_pos,ceiling_neg)):.2f} dBFS)")
+        print(f"[declip{ch}] Detected  : {n_clipped}/{L} "
+              f"({100*n_clipped/L:.1f}%)  "
+              f"Icp={int(masks.Icp.sum())}  Icm={int(masks.Icm.sum())}")
+        print(f"[declip{ch}] Algorithm : {params.algo.upper()}  "
+              f"frame={params.frame.upper()}  mode={params.mode.upper()}  "
+              f"win={params.window_length}  hop={params.hop_length} "
+              f"({100*(1-params.hop_length/params.window_length):.0f}% overlap)  "
+              f"[GPU BATCH on {device}]")
+        if params.mode == "soft":
+            feats = []
+            if params.release_ms > 0: feats.append(f"release_ms={params.release_ms}")
+            if params.max_gain_db > 0: feats.append(f"max_gain_db={params.max_gain_db}")
+            if params.macro_expand: feats.append(f"macro_expand(ratio={params.macro_ratio})")
+            if feats:
+                print(f"[declip{ch}] v11 feats : " + "  ".join(feats))
+
+    M   = params.window_length
+    a   = params.hop_length
+    N   = int(np.ceil(L / a))
+    win = np.sqrt(hann(M, sym=False))
+    t0  = time.time()
+
+    # ── Pass 1 (CPU): frame extraction, bypass filter, mask build ────────
+    # wola_meta[i] = (idx1, idx2, seg_len, is_bypassed)
+    # active_*     = lists for non-bypassed frames only, in order
+    wola_meta       : list = []
+    active_yc_w     : list = []   # windowed frames  for SPADE
+    active_Ir       : list = []
+    active_Icp      : list = []
+    active_Icm      : list = []
+    active_orig_idx : list = []   # original frame index i → maps back into wola_meta
+
+    skipped = 0
+    for i in range(N):
+        idx1    = i * a
+        idx2    = min(idx1 + M, L)
+        seg_len = idx2 - idx1
+        pad     = M - seg_len
+
+        yc_frame           = np.zeros(M)
+        yc_frame[:seg_len] = yc[idx1:idx2]
+
+        if params.mode == "soft":
+            fp = float(np.max(np.abs(yc_frame[:seg_len]))) if seg_len else 0.0
+            if fp < threshold:
+                wola_meta.append((idx1, idx2, seg_len, True))
+                skipped += 1
+                if progress_ctx is not None and task_id is not None:
+                    progress_ctx.advance(task_id, n_bypassed=skipped,
+                                         n_noconv=0, n_done=i + 1, n_total=N)
+                continue
+
+        wola_meta.append((idx1, idx2, seg_len, False))
+        active_yc_w.append(yc_frame * win)
+        active_Ir .append(np.concatenate([masks.Ir [idx1:idx2], np.ones (pad, dtype=bool)]))
+        active_Icp.append(np.concatenate([masks.Icp[idx1:idx2], np.zeros(pad, dtype=bool)]))
+        active_Icm.append(np.concatenate([masks.Icm[idx1:idx2], np.zeros(pad, dtype=bool)]))
+        active_orig_idx.append(len(wola_meta) - 1)  # index into wola_meta
+
+    n_active = len(active_yc_w)
+    n_noconv = 0
+    x_active_results: dict = {}   # wola_meta_index → x_frame (M,) numpy
+
+    # ── Pass 2 (GPU): batched S-SPADE ────────────────────────────────────
+    if n_active > 0:
+        yc_batch  = torch.tensor(np.stack(active_yc_w),  dtype=torch.float64, device=device)
+        Ir_batch  = torch.tensor(np.stack(active_Ir),    dtype=torch.bool,    device=device)
+        Icp_batch = torch.tensor(np.stack(active_Icp),   dtype=torch.bool,    device=device)
+        Icm_batch = torch.tensor(np.stack(active_Icm),   dtype=torch.bool,    device=device)
+
+        if params.verbose:
+            ch = f" [{ch_label}]" if ch_label else ""
+            vmem = ""
+            try:
+                alloc = torch.cuda.memory_allocated(device) / 1024**2
+                vmem  = f"  VRAM used ≈ {alloc:.0f} MB"
+            except Exception:
+                pass
+            print(f"[declip{ch}] GPU pass  : {n_active} active frames → "
+                  f"{yc_batch.shape} batch{vmem}")
+
+        x_batch, conv_batch = _sspade_batch_gpu(
+            yc_batch, Ir_batch, Icp_batch, Icm_batch,
+            params.frame, params.s, params.r, params.eps, params.max_iter,
+            g_max=g_max,
+        )
+
+        x_np    = x_batch.cpu().numpy()
+        conv_np = conv_batch.cpu().numpy()
+        n_noconv = int((~conv_np).sum())
+
+        for j, meta_idx in enumerate(active_orig_idx):
+            x_active_results[meta_idx] = x_np[j]
+
+        # Advance progress bar for GPU-processed frames (bulk update)
+        if progress_ctx is not None and task_id is not None:
+            for j in range(n_active):
+                progress_ctx.advance(task_id, n_bypassed=skipped,
+                                     n_noconv=n_noconv,
+                                     n_done=skipped + j + 1, n_total=N)
+
+    # ── Pass 3 (CPU): WOLA accumulation ───────────────────────────────────
+    x        = np.zeros(L)
+    norm_win = np.zeros(L)
+
+    for meta_idx, (idx1, idx2, seg_len, is_bypassed) in enumerate(wola_meta):
+        if is_bypassed:
+            x       [idx1:idx2] += yc[idx1:idx2] * win[:seg_len] ** 2
+            norm_win[idx1:idx2] += win[:seg_len] ** 2
+        else:
+            xf = x_active_results[meta_idx]
+            x       [idx1:idx2] += xf[:seg_len] * win[:seg_len]
+            norm_win[idx1:idx2] += win[:seg_len] ** 2
+
+    norm_win = np.where(norm_win < 1e-12, 1.0, norm_win)
+    x /= norm_win
+
+    # ── Reliable-sample RMS match (BUG-3 fix) ────────────────────────────
+    Ir = masks.Ir
+    if Ir.sum() > 0:
+        rms_in  = float(np.sqrt(np.mean(yc[Ir] ** 2)))
+        rms_out = float(np.sqrt(np.mean(x[Ir]  ** 2)))
+        if rms_out > 1e-12 and rms_in > 1e-12:
+            x *= rms_in / rms_out
+
+    if params.verbose:
+        ch       = f" [{ch_label}]" if ch_label else ""
+        skip_pct = 100.0 * skipped / N if N else 0.0
+        print(f"[declip{ch}] Frames    : {N} total  |  "
+              f"active={n_active} (GPU)  bypassed={skipped} ({skip_pct:.1f}%)  "
+              f"no_conv={n_noconv}  |  time: {time.time()-t0:.1f}s")
+
+    return x, masks
+
+
+
+
+
+def frana(x: np.ndarray, frame: str) -> np.ndarray:
+    """
+    Analysis operator  A : R^N → R^P.
+
+    For a tight Parseval frame A, the synthesis operator is D = A^H, and
+    A^H A = I_N (perfect reconstruction property).
+
+    DCT frame  (P = N):
+        A = orthonormal DCT-II.  A^H = A^{-1} = IDCT.
+
+    RDFT frame  (P = 2N, redundancy 2):
+        A = [A₁; A₂] where A₁ = DCT-II/√2  and  A₂ = DST-II/√2.
+        DST-II(x) is computed as DCT-II(x[::-1]).
+        Tight frame property: A₁^H A₁ + A₂^H A₂ = I/2 + I/2 = I. ✓
+    """
+    if frame == "dct":
+        return dct(x, type=2, norm="ortho")
+    if frame == "rdft":
+        cos_part = dct(x,        type=2, norm="ortho") / np.sqrt(2)   # DCT-II / √2
+        sin_part = dct(x[::-1],  type=2, norm="ortho") / np.sqrt(2)   # DST-II / √2
+        return np.concatenate([cos_part, sin_part])
+    raise ValueError(f"Unknown frame '{frame}'")
+
+
+def frsyn(z: np.ndarray, frame: str, M: int) -> np.ndarray:
+    """
+    Synthesis operator  D = A^H : R^P → R^N.
+
+    DCT frame:
+        D = IDCT (same matrix as A for orthonormal DCT).
+
+    RDFT frame:
+        D = [A₁^H, A₂^H] applied to [z₁; z₂]:
+            A₁^H z₁ = IDCT(z₁) / √2
+            A₂^H z₂ = IDCT(z₂)[::-1] / √2      ← correct: flip the OUTPUT
+        Note: the original v1 had the bug  idct(z₂[::-1]) — flipping the INPUT.
+              Correct adjoint of DST-II requires IDCT(z₂)[::-1], NOT IDCT(z₂[::-1]).
+    """
+    if frame == "dct":
+        return idct(z, type=2, norm="ortho")
+    if frame == "rdft":
+        cos_part = idct(z[:M],  type=2, norm="ortho") / np.sqrt(2)
+        sin_part = idct(z[M:],  type=2, norm="ortho")[::-1] / np.sqrt(2)  # BUG-1 fix
+        return cos_part + sin_part
+    raise ValueError(f"Unknown frame '{frame}'")
+
+
+# ============================================================================
+# Hard thresholding  H_k
+# ============================================================================
+
+def hard_thresh(u: np.ndarray, k: int) -> np.ndarray:
+    """
+    Hard-thresholding operator H_k.
+
+    Keeps the k largest-magnitude components of u; sets all others to zero.
+    Corresponds to step 2 of both Algorithm 1 and Algorithm 2 in [1][2].
+
+    Parameters
+    ----------
+    u : coefficient vector  (in R^P)
+    k : number of non-zero coefficients to retain
+
+    Notes
+    -----
+    The papers remark that for real signals represented with complex DFT,
+    thresholding should act on conjugate pairs to preserve the real-signal
+    structure.  Since our RDFT frame uses real DCT/DST, all coefficients
+    are real-valued and standard element-wise thresholding is appropriate.
+    """
+    k = int(np.clip(k, 1, len(u)))
+    alpha = np.sort(np.abs(u))[::-1][k - 1]   # k-th largest magnitude
+    return u * (np.abs(u) >= alpha)
+
+
+# ============================================================================
+# Projection onto the consistency set Γ
+# ============================================================================
+
+def proj_gamma(
+    w:     np.ndarray,
+    yc:    np.ndarray,
+    masks: ClippingMasks,
+    g_max: float = float("inf"),   # v11: ratio-aware upper bound (linear)
+) -> np.ndarray:
+    """
+    Orthogonal projection onto  Γ(y)  in the time domain.
+
+    Implements eq. (6) of [2] / eq. (2) of [1]:
+
+        [proj_Γ(w)]_n = y_n               if n ∈ R   (reliable)
+                      = max{w_n,  τ}      if n ∈ H   (positive clip, i.e. ≥ τ)
+                      = min{w_n, −τ}      if n ∈ L   (negative clip, i.e. ≤ −τ)
+
+    Equivalently, using bounding vectors b_L, b_H as in eq. (7)/(9) of [2]:
+        proj_{[b_L, b_H]}(w) = min{max{b_L, w}, b_H}
+
+    v11 — ratio-aware upper bound (g_max > 0, default disabled = inf):
+        [proj_Γ(w)]_n = clip(max(w_n, yc_n), yc_n, yc_n · g_max)  for n ∈ Icp
+                      = clip(min(w_n, yc_n), yc_n · g_max, yc_n)  for n ∈ Icm
+        This prevents ADMM from generating transients above the limiter’s
+        expected maximum gain reduction while still honouring the lower bound.
+
+    Parameters
+    ----------
+    w     : time-domain signal to project  (R^N)
+    yc    : original clipped signal  (R^N), provides boundary values
+    masks : clipping masks (Ir, Icp, Icm)
+    g_max : linear gain ceiling (default: inf = no cap, i.e. v10 behaviour).
+            Compute from max_gain_db as: g_max = 10 ** (max_gain_db / 20).
+    """
+    v = w.copy()
+    v[masks.Ir]  = yc[masks.Ir]                              # reliable: fix exactly
+    # Positive clipped: lower bound ≥ yc, optional upper bound ≤ yc * g_max
+    lo_p = yc[masks.Icp]
+    if np.isfinite(g_max):
+        hi_p = lo_p * g_max
+    else:
+        hi_p = np.full_like(lo_p, np.inf)          # avoid 0 * inf = nan
+    v[masks.Icp] = np.clip(np.maximum(v[masks.Icp], lo_p), lo_p, hi_p)
+    # Negative clipped: upper bound ≤ yc, optional lower bound ≥ yc * g_max
+    lo_m = yc[masks.Icm]                                     # negative values
+    if np.isfinite(g_max):
+        lo_m_cap = lo_m * g_max                    # more negative than lo_m
+    else:
+        lo_m_cap = np.full_like(lo_m, -np.inf)    # avoid 0 * inf = nan
+    v[masks.Icm] = np.clip(np.minimum(v[masks.Icm], lo_m), lo_m_cap, lo_m)
+    return v
+
+
+# ============================================================================
+# S-SPADE  (Algorithm 1 in [2])
+# ============================================================================
+
+def tight_sspade(
+    yc:       np.ndarray,
+    masks:    ClippingMasks,
+    frame:    str,
+    s:        int,
+    r:        int,
+    eps:      float,
+    max_iter: int,
+    g_max:    float = float("inf"),   # v11: ratio-aware upper bound
+) -> Tuple[np.ndarray, bool]:
+    """
+    S-SPADE for one windowed audio frame.
+
+    Implements Algorithm 1 from [2], which uses the closed-form projection
+    lemma (eq. 12) to make per-iteration cost equal to A-SPADE:
+
+        ẑ^(i) = v - D^* ( D v - proj_{[b_L,b_H]}(D v) )
+        where  v = z̄^(i) - u^(i-1)
+
+    State variables
+    ---------------
+    zi : current estimate in coefficient domain  (R^P)
+    ui : dual / guidance variable  (R^P)   — coefficient domain
+    k  : current sparsity level (number of non-zero coefficients)
+
+    Convergence criterion (Algorithm 1, row 4 in [2])
+    -------------------------------------------------
+        ‖ẑ^(i) - z̄^(i)‖₂ ≤ ε
+    """
+    M = len(yc)
+    zi = frana(yc, frame)          # ẑ^(0) = A^H y  (eq. D^H y in [2])
+    ui = np.zeros_like(zi)         # u^(0) = 0
+    k  = s
+    converged = False
+
+    for i in range(1, max_iter + 1):
+
+        # ── Step 2 : enforce sparsity ─────────────────────────────────────
+        # z̄^(i) = H_k( ẑ^(i-1) + u^(i-1) )
+        zb = hard_thresh(zi + ui, k)
+
+        # ── Step 3 : project onto Γ via eq.(12) from [2] ─────────────────
+        # v = z̄^(i) - u^(i-1)  (coefficient domain)
+        v_coeff = zb - ui
+        # D v  (time domain)
+        Dv = frsyn(v_coeff, frame, M)
+        # proj_{Γ}(D v)
+        proj_Dv = proj_gamma(Dv, yc, masks, g_max=g_max)
+        # ẑ^(i) = v - D^*( D v - proj(D v) )
+        zi = v_coeff - frana(Dv - proj_Dv, frame)
+
+        # ── Step 4 : convergence check ────────────────────────────────────
+        # ‖ẑ^(i) - z̄^(i)‖₂ ≤ ε
+        if np.linalg.norm(zi - zb) <= eps:
+            converged = True
+            break
+
+        # ── Step 7 : update dual variable ────────────────────────────────
+        # u^(i) = u^(i-1) + ẑ^(i) - z̄^(i)
+        ui = ui + zi - zb
+
+        # ── Sparsity relaxation (rows 9-11 in [2]) ────────────────────────
+        if i % r == 0:
+            k += s
+
+    # Return time-domain estimate:  x̂ = D ẑ^(i)
+    return frsyn(zi, frame, M), converged
+
+
+# ============================================================================
+# A-SPADE  (Algorithm 2 in [2])
+# ============================================================================
+
+def tight_aspade(
+    yc:       np.ndarray,
+    masks:    ClippingMasks,
+    frame:    str,
+    s:        int,
+    r:        int,
+    eps:      float,
+    max_iter: int,
+    g_max:    float = float("inf"),   # v11: ratio-aware upper bound
+) -> Tuple[np.ndarray, bool]:
+    """
+    A-SPADE for one windowed audio frame.
+
+    Implements Algorithm 2 from [2].  The projection step uses the
+    closed-form formula from eq.(5)/(8) of [2]:
+
+        x̂^(i) = proj_{[b_L, b_H]}( A^H ( z̄^(i) − u^(i-1) ) )
+               = proj_Γ( D ( z̄^(i) − u^(i-1) ) )
+               = proj_Γ( frsyn(zb − ui) )
+
+    State variables
+    ---------------
+    xi : current estimate in signal domain  (R^N)
+    ui : dual / guidance variable  (R^P)   — COEFFICIENT domain  [BUG-2 fix]
+    k  : current sparsity level
+
+    Convergence criterion (Algorithm 2, row 4 in [2])
+    -------------------------------------------------
+        ‖A x̂^(i) − z̄^(i)‖₂ ≤ ε      (coefficient-domain norm)  [BUG-2c fix]
+    """
+    M = len(yc)
+    P = _frame_size(M, frame)
+
+    xi = yc.copy()           # x̂^(0) = y
+    ui = np.zeros(P)         # u^(0) = 0  — coefficient domain R^P  [BUG-2 fix]
+    k  = s
+    converged = False
+
+    for i in range(1, max_iter + 1):
+
+        # ── Step 2 : enforce sparsity ─────────────────────────────────────
+        # z̄^(i) = H_k( A x̂^(i-1) + u^(i-1) )
+        # Note: frana(xi) + ui, NOT frana(xi + frsyn(ui))  [BUG-2a fix]
+        zb = hard_thresh(frana(xi, frame) + ui, k)
+
+        # ── Step 3 : project onto Γ ───────────────────────────────────────
+        # x̂^(i) = proj_Γ( A^H( z̄^(i) - u^(i-1) ) )
+        #        = proj_Γ( frsyn( zb - ui ) )            [BUG-2b fix]
+        xi_new = proj_gamma(frsyn(zb - ui, frame, M), yc, masks, g_max=g_max)
+
+        # ── Step 4 : convergence check ────────────────────────────────────
+        # ‖A x̂^(i) - z̄^(i)‖₂ ≤ ε   (coefficient-domain norm)  [BUG-2c fix]
+        if np.linalg.norm(frana(xi_new, frame) - zb) <= eps:
+            converged = True
+            xi = xi_new
+            break
+
+        # ── Step 7 : update dual variable ────────────────────────────────
+        # u^(i) = u^(i-1) + A x̂^(i) - z̄^(i)             [BUG-2d fix]
+        ui = ui + frana(xi_new, frame) - zb
+        xi = xi_new
+
+        # ── Sparsity relaxation ───────────────────────────────────────────
+        if i % r == 0:
+            k += s
+
+    return xi, converged
+
+
+# ============================================================================
+# Main declipping pipeline
+# ============================================================================
+
+def _compute_masks(yc: np.ndarray, threshold: float) -> ClippingMasks:
+    """
+    Compute clipping/limiting masks from a 1-D signal and a detection threshold.
+
+    Works for both modes:
+      hard (mode='hard'):  threshold = tau (samples exactly at digital ceiling)
+      soft (mode='soft'):  threshold = tau * 10^(-delta_db/20)  (limiter threshold)
+
+    In soft mode, samples above the threshold have their TRUE value constrained
+    to be ≥ their current (limited) value.  proj_gamma already implements this
+    correctly via  v[Icp] = max(v[Icp], yc[Icp])  — since yc[Icp] is the actual
+    limited value, not tau.  No change to the projection operator is needed.
+    """
+    Icp = yc >= threshold
+    Icm = yc <= -threshold
+    Ir  = ~(Icp | Icm)
+    return ClippingMasks(Ir=Ir, Icp=Icp, Icm=Icm)
+
+
+# ============================================================================
+# v11 — Delimiting helper functions
+# ============================================================================
+
+def _dilate_masks_soft(
+    masks:           ClippingMasks,
+    yc:              np.ndarray,
+    release_samples: int,
+) -> ClippingMasks:
+    """
+    Forward morphological dilation of the soft-mode clipping masks.
+
+    A mastering limiter does not merely clip the peak sample; its release time
+    causes gain reduction to persist for `release_samples` samples after each
+    peak.  Without dilation, those post-peak samples are pinned as "reliable"
+    (Ir), forcing the ADMM solver to anchor the reconstruction to artificially
+    attenuated values and producing the pumping artifact.
+
+    Algorithm
+    ---------
+    For each True position in Icp or Icm, the following `release_samples`
+    positions are also flagged as constrained (Icp/Icm).  Implemented as a
+    causal linear convolution:
+
+        dilated = convolve(mask, ones(release_samples + 1))[:N] > 0
+
+    Newly flagged samples are reclassified by polarity:
+        yc[n] >= 0  →  Icp  (true value ≥ yc[n], always satisfied by limiter model)
+        yc[n] <  0  →  Icm  (true value ≤ yc[n], same reasoning)
+
+    This is mathematically valid because a gain-reducing limiter always
+    produces  |yc[n]| ≤ |true[n]|  on every attenuated sample.
+
+    Parameters
+    ----------
+    masks           : original ClippingMasks from _compute_masks
+    yc              : DC-removed signal (same length as masks)
+    release_samples : dilation width = round(release_ms * sr / 1000)
+
+    Returns
+    -------
+    ClippingMasks with expanded Icp, Icm and correspondingly shrunk Ir.
+    """
+    if release_samples <= 0:
+        return masks
+
+    N    = len(yc)
+    kern = np.ones(release_samples + 1, dtype=np.float64)
+
+    # Causal forward dilation: each True position infects the next
+    # release_samples positions (conv[:N] gives the causal output).
+    dil_cp = np.convolve(masks.Icp.astype(np.float64), kern)[:N] > 0
+    dil_cm = np.convolve(masks.Icm.astype(np.float64), kern)[:N] > 0
+
+    # Union of original and dilated masks
+    new_Icp = dil_cp | dil_cm  # will be filtered by polarity below
+    new_Icm = dil_cp | dil_cm
+
+    # Assign dilated samples by polarity of the limited signal
+    new_Icp =  new_Icp & (yc >= 0)   # positive half
+    new_Icm =  new_Icm & (yc <  0)   # negative half
+
+    # Reliable = everything not in Icp or Icm
+    new_Ir  = ~(new_Icp | new_Icm)
+
+    return ClippingMasks(Ir=new_Ir, Icp=new_Icp, Icm=new_Icm)
+
+
+def _lr_split(x: np.ndarray, fc: float, sr: int) -> "Tuple[np.ndarray, np.ndarray]":
+    """
+    Phase-perfect Linkwitz-Riley crossover at frequency `fc` Hz.
+
+    Returns (lp, hp) such that lp + hp == x exactly (perfect reconstruction
+    by construction: hp = x - lp).  The LP is a zero-phase 4th-order
+    Butterworth realised with sosfiltfilt.
+
+    A 4th-order zero-phase Butterworth (sosfiltfilt of 2nd-order coefficients)
+    has the same amplitude response as LR4 at the crossover point (−6 dB at
+    fc) and is computationally convenient.  Summing LP + HP = x eliminates
+    any phase-cancellation artifact at the crossover frequency.
+
+    Parameters
+    ----------
+    x  : 1-D signal array
+    fc : crossover frequency in Hz  (clamped to [1, sr/2 − 1])
+    sr : sample rate in Hz
+    """
+    from scipy.signal import butter, sosfiltfilt
+    fc_safe = float(np.clip(fc, 1.0, sr / 2.0 - 1.0))
+    sos = butter(2, fc_safe, btype="low", fs=sr, output="sos")
+    lp  = sosfiltfilt(sos, x)
+    hp  = x - lp           # perfect reconstruction: no leakage at any frequency
+    return lp, hp
+
+
+def _macro_expand_pass(
+    yc:          np.ndarray,
+    sr:          int,
+    attack_ms:   float = 10.0,
+    release_ms:  float = 200.0,
+    ratio:       float = 1.2,
+) -> np.ndarray:
+    """
+    Macro-dynamics upward expansion pre-pass.
+
+    Restores the slow (>21 ms) amplitude modulation suppressed by a mastering
+    limiter's release time — the "body compression" that SPADE cannot undo
+    because it operates frame-by-frame at ~21 ms windows.
+
+    Algorithm
+    ---------
+    1. Compute a zero-phase smoothed peak envelope using sosfiltfilt.
+       The attack and release IIR time constants map to Butterworth LP cutoffs:
+           fc_att = 2.2 / (2π · attack_s)   [−3 dB at attack cutoff]
+           fc_rel = 2.2 / (2π · release_s)
+       Two passes (attack on rising, release on falling) are approximated by
+       using the *slower* of the two for the LP filter (conservative choice).
+
+    2. Threshold: 80th-percentile of the non-silent envelope values.
+       Above the threshold the signal is already "loud" → no expansion.
+       Below the threshold it was compressed → apply upward expansion gain.
+
+    3. Expansion gain (standard upward-expander transfer function):
+           g(n) = (env(n) / threshold)^(1/ratio − 1)   env < threshold
+                = 1.0                                   otherwise
+       For ratio > 1, (1/ratio − 1) < 0, so g > 1 when env < threshold
+       (quiet sections get boosted).
+
+    4. Gain is smoothed with a 20 Hz LP to prevent clicks, then hard-clipped
+       to [1.0, ∞) so the pre-pass only expands — it never attenuates.
+
+    Parameters
+    ----------
+    yc         : 1-D float signal (DC-removed, level-normalised)
+    sr         : sample rate in Hz
+    attack_ms  : expander attack time constant (ms); typically 5–20 ms
+    release_ms : expander release time constant (ms); typically 100–300 ms
+    ratio      : expansion ratio >1.0; 1.0 = bypass, 1.2 = gentle
+
+    Returns
+    -------
+    Expanded signal with the same length as yc.
+    """
+    from scipy.signal import butter, sosfiltfilt
+
+    if ratio <= 1.0:
+        return yc.copy()
+
+    x_abs = np.abs(yc)
+
+    # ── Envelope follower ─────────────────────────────────────────────────
+    # Use the *slower* time constant (release) for the zero-phase LP filter.
+    # This approximates a peak-hold envelope that attacks fast and releases slow.
+    rel_s  = max(release_ms, attack_ms) / 1000.0
+    fc_env = min(2.2 / (2.0 * np.pi * rel_s), sr / 2.0 - 1.0)
+    sos_e  = butter(2, fc_env, fs=sr, output="sos")
+    env    = sosfiltfilt(sos_e, x_abs)
+    env    = np.maximum(env, 1e-10)
+
+    # ── Threshold: 80th percentile of non-silent samples ─────────────────
+    mask_sig = env > 1e-6
+    if not mask_sig.any():
+        return yc.copy()
+    thresh = float(np.percentile(env[mask_sig], 80))
+    thresh = max(thresh, 1e-8)
+
+    # ── Expansion gain ────────────────────────────────────────────────────
+    exponent = 1.0 / ratio - 1.0           # negative for ratio > 1
+    g = np.where(env >= thresh,
+                 1.0,
+                 (env / thresh) ** exponent)
+
+    # ── Smooth gain to avoid clicks (~20 Hz LP) ───────────────────────────
+    fc_g  = min(20.0, sr / 2.0 - 1.0)
+    sos_g = butter(2, fc_g, fs=sr, output="sos")
+    g     = sosfiltfilt(sos_g, g)
+    g     = np.maximum(g, 1.0)            # upward only — never attenuate
+
+    return yc * g
+
+
+def _declip_mono(
+    yc:            np.ndarray,
+    params:        DeclipParams,
+    tau:           float,          # pre-computed global ceiling — used only as hint;
+                                   # always recomputed internally after DC removal.
+    ch_label:      str = "",
+    frame_workers: int = 1,        # v8: intra-channel frame-level parallelism
+    progress_ctx   = None,         # v9: shared _*Progress instance (or None)
+    task_id        = None,         # v9: task handle returned by progress_ctx.add_task
+) -> Tuple[np.ndarray, ClippingMasks]:
+    """
+    Core mono declipping / delimiting pipeline (internal).
+
+    Parameters
+    ----------
+    yc       : 1-D float array — one channel of the input signal
+    params   : DeclipParams
+    tau      : ceiling hint (pre-computed in declip()); kept for API compat,
+               recomputed internally after DC removal.
+    ch_label : string used in verbose output, e.g. "L" or "R"
+
+    DC removal (BUG-4 fix, v5)
+    --------------------------
+    A DC offset as small as 0.3% makes the global peak asymmetric, causing
+    the lower-polarity ceiling to fall just below tau and be misclassified as
+    reliable.  Fix: subtract per-channel mean before all threshold computations.
+    The DC is discarded on output (recording artefact, not musical content).
+
+    Soft mode (v6)
+    --------------
+    When params.mode == 'soft', the threshold is set to:
+        threshold = ceiling * 10^(-delta_db / 20)
+    where ceiling = max(|yc|) after DC removal.
+    This marks all samples above the limiter threshold as potentially attenuated.
+    The BUG-4 half-wave issue is inherently avoided in soft mode because the
+    threshold sits delta_db dB BELOW the ceiling; small DC asymmetries (typically
+    < 0.05 dB) cannot push the opposite polarity's ceiling below the threshold.
+    DC removal is still performed for cleanliness.
+
+    proj_gamma correctness in soft mode
+    ------------------------------------
+    For limited samples, the true value satisfies:  true ≥ yc[n]  (one-sided).
+    proj_gamma already implements exactly this:
+        v[Icp] = max(v[Icp], yc[Icp])
+    Since yc[Icp] here is the *actual limited value* (not tau), the constraint
+    is correct.  No change to tight_sspade or tight_aspade is needed.
+    """
+    # ── DC removal (BUG-4 fix, applies to both modes) ────────────────────
+    dc_offset = float(np.mean(yc))
+    yc        = yc - dc_offset                  # DC-free working copy
+
+    # ── Ceiling and threshold ─────────────────────────────────────────────
+    ceiling_pos = float(np.max(yc))             # positive peak after DC removal
+    ceiling_neg = float(-np.min(yc))            # negative peak (absolute value)
+
+    if params.mode == "hard":
+        # BUG-4 fix: use min(pos, neg) so both half-waves are always detected
+        threshold = min(ceiling_pos, ceiling_neg)
+    else:
+        # soft mode: threshold = ceiling − delta_db dB
+        # Use max(pos, neg) for ceiling — we want the actual brickwall level,
+        # and the threshold is well below it so small asymmetries don't matter.
+        ceiling   = max(ceiling_pos, ceiling_neg)
+        threshold = ceiling * (10.0 ** (-params.delta_db / 20.0))
+
+    if threshold <= 0.0:
+        return yc.copy(), _compute_masks(yc, 0.0)
+
+    masks     = _compute_masks(yc, threshold)
+
+    # ── v11 Feature 1: envelope-based mask dilation ───────────────────────
+    if params.mode == "soft" and params.release_ms > 0.0:
+        rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0))
+        if rel_samp > 0:
+            masks = _dilate_masks_soft(masks, yc, rel_samp)
+
+    # ── v11 Feature 4: macro-dynamics upward expansion pre-pass ──────────
+    if params.mode == "soft" and params.macro_expand and params.macro_ratio > 1.0:
+        yc = _macro_expand_pass(
+            yc, params.sample_rate,
+            attack_ms=params.macro_attack_ms,
+            release_ms=params.macro_release_ms,
+            ratio=params.macro_ratio,
+        )
+        # Recompute masks on the expanded signal so Ir values are correct
+        masks = _compute_masks(yc, threshold)
+        if params.release_ms > 0.0:
+            rel_samp = max(0, round(params.release_ms * params.sample_rate / 1000.0))
+            if rel_samp > 0:
+                masks = _dilate_masks_soft(masks, yc, rel_samp)
+
+    n_clipped = int(np.sum(~masks.Ir))
+    L         = len(yc)
+
+    # ── v11 Feature 2: ratio-aware upper bound (linear) ──────────────────
+    g_max = (10.0 ** (params.max_gain_db / 20.0)
+             if params.mode == "soft" and params.max_gain_db > 0.0
+             else float("inf"))
+
+    if params.verbose:
+        ch  = (" [" + ch_label + "]") if ch_label else ""
+        tag = "threshold" if params.mode == "soft" else "tau"
+        print(f"[declip{ch}] Length    : {L} samples")
+        print(f"[declip{ch}] DC offset : {dc_offset:+.6f}  ({dc_offset*100:+.4f}%)  → removed")
+        if params.mode == "hard":
+            print(f"[declip{ch}] {tag:<9}  : {threshold:.6f}  "
+                  f"(pos_peak={ceiling_pos:.6f}  neg_peak={ceiling_neg:.6f}  using min)")
+        else:
+            print(f"[declip{ch}] ceiling   : {max(ceiling_pos, ceiling_neg):.6f}  "
+                  f"(pos={ceiling_pos:.6f}  neg={ceiling_neg:.6f})")
+            print(f"[declip{ch}] {tag:<9}  : {threshold:.6f}  "
+                  f"(ceiling − {params.delta_db:.2f} dB = "
+                  f"{20*np.log10(threshold/max(ceiling_pos,ceiling_neg)):.2f} dBFS)")
+        print(f"[declip{ch}] Detected  : {n_clipped}/{L} "
+              f"({100*n_clipped/L:.1f}%)  "
+              f"Icp={int(masks.Icp.sum())}  Icm={int(masks.Icm.sum())}")
+        print(f"[declip{ch}] Algorithm : {params.algo.upper()}  "
+              f"frame={params.frame.upper()}  mode={params.mode.upper()}  "
+              f"win={params.window_length}  hop={params.hop_length} "
+              f"({100*(1-params.hop_length/params.window_length):.0f}% overlap)")
+        if params.mode == "soft":
+            feats = []
+            if params.release_ms > 0: feats.append(f"release_ms={params.release_ms}")
+            if params.max_gain_db > 0: feats.append(f"max_gain_db={params.max_gain_db}")
+            if params.macro_expand: feats.append(f"macro_expand(ratio={params.macro_ratio})")
+            if feats:
+                print(f"[declip{ch}] v11 feats : " + "  ".join(feats))
+
+    spade_fn = tight_sspade if params.algo == "sspade" else tight_aspade
+
+    M        = params.window_length
+    a        = params.hop_length
+    N        = int(np.ceil(L / a))
+    win      = np.sqrt(hann(M, sym=False))   # sqrt-Hann: satisfies COLA
+    x        = np.zeros(L)
+    norm_win = np.zeros(L)
+    no_conv  = 0
+    skipped  = 0          # frames bypassed by frame-adaptive threshold (soft only)
+    t0       = time.time()
+
+    # ── Per-frame worker (pure computation, no shared-state writes) ──────
+    # Returns all data needed for WOLA accumulation; the accumulation itself
+    # is always done sequentially to avoid race conditions on x / norm_win.
+    def _process_frame(i: int):
+        idx1    = i * a
+        idx2    = min(idx1 + M, L)
+        seg_len = idx2 - idx1
+        pad     = M - seg_len
+
+        yc_frame           = np.zeros(M)
+        yc_frame[:seg_len] = yc[idx1:idx2]
+
+        # ── Frame-adaptive bypass (soft mode only, v7) ───────────────────
+        if params.mode == "soft":
+            frame_peak = float(np.max(np.abs(yc_frame[:seg_len]))) if seg_len > 0 else 0.0
+            if frame_peak < threshold:
+                return idx1, idx2, seg_len, None, False, True   # bypassed=True
+
+        yc_frame_w = yc_frame * win
+
+        fm = ClippingMasks(
+            Ir  = np.concatenate([masks.Ir [idx1:idx2], np.ones (pad, dtype=bool)]),
+            Icp = np.concatenate([masks.Icp[idx1:idx2], np.zeros(pad, dtype=bool)]),
+            Icm = np.concatenate([masks.Icm[idx1:idx2], np.zeros(pad, dtype=bool)]),
+        )
+
+        x_frame, conv = spade_fn(
+            yc_frame_w, fm,
+            params.frame, params.s, params.r, params.eps, params.max_iter,
+            g_max=g_max,
+        )
+        return idx1, idx2, seg_len, x_frame, conv, False        # bypassed=False
+
+    # ── Parallel SPADE compute (v8) + live progress (v9) ─────────────────
+    # scipy.fft.dct releases the GIL → threads run truly in parallel on DCT.
+    # WOLA accumulation (cheap) is kept sequential to avoid data races.
+    #
+    # Progress strategy:
+    #   parallel:   pool.submit + as_completed → advance bar as each frame lands
+    #   sequential: plain loop with advance after each frame
+    #
+    # frame_results[i] is stored by *original index* so WOLA order is preserved.
+    frame_results: list = [None] * N
+    _n_bypassed = 0
+    _n_noconv   = 0
+
+    def _advance(n_done: int):
+        if progress_ctx is not None and task_id is not None:
+            progress_ctx.advance(task_id,
+                                 n_bypassed=_n_bypassed,
+                                 n_noconv=_n_noconv,
+                                 n_done=n_done,
+                                 n_total=N)
+
+    if frame_workers > 1:
+        from concurrent.futures import as_completed
+        with ThreadPoolExecutor(max_workers=frame_workers) as pool:
+            future_to_idx = {pool.submit(_process_frame, i): i for i in range(N)}
+            n_done = 0
+            for future in as_completed(future_to_idx):
+                i = future_to_idx[future]
+                frame_results[i] = future.result()
+                n_done += 1
+                # Peek at result to update live counters before advancing bar
+                *_, conv, bypassed = frame_results[i]
+                if bypassed:
+                    _n_bypassed += 1
+                elif not conv:
+                    _n_noconv += 1
+                _advance(n_done)
+    else:
+        for i in range(N):
+            frame_results[i] = _process_frame(i)
+            *_, conv, bypassed = frame_results[i]
+            if bypassed:
+                _n_bypassed += 1
+            elif not conv:
+                _n_noconv += 1
+            _advance(i + 1)
+
+    # ── Sequential WOLA accumulation ─────────────────────────────────────
+    for idx1, idx2, seg_len, x_frame, conv, bypassed in frame_results:
+        if bypassed:
+            yc_seg = yc[idx1:idx2]
+            x       [idx1:idx2] += yc_seg * win[:seg_len] ** 2
+            norm_win[idx1:idx2] += win[:seg_len] ** 2
+            skipped += 1
+        else:
+            if not conv:
+                no_conv += 1
+            x       [idx1:idx2] += x_frame[:seg_len] * win[:seg_len]
+            norm_win[idx1:idx2] += win[:seg_len] ** 2
+
+    # WOLA normalisation
+    norm_win = np.where(norm_win < 1e-12, 1.0, norm_win)
+    x /= norm_win
+
+    # ── Reliable-sample level matching (BUG-3 fix) ───────────────────────
+    # Rescale output so its RMS on reliable samples matches the input RMS.
+    # Eliminates per-channel WOLA gain drift (up to 5 dB in stereo material).
+    Ir = masks.Ir
+    if Ir.sum() > 0:
+        rms_in  = float(np.sqrt(np.mean(yc[Ir] ** 2)))
+        rms_out = float(np.sqrt(np.mean(x[Ir]  ** 2)))
+        if rms_out > 1e-12 and rms_in > 1e-12:
+            x *= rms_in / rms_out
+
+    if params.verbose:
+        ch = (" [" + ch_label + "]") if ch_label else ""
+        active = N - skipped
+        skip_pct = 100.0 * skipped / N if N > 0 else 0.0
+        if params.mode == "soft" and skipped > 0:
+            print(f"[declip{ch}] Frames    : {N} total  |  "
+                  f"active={active}  bypassed={skipped} ({skip_pct:.1f}%)  "
+                  f"no_conv={no_conv}  |  time: {time.time()-t0:.1f}s")
+        else:
+            print(f"[declip{ch}] Frames    : {N}  (no conv: {no_conv})  "
+                  f"time: {time.time()-t0:.1f}s")
+
+    return x, masks
+
+
+def declip(
+    yc:     np.ndarray,
+    params: "DeclipParams | None" = None,
+) -> "Tuple[np.ndarray, Union[ClippingMasks, List[ClippingMasks]]]":
+    """
+    Declip a hard-clipped audio signal — mono or multi-channel.
+
+    Accepts either:
+      * a 1-D array  (N_samples,)              — mono
+      * a 2-D array  (N_samples, N_channels)   — stereo / surround
+
+    For multi-channel input, tau is detected from the global peak across
+    ALL channels, modelling the single hardware clipping threshold correctly.
+    Each channel is then processed independently.  Parallel processing is
+    controlled by params.n_jobs.
+
+    Parameters
+    ----------
+    yc     : float array, shape (N,) or (N, C)
+    params : DeclipParams  (defaults used if None)
+
+    Returns
+    -------
+    x       : declipped signal, same shape as yc
+    masks   : ClippingMasks          (mono input)
+              list of ClippingMasks  (multi-channel input, one per channel)
+    """
+    if params is None:
+        params = DeclipParams()
+
+    yc = np.asarray(yc, dtype=float)
+
+    # ── v11 Feature 3: Multiband (Linkwitz-Riley) routing ───────────────────
+    # When multiband=True, we split the signal into frequency bands, process
+    # each independently with its own delta_db, then sum back.  The split
+    # uses perfect-reconstruction LP+HP pairs (HP = input − LP), so the sum
+    # always reconstructs the original without leakage artifacts.
+    # This wrapper recurses into declip() with multiband=False for each band.
+    if params.multiband and params.mode == "soft":
+        from dataclasses import replace as _dc_replace
+        crossovers  = list(params.band_crossovers)
+        n_bands     = len(crossovers) + 1
+        sr          = params.sample_rate
+
+        # Per-band delta_db: use band_delta_db if fully specified, else fall back
+        if len(params.band_delta_db) == n_bands:
+            band_deltas = list(params.band_delta_db)
+        else:
+            band_deltas = [params.delta_db] * n_bands
+
+        # Split signal into bands using cascaded LP / HP = input − LP
+        sig_1d = yc if yc.ndim == 1 else None   # handle below per-channel
+        if yc.ndim == 2:
+            # Process each channel’s bands independently, same crossovers
+            n_samp, n_ch = yc.shape
+            out = np.zeros_like(yc)
+            all_masks = []
+            for c in range(n_ch):
+                ch_sig  = yc[:, c]
+                ch_out  = np.zeros(n_samp)
+                ch_masks = []
+                remainder = ch_sig.copy()
+                for b, (fc, d_db) in enumerate(zip(crossovers, band_deltas[:-1])):
+                    lp, remainder = _lr_split(remainder, fc, sr)
+                    band_params = _dc_replace(params, multiband=False, delta_db=d_db)
+                    band_fixed, band_mask = declip(lp, band_params)
+                    ch_out  += band_fixed
+                    ch_masks.append(band_mask)
+                # Last band (remainder is the HP)
+                band_params = _dc_replace(params, multiband=False, delta_db=band_deltas[-1])
+                band_fixed, band_mask = declip(remainder, band_params)
+                ch_out  += band_fixed
+                ch_masks.append(band_mask)
+                out[:, c] = ch_out
+                all_masks.append(ch_masks)
+            return out, all_masks
+        else:
+            # Mono multiband
+            out = np.zeros_like(yc)
+            all_masks = []
+            remainder = yc.copy()
+            for b, (fc, d_db) in enumerate(zip(crossovers, band_deltas[:-1])):
+                lp, remainder = _lr_split(remainder, fc, sr)
+                band_params = _dc_replace(params, multiband=False, delta_db=d_db)
+                band_fixed, band_mask = declip(lp, band_params)
+                out       += band_fixed
+                all_masks.append(band_mask)
+            # Last band
+            band_params = _dc_replace(params, multiband=False, delta_db=band_deltas[-1])
+            band_fixed, band_mask = declip(remainder, band_params)
+            out       += band_fixed
+            all_masks.append(band_mask)
+            return out, all_masks
+
+    # ── Normalisation fix ────────────────────────────────────────────────
+    # SPADE recovers values *above* tau at formerly-clipped positions.
+    # If the input is at the digital ceiling (tau = 1.0), those recovered
+    # values exceed 1.0 and any hard np.clip(-1,1) by the caller destroys
+    # all improvement, making the output identical to the input.
+    # Fix: normalise so tau < 1.0 before processing; undo normalisation after.
+    NORM_TARGET = 0.9
+    global_peak = float(np.max(np.abs(yc)))
+    if global_peak > NORM_TARGET:
+        scale   = NORM_TARGET / global_peak   # < 1
+        yc_norm = yc * scale
+    else:
+        scale   = 1.0
+        yc_norm = yc
+
+    # ── GPU detection (once, shared across all channels) ─────────────────
+    gpu_dev = _resolve_gpu_device(params)
+
+    # ── Mono path ────────────────────────────────────────────────────────
+    if yc_norm.ndim == 1:
+        tau = float(np.max(np.abs(yc_norm)))
+        if tau == 0.0:
+            warnings.warn("Input signal is all zeros.")
+            return yc.copy(), _compute_masks(yc, 0.0)
+
+        if gpu_dev is not None:
+            # GPU path: single channel, no threading needed
+            if params.show_progress:
+                N_frames = int(np.ceil(len(yc_norm) / params.hop_length))
+                prog = _make_progress(1)
+                with prog:
+                    task = prog.add_task("mono", total=N_frames)
+                    fixed, masks = _declip_mono_gpu(
+                        yc_norm, params, tau, ch_label="mono",
+                        device=gpu_dev, progress_ctx=prog, task_id=task,
+                    )
+            else:
+                fixed, masks = _declip_mono_gpu(
+                    yc_norm, params, tau, ch_label="mono", device=gpu_dev,
+                )
+        else:
+            # CPU path (v8/v9)
+            n_workers = params.n_jobs if params.n_jobs > 0 else os.cpu_count() or 1
+            if params.show_progress:
+                N_frames = int(np.ceil(len(yc_norm) / params.hop_length))
+                prog = _make_progress(1)
+                with prog:
+                    task = prog.add_task("mono", total=N_frames)
+                    fixed, masks = _declip_mono(
+                        yc_norm, params, tau,
+                        frame_workers=n_workers,
+                        progress_ctx=prog, task_id=task,
+                    )
+            else:
+                fixed, masks = _declip_mono(yc_norm, params, tau, frame_workers=n_workers)
+        return fixed / scale, masks
+
+    # ── Multi-channel path ───────────────────────────────────────────────
+    if yc_norm.ndim != 2:
+        raise ValueError(
+            f"yc must be 1-D (mono) or 2-D (samples x channels), got shape {yc.shape}"
+        )
+
+    n_samples, n_ch = yc_norm.shape
+
+    # Global tau: same hardware threshold for all channels
+    tau = float(np.max(np.abs(yc_norm)))
+    if tau == 0.0:
+        warnings.warn("Input signal is all zeros.")
+        empty_masks = [_compute_masks(yc[:, c], 0.0) for c in range(n_ch)]
+        return yc.copy(), empty_masks
+
+    # Channel labels: L/R for stereo, Ch0/Ch1/… for more
+    if n_ch == 2:
+        labels = ["L", "R"]
+    else:
+        labels = ["Ch" + str(c) for c in range(n_ch)]
+
+    if params.verbose:
+        print(f"[declip] {n_ch}-channel signal  |  "
+              f"tau={tau:.4f}  |  mode={params.mode.upper()}  |  "
+              + (f"device={gpu_dev}" if gpu_dev else f"n_jobs={params.n_jobs}")
+              + (f"  |  delta_db={params.delta_db:.2f}" if params.mode == "soft" else ""))
+
+    # ── Parallel / sequential dispatch ───────────────────────────────────
+    N_frames = int(np.ceil(n_samples / params.hop_length))
+    prog     = _make_progress(n_ch) if params.show_progress else None
+
+    if gpu_dev is not None:
+        # GPU path: channels processed sequentially (GPU already uses all VRAM
+        # for the frame batch; no benefit from running channels concurrently)
+        def _process_channel(c: int, task_id=None):
+            return _declip_mono_gpu(
+                yc_norm[:, c], params, tau,
+                ch_label=labels[c], device=gpu_dev,
+                progress_ctx=prog, task_id=task_id,
+            )
+    else:
+        # CPU path: two-level parallelism (channel-workers × frame-workers)
+        total_workers    = params.n_jobs if params.n_jobs > 0 else os.cpu_count() or 1
+        channel_workers  = min(total_workers, n_ch)
+        frame_workers_ch = max(1, total_workers // channel_workers)
+
+        def _process_channel(c: int, task_id=None):
+            return _declip_mono(
+                yc_norm[:, c], params, tau,
+                ch_label=labels[c],
+                frame_workers=frame_workers_ch,
+                progress_ctx=prog,
+                task_id=task_id,
+            )
+
+    # Channel-level concurrency: GPU uses 1 worker (sequential), CPU uses n_ch
+    ch_workers = 1 if gpu_dev is not None else min(
+        params.n_jobs if params.n_jobs > 0 else os.cpu_count() or 1, n_ch
+    )
+
+    def _run():
+        if prog is not None:
+            task_ids = [prog.add_task(labels[c], total=N_frames) for c in range(n_ch)]
+        else:
+            task_ids = [None] * n_ch
+
+        if ch_workers == 1:
+            return [_process_channel(c, task_ids[c]) for c in range(n_ch)]
+        else:
+            with ThreadPoolExecutor(max_workers=ch_workers) as pool:
+                futures = [pool.submit(_process_channel, c, task_ids[c]) for c in range(n_ch)]
+                return [f.result() for f in futures]
+
+    if prog is not None:
+        with prog:
+            results = _run()
+    else:
+        results = _run()
+
+    # Reassemble into (N_samples, N_channels)
+    fixed_channels = [r[0] for r in results]
+    masks_list     = [r[1] for r in results]
+    x_out = np.column_stack(fixed_channels) / scale
+
+    return x_out, masks_list
+
+
+# ============================================================================
+# Quality metrics
+# ============================================================================
+
+def sdr(reference: np.ndarray, estimate: np.ndarray) -> float:
+    """
+    Signal-to-Distortion Ratio (dB).
+
+    Definition from eq.(14) in [2]:
+        SDR(u, v) = 10 log₁₀( ‖u‖² / ‖u − v‖² )
+    """
+    noise = reference - estimate
+    denom = np.sum(noise ** 2)
+    if denom < 1e-20:
+        return float("inf")
+    return 10.0 * np.log10(np.sum(reference ** 2) / denom)
+
+
+def delta_sdr(
+    reference: np.ndarray,
+    clipped:   np.ndarray,
+    estimate:  np.ndarray,
+) -> float:
+    """
+    ΔSDR improvement (dB) — eq.(13) in [2]:
+        ΔSDR = SDR(x, x̂) − SDR(x, y)
+    """
+    return sdr(reference, estimate) - sdr(reference, clipped)
+
+
+# ============================================================================
+# Command-line interface
+# ============================================================================
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        description="SPADE Audio Declipping / Limiter Recovery (v11)",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("input",  help="Input clipped / limited audio file (WAV, FLAC, ...)")
+    p.add_argument("output", help="Output restored audio file")
+    p.add_argument("--algo",          choices=["sspade", "aspade"], default="sspade")
+    p.add_argument("--window-length", type=int,   default=1024, dest="window_length")
+    p.add_argument("--hop-length",    type=int,   default=256,  dest="hop_length")
+    p.add_argument("--frame",         choices=["dct", "rdft"], default="rdft")
+    p.add_argument("--s",             type=int,   default=1)
+    p.add_argument("--r",             type=int,   default=1)
+    p.add_argument("--eps",           type=float, default=0.1)
+    p.add_argument("--max-iter",      type=int,   default=1000, dest="max_iter")
+    p.add_argument("--n-jobs",        type=int,   default=1,    dest="n_jobs",
+                   help="CPU parallel workers for multi-channel (-1 = all cores). "
+                        "Ignored when GPU is active.")
+    p.add_argument("--mode",          choices=["hard", "soft"], default="hard",
+                   help="'hard' = standard clipping recovery; "
+                        "'soft' = brickwall limiter recovery")
+    p.add_argument("--delta-db",      type=float, default=1.0,  dest="delta_db",
+                   help="[soft mode] dB below 0 dBFS where the limiter starts acting "
+                        "(e.g. 2.5 means threshold at -2.5 dBFS)")
+    p.add_argument("--gpu-device",    type=str,   default="auto", dest="gpu_device",
+                   help="PyTorch device for GPU path: 'auto', 'cuda', 'cuda:0', 'cpu'. "
+                        "AMD ROCm GPUs appear as 'cuda' in PyTorch-ROCm.")
+    p.add_argument("--no-gpu",        action="store_true", dest="no_gpu",
+                   help="Disable GPU acceleration; use CPU (v8/v9 threading) path instead.")
+    # v11 delimiting features
+    p.add_argument("--release-ms",     type=float, default=0.0,   dest="release_ms",
+                   help="[v11, soft] Limiter release time in ms for mask dilation "
+                        "(0 = disabled, typical 10-50 ms)")
+    p.add_argument("--max-gain-db",    type=float, default=0.0,   dest="max_gain_db",
+                   help="[v11, soft] Max transient recovery in dB above limited value "
+                        "(0 = disabled, e.g. 6 for +6 dB cap)")
+    p.add_argument("--multiband",      action="store_true",
+                   help="[v11, soft] Enable Linkwitz-Riley sub-band processing")
+    p.add_argument("--band-crossovers", type=float, nargs="+", default=[250.0, 4000.0],
+                   dest="band_crossovers",
+                   help="[v11] Crossover frequencies in Hz (e.g. 250 4000)")
+    p.add_argument("--band-delta-db",  type=float, nargs="+", default=[],
+                   dest="band_delta_db",
+                   help="[v11] Per-band delta_db values (must match number of bands)")
+    p.add_argument("--macro-expand",   action="store_true",  dest="macro_expand",
+                   help="[v11, soft] Enable macro-dynamics upward expansion pre-pass")
+    p.add_argument("--macro-attack-ms",  type=float, default=10.0,  dest="macro_attack_ms",
+                   help="[v11] Expander attack time (ms, default 10)")
+    p.add_argument("--macro-release-ms", type=float, default=200.0, dest="macro_release_ms",
+                   help="[v11] Expander release time (ms, default 200)")
+    p.add_argument("--macro-ratio",    type=float, default=1.2,  dest="macro_ratio",
+                   help="[v11] Expansion ratio >1.0 (default 1.2; 1.0 = bypass)")
+    p.add_argument("--verbose",       action="store_true")
+    p.add_argument("--reference",     default=None,
+                   help="Clean reference file for delta-SDR measurement")
+    return p
+
+
+def main() -> None:
+    try:
+        import soundfile as sf
+    except ImportError:
+        raise SystemExit("Install soundfile:  pip install soundfile")
+
+    args   = _build_parser().parse_args()
+    yc, sr = sf.read(args.input, always_2d=True)   # shape: (N, C) always
+    yc     = yc.astype(float)
+    n_samp, n_ch = yc.shape
+
+    print("Input   :", args.input,
+          "|", n_samp, "samples @", sr, "Hz |", n_ch, "channel(s)")
+
+    params = DeclipParams(
+        algo=args.algo, window_length=args.window_length,
+        hop_length=args.hop_length, frame=args.frame,
+        s=args.s, r=args.r, eps=args.eps, max_iter=args.max_iter,
+        verbose=args.verbose, n_jobs=args.n_jobs,
+        mode=args.mode, delta_db=args.delta_db,
+        use_gpu=not args.no_gpu, gpu_device=args.gpu_device,
+        # v11: delimiting features
+        sample_rate=sr,
+        release_ms=args.release_ms,
+        max_gain_db=args.max_gain_db,
+        multiband=args.multiband,
+        band_crossovers=tuple(args.band_crossovers),
+        band_delta_db=tuple(args.band_delta_db),
+        macro_expand=args.macro_expand,
+        macro_attack_ms=args.macro_attack_ms,
+        macro_release_ms=args.macro_release_ms,
+        macro_ratio=args.macro_ratio,
+    )
+
+    # Pass 1-D array for mono so return type stays ClippingMasks (not list)
+    yc_in        = yc[:, 0] if n_ch == 1 else yc
+    fixed, masks = declip(yc_in, params)
+    # NOTE: do NOT clip to [-1, 1] — recovered transients may legitimately
+    # exceed 1.0.  Write as 32-bit float to preserve them.
+
+    # soundfile always wants 2-D for write
+    fixed_2d = fixed[:, None] if fixed.ndim == 1 else fixed
+    sf.write(args.output, fixed_2d.astype(np.float32), sr, subtype="FLOAT")
+    print("Output  :", args.output)
+
+    # Per-channel clipping summary
+    masks_iter = [masks] if n_ch == 1 else masks
+    labels     = ["L", "R"] if n_ch == 2 else ["Ch" + str(c) for c in range(n_ch)]
+    for m, lbl in zip(masks_iter, labels):
+        n_clip = int(np.sum(~m.Ir))
+        pct    = 100.0 * n_clip / n_samp
+        print("  [" + lbl + "] clipped:", n_clip, "/", n_samp,
+              "samples (" + str(round(pct, 1)) + "%)")
+
+    # Optional SDR vs. clean reference
+    if args.reference:
+        ref, _ = sf.read(args.reference, always_2d=True)
+        ref    = ref.astype(float)
+        L      = min(ref.shape[0], fixed_2d.shape[0])
+        for c in range(min(n_ch, ref.shape[1])):
+            lbl = labels[c]
+            r_c = ref[:L, c]
+            y_c = yc[:L, c]
+            f_c = fixed_2d[:L, c]
+            print("  [" + lbl + "]"
+                  "  SDR clipped="   + str(round(sdr(r_c, y_c), 2)) + " dB"
+                  "  declipped="     + str(round(sdr(r_c, f_c), 2)) + " dB"
+                  "  delta="         + str(round(delta_sdr(r_c, y_c, f_c), 2)) + " dB")
+
+
+# =============================================================================
+# Demo / self-test  (mono + stereo)
+# =============================================================================
+
+def _demo() -> None:
+    """
+    Self-test: mono and stereo synthetic signals, both algorithms, both frames.
+    """
+    print("=" * 65)
+    print("SPADE Declipping v3 — Self-Test  (mono + stereo)")
+    print("=" * 65)
+
+    sr = 16_000
+    t  = np.linspace(0, 1, sr, endpoint=False)
+
+    def make_tonal(freqs_amps):
+        sig = sum(a * np.sin(2 * np.pi * f * t) for f, a in freqs_amps)
+        return sig / np.max(np.abs(sig))
+
+    clean_L = make_tonal([(440, 0.5), (880, 0.3), (1320, 0.15)])
+    clean_R = make_tonal([(550, 0.5), (1100, 0.3), (2200, 0.1)])
+    clean_stereo = np.column_stack([clean_L, clean_R])   # (N, 2)
+
+    theta_c = 0.6
+    clipped_stereo = np.clip(clean_stereo, -theta_c, theta_c)
+    n_clip_L = np.mean(np.abs(clipped_stereo[:, 0]) >= theta_c) * 100
+    n_clip_R = np.mean(np.abs(clipped_stereo[:, 1]) >= theta_c) * 100
+    print("\ntheta_c =", theta_c,
+          " | L clipped:", str(round(n_clip_L, 1)) + "%",
+          " R clipped:", str(round(n_clip_R, 1)) + "%")
+
+    for algo in ("sspade", "aspade"):
+        for fr in ("dct", "rdft"):
+            params = DeclipParams(
+                algo=algo, frame=fr,
+                window_length=1024, hop_length=256,
+                s=1, r=1, eps=0.1, max_iter=500,
+                n_jobs=2,        # process L and R in parallel
+                verbose=False,
+            )
+            fixed, masks_list = declip(clipped_stereo, params)
+            dsdr_L = delta_sdr(clean_stereo[:, 0], clipped_stereo[:, 0], fixed[:, 0])
+            dsdr_R = delta_sdr(clean_stereo[:, 1], clipped_stereo[:, 1], fixed[:, 1])
+            tag = algo.upper() + " + " + fr.upper()
+            print("  " + tag + "  |  L DSDR=" + str(round(dsdr_L, 1)) + " dB"
+                  "  R DSDR=" + str(round(dsdr_R, 1)) + " dB")
+
+    # Quick mono sanity check
+    print("\n--- Mono sanity check ---")
+    clipped_mono = np.clip(clean_L, -theta_c, theta_c)
+    params_mono  = DeclipParams(algo="sspade", frame="rdft",
+                                window_length=1024, hop_length=256,
+                                s=1, r=1, eps=0.1, max_iter=500)
+    fixed_mono, _ = declip(clipped_mono, params_mono)
+    print("  SSPADE+RDFT mono  DSDR =",
+          str(round(delta_sdr(clean_L, clipped_mono, fixed_mono), 1)), "dB")
+
+    print("\nSelf-test complete.")
+
+
+if __name__ == "__main__":
+    import sys
+    if "--demo" in sys.argv:
+        _demo()
+    else:
+        main()

spade_unrolled.py

@@ -0,0 +1,1484 @@
+"""
+spade_unrolled.py  —  SPADE Unrolled  (Algorithm Unrolling + Context Encoder)
+================================================================================
+
+Replaces the fixed S-SPADE solver (v12) with a learned parameter predictor.
+
+Architecture
+------------
+
+  Input (limited audio frame + K context frames)
+       ↓
+  SpectralFeatureExtractor
+    • log-mel spectrogram (n_mels=32) per frame
+    • short-time loudness proxy (RMS in dB)
+    → shape: (B, K+1, n_mels+1)
+       ↓
+  ContextEncoder (causal GRU)
+    • 2-layer GRU, hidden_size=128
+    • Only K previous frames are seen (strict causality)
+    → h_t: (B, 128)
+       ↓
+  ParameterHead  (linear → 5 outputs per frame)
+    • lambda_lf   : soft-threshold for LF bins (≥ 0)
+    • lambda_hf   : soft-threshold for HF bins (≥ 0)
+    • delta_factor: scales delta_db    ∈ [0.5, 2.0]
+    • gmax_factor : scales max_gain_db ∈ [0.5, 2.0]
+    • eps_factor  : scales convergence eps ∈ [0.5, 2.0]
+       ↓
+  UnrolledADMM   (K_unroll=8 fixed layers, fully differentiable)
+    Each layer:
+      1. Analysis:     z = frana(x, frame)          — DCT / RDFT
+      2. Soft-thresh:  z̃ = S_λ(z + u)              — stratified LF/HF
+      3. Synthesis:    Dv = frsyn(z̃ - u, frame, M)  — reconstruction
+      4. Projection:   pDv = proj_Γ(Dv, yc, masks, g_max)
+      5. Residual:     z ← z̃ - u - frana(Dv - pDv, frame)
+      6. Dual update:  u ← u + z - z̃
+    →  x̂ = frsyn(z_K, frame, M)
+       ↓
+  Output: restored audio frame (B, M)
+
+Key differences from v12 (classical SPADE)
+-------------------------------------------
+• Hard thresholding H_k (L0)  →  differentiable soft thresholding S_λ (L1 proxy)
+• Fixed hyperparameters       →  predicted per-frame by ContextEncoder
+• Fixed iteration count       →  exactly K_unroll unrolled layers (no convergence loop)
+• Global sparsity level k     →  independent LF/HF soft-threshold budgets
+
+Transform operators  (GPU-compatible, differentiable)
+------------------------------------------------------
+The DCT-II / RDFT analysis-synthesis operators from spade_declip_v12 are
+re-implemented in PyTorch so gradients flow through them.  Numerically they
+match scipy to float32 precision.
+
+Projection operator
+-------------------
+proj_Γ is already differentiable (clamp + max/min).  Gradients flow through
+the Icp / Icm branches; Ir samples are pinned (zero gradient, correct).
+
+WOLA (Weighted Overlap-Add) integration
+----------------------------------------
+The model processes individual frames.  The full WOLA loop lives in
+SPADEUnrolledInference which wraps UnrolledSPADE with frame extraction +
+accumulation.  Training uses individual frames to allow per-sample gradient
+computation without materialising the full signal in the graph.
+
+References
+----------
+[1] Gregor & LeCun, "Learning Fast Approximations of Sparse Coding", ICML 2010.
+[2] Adler et al., "Learned Primal-Dual Reconstruction", IEEE TMI 2018.
+[3] Kitić et al., "SPADE", LVA/ICA 2015 (arXiv:1506.01830).
+[4] Záviška et al., "Revisiting SPADE", 2018 (arXiv:1807.03612).
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Tuple
+
+import numpy as np
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    _TORCH_OK = True
+except ImportError:
+    _TORCH_OK = False
+    raise ImportError("PyTorch is required for spade_unrolled.py  (pip install torch)")
+
+
+# =============================================================================
+# Config dataclass
+# =============================================================================
+
+@dataclass
+class UnrolledConfig:
+    """All hyperparameters for the SPADE-Unrolled model."""
+
+    # ── Signal / transform ────────────────────────────────────────────────
+    # Defaults from run_smart_sweep.py rank-1 result:
+    #   window=2048, hop=512  (score=0.916, the best-performing WOLA config)
+    window_length:  int   = 2048          # M — samples per WOLA frame
+    hop_length:     int   = 512           # a — WOLA hop
+    frame:          Literal["dct", "rdft"] = "rdft"  # transform type
+    sample_rate:    int   = 44100
+
+    # ── Unrolling ─────────────────────────────────────────────────────────
+    # K_unroll=4: literatura su algorithm unrolling (LISTA, ALISTA, ISTA-Net)
+    # mostra 3-5 layer come punto ottimale. Con K=8 e soft-thresh, il prodotto
+    # dei Jacobiani attraverso le dead zones → grad ≈ 0 al GRU.
+    K_unroll: int = 4                     # number of ADMM layers per frame
+
+    # ── Context encoder ───────────────────────────────────────────────────
+    K_context:    int = 8                 # # of past frames fed to GRU
+    n_mels:       int = 32                # mel bands for feature extraction
+    gru_hidden:   int = 128               # GRU hidden size
+    gru_layers:   int = 2                 # GRU depth
+
+    # ── Per-frame parameter bounds ────────────────────────────────────────
+    # All outputs of the head are mapped to these ranges.
+    #
+    # Lambda calibration rationale  (POST-NORMALISATION)
+    # ---------------------------------------------------
+    # UnrolledADMM normalises each frame by its max DCT coefficient magnitude,
+    # so inside the ADMM loop ALL coefficients are in [-1, 1] with max = 1.0.
+    # Lambda must therefore be expressed relative to this [0, 1] scale.
+    #
+    # For a typical kick drum (M=1024, 44100 Hz), the 47 LF bins (≤ 1 kHz)
+    # have post-normalisation magnitudes distributed roughly as 1/k:
+    #   p25 ≈ 0.028  median ≈ 0.042  p75 ≈ 0.083
+    # A lambda in (0.01, 0.50) spans the full meaningful sparsification range
+    # from "keep almost all" to "keep only the dominant few" coefficients.
+    #
+    # Previous range (1e-6, 0.015) was 10-100× too small: even at the maximum
+    # λ=0.015, ZERO LF coefficients were ever thresholded → pure all-pass →
+    # encoder collapsed to identity (λ→0) because the loss gradient for λ
+    # was essentially zero everywhere in (0, 0.015).
+    lambda_lf_range:  Tuple[float, float] = (1e-3, 0.50)
+    # Upper bound reduced 0.30 → 0.08.
+    # For M=2048, sr=44100: HF DCT coefficients (>1kHz, post-normalisation)
+    # have typical magnitudes 0.01–0.06.  With λ_hf=0.10 (old upper range median)
+    # *all* HF content was zeroed → dsdr_high < −1 dB at every epoch.
+    # Cap at 0.08 ensures only sub-noise coefficients are thresholded.
+    lambda_hf_range:  Tuple[float, float] = (1e-3, 0.08)
+    delta_factor_range:  Tuple[float, float] = (0.5,  1.5)
+    # [FIX] Range expanded to (0.5, 2.0): with base_max_gain_db=12 this maps
+    # to g_max ∈ [6, 24] dB, giving the Parameter Head full freedom to be
+    # conservative in the mid band (g_fac≈0.5 → 6 dB) or aggressive in
+    # sub-bass (g_fac≈2.0 → 24 dB) without hitting a hard floor/ceiling.
+    # The old (0.85, 1.5) floor was causing mid regression: the model could
+    # not reduce gain selectively in the 500–2000 Hz region.
+    gmax_factor_range:   Tuple[float, float] = (0.2, 2.0)
+    eps_factor_range:    Tuple[float, float] = (0.5,  1.5)
+
+    # ── LF/HF split ──────────────────────────────────────────────────────
+    # 8000 Hz is the crossover between:
+    #   LF (0–8 kHz): learned reconstruction — this is where v11 S-SPADE
+    #                 struggled (kick body, transient fundamental, sub-bass).
+    #                 The model learns a content-adaptive sparse prior here.
+    #   HF (8–22 kHz): v11 S-SPADE hard thresholding H_k is used unchanged
+    #                  via HybridSPADEInference — v11 already recovers HF
+    #                  transients (cymbal snap, hi-hat attack) accurately.
+    # During training, the model processes the full LF-bandpassed signal.
+    # At inference, HybridSPADEInference handles the LR split and v11 HF.
+    lf_cutoff_hz: float = 8000.0          # bins below this → LF soft thresh (learned)
+
+    # ── Base SPADE params (encoder predicts *multipliers* of these) ───────
+    # Initialised from run_smart_sweep.py rank-1 result (score=0.916):
+    #   delta_db=3.5, eps=0.05
+    # max_gain_db: sweep rank-1 = 9.0, but Phase-1 training showed the model
+    # converges to g_fac≈0.50 (factor range lower bound) which gives 4.5 dB.
+    # Using base=6.0 dB instead: g_fac=0.75 (mid-range) → 4.5 dB, and the
+    # model can still explore up to 9.0 dB (g_fac=1.5) if needed.
+    base_delta_db:    float = 3.5         # rank-1: delta_db
+    base_max_gain_db: float = 6.0         # calibrated: g_fac=0.75 → 4.5 dB (Phase-1 optimum)
+    base_eps:         float = 0.05        # rank-1: eps
+
+    # lf_delta_db from rank-1 = 1.0 vs delta_db = 3.5  →  ratio ≈ 0.286
+    # Used to derive a softer lambda_lf initialisation relative to lambda_hf:
+    # lower lf_delta means LF region is recovered more aggressively (fewer
+    # coefficients zeroed), so lambda_lf_init < lambda_hf_init.
+    lf_delta_ratio:   float = 0.286       # lf_delta_db / delta_db  (rank-1: 1.0/3.5)
+
+
+# =============================================================================
+# Transform operators (differentiable, GPU-compatible)
+# =============================================================================
+
+def _dct2(x: torch.Tensor) -> torch.Tensor:
+    """Batched orthonormal DCT-II.  x: (..., N) → (..., N).
+    Matches scipy.fft.dct(x, type=2, norm='ortho') to float32.
+    Makhoul (1980) FFT-based algorithm.
+    """
+    N = x.shape[-1]
+    v = torch.cat([x[..., ::2], x[..., 1::2].flip(-1)], dim=-1)
+    V = torch.fft.fft(v.double(), dim=-1)
+    k = torch.arange(N, device=x.device, dtype=torch.float64)
+    tw = torch.exp(-1j * math.pi * k / (2.0 * N))
+    C = (tw * V).real * math.sqrt(2.0 / N)
+    C = C.clone()
+    C[..., 0] /= math.sqrt(2.0)
+    return C.to(x.dtype)
+
+
+def _idct2(X: torch.Tensor) -> torch.Tensor:
+    """Batched orthonormal IDCT-II.  X: (..., N) → (..., N).
+    Inverse of _dct2.  BUG-GPU-3 fix included.
+    """
+    N = X.shape[-1]
+    C = X.double() * math.sqrt(N / 2.0)
+    C = C.clone()
+    C[..., 0] *= math.sqrt(2.0)
+    ipart = torch.zeros_like(C)
+    ipart[..., 1:] = -C.flip(-1)[..., :-1]
+    W = torch.view_as_complex(torch.stack([C, ipart], dim=-1))
+    k = torch.arange(N, device=X.device, dtype=torch.float64)
+    V = W * torch.exp(1j * math.pi * k / (2.0 * N))
+    v = torch.fft.ifft(V, dim=-1).real
+    half = (N + 1) // 2
+    x = torch.empty_like(v)
+    x[..., ::2] = v[..., :half]
+    x[..., 1::2] = v[..., half:].flip(-1)
+    return x.to(X.dtype)
+
+
+def frana(x: torch.Tensor, frame: str) -> torch.Tensor:
+    """Analysis operator A: (..., M) → (..., P).
+    DCT:  P = M;  RDFT: P = 2M.
+    Differentiable.
+    """
+    if frame == "dct":
+        return _dct2(x)
+    s2 = math.sqrt(2.0)
+    return torch.cat([_dct2(x) / s2, _dct2(x.flip(-1)) / s2], dim=-1)
+
+
+def frsyn(z: torch.Tensor, frame: str, M: int) -> torch.Tensor:
+    """Synthesis operator D = A^H: (..., P) → (..., M).
+    Adjoint of frana.  BUG-1 fix: flip output (not input) for DST part.
+    Differentiable.
+    """
+    if frame == "dct":
+        return _idct2(z)
+    s2 = math.sqrt(2.0)
+    cos_part = _idct2(z[..., :M]) / s2
+    sin_part = _idct2(z[..., M:]).flip(-1) / s2
+    return cos_part + sin_part
+
+
+def build_lf_mask(M: int, frame: str, sr: int, lf_cutoff_hz: float,
+                  device: torch.device) -> torch.Tensor:
+    """Boolean mask: True for LF bins (freq < lf_cutoff_hz).  Shape: (P,)."""
+    P = M if frame == "dct" else 2 * M
+    mask = torch.zeros(P, dtype=torch.bool, device=device)
+    k_cut = int(math.ceil(lf_cutoff_hz * 2.0 * M / sr))
+    k_cut = max(1, min(k_cut, M))
+    if frame == "dct":
+        mask[:k_cut] = True
+    else:
+        mask[:k_cut] = True
+        mask[M:M + k_cut] = True
+    return mask
+
+
+# =============================================================================
+# Differentiable Projection onto Γ
+# =============================================================================
+
+def proj_gamma_torch(
+    w: torch.Tensor,          # (..., M) — time-domain estimate
+    yc: torch.Tensor,         # (..., M) — limited signal
+    Ir: torch.Tensor,         # (..., M) bool — reliable
+    Icp: torch.Tensor,        # (..., M) bool — positive-clipped
+    Icm: torch.Tensor,        # (..., M) bool — negative-clipped
+    g_max: float = float("inf"),
+) -> torch.Tensor:
+    """
+    Differentiable projection onto the consistency set Γ.
+
+    Reliable samples: pin to yc (zero gradient — correct for training).
+    Positive clipped: lower bound max(w, yc), optional upper bound yc*g_max.
+    Negative clipped: upper bound min(w, yc), optional lower bound yc*g_max.
+
+    NOTE: The gradient through Ir positions is zero by construction — the
+    model cannot change reliable samples.  This is the physically correct
+    inductive bias: SPADE must be transparent on non-limited regions.
+    """
+    v = w.clone()
+
+    # Reliable: pin exactly — no gradient contribution from these
+    v = torch.where(Ir, yc, v)
+
+    # Positive clipped: lower-bound constraint ≥ yc
+    lower_p = yc * Icp.float()
+    if math.isfinite(g_max):
+        upper_p = (lower_p * g_max).clamp(min=lower_p)
+        v = torch.where(Icp, torch.clamp(torch.maximum(v, lower_p),
+                                          min=lower_p, max=upper_p), v)
+    else:
+        v = torch.where(Icp, torch.maximum(v, yc), v)
+
+    # Negative clipped: upper-bound constraint ≤ yc
+    upper_m = yc * Icm.float()  # negative values
+    if math.isfinite(g_max):
+        lower_m_cap = (upper_m * g_max).clamp(max=upper_m)
+        v = torch.where(Icm, torch.clamp(torch.minimum(v, upper_m),
+                                          min=lower_m_cap, max=upper_m), v)
+    else:
+        v = torch.where(Icm, torch.minimum(v, yc), v)
+
+    return v
+
+
+# =============================================================================
+# Differentiable stratified soft thresholding
+# =============================================================================
+
+def soft_thresh_stratified(
+    z: torch.Tensor,          # (..., P) — coefficient vector
+    u: torch.Tensor,          # (..., P) — dual variable (same shape)
+    lambda_lf: torch.Tensor,  # (..., 1) — LF threshold
+    lambda_hf: torch.Tensor,  # (..., 1) — HF threshold
+    lf_mask: torch.Tensor,    # (P,)     — True = LF bin
+) -> torch.Tensor:
+    """
+    Differentiable soft-thresholding S_λ(z+u) with separate LF/HF budgets.
+
+    S_λ(x) = sign(x) * max(|x| - λ, 0)
+
+    LF bins (lf_mask=True) : threshold = lambda_lf
+    HF bins (lf_mask=False): threshold = lambda_hf
+
+    Replaces the hard (non-differentiable) H_k thresholding in classical SPADE.
+    """
+    x = z + u
+    # Broadcast lf_mask to match x shape
+    lf = lf_mask.view(*([1] * (x.dim() - 1)), -1)  # (..., P)
+    lam = torch.where(lf, lambda_lf, lambda_hf)    # (..., P)
+    return torch.sign(x) * F.relu(x.abs() - lam)
+
+
+# =============================================================================
+# Spectral Feature Extractor  (for Context Encoder input)
+# =============================================================================
+
+class SpectralFeatureExtractor(nn.Module):
+    """
+    Converts a raw audio frame (shape: B × M) into a feature vector
+    suitable for the ContextEncoder.
+
+    Features per frame:
+      • log-mel spectrogram: n_mels values (shape of spectral envelope)
+      • short-time loudness:  1 value (RMS in dB, proxy for LUFS)
+      → total: n_mels + 1  features
+
+    Implementation note:
+      Uses a fixed (non-trained) triangular mel filterbank computed from
+      the DCT-II power spectrum.  Mel filters are registered as buffers so
+      they move with the module to the correct device automatically.
+    """
+
+    def __init__(self, cfg: UnrolledConfig):
+        super().__init__()
+        self.M   = cfg.window_length
+        self.sr  = cfg.sample_rate
+        self.n_mels = cfg.n_mels
+        self.P = self.M if cfg.frame == "dct" else 2 * self.M
+
+        # ── Build mel filterbank (fixed, not trained) ─────────────────────
+        # Map DCT frequency bins → mel scale using triangular filters.
+        # We use only the DCT-part (first M bins of RDFT) for the spectrogram.
+        mel_filters = self._build_mel_filterbank()           # (n_mels, M)
+        self.register_buffer("mel_filters", mel_filters)
+
+    def _build_mel_filterbank(self) -> torch.Tensor:
+        """Triangular mel filterbank as a (n_mels, M) matrix."""
+        def hz_to_mel(f):
+            return 2595.0 * math.log10(1.0 + f / 700.0)
+
+        def mel_to_hz(m):
+            return 700.0 * (10.0 ** (m / 2595.0) - 1.0)
+
+        M  = self.M
+        sr = self.sr
+        n_mels = self.n_mels
+
+        mel_lo = hz_to_mel(20.0)
+        mel_hi = hz_to_mel(min(sr / 2.0, 20000.0))
+        mel_pts = torch.linspace(mel_lo, mel_hi, n_mels + 2)
+        hz_pts  = torch.tensor([mel_to_hz(m.item()) for m in mel_pts])
+
+        # DCT-II bin frequencies: f_k = k * sr / (2M)
+        freqs   = torch.arange(M, dtype=torch.float32) * sr / (2.0 * M)
+        filters = torch.zeros(n_mels, M)
+
+        for m in range(n_mels):
+            f_lo = hz_pts[m].item()
+            f_c  = hz_pts[m + 1].item()
+            f_hi = hz_pts[m + 2].item()
+            # Rising flank: lo → c
+            mask_r = (freqs >= f_lo) & (freqs <= f_c)
+            if (f_c - f_lo) > 0:
+                filters[m][mask_r] = (freqs[mask_r] - f_lo) / (f_c - f_lo)
+            # Falling flank: c → hi
+            mask_f = (freqs > f_c) & (freqs <= f_hi)
+            if (f_hi - f_c) > 0:
+                filters[m][mask_f] = (f_hi - freqs[mask_f]) / (f_hi - f_c)
+
+        # Normalise each filter to unit area (power-preserving)
+        area = filters.sum(dim=-1, keepdim=True).clamp(min=1e-8)
+        return filters / area
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        x: (B, M) — raw audio frame (windowed or not)
+        returns: (B, n_mels + 1) — spectral features
+        """
+        B, M = x.shape
+
+        # ── Log-mel spectrogram ───────────────────────────────────────────
+        dct_coeff = _dct2(x.float())               # (B, M)
+        power_spec = dct_coeff[:, :M] ** 2          # (B, M) — DCT-part power
+        mel_spec   = torch.matmul(power_spec,
+                                   self.mel_filters.T)          # (B, n_mels)
+        log_mel    = torch.log(mel_spec.clamp(min=1e-10))
+
+        # ── Short-time loudness (RMS in dB) ───────────────────────────────
+        rms  = x.pow(2).mean(dim=-1, keepdim=True).clamp(min=1e-10).sqrt()
+        lufs = 20.0 * torch.log10(rms.clamp(min=1e-10))  # (B, 1) — dBFS approx
+
+        return torch.cat([log_mel, lufs], dim=-1)           # (B, n_mels+1)
+
+
+# =============================================================================
+# Context Encoder  (causal GRU → per-frame parameters)
+# =============================================================================
+
+class ContextEncoder(nn.Module):
+    """
+    Causal GRU encoder that predicts per-frame SPADE parameters from
+    the spectral context of K previous frames + the current frame.
+
+    Input:  (B, K_context+1, n_feats) — spectral features, last dim = current
+    Output: (B, 5) — [lambda_lf, lambda_hf, delta_factor, gmax_factor, eps_factor]
+                     All values are in their configured physical range.
+
+    Architecture:
+      Input linear projection → 2-layer GRU → last hidden state → ParameterHead
+
+    Causality:
+      The GRU processes the context sequence [frame_{t-K}, …, frame_{t-1}, frame_t]
+      in forward order.  Only the hidden state at the LAST position (frame_t) is
+      used to predict parameters for frame_t.  No future frames are seen.
+
+    Parameter ~count:
+      input_proj:   (n_feats, 64)            →   64 * (n_feats+1)  ≈   2 K
+      GRU layer 1:  input=64, hidden=128     →   3 * 128 * (64+128+1)  ≈  74 K
+      GRU layer 2:  input=128, hidden=128    →   3 * 128 * (128+128+1) ≈  98 K
+      head:         128 → 64 → 5            →   ~ 8 K
+      ─────────────────────────────────────────────────────────────────────
+      Total:        ~ 182 K  (target ≤ 200 K)
+    """
+
+    def __init__(self, cfg: UnrolledConfig):
+        super().__init__()
+        self.cfg    = cfg
+        n_feats     = cfg.n_mels + 1          # spectral + loudness
+        proj_dim    = 64
+
+        self.input_proj = nn.Sequential(
+            nn.Linear(n_feats, proj_dim),
+            nn.LayerNorm(proj_dim),
+            nn.GELU(),
+        )
+        self.gru = nn.GRU(
+            input_size=proj_dim,
+            hidden_size=cfg.gru_hidden,
+            num_layers=cfg.gru_layers,
+            batch_first=True,
+            dropout=0.1 if cfg.gru_layers > 1 else 0.0,
+        )
+        self.head = nn.Sequential(
+            nn.Linear(cfg.gru_hidden, 64),
+            nn.GELU(),
+            nn.Linear(64, 5),   # 5 output parameters
+        )
+        # ── Bias initialisation ───────────────────────────────────────────
+        # delta/gmax/eps: with range (0.5, 1.5), sigmoid(0) = 0.5 → factor = 1.0
+        # (identity: start exactly at the sweep-optimised base values).
+        # bias[2,3,4] remain at 0 → correct.
+        #
+        # lambda_lf / lambda_hf: start near median post-normalised coeff (~0.042).
+        # The sweep rank-1 has lf_delta_ratio=0.286, meaning LF recovery is softer
+        # (lower effective threshold).  We encode this as lambda_lf starting lower
+        # than lambda_hf, so fewer LF coefficients are zeroed on iteration 1.
+        #
+        # For lambda range (lo, hi) = (1e-3, 0.5):
+        #   bias_hf = -1.4 → sigmoid(-1.4)=0.198 → lambda_hf ≈ 0.001+0.499*0.198 = 0.10
+        #   bias_lf = bias_hf + ln(lf_delta_ratio) ≈ -1.4 + (-1.25) = -2.65
+        #           → sigmoid(-2.65)=0.066 → lambda_lf ≈ 0.001+0.499*0.066 = 0.034
+        # Ratio lambda_lf/lambda_hf ≈ 0.34 — reflects the softer LF threshold.
+        lf_ratio = getattr(cfg, "lf_delta_ratio", 1.0)
+        lf_bias_offset = math.log(max(lf_ratio, 1e-3))   # negative → lower lambda_lf
+        with torch.no_grad():
+            self.head[-1].bias[0] = -1.4 + lf_bias_offset  # lambda_lf init ≈ 0.034 (range 0.001–0.50)
+            # lambda_hf: range changed to (0.001, 0.08), span=0.079.
+            # Target init ≈ 0.03 (passes real transient energy, zeros only noise).
+            # sigmoid(-0.54) = 0.368 → λ_hf = 0.001 + 0.079*0.368 ≈ 0.030
+            # Previous bias=-1.4 with old range (0.001,0.30) also gave 0.10,
+            # but 0.10 zeroed all HF DCT bins for M=2048 → dsdr_high always < 0.
+            self.head[-1].bias[1] = -0.54                   # lambda_hf init ≈ 0.030
+
+    def forward(self, feat_seq: torch.Tensor) -> torch.Tensor:
+        """
+        feat_seq: (B, K_context+1, n_feats) — spectral features, ordered t-K … t
+        returns:  (B, 5) — physical parameter values
+        """
+        B, T, _ = feat_seq.shape
+        projected = self.input_proj(feat_seq)           # (B, T, 64)
+        gru_out, _ = self.gru(projected)                # (B, T, 128)
+        h_t = gru_out[:, -1, :]                         # (B, 128) — last step only
+
+        raw = self.head(h_t)                            # (B, 5)  — unconstrained
+        params = self._scale_outputs(raw)               # (B, 5)  — physical ranges
+        return params
+
+    def _scale_outputs(self, raw: torch.Tensor) -> torch.Tensor:
+        """Apply sigmoid + affine rescaling to map raw logits → physical ranges."""
+        s = torch.sigmoid(raw)                          # (B, 5) in (0, 1)
+
+        def rescale(x_01, lo, hi):
+            return lo + (hi - lo) * x_01
+
+        cfg = self.cfg
+        lambda_lf    = rescale(s[:, 0], *cfg.lambda_lf_range)
+        lambda_hf    = rescale(s[:, 1], *cfg.lambda_hf_range)
+        delta_factor = rescale(s[:, 2], *cfg.delta_factor_range)
+        gmax_factor  = rescale(s[:, 3], *cfg.gmax_factor_range)
+        eps_factor   = rescale(s[:, 4], *cfg.eps_factor_range)
+
+        return torch.stack([lambda_lf, lambda_hf, delta_factor,
+                             gmax_factor, eps_factor], dim=-1)
+
+
+# =============================================================================
+# Unrolled ADMM  (K_unroll differentiable SPADE layers)
+# =============================================================================
+
+class UnrolledADMM(nn.Module):
+    """
+    K_unroll unrolled S-SPADE ADMM layers with differentiable soft thresholding.
+
+    Each layer follows the S-SPADE update equations from [4] eq.(12),
+    with hard thresholding H_k replaced by stratified soft thresholding S_λ:
+
+        z̄^(l) = S_{λ_LF, λ_HF}( z^(l-1) + u^(l-1) )   ← stratified soft thresh
+        v^(l)  = z̄^(l) - u^(l-1)
+        Dv     = frsyn(v^(l), frame, M)
+        pDv    = proj_Γ(Dv, yc, masks, g_max)
+        z^(l)  = v^(l) - frana(Dv - pDv, frame)
+        u^(l)  = u^(l-1) + z^(l) - z̄^(l)               ← dual update
+
+    The frame parameters (lambda_lf, lambda_hf, g_max) are computed ONCE before
+    the loop from the ContextEncoder output and held constant across all layers
+    for the current frame.
+
+    Learnable per-layer scalings
+    ----------------------------
+    Following Gregor & LeCun (2010), we add a learnable scale per layer for
+    both the threshold and the dual step:
+        layer_lf_scale[l]   : multiplied on lambda_lf before thresholding
+        layer_hf_scale[l]   : multiplied on lambda_hf before thresholding
+        layer_dual_scale[l] : multiplied on the dual update magnitude
+
+    These are initialised to 1.0 and learned jointly with the encoder.
+    They allow the unrolled ADMM to adapt the effective threshold per layer
+    (e.g. coarser thresh early, finer late) without changing the architecture.
+
+    Total learnable params here: 3 × K_unroll  ≈ 24 scalars  (negligible)
+    """
+
+    def __init__(self, cfg: UnrolledConfig):
+        super().__init__()
+        self.cfg      = cfg
+        self.M        = cfg.window_length
+        self.frame    = cfg.frame
+        self.K        = cfg.K_unroll
+
+        # Per-layer learnable scale factors.
+        # Mirror S-SPADE where k increases over iterations (threshold decreases).
+        # Range [1.5 → 0.3]: aggressive early thresholding, fine late.
+        # Kept smaller than before (was [3.0,0.6]) to avoid over-killing the
+        # gradient in the first layers.
+        n = self.K
+        init_scales = torch.linspace(1.5, 0.3, n)
+        self.layer_lf_scale   = nn.Parameter(init_scales.clone())
+        self.layer_hf_scale   = nn.Parameter(init_scales.clone())
+        self.layer_dual_scale = nn.Parameter(torch.ones(n))
+
+    def forward(
+        self,
+        yc_w: torch.Tensor,           # (B, M)  — windowed limited frame
+        Ir:   torch.Tensor,           # (B, M)  bool — reliable
+        Icp:  torch.Tensor,           # (B, M)  bool — pos-clipped
+        Icm:  torch.Tensor,           # (B, M)  bool — neg-clipped
+        lambda_lf:  torch.Tensor,     # (B,)    — LF soft-threshold
+        lambda_hf:  torch.Tensor,     # (B,)    — HF soft-threshold
+        g_max:      torch.Tensor,     # (B,)    — linear gain cap
+        lf_mask:    torch.Tensor,     # (P,)    bool — LF bin mask
+    ) -> Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
+        """
+        Returns
+        -------
+        x_hat     : (B, M)       — restored frame (final layer)
+        z_thresh  : (B, P)       — thresholded coefficients at final layer
+                                   (used for sparsity loss: L1 penalty)
+        x_hat_mid : (B, M) | None — restored frame at K//2 layer
+                                   (used for deep supervision auxiliary loss)
+        """
+        B, M = yc_w.shape
+        P    = M if self.frame == "dct" else 2 * M
+
+        # ── Per-frame input normalisation ─────────────────────────────────
+        # Scale yc_w so that the max DCT coefficient magnitude ≈ 1.0.
+        # IMPORTANT: .detach() — frame_scale is a normalisation constant
+        # computed from the INPUT (not a learned parameter).  Without detach,
+        # the gradient flows back through amax/clamp into the DCT of yc_w,
+        # creating a confusing secondary path that competes with ∂loss/∂λ.
+        yc_d = yc_w.double()
+        z_init = frana(yc_d, self.frame)                     # (B, P)
+        frame_scale = z_init.abs().amax(dim=-1, keepdim=True).clamp(min=1e-8).detach()
+        yc_d_norm = yc_d / frame_scale                       # normalised frame
+
+        # ── Initialise ADMM state ─────────────────────────────────────────
+        zi = frana(yc_d_norm, self.frame)        # (B, P)  float64
+        ui = torch.zeros_like(zi)
+
+        # Expand lambda tensors for broadcasting: (B,) → (B, 1)
+        lam_lf = lambda_lf.unsqueeze(-1).double()    # (B, 1)
+        lam_hf = lambda_hf.unsqueeze(-1).double()    # (B, 1)
+
+        # Normalise masks and yc to the same frame scale
+        Ir_d  = Ir.bool()
+        Icp_d = Icp.bool()
+        Icm_d = Icm.bool()
+        yc_norm_d = yc_d_norm   # already computed above
+
+        # g_max is scale-invariant (ratio), no adjustment needed
+
+        # ── Unrolled ADMM layers ──────────────────────────────────────────
+        mid_layer = self.K // 2
+        x_hat_mid: Optional[torch.Tensor] = None
+        zb_last = torch.zeros_like(zi)   # will hold last thresholded coefficients
+
+        for l in range(self.K):
+            scale_lf   = self.layer_lf_scale[l].double().clamp(min=0.1)   # prevent negative
+            scale_hf   = self.layer_hf_scale[l].double().clamp(min=0.1)
+            scale_dual = self.layer_dual_scale[l].double()
+
+            # Step 2: stratified soft thresholding
+            zb = soft_thresh_stratified(
+                zi, ui,
+                lam_lf * scale_lf,
+                lam_hf * scale_hf,
+                lf_mask,
+            )                                         # (B, P)
+            zb_last = zb   # track for sparsity loss
+
+            # Step 3: projection onto Γ via eq.(12)
+            v_c  = zb - ui                            # (B, P)
+            Dv   = frsyn(v_c, self.frame, M)          # (B, M)
+
+            # Differentiable proj_Γ on the normalised domain
+            pDv = Dv.clone()
+            pDv = torch.where(Ir_d, yc_norm_d, pDv)
+
+            # Positive clipped
+            lo_p = yc_norm_d
+            hi_p = lo_p * g_max.unsqueeze(-1).double().clamp(min=1.0)
+            pDv  = torch.where(Icp_d, torch.clamp(torch.maximum(pDv, lo_p),
+                                                   min=lo_p, max=hi_p), pDv)
+
+            # Negative clipped
+            up_m   = yc_norm_d
+            lo_m   = up_m * g_max.unsqueeze(-1).double().clamp(min=1.0)
+            lo_m_c = torch.minimum(lo_m, up_m)
+            pDv    = torch.where(Icm_d, torch.clamp(torch.minimum(pDv, up_m),
+                                                    min=lo_m_c, max=up_m), pDv)
+
+            # ADMM coefficient update — eq.(12) from [4]
+            zi = v_c - frana(Dv - pDv, self.frame)    # (B, P)
+
+            # Dual update
+            ui = ui + (zi - zb) * scale_dual
+
+            # ── Deep supervision: record mid-layer reconstruction ─────────
+            if l == mid_layer - 1:
+                x_mid_norm = frsyn(zi, self.frame, M)
+                x_hat_mid  = (x_mid_norm * frame_scale).float()
+
+        # Synthesise output and invert the per-frame normalisation
+        x_hat_norm = frsyn(zi, self.frame, M)              # (B, M)
+        x_hat = (x_hat_norm * frame_scale).float()         # back to original scale
+
+        # Return thresholded coefficients (float32, original scale) for sparsity loss
+        z_thresh = (zb_last * frame_scale).float()
+
+        return x_hat, z_thresh, x_hat_mid
+
+
+# =============================================================================
+# Full SPADE-Unrolled model
+# =============================================================================
+
+class SPADEUnrolled(nn.Module):
+    """
+    Full SPADE-Unrolled model.
+
+    Combines:
+      1. SpectralFeatureExtractor  — raw frames → spectral features
+      2. ContextEncoder            — spectral context → per-frame SPADE params
+      3. UnrolledADMM              — K differentiable ADMM layers
+
+    Forward pass (single-frame mode for training):
+      • Takes a batch of (limited frame, K context frames, clipping masks)
+      • Returns the restored frame and the predicted parameters (for logging)
+
+    Inference mode (WOLA loop):
+      • Use SPADEUnrolledInference wrapper to process full signals
+    """
+
+    def __init__(self, cfg: UnrolledConfig):
+        super().__init__()
+        self.cfg = cfg
+
+        self.feature_extractor = SpectralFeatureExtractor(cfg)
+        self.context_encoder   = ContextEncoder(cfg)
+        self.unrolled_admm     = UnrolledADMM(cfg)
+
+        # LF mask — registered as buffer (moves with module.to(device))
+        # Built lazily on first forward call (needs device info)
+        self._lf_mask: Optional[torch.Tensor] = None
+
+    def _get_lf_mask(self, device: torch.device) -> torch.Tensor:
+        if self._lf_mask is None or self._lf_mask.device != device:
+            self._lf_mask = build_lf_mask(
+                self.cfg.window_length, self.cfg.frame,
+                self.cfg.sample_rate, self.cfg.lf_cutoff_hz,
+                device,
+            )
+        return self._lf_mask
+
+    def forward(
+        self,
+        yc_w:      torch.Tensor,   # (B, M)         — current windowed limited frame
+        ctx_frames: torch.Tensor,  # (B, K_ctx, M)  — K previous frames (limited, windowed)
+        Ir:        torch.Tensor,   # (B, M)  bool
+        Icp:       torch.Tensor,   # (B, M)  bool
+        Icm:       torch.Tensor,   # (B, M)  bool
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
+        """
+        Returns
+        -------
+        x_hat    : (B, M)       — restored frame (float32)
+        params   : (B, 5)       — predicted per-frame parameters
+        z_thresh : (B, P)       — thresholded coefficients (for sparsity loss)
+        x_hat_mid: (B, M)|None  — mid-layer reconstruction (for deep supervision)
+        """
+        B = yc_w.shape[0]
+        device = yc_w.device
+
+        # ── 1. Extract spectral features ──────────────────────────────────
+        # Current frame features
+        feat_curr = self.feature_extractor(yc_w)          # (B, n_feats)
+
+        # Context frames features: process all at once for efficiency
+        B, K, M = ctx_frames.shape
+        ctx_flat = ctx_frames.reshape(B * K, M)
+        feat_ctx_flat = self.feature_extractor(ctx_flat)   # (B*K, n_feats)
+        feat_ctx = feat_ctx_flat.reshape(B, K, -1)         # (B, K, n_feats)
+
+        # Concatenate: [ctx_{t-K}, …, ctx_{t-1}, current_t]
+        feat_seq = torch.cat([feat_ctx, feat_curr.unsqueeze(1)], dim=1)  # (B, K+1, n_feats)
+
+        # ── 2. Predict per-frame parameters ───────────────────────────────
+        params = self.context_encoder(feat_seq)             # (B, 5)
+
+        lambda_lf    = params[:, 0]   # (B,)
+        lambda_hf    = params[:, 1]   # (B,)
+        delta_factor = params[:, 2]   # (B,)
+        gmax_factor  = params[:, 3]   # (B,)
+        # eps_factor = params[:, 4]  — used for convergence check (inference only)
+
+        # Compute physical gain cap (linear) from predicted multiplier
+        g_max_db = self.cfg.base_max_gain_db * gmax_factor  # (B,) dB
+        g_max    = 10.0 ** (g_max_db / 20.0)                # (B,) linear
+
+        # ── 3. Run unrolled ADMM ───────────────────────────────────────────
+        lf_mask = self._get_lf_mask(device)                  # (P,)
+
+        x_hat, z_thresh, x_hat_mid = self.unrolled_admm(
+            yc_w=yc_w,
+            Ir=Ir, Icp=Icp, Icm=Icm,
+            lambda_lf=lambda_lf,
+            lambda_hf=lambda_hf,
+            g_max=g_max,
+            lf_mask=lf_mask,
+        )   # (B, M), (B, P), (B, M)|None
+
+        return x_hat, params, z_thresh, x_hat_mid
+
+    def parameter_count(self) -> int:
+        """Total trainable parameters."""
+        return sum(p.numel() for p in self.parameters() if p.requires_grad)
+
+
+# =============================================================================
+# Loss functions
+# =============================================================================
+
+class SPADEUnrolledLoss(nn.Module):
+    """
+    Composite loss for SPADE-Unrolled training.
+
+    Components
+    ----------
+    1. Mask MSE       (w_mask=2.0)     MSE on Icp|Icm — recovery region only
+    2. Transparency   (w_transp=0.1)   MSE on Ir       — non-limited must be unchanged
+    3. STFT           (w_stft=0.05)    Multi-scale L1.
+    4. LF coeff MSE   (w_lf_coeff=2.0) PRIMARY LF loss.
+    5. LF energy      (w_lf_energy=0.5) One-sided RMS under-recovery penalty.
+    6. Over-recovery  (w_over=0.3)     LF energy > GT+3dB.
+    7. λ reg          (w_reg=5.0)      Anti-saturation: L2 from target center.
+       Centers: λ_lf=0.034, λ_hf=0.03 — calibrated for M=2048, sr=44100.
+       IMPORTANT: λ_hf_center was previously 0.10 (calibrated for M=1024).
+       For M=2048, HF DCT coefficients post-normalisation are 0.01–0.05;
+       λ_hf=0.10 zeroed all of them → dsdr_high < −1.8 dB every epoch.
+       λ_hf_center=0.03 allows real HF transient content to pass through.
+    7b.g_fac floor    (w_gfac_floor=3.0) ReLU(floor - g_fac)^2 penalty.
+       Blocks the attenuative shortcut: without this, g_fac collapses toward
+       the range lower bound (0.5) making g_max ≈ 3 dB, which attenuates the
+       signal rather than declipping it (observed: dsdr_high/mid both < 0 from
+       epoch 1, worsening steadily to −1.2 / −0.7 dB by ep22).
+       floor=0.85 → g_max ≥ 5.1 dB — conservative but blocks the shortcut.
+    8. Sparsity       (w_sparsity=0.5) L1 of thresholded coefficients z_thresh.
+       Penalises passing too many coefficients: forces λ to actually zero things out.
+       Combined with λ-reg this creates a stable equilibrium where the ADMM does
+       real sparse solving rather than degenerating to an identity mapping.
+    9. Deep supervision (w_ds=0.5)     Auxiliary mask+LF loss at mid-layer (K//2).
+       Directly injects gradient into the GRU, preventing vanishing gradients
+       across K unrolled ADMM layers.
+    """
+
+    def __init__(
+        self,
+        w_mask:           float = 2.0,
+        w_transp:         float = 0.1,
+        w_stft:           float = 0.05,
+        w_lf_coeff:       float = 2.0,
+        w_lf_energy:      float = 0.5,
+        w_over:           float = 0.3,
+        w_reg:            float = 5.0,
+        w_sparsity:       float = 0.5,
+        w_ds:             float = 0.15,    # deep supervision — guide gradient early, don't dominate
+        w_gfac_floor:     float = 3.0,     # g_fac floor penalty: ReLU(g_floor - g_fac)^2
+        gfac_floor:       float = 0.5,     # [FIX] matches new gmax_factor_range lower bound (0.5, 2.0)
+        sample_rate:      int   = 44100,
+        lf_cutoff_hz:     float = 500.0,
+        lambda_lf_center: float = 0.034,   # softer LF: reflects lf_delta_ratio=0.286
+        # hf_center corrected 0.10 → 0.03.
+        # 0.10 was calibrated for M=1024 but model uses M=2048.  For M=2048,
+        # HF post-normalised magnitudes are 0.01–0.05; λ_hf=0.10 zeros them all
+        # (confirmed: dsdr_high stable at −1.8 dB while λ-reg held λ_hf=0.10).
+        lambda_hf_center: float = 0.03,
+    ):
+        super().__init__()
+        self.w_mask        = w_mask
+        self.w_transp      = w_transp
+        self.w_stft        = w_stft
+        self.w_lf_coeff    = w_lf_coeff
+        self.w_lf_energy   = w_lf_energy
+        self.w_over        = w_over
+        self.w_reg         = w_reg
+        self.w_sparsity    = w_sparsity
+        self.w_ds          = w_ds
+        self.w_gfac_floor  = w_gfac_floor
+        self.gfac_floor    = gfac_floor
+        self.sr            = sample_rate
+        self.lf_cutoff     = lf_cutoff_hz
+        self.lf_center     = lambda_lf_center
+        self.hf_center     = lambda_hf_center
+        self.stft_wins     = [256, 512, 1024]
+
+    def _frame_loss(
+        self,
+        x_hat:   torch.Tensor,   # (B, M)
+        x_clean: torch.Tensor,   # (B, M)
+        yc_w:    torch.Tensor,   # (B, M)
+        Ir:      torch.Tensor,   # (B, M) bool
+        Icp:     torch.Tensor,   # (B, M) bool
+        Icm:     torch.Tensor,   # (B, M) bool
+    ) -> Tuple[torch.Tensor, dict]:
+        """Compute mask + transparency + STFT + LF losses for one frame estimate."""
+        B, M = x_hat.shape
+        losses = {}
+
+        mask_active = (Icp | Icm).float()
+        mask_ir     = Ir.float()
+        n_active    = mask_active.sum(dim=-1).clamp(min=1)
+        n_ir        = mask_ir.sum(dim=-1).clamp(min=1)
+
+        # 1. Mask MSE
+        sq_err_active = ((x_hat - x_clean) ** 2) * mask_active
+        loss_mask = (sq_err_active.sum(dim=-1) / n_active).mean()
+        losses["mask"] = loss_mask.item()
+
+        # 2. Transparency
+        sq_err_ir = ((x_hat - x_clean) ** 2) * mask_ir
+        loss_transp = (sq_err_ir.sum(dim=-1) / n_ir).mean()
+        losses["transp"] = loss_transp.item()
+
+        # 3. Multi-scale STFT
+        loss_stft = x_hat.new_zeros(1)
+        for win in self.stft_wins:
+            hop = win // 4
+            wnd = torch.hann_window(win, device=x_hat.device)
+            def _stft(x, _w=wnd, _win=win, _hop=hop):
+                return torch.stft(x, n_fft=_win, hop_length=_hop,
+                                  win_length=_win, window=_w, return_complex=True)
+            loss_stft = loss_stft + F.l1_loss(_stft(x_hat.float()).abs(),
+                                               _stft(x_clean.float()).abs())
+        loss_stft = loss_stft / len(self.stft_wins)
+        losses["stft"] = loss_stft.item()
+
+        # 4. LF coefficient MSE (PRIMARY)
+        k_cut = int(math.ceil(self.lf_cutoff * 2.0 * M / self.sr))
+        k_cut = max(1, min(k_cut, M))
+        dct_res_hat   = _dct2(x_hat.float() - yc_w.float())[:, :k_cut]
+        dct_res_clean = _dct2(x_clean.float() - yc_w.float())[:, :k_cut]
+        loss_lf_coeff = F.mse_loss(dct_res_hat, dct_res_clean)
+        losses["lf_coeff"] = loss_lf_coeff.item()
+
+        # 5. LF energy asymmetric
+        dct_hat   = _dct2(x_hat.float())[:, :k_cut]
+        dct_clean = _dct2(x_clean.float())[:, :k_cut]
+        rms_lf_hat   = dct_hat.pow(2).mean(dim=-1).clamp(min=1e-10).sqrt()
+        rms_lf_clean = dct_clean.pow(2).mean(dim=-1).clamp(min=1e-10).sqrt()
+        loss_lf_energy = F.relu(rms_lf_clean - rms_lf_hat).pow(2).mean()
+        losses["lf_energy"] = loss_lf_energy.item()
+
+        # 6. Over-recovery
+        loss_over = F.relu(rms_lf_hat - rms_lf_clean * 10.0 ** (3.0/20.0)).pow(2).mean()
+        losses["over"] = loss_over.item()
+
+        total = (self.w_mask      * loss_mask
+               + self.w_transp    * loss_transp
+               + self.w_stft      * loss_stft.squeeze()
+               + self.w_lf_coeff  * loss_lf_coeff
+               + self.w_lf_energy * loss_lf_energy
+               + self.w_over      * loss_over)
+        return total, losses
+
+    def forward(
+        self,
+        x_hat:     torch.Tensor,              # (B, M)
+        x_clean:   torch.Tensor,              # (B, M)
+        yc_w:      torch.Tensor,              # (B, M)
+        Ir:        torch.Tensor,              # (B, M) bool
+        Icp:       torch.Tensor,              # (B, M) bool
+        Icm:       torch.Tensor,              # (B, M) bool
+        params:    Optional[torch.Tensor] = None,  # (B, 5)
+        z_thresh:  Optional[torch.Tensor] = None,  # (B, P) thresholded coeffs
+        x_hat_mid: Optional[torch.Tensor] = None,  # (B, M) mid-layer x_hat
+    ) -> Tuple[torch.Tensor, dict]:
+        losses = {}
+
+        # ── Primary frame losses ──────────────────────────────────────────
+        total, frame_losses = self._frame_loss(x_hat, x_clean, yc_w, Ir, Icp, Icm)
+        losses.update(frame_losses)
+
+        # ── 7. λ anti-saturation regularization (STRONGER, CORRECT CENTERS) ─
+        loss_reg = x_hat.new_zeros(1)
+        if params is not None and self.w_reg > 0:
+            loss_reg = ((params[:, 0] - self.lf_center).pow(2).mean() +
+                        (params[:, 1] - self.hf_center).pow(2).mean())
+        losses["reg"] = loss_reg.item()
+        total = total + self.w_reg * loss_reg.squeeze()
+
+        # ── 7b. g_fac floor penalty ───────────────────────────────────────
+        # Prevents the model from using gain attenuation as a shortcut to
+        # satisfy the mask/over losses.  Without this, g_fac drifts toward
+        # the range lower bound (observed: 0.5 → ~0.54 by ep22) causing
+        # dsdr_high < 0 and dsdr_mid < 0 — the model makes the signal worse.
+        #
+        # Loss = w_gfac_floor * mean( ReLU(floor - g_fac)^2 )
+        # Zero when g_fac >= floor.  Quadratic below floor → smooth gradient.
+        loss_gfac_floor = x_hat.new_zeros(1)
+        if params is not None and self.w_gfac_floor > 0:
+            g_fac = params[:, 3]    # (B,)
+            loss_gfac_floor = F.relu(self.gfac_floor - g_fac).pow(2).mean()
+        losses["gfac_floor"] = loss_gfac_floor.item()
+        total = total + self.w_gfac_floor * loss_gfac_floor.squeeze()
+
+        # ── 8. Sparsity loss: L1 of z_thresh ─────────────────────────────
+        # Penalises z_thresh being large: encourages λ to zero out coefficients.
+        # This breaks the identity-mapping local minimum (λ→0 = all coeffs pass).
+        loss_sparsity = x_hat.new_zeros(1)
+        if z_thresh is not None and self.w_sparsity > 0:
+            loss_sparsity = z_thresh.abs().mean()
+        losses["sparsity"] = loss_sparsity.item()
+        total = total + self.w_sparsity * loss_sparsity.squeeze()
+
+        # ── 9. Deep supervision: auxiliary loss at mid-layer ──────────────
+        # Same primary losses applied to x_hat_mid (reconstruction at K//2).
+        # Injects gradient directly into the GRU, preventing vanishing gradients.
+        loss_ds = x_hat.new_zeros(1)
+        if x_hat_mid is not None and self.w_ds > 0:
+            ds_total, _ = self._frame_loss(x_hat_mid, x_clean, yc_w, Ir, Icp, Icm)
+            loss_ds = ds_total
+        losses["ds"] = loss_ds.item()
+        total = total + self.w_ds * loss_ds.squeeze()
+
+        losses["total"] = total.item()
+        return total, losses
+
+
+
+# =============================================================================
+# WOLA-based inference wrapper
+# =============================================================================
+
+class SPADEUnrolledInference:
+    """
+    Wraps SPADEUnrolled to process a full audio signal via WOLA.
+
+    Equivalent to _declip_mono_gpu but calls the learned model instead of
+    the classical SPADE solver.  Used at test time only (not differentiable
+    end-to-end because of the frame-level sliding window).
+
+    Usage
+    -----
+        model = SPADEUnrolled(cfg)
+        model.load_state_dict(...)
+        model.eval()
+
+        infer = SPADEUnrolledInference(model, delta_db=2.5, device="cuda")
+        x_hat = infer.process(y_limited, sample_rate=44100)
+    """
+
+    def __init__(
+        self,
+        model:     SPADEUnrolled,
+        delta_db:  float = 2.5,
+        max_gain_db: float = 6.0,
+        device:    str = "cuda",
+        batch_frames: int = 256,  # GPU batch size for frame processing
+    ):
+        self.model = model.to(device)
+        self.model.eval()
+        self.cfg        = model.cfg
+        self.delta_db   = delta_db
+        self.max_gain_db = max_gain_db
+        self.device     = device
+        self.batch_frames = batch_frames
+
+    @torch.no_grad()
+    def process(self, y_limited: np.ndarray, sample_rate: int = 44100) -> np.ndarray:
+        """
+        y_limited : (N,) or (N, C) — limited audio
+        returns   : (N,) or (N, C) — restored audio
+        """
+        from scipy.signal.windows import hann as _hann
+        try:
+            from spade_declip_v12 import _compute_masks, _dilate_masks_soft
+        except ImportError:
+            raise ImportError("spade_declip_v12.py must be in the Python path")
+
+        mono = y_limited.ndim == 1
+        if mono:
+            y_limited = y_limited[:, None]
+        _, C = y_limited.shape
+        outputs = []
+
+        for ch in range(C):
+            yc = y_limited[:, ch].astype(np.float64)
+            dc = float(np.mean(yc))
+            yc -= dc
+
+            ceiling = float(np.max(np.abs(yc)))
+            thresh  = ceiling * (10.0 ** (-self.delta_db / 20.0))
+            if thresh <= 0:
+                outputs.append(yc)
+                continue
+
+            masks_obj = _compute_masks(yc, thresh)
+
+            M = self.cfg.window_length
+            a = self.cfg.hop_length
+            N = int(np.ceil(len(yc) / a))
+            win = np.sqrt(_hann(M, sym=False))
+
+            out_buf  = np.zeros(len(yc) + M)
+            norm_buf = np.zeros(len(yc) + M)
+            L = len(yc)
+
+            # Build context buffer: circular buffer of K_ctx frames
+            K_ctx = self.cfg.K_context
+            ctx_buf = np.zeros((K_ctx, M), dtype=np.float32)
+
+            for i in range(N):
+                idx1    = i * a
+                idx2    = min(idx1 + M, L)
+                seg_len = idx2 - idx1
+
+                yc_frame = np.zeros(M)
+                yc_frame[:seg_len] = yc[idx1:idx2]
+                win_frame = yc_frame * win
+
+                # Bypass: no limiting in this frame
+                frame_peak = np.max(np.abs(yc[idx1:idx2]))
+                if frame_peak < thresh:
+                    out_buf[idx1:idx1+M]  += win_frame * win
+                    norm_buf[idx1:idx1+M] += win ** 2
+                    ctx_buf = np.roll(ctx_buf, -1, axis=0)
+                    ctx_buf[-1] = win_frame.astype(np.float32)
+                    continue
+
+                # Extract masks for this frame
+                Ir_f  = masks_obj.Ir[idx1:idx2]
+                Icp_f = masks_obj.Icp[idx1:idx2]
+                Icm_f = masks_obj.Icm[idx1:idx2]
+
+                # Pad masks to M
+                Ir_p  = np.zeros(M, dtype=bool); Ir_p[:seg_len]  = Ir_f
+                Icp_p = np.zeros(M, dtype=bool); Icp_p[:seg_len] = Icp_f
+                Icm_p = np.zeros(M, dtype=bool); Icm_p[:seg_len] = Icm_f
+                Ir_p[seg_len:] = True   # padded region = reliable
+
+                # To tensors
+                def _t(arr, dtype=torch.float32):
+                    return torch.tensor(arr, dtype=dtype,
+                                        device=self.device).unsqueeze(0)
+
+                yc_t  = _t(win_frame.astype(np.float32))
+                ctx_t = torch.tensor(ctx_buf, dtype=torch.float32,
+                                     device=self.device).unsqueeze(0)  # (1, K, M)
+                Ir_t  = _t(Ir_p, dtype=torch.bool)
+                Icp_t = _t(Icp_p, dtype=torch.bool)
+                Icm_t = _t(Icm_p, dtype=torch.bool)
+
+                with torch.no_grad():
+                    x_hat_t, _, _, _ = self.model(yc_t, ctx_t, Ir_t, Icp_t, Icm_t)
+
+                x_hat = x_hat_t.squeeze(0).cpu().numpy()
+
+                out_buf[idx1:idx1+M]  += x_hat * win
+                norm_buf[idx1:idx1+M] += win ** 2
+
+                # Update context buffer
+                ctx_buf = np.roll(ctx_buf, -1, axis=0)
+                ctx_buf[-1] = win_frame.astype(np.float32)
+
+            # Normalise WOLA
+            safe_norm = np.where(norm_buf > 1e-8, norm_buf, 1.0)
+            recovered = out_buf / safe_norm
+            recovered = recovered[:L] + dc
+            outputs.append(recovered)
+
+        result = np.column_stack(outputs)
+        return result[:, 0] if mono else result
+
+
+
+# =============================================================================
+# Hybrid inference: v11 S-SPADE (HF unchanged) + SPADEUnrolled (LF learned)
+# =============================================================================
+
+class HybridSPADEInference:
+    """
+    Hybrid audio delimiting inference.
+
+    Architecture
+    ------------
+    1. LR crossover split at `crossover_hz` (default 8000 Hz).
+       Uses the same phase-perfect Butterworth HP = x − LP formula as v11
+       `_lr_split`, ensuring lf + hf == x exactly (no energy loss or leakage).
+
+    2. HF band (≥ crossover_hz):
+       → ``spade_declip_v11._sspade_batch_gpu`` (GPU) or
+         ``spade_declip_v11.tight_sspade``      (CPU)
+       Algorithm is BYTE-FOR-BYTE identical to v11.  Hard thresholding H_k
+       with progressive relaxation (k starts at hf_s, increments by hf_s
+       every hf_r iterations up to hf_max_iter).
+
+    3. LF band (< crossover_hz):
+       → ``SPADEUnrolledInference.process()`` — learned reconstruction.
+       ContextEncoder predicts per-frame lambda_lf, g_max, delta from the
+       K previous frames; UnrolledADMM applies K_unroll differentiable
+       soft-threshold layers.
+
+    4. Output = lf_recovered + hf_recovered.
+
+    Rationale for 8 kHz crossover
+    ------------------------------
+    v11 S-SPADE recovers HF transients (cymbal snap, hi-hat attack) well:
+    the DCT coefficients above 8 kHz are sparse and hard thresholding with
+    small k finds them reliably.  Below 8 kHz (kick body, bass fundamental)
+    v11 under-recovers because:
+      • The "true" sparsity level k is content-dependent and poorly set
+        by the fixed s/r schedule in the time available (K_unroll layers).
+      • Tonal/sustain content is not globally sparse, so H_k wastes budget
+        zeroing low-energy HF coefficients instead of recovering LF energy.
+    The learned model addresses both issues via adaptive lambda_lf and g_max.
+
+    Parameters
+    ----------
+    model          : trained SPADEUnrolled (loaded from checkpoint)
+    crossover_hz   : LR crossover frequency (default 8000 Hz)
+    lf_delta_db    : threshold for LF band mask detection (dB below ceiling)
+    lf_max_gain_db : gain cap for LF band recovery
+    lf_release_ms  : mask dilation for LF band (limiter release smear)
+    hf_delta_db    : threshold for HF band mask detection
+    hf_s           : v11 sparsity step (k starts at hf_s, increments by hf_s)
+    hf_r           : v11 sparsity relaxation period (k incremented every hf_r iter)
+    hf_eps         : v11 convergence threshold
+    hf_max_iter    : v11 max iterations per frame
+    hf_max_gain_db : v11 ratio-aware gain cap for HF band
+    hf_release_ms  : v11 mask dilation for HF band
+    hf_window_length : v11 WOLA window for HF band (default 2048)
+    hf_hop_length    : v11 WOLA hop for HF band   (default 512)
+    device         : 'cuda' | 'cpu' | 'auto'
+    batch_frames   : GPU batch size for SPADEUnrolled LF processing
+    """
+
+    def __init__(
+        self,
+        model:            "SPADEUnrolled",
+        crossover_hz:     float = 8000.0,
+        lf_delta_db:      float = 1.5,
+        lf_max_gain_db:   float = 6.0,
+        lf_release_ms:    float = 0.0,
+        hf_delta_db:      float = 1.5,
+        hf_s:             int   = 1,
+        hf_r:             int   = 1,
+        hf_eps:           float = 0.05,
+        hf_max_iter:      int   = 500,
+        hf_max_gain_db:   float = 6.0,
+        hf_release_ms:    float = 0.0,
+        hf_window_length: int   = 2048,
+        hf_hop_length:    int   = 512,
+        device:           str   = "auto",
+        batch_frames:     int   = 256,
+    ):
+        if device == "auto":
+            try:
+                import torch as _t
+                device = "cuda" if _t.cuda.is_available() else "cpu"
+            except ImportError:
+                device = "cpu"
+
+        self.model    = model.to(device)
+        self.model.eval()
+        self.cfg      = model.cfg
+
+        self.crossover_hz     = crossover_hz
+        self.lf_delta_db      = lf_delta_db
+        self.lf_max_gain_db   = lf_max_gain_db
+        self.lf_release_ms    = lf_release_ms
+        self.hf_delta_db      = hf_delta_db
+        self.hf_s             = hf_s
+        self.hf_r             = hf_r
+        self.hf_eps           = hf_eps
+        self.hf_max_iter      = hf_max_iter
+        self.hf_max_gain_db   = hf_max_gain_db
+        self.hf_release_ms    = hf_release_ms
+        self.hf_window_length = hf_window_length
+        self.hf_hop_length    = hf_hop_length
+        self.device           = device
+        self.batch_frames     = batch_frames
+
+        # Cached LF inference wrapper (re-used across calls)
+        self._lf_infer = SPADEUnrolledInference(
+            model,
+            delta_db      = lf_delta_db,
+            max_gain_db   = lf_max_gain_db,
+            device        = device,
+            batch_frames  = batch_frames,
+        )
+
+    @staticmethod
+    def _lr_split(
+        x: np.ndarray,
+        crossover_hz: float,
+        sr: int,
+    ) -> "Tuple[np.ndarray, np.ndarray]":
+        """
+        Phase-perfect Linkwitz-Riley crossover.  lp + hp == x exactly.
+        Identical to spade_declip_v11._lr_split.
+        """
+        from scipy.signal import butter, sosfiltfilt
+        fc = float(np.clip(crossover_hz, 1.0, sr / 2.0 - 1.0))
+        sos = butter(2, fc, btype="low", fs=sr, output="sos")
+        lp  = sosfiltfilt(sos, x)
+        hp  = x - lp
+        return lp, hp
+
+    def _process_hf_band(
+        self,
+        hf_mono: np.ndarray,
+        sr:      int,
+    ) -> np.ndarray:
+        """
+        Run v11 S-SPADE on the HF band.  Algorithm is identical to v11.
+        Imports lazily so spade_declip_v11 is only required at inference.
+        """
+        try:
+            from spade_declip_v11 import (
+                declip as _v11_declip,
+                DeclipParams as _V11Params,
+            )
+        except ImportError:
+            raise ImportError(
+                "spade_declip_v11.py must be in the Python path for HF processing."
+            )
+
+        params = _V11Params(
+            algo          = "sspade",
+            frame         = self.cfg.frame,
+            mode          = "soft",
+            delta_db      = self.hf_delta_db,
+            window_length = self.hf_window_length,
+            hop_length    = self.hf_hop_length,
+            s             = self.hf_s,
+            r             = self.hf_r,
+            eps           = self.hf_eps,
+            max_iter      = self.hf_max_iter,
+            max_gain_db   = self.hf_max_gain_db,
+            release_ms    = self.hf_release_ms,
+            sample_rate   = sr,
+            use_gpu       = (self.device != "cpu"),
+            gpu_device    = (self.device if self.device != "cpu" else "auto"),
+            show_progress = False,
+            verbose       = False,
+        )
+        fixed, _ = _v11_declip(hf_mono, params)
+        return fixed
+
+    @torch.no_grad()
+    def process(
+        self,
+        y_limited:   np.ndarray,
+        sample_rate: int = 44100,
+    ) -> np.ndarray:
+        """
+        y_limited : (N,) or (N, C) — limited audio at any sample rate
+        returns   : (N,) or (N, C) — hybrid-recovered audio
+
+        Pipeline per channel
+        --------------------
+        1. LR crossover split at self.crossover_hz
+           → lf_band (0 – crossover_hz)
+           → hf_band (crossover_hz – Nyquist)
+        2. HF: spade_declip_v11 S-SPADE (identical algorithm, unchanged)
+        3. LF: SPADEUnrolledInference (learned soft-threshold ADMM)
+        4. hf_recovered + lf_recovered = full signal
+        """
+        mono = y_limited.ndim == 1
+        if mono:
+            y_limited = y_limited[:, None]
+        _, C = y_limited.shape
+        out_channels = []
+
+        for ch in range(C):
+            yc = y_limited[:, ch].astype(np.float64)
+
+            # ── Phase-perfect LR split ────────────────────────────────────
+            lf_band, hf_band = self._lr_split(yc, self.crossover_hz, sample_rate)
+
+            # ── HF: v11 S-SPADE (unchanged) ────────────────────────────────
+            hf_rec = self._process_hf_band(hf_band.astype(np.float64), sample_rate)
+
+            # ── LF: SPADEUnrolled (learned) ────────────────────────────────
+            lf_rec = self._lf_infer.process(
+                lf_band.astype(np.float32), sample_rate
+            )
+
+            # ── Recombine ─────────────────────────────────────────────────
+            L = min(len(lf_rec), len(hf_rec))
+            combined = lf_rec[:L].astype(np.float64) + hf_rec[:L]
+            out_channels.append(combined)
+
+        result = np.column_stack(out_channels)
+        return result[:, 0] if mono else result
+
+
+# =============================================================================
+# Model factory
+# =============================================================================
+
+def build_model(cfg: Optional[UnrolledConfig] = None) -> SPADEUnrolled:
+    """Construct a SPADEUnrolled model with default or custom config."""
+    if cfg is None:
+        cfg = UnrolledConfig()
+    model = SPADEUnrolled(cfg)
+    n = model.parameter_count()
+    print(f"[SPADEUnrolled] Built model: {n:,} trainable parameters")
+    return model
+
+
+# =============================================================================
+# Quick sanity check
+# =============================================================================
+
+def _smoke_test():
+    """Run a forward pass with random data to verify shapes and dtypes."""
+    print("=" * 60)
+    print("SPADE Unrolled — Smoke Test")
+    print("=" * 60)
+
+    cfg = UnrolledConfig(
+        window_length=512,
+        hop_length=128,
+        K_unroll=4,
+        K_context=4,
+        n_mels=16,
+        gru_hidden=64,
+        gru_layers=1,
+    )
+    model = build_model(cfg)
+    model.eval()
+
+    B = 4
+    M = cfg.window_length
+    K = cfg.K_context
+
+    # Random limited frames + masks
+    yc    = torch.randn(B, M) * 0.5
+    ctx   = torch.randn(B, K, M) * 0.5
+    thresh = 0.3
+    Ir    = yc.abs() < thresh
+    Icp   = yc >= thresh
+    Icm   = yc <= -thresh
+
+    with torch.no_grad():
+        x_hat, params, z_thresh, x_hat_mid = model(yc, ctx, Ir, Icp, Icm)
+
+    print(f"  Input  yc:      {tuple(yc.shape)}  dtype={yc.dtype}")
+    print(f"  Output x_hat:   {tuple(x_hat.shape)}  dtype={x_hat.dtype}")
+    print(f"  Params:         {tuple(params.shape)}  dtype={params.dtype}")
+    print(f"  Param ranges:")
+    print(f"    lambda_lf   ∈ [{params[:,0].min():.4f}, {params[:,0].max():.4f}]")
+    print(f"    lambda_hf   ∈ [{params[:,1].min():.4f}, {params[:,1].max():.4f}]")
+    print(f"    delta_fac   ∈ [{params[:,2].min():.4f}, {params[:,2].max():.4f}]")
+    print(f"    gmax_fac    ∈ [{params[:,3].min():.4f}, {params[:,3].max():.4f}]")
+    print(f"    eps_fac     ∈ [{params[:,4].min():.4f}, {params[:,4].max():.4f}]")
+
+    # Loss test
+    x_clean = yc + torch.randn_like(yc) * 0.1
+    loss_fn = SPADEUnrolledLoss()
+    loss, details = loss_fn(x_hat, x_clean, yc, Ir, Icp, Icm)
+    print(f"\n  Loss: {loss.item():.6f}")
+    for k, v in details.items():
+        print(f"    {k:12s}: {v:.6f}")
+
+    # Check gradients
+    model.train()
+    x_hat2, _, z2, xm2 = model(yc, ctx, Ir, Icp, Icm)
+    loss2, _  = loss_fn(x_hat2, x_clean, yc, Ir, Icp, Icm, z_thresh=z2, x_hat_mid=xm2)
+    loss2.backward()
+    grad_norms = {
+        name: p.grad.norm().item()
+        for name, p in model.named_parameters()
+        if p.grad is not None
+    }
+    print(f"\n  Gradient norms (sample):")
+    for k, v in list(grad_norms.items())[:6]:
+        print(f"    {k:40s}: {v:.6f}")
+
+    print("\n  ✓ Smoke test passed.")
+
+
+if __name__ == "__main__":
+    _smoke_test()

train_spade_unrolled.py

@@ -0,0 +1,1485 @@
+"""
+train_spade_unrolled.py  —  Two-phase training for SPADE Unrolled  (v13 integration)
+=================================================================
+
+Phase 1 — Isolated drum samples + pink noise
+    • Corpus:       Kicks / Snares / Perc / Tops  (same as run_smart_sweep.py)
+    • Augmentation: limiter threshold ∈ [−1.5, −4.5 dBFS], release ∈ [40, 120 ms]
+    • Noise:        pink noise @ −20 dBFS (background proxy, prevents silent-region exploit)
+    • Purpose:      learn limiter signature from clean transients with exact GT
+
+Phase 2 — Full mix (Strategy A: synthetic limiter on real mixes)
+    • Corpus:       WAV/FLAC stems or premix files (user-provided, see --mix-dir)
+    • Same limiter as Phase 1 applied to full mix → GT = premix
+    • Mixed batching: α% Phase-1 + (1−α)% Phase-2 (default α=30%)
+    • Loss weights: higher w_transp (Ir regions critical in polyphonic content)
+
+Training strategy
+-----------------
+    Phase 1 → checkpoint  → Phase 2 (fine-tune, mixed batching)
+                ↑ saved separately to detect catastrophic forgetting
+
+Scheduler
+---------
+    OneCycleLR in both phases.  Phase 2 starts at lr/10 of Phase 1 peak.
+
+Pruning (Phase 2)
+-----------------
+    Validation on BOTH Phase-1 and Phase-2 val sets.  Training stops when
+    Phase-2 composite score stops improving OR Phase-1 score degrades > threshold.
+
+CLI
+---
+    # Phase 1 only (test)
+    python train_spade_unrolled.py --phase 1 --epochs 30 --drum-dir ./Samples
+
+    # Phase 2 (requires Phase-1 checkpoint)
+    python train_spade_unrolled.py --phase 2 --epochs 20 --drum-dir ./Samples \
+        --mix-dir ./FullMix --ckpt-phase1 phase1_best.pt
+
+    # Full two-phase run
+    python train_spade_unrolled.py --phase both --epochs-p1 50 --epochs-p2 30 \
+        --drum-dir ./Samples --mix-dir ./FullMix
+
+    # Resume
+    python train_spade_unrolled.py --phase 2 --resume checkpoints/epoch_10.pt \
+        --drum-dir ./Samples --mix-dir ./FullMix
+
+    # v13 integration (recommended): match HybridSPADEInference deployment
+    #   --lf-band-hz 8000   : LP-filter frames to 8kHz (crossover_hz default)
+    #   --loss-lf-cutoff 500: focus LF coefficient loss on sub-bass/bass failure zone
+    #   mask dilation is ON by default (disable with --no-mask-dilation)
+    python train_spade_unrolled.py --phase both --epochs-p1 50 --epochs-p2 30 \
+        --drum-dir ./Samples --mix-dir ./FullMix \
+        --lf-band-hz 8000 --loss-lf-cutoff 500
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import random
+import time
+import warnings
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import scipy.signal as sig
+
+try:
+    import soundfile as sf
+    _HAS_SF = True
+except ImportError:
+    _HAS_SF = False
+    warnings.warn("soundfile not found — pip install soundfile")
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from torch.utils.data import Dataset, DataLoader, ConcatDataset, WeightedRandomSampler
+    _HAS_TORCH = True
+except ImportError:
+    _HAS_TORCH = False
+    raise ImportError("PyTorch required — pip install torch")
+
+from spade_unrolled import (
+    SPADEUnrolled, UnrolledConfig, SPADEUnrolledLoss, build_model,
+)
+
+# ── Try importing SPADE internals for corpus preparation ─────────────────────
+try:
+    from spade_declip_v13 import (_compute_masks, _dilate_masks_soft,
+                                      _lr_split as _v13_lr_split)
+    _HAS_SPADE = True
+except ImportError:
+    _HAS_SPADE = False
+    warnings.warn("spade_declip_v13.py not found — mask computation disabled")
+
+# =============================================================================
+# Constants
+# =============================================================================
+
+DRUM_DIRS      = ["Kicks", "Snares", "Perc", "Tops"]
+SAMPLE_RATE    = 44100
+
+# Limiter augmentation ranges (Phase 1)
+AUG_THRESH_RANGE  = (-1.5, -4.5)   # dBFS — limiter threshold
+AUG_RELEASE_RANGE = (40.0, 120.0)  # ms
+PINK_NOISE_DB     = -20.0          # dB relative to peak
+
+# Default training hyperparameters
+BATCH_SIZE   = 32
+LR_PHASE1    = 3e-4
+LR_PHASE2    = 3e-5   # Phase 2 starts at 1/10 of Phase 1
+WEIGHT_DECAY = 1e-4
+GRAD_CLIP    = 1.0
+
+# Mixed batching: fraction of Phase-1 samples in each Phase-2 batch
+PHASE1_MIX_FRAC = 0.30
+
+# Validation: catastrophic forgetting threshold
+FORGETTING_THRESHOLD_DB = 2.0   # Phase-1 composite score must not drop > this dB
+
+
+# =============================================================================
+# Pink noise generator  (causal IIR, only used for corpus generation)
+# =============================================================================
+
+def generate_pink_noise(n_samples: int, rng: np.random.Generator) -> np.ndarray:
+    """Voss-McCartney 5-pole IIR approximation of 1/f noise."""
+    b = np.array([ 0.049922035, -0.095993537,  0.050612699, -0.004408786])
+    a = np.array([ 1.0,         -2.494956002,  2.017265875, -0.522189400])
+    white = rng.standard_normal(n_samples)
+    pink  = sig.lfilter(b, a, white)
+    rms   = np.sqrt(np.mean(pink ** 2))
+    return pink / (rms + 1e-12)
+
+
+# =============================================================================
+# Synthetic brickwall limiter
+# =============================================================================
+
+def apply_brickwall_limiter(
+    audio: np.ndarray,
+    sr:    int,
+    threshold_db: float,
+    release_ms:   float,
+) -> np.ndarray:
+    """
+    Brickwall limiter with 1-sample attack, exponential release.
+    audio: (N,) — normalised to 0 dBFS peak.
+    Returns: (N,) — limited signal (peak ≈ threshold_db dBFS).
+    """
+    thr_lin = 10 ** (-abs(threshold_db) / 20.0)
+    rc      = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9))
+
+    out = np.empty_like(audio)
+    env = 1.0
+    for n in range(len(audio)):
+        pk     = abs(audio[n])
+        target = thr_lin / pk if pk > thr_lin else 1.0
+        env    = target if target < env else rc * env + (1.0 - rc) * target
+        out[n] = audio[n] * env
+    return out
+
+
+# =============================================================================
+# Corpus preparation: build list of (clean, limited) sample pairs
+# =============================================================================
+
+@dataclass
+class AudioSample:
+    """A single training sample: original + limited pair."""
+    clean:   np.ndarray   # (N,) float64 — original at 0 dBFS
+    limited: np.ndarray   # (N,) float64 — after limiter
+    sr:      int
+    threshold_db: float
+    release_ms:   float
+    source:       str     # file path for debugging
+
+
+def load_audio_file(path: Path, target_sr: int = SAMPLE_RATE) -> Optional[np.ndarray]:
+    """Load and resample audio file to mono float64."""
+    if not _HAS_SF:
+        return None
+    try:
+        audio, sr = sf.read(str(path), always_2d=True)
+        audio = audio.mean(axis=1)          # mono
+        if sr != target_sr:
+            # Simple nearest-neighbour resample (scipy not always available)
+            try:
+                from scipy.signal import resample_poly
+                from math import gcd
+                g = gcd(target_sr, sr)
+                audio = resample_poly(audio, target_sr // g, sr // g)
+            except Exception:
+                pass
+        peak = np.max(np.abs(audio))
+        if peak < 1e-8:
+            return None
+        return audio.astype(np.float64) / peak   # 0 dBFS peak
+    except Exception as e:
+        warnings.warn(f"Could not load {path}: {e}")
+        return None
+
+
+def build_drum_corpus(
+    base_dir: Path,
+    rng: np.random.Generator,
+    augment: bool = True,
+) -> List[AudioSample]:
+    """
+    Build corpus of drum samples with synthetic limiting.
+    Mirrors the corpus in run_smart_sweep.py + augmentation.
+
+    augment=True: randomise threshold and release per sample.
+    augment=False: use fixed LIMITER_THRESHOLD_DB=3.0, RELEASE_MS=80.
+    """
+    samples = []
+    drum_dirs = [base_dir / d for d in DRUM_DIRS if (base_dir / d).exists()]
+    if not drum_dirs:
+        # Flat structure fallback
+        drum_dirs = [base_dir]
+
+    audio_files = []
+    for d in drum_dirs:
+        for ext in ["*.wav", "*.WAV", "*.flac", "*.FLAC", "*.aif", "*.aiff"]:
+            audio_files.extend(d.glob(ext))
+
+    if not audio_files:
+        warnings.warn(f"No audio files found in {base_dir}")
+        return samples
+
+    for path in audio_files:
+        audio = load_audio_file(path, SAMPLE_RATE)
+        if audio is None:
+            continue
+
+        # Add pink noise background (same logic as run_smart_sweep.py)
+        pink  = generate_pink_noise(len(audio), rng)
+        gain  = float(np.max(np.abs(audio))) * (10 ** (PINK_NOISE_DB / 20.0))
+        mixed = audio + pink * gain
+        peak  = np.max(np.abs(mixed))
+        if peak > 1e-8:
+            mixed /= peak   # re-normalise to 0 dBFS
+
+        # Limiter parameters
+        if augment:
+            thr_db  = rng.uniform(*sorted(AUG_THRESH_RANGE))   # e.g. -1.5 to -4.5
+            rel_ms  = rng.uniform(*AUG_RELEASE_RANGE)
+        else:
+            thr_db  = -3.0
+            rel_ms  = 80.0
+
+        limited = apply_brickwall_limiter(mixed, SAMPLE_RATE, thr_db, rel_ms)
+
+        samples.append(AudioSample(
+            clean=mixed, limited=limited,
+            sr=SAMPLE_RATE,
+            threshold_db=thr_db, release_ms=rel_ms,
+            source=str(path),
+        ))
+
+    return samples
+
+
+def build_fullmix_corpus(
+    mix_dir: Path,
+    rng: np.random.Generator,
+    augment: bool = True,
+) -> List[AudioSample]:
+    """
+    Build corpus of full-mix samples (Strategy A from checklist).
+    Applies the same synthetic limiter as Phase 1 to real mix material.
+    NO pink noise added: the mix content itself provides the background.
+    """
+    samples = []
+    audio_files = []
+    for ext in ["*.wav", "*.WAV", "*.flac", "*.FLAC"]:
+        audio_files.extend(mix_dir.rglob(ext))
+
+    for path in audio_files:
+        audio = load_audio_file(path, SAMPLE_RATE)
+        if audio is None:
+            continue
+
+        if augment:
+            thr_db = rng.uniform(*sorted(AUG_THRESH_RANGE))
+            rel_ms = rng.uniform(*AUG_RELEASE_RANGE)
+        else:
+            thr_db = -3.0
+            rel_ms = 80.0
+
+        limited = apply_brickwall_limiter(audio, SAMPLE_RATE, thr_db, rel_ms)
+        samples.append(AudioSample(
+            clean=audio, limited=limited,
+            sr=SAMPLE_RATE,
+            threshold_db=thr_db, release_ms=rel_ms,
+            source=str(path),
+        ))
+
+    return samples
+
+
+# =============================================================================
+# Frame dataset: extract random frames from AudioSample list
+# =============================================================================
+
+class FrameDataset(Dataset):
+    """
+    Random-frame dataset: returns (yc_w, ctx, x_clean_w, Ir, Icp, Icm) tuples.
+
+    Each call to __getitem__ draws a RANDOM frame from a RANDOM AudioSample.
+    This means len(dataset) is a virtual epoch length (n_virtual), not the
+    number of samples.  Caller sets n_virtual = n_samples * avg_frames.
+
+    Context frames are the K windows immediately BEFORE the current frame.
+    For the first K frames, context is zero-padded.
+
+    Mask computation requires delta_db, which is derived from the sample's
+    threshold_db.  delta_db = abs(threshold_db) is the v12 convention.
+    """
+
+    def __init__(
+        self,
+        samples:              List[AudioSample],
+        cfg:                  UnrolledConfig,
+        n_virtual:            int   = 10000,
+        rng_seed:             int   = 42,
+        lf_band_hz:           float = 0.0,    # v13: LP-filter training data to match inference LR split
+        apply_mask_dilation:  bool  = False,  # v13: dilate masks with sample release_ms
+    ):
+        if not samples:
+            raise ValueError("Empty sample list passed to FrameDataset")
+        self.samples             = samples
+        self.cfg                 = cfg
+        self.M                   = cfg.window_length
+        self.a                   = cfg.hop_length
+        self.K_ctx               = cfg.K_context
+        self.n_virtual           = n_virtual
+        self.rng                 = np.random.default_rng(rng_seed)
+        self.lf_band_hz          = lf_band_hz
+        self.apply_mask_dilation = apply_mask_dilation
+
+        from scipy.signal.windows import hann
+        self.win = np.sqrt(hann(self.M, sym=False)).astype(np.float32)
+
+        # Pre-build LR-split LP filter if requested (same as v13 _lr_split)
+        self._lp_sos = None
+        if lf_band_hz > 0.0 and _HAS_SPADE:
+            from scipy.signal import butter
+            fc = float(np.clip(lf_band_hz, 1.0, cfg.sample_rate / 2.0 - 1.0))
+            self._lp_sos = butter(2, fc, btype="low", fs=cfg.sample_rate, output="sos")
+
+    def __len__(self):
+        return self.n_virtual
+
+    def __getitem__(self, _idx: int):
+        # ── Pick a random sample ──────────────────────────────────────────
+        s = self.samples[self.rng.integers(len(self.samples))]
+
+        # ── v13: apply LR split to match HybridSPADEInference inference distribution
+        # When lf_band_hz > 0, LP-filter both clean and limited to the LF band
+        # before frame extraction.  This eliminates the train/inference mismatch
+        # where the model trained on full-bandwidth drums but was deployed on the
+        # 0–8 kHz LP band.
+        if self._lp_sos is not None:
+            from scipy.signal import sosfiltfilt
+            clean_sig   = sosfiltfilt(self._lp_sos, s.clean).astype(np.float64)
+            limited_sig = sosfiltfilt(self._lp_sos, s.limited).astype(np.float64)
+        else:
+            clean_sig   = s.clean
+            limited_sig = s.limited
+
+        L = len(clean_sig)
+        if L < self.M:
+            # Too short: zero-pad
+            pad   = self.M - L
+            clean   = np.pad(clean_sig,   (0, pad))
+            limited = np.pad(limited_sig, (0, pad))
+            i = 0
+        else:
+            # Pick a random frame index (at least partially within signal)
+            max_idx = max(0, (L - self.M) // self.a)
+            i       = self.rng.integers(0, max_idx + 1) if max_idx > 0 else 0
+            clean   = clean_sig
+            limited = limited_sig
+
+        # Extract current frame
+        idx1    = i * self.a
+        idx2    = min(idx1 + self.M, L)
+        seg_len = idx2 - idx1
+
+        yc_w    = np.zeros(self.M, dtype=np.float32)
+        x_clean = np.zeros(self.M, dtype=np.float32)
+        yc_w[:seg_len]    = (limited[idx1:idx2] * self.win[:seg_len]).astype(np.float32)
+        x_clean[:seg_len] = (clean[idx1:idx2]   * self.win[:seg_len]).astype(np.float32)
+
+        # ���─ Compute masks ────────────────────────────────────────────────
+        # v13: optionally apply _dilate_masks_soft so training masks match the
+        # dilated masks used at inference (release_ms dilation in _declip_mono_gpu).
+        # Without dilation, the model is trained on sharp-edge masks but evaluated
+        # on masks that include the limiter release tail — a systematic distribution
+        # mismatch that causes the model to under-recover post-peak samples.
+        delta_db = abs(s.threshold_db)
+        ceiling  = float(np.max(np.abs(limited)))
+        thresh   = ceiling * (10.0 ** (-delta_db / 20.0))
+        thresh   = max(thresh, 1e-8)
+
+        yc_raw = limited[idx1:idx2]
+        Ir_s   = np.abs(yc_raw) < thresh
+        Icp_s  = yc_raw >= thresh
+        Icm_s  = yc_raw <= -thresh
+
+        Ir  = np.ones(self.M, dtype=bool)
+        Icp = np.zeros(self.M, dtype=bool)
+        Icm = np.zeros(self.M, dtype=bool)
+        Ir[:seg_len]  = Ir_s
+        Icp[:seg_len] = Icp_s
+        Icm[:seg_len] = Icm_s
+
+        # v13: dilate masks with sample-specific release_ms if enabled
+        if self.apply_mask_dilation and _HAS_SPADE and s.release_ms > 0.0:
+            from spade_declip_v13 import ClippingMasks as _CM
+            # Apply dilation on the FULL frame (not just the active segment)
+            # to get temporally consistent masks matching the inference path.
+            masks_obj = _CM(Ir=Ir, Icp=Icp, Icm=Icm)
+            rel_samp  = max(0, round(s.release_ms * self.cfg.sample_rate / 1000.0))
+            if rel_samp > 0:
+                yc_for_dil = np.zeros(self.M, dtype=np.float64)
+                yc_for_dil[:seg_len] = yc_raw
+                masks_obj = _dilate_masks_soft(masks_obj, yc_for_dil, rel_samp)
+                Ir  = masks_obj.Ir
+                Icp = masks_obj.Icp
+                Icm = masks_obj.Icm
+
+        # Extract K context frames (strictly causal: before frame i)
+        ctx = np.zeros((self.K_ctx, self.M), dtype=np.float32)
+        for k in range(self.K_ctx):
+            ci = i - (self.K_ctx - k)   # context frame index: i-K, i-K+1, …, i-1
+            if ci < 0:
+                continue                # zero-pad before signal start
+            c_idx1 = ci * self.a
+            c_idx2 = min(c_idx1 + self.M, L)
+            c_seg  = c_idx2 - c_idx1
+            if c_seg <= 0:
+                continue
+            ctx[k, :c_seg] = (limited[c_idx1:c_idx2] * self.win[:c_seg]).astype(np.float32)
+
+        return (
+            torch.from_numpy(yc_w),
+            torch.from_numpy(ctx),
+            torch.from_numpy(x_clean),
+            torch.from_numpy(Ir),
+            torch.from_numpy(Icp),
+            torch.from_numpy(Icm),
+        )
+
+
+# =============================================================================
+# Mixed Batch Sampler for Phase 2
+# =============================================================================
+
+class MixedBatchDataset(Dataset):
+    """
+    Samples from two datasets with a fixed mixing ratio.
+    Used in Phase 2: PHASE1_MIX_FRAC from Phase-1, rest from Phase-2.
+
+    Implements the mixed batching strategy from the checklist (option B):
+    "keep contact with Phase-1 distribution during Phase-2 training".
+    """
+
+    def __init__(
+        self,
+        dataset_p1: FrameDataset,
+        dataset_p2: FrameDataset,
+        p1_frac:    float = PHASE1_MIX_FRAC,
+        n_virtual:  int   = 20000,
+    ):
+        self.ds_p1     = dataset_p1
+        self.ds_p2     = dataset_p2
+        self.p1_frac   = p1_frac
+        self.n_virtual = n_virtual
+        self.rng       = random.Random(0)
+
+    def __len__(self):
+        return self.n_virtual
+
+    def __getitem__(self, idx: int):
+        if self.rng.random() < self.p1_frac:
+            return self.ds_p1[idx % len(self.ds_p1)]
+        else:
+            return self.ds_p2[idx % len(self.ds_p2)]
+
+
+# =============================================================================
+# Composite evaluation score (mirrors run_smart_sweep.py)
+# =============================================================================
+
+def compute_composite_score(
+    x_hat:   np.ndarray,    # (N,) — restored signal
+    x_clean: np.ndarray,    # (N,) — ground truth
+    limited: np.ndarray,    # (N,) — limited signal (for GT residual)
+    sr:      int = SAMPLE_RATE,
+) -> Dict[str, float]:
+    """
+    Compute the composite score from run_smart_sweep.py.
+
+    cosine_sim  — global spectral shape (12 log bands)
+    energy_lf_db— RMS(hat)−RMS(GT) in 20–500 Hz
+    composite   — cosine × pen_lf^0.5 × pen_hf^0.2
+    """
+    eps = 1e-10
+
+    gt_res  = x_clean - limited     # ground truth residual
+    est_res = x_hat   - limited     # estimated residual
+
+    # Normalise residuals for cosine sim
+    gt_n  = gt_res  / (np.max(np.abs(gt_res))  + eps)
+    est_n = est_res / (np.max(np.abs(est_res)) + eps)
+
+    # Global cosine sim on DCT coefficients
+    from scipy.fft import dct as scipy_dct
+    G = scipy_dct(gt_n,  type=2, norm='ortho')
+    E = scipy_dct(est_n, type=2, norm='ortho')
+    cosine = float(np.dot(G, E) / (np.linalg.norm(G) * np.linalg.norm(E) + eps))
+
+    # LF band RMS (20–500 Hz) on ORIGINAL scale
+    N      = len(x_hat)
+    k_cut  = int(math.ceil(500.0 * 2.0 * N / sr))
+    k_cut  = max(1, min(k_cut, N))
+
+    rms_lf_gt  = np.sqrt(np.mean(scipy_dct(x_clean, type=2, norm='ortho')[:k_cut]**2) + eps)
+    rms_lf_hat = np.sqrt(np.mean(scipy_dct(x_hat,   type=2, norm='ortho')[:k_cut]**2) + eps)
+    energy_lf_db = 20.0 * math.log10(rms_lf_hat / rms_lf_gt + eps)
+
+    # HF band RMS (2k–20k Hz)
+    k_hf_lo = int(math.ceil(2000.0  * 2.0 * N / sr))
+    k_hf_hi = int(math.ceil(20000.0 * 2.0 * N / sr))
+    k_hf_lo = max(1, min(k_hf_lo, N))
+    k_hf_hi = max(k_hf_lo + 1, min(k_hf_hi, N))
+
+    rms_hf_gt  = np.sqrt(np.mean(scipy_dct(x_clean, type=2, norm='ortho')[k_hf_lo:k_hf_hi]**2) + eps)
+    rms_hf_hat = np.sqrt(np.mean(scipy_dct(x_hat,   type=2, norm='ortho')[k_hf_lo:k_hf_hi]**2) + eps)
+    energy_hf_db = 20.0 * math.log10(rms_hf_hat / rms_hf_gt + eps)
+
+    pen_lf = math.exp(min(0.0, energy_lf_db) / 6.0)
+    pen_hf = math.exp(min(0.0, energy_hf_db) / 10.0)
+    composite = cosine * (pen_lf ** 0.5) * (pen_hf ** 0.2)
+
+    return {
+        "cosine":        cosine,
+        "energy_lf_db":  energy_lf_db,
+        "energy_hf_db":  energy_hf_db,
+        "composite":     composite,
+    }
+
+
+# =============================================================================
+# Delta SDR metrics  (global + multiband)
+# =============================================================================
+
+def _sdr_batch(ref: torch.Tensor, est: torch.Tensor,
+               eps: float = 1e-10) -> torch.Tensor:
+    """SDR in dB per sample.  ref, est: (B, N) → (B,)."""
+    return 10.0 * torch.log10(
+        ref.pow(2).sum(-1) / ((ref - est).pow(2).sum(-1) + eps) + eps
+    )
+
+
+def _delta_sdr_batch(
+    clean:    torch.Tensor,   # (B, N) — GT
+    limited:  torch.Tensor,   # (B, N) — model input
+    enhanced: torch.Tensor,   # (B, N) — model output
+    eps: float = 1e-10,
+) -> torch.Tensor:
+    """ΔSDR = SDR(enhanced, clean) − SDR(limited, clean) per sample. (B,)"""
+    return _sdr_batch(clean, enhanced, eps) - _sdr_batch(clean, limited, eps)
+
+
+def _bandpass_fft(x: torch.Tensor, sr: int,
+                  f_lo: float, f_hi: float) -> torch.Tensor:
+    """Zero-phase FFT bandpass filter on last dimension."""
+    N = x.shape[-1]
+    X     = torch.fft.rfft(x, n=N)
+    freqs = torch.fft.rfftfreq(N, d=1.0 / sr)
+    X_filt = X * ((freqs >= f_lo) & (freqs < f_hi)).to(x.device)
+    return torch.fft.irfft(X_filt, n=N)
+
+
+# Bands aligned with v13 diagnostic zones.
+# The ML model processes only the LF band (0–lf_band_hz Hz, default 8000 Hz).
+# Monitoring the 4–22 kHz "high" band of the MODEL output is meaningless
+# (that content is handled by classical SPADE and never passes through the model).
+# New bands focus on the sub-bass under-recovery problem identified in the
+# v13 analysis: sub-bass (0–250 Hz) and bass (250–500 Hz) were −13 to −22 dB
+# below GT while mid-frequency bins were already well-recovered.
+_BANDS = {
+    "sub_bass": (0.0,    250.0),   # Primary failure zone (v13 analysis)
+    "bass":     (250.0,  500.0),   # lf_split_hz boundary zone
+    "low_mid":  (500.0,  2000.0),  # Previously OK in v11 ML model
+    "mid":      (2000.0, 8000.0),  # Upper LF band (model ceiling at inference)
+}
+
+
+def _multiband_delta_sdr_batch(
+    clean:    torch.Tensor,   # (B, N)
+    limited:  torch.Tensor,   # (B, N)
+    enhanced: torch.Tensor,   # (B, N)
+    sr:       int = SAMPLE_RATE,
+    eps:      float = 1e-10,
+) -> Dict[str, float]:
+    """
+    ΔSDR per frequency band.  Returns dict with keys dsdr_low/mid/high.
+
+    Diagnostic guide
+    ----------------
+    dsdr_high ↑  but  dsdr_low flat/neg → spectral bias: raise w_lf_coeff
+    dsdr_high < 0                       → transient smearing (g_fac too low,
+                                          or w_transp too high)
+    dsdr_global < 0                     → model degrading signal overall
+    """
+    results: Dict[str, float] = {}
+    for band_name, (f_lo, f_hi) in _BANDS.items():
+        c_b = _bandpass_fft(clean,    sr, f_lo, f_hi)
+        l_b = _bandpass_fft(limited,  sr, f_lo, f_hi)
+        e_b = _bandpass_fft(enhanced, sr, f_lo, f_hi)
+        if c_b.pow(2).mean().item() < 1e-12:
+            results[f"dsdr_{band_name}"] = 0.0
+        else:
+            results[f"dsdr_{band_name}"] = _delta_sdr_batch(
+                c_b, l_b, e_b, eps).mean().item()
+    return results
+
+
+# =============================================================================
+# Training loop
+# =============================================================================
+
+@dataclass
+class TrainConfig:
+    """Training hyperparameters."""
+    # Directories
+    drum_dir:      str = "./Samples"
+    mix_dir:       str = ""               # required for Phase 2
+    ckpt_dir:      str = "./checkpoints"
+
+    # Training phases
+    phase:         str = "both"           # "1", "2", or "both"
+    epochs_p1:     int = 50
+    epochs_p2:     int = 30
+
+    # Optimisation
+    batch_size:    int = BATCH_SIZE
+    lr_phase1:     float = LR_PHASE1
+    lr_phase2:     float = LR_PHASE2
+    weight_decay:  float = WEIGHT_DECAY
+    grad_clip:     float = GRAD_CLIP
+
+    # Mixed batching
+    p1_mix_frac:   float = PHASE1_MIX_FRAC
+
+    # Virtual epoch size
+    frames_per_epoch: int = 8000
+
+    # Phase-2 mixed-epoch size
+    frames_per_epoch_p2: int = 16000
+
+    # Validation split
+    val_frac:      float = 0.15
+
+    # Catastrophic forgetting threshold (Phase 2)
+    forgetting_thr: float = FORGETTING_THRESHOLD_DB
+
+    # Loss weights — Phase 1
+    # w_stft kept low (0.05): when dominant, creates conflicting gradient
+    # that locks λ_hf at maximum regardless of recovery quality.
+    # w_lf_coeff is the primary LF signal (coefficient MSE, direct gradient).
+    # w_reg penalises λ saturation to zero/max.
+    loss_w_mask:      float = 2.0
+    loss_w_transp_p1: float = 0.1    # sparse Ir in Phase 1 (drums)
+    loss_w_transp_p2: float = 1.0    # Ir = majority in Phase 2 (full mix)
+    loss_w_stft:      float = 0.05
+    loss_w_lf_coeff:  float = 2.0    # NEW primary LF loss
+    loss_w_lf_energy: float = 0.5    # secondary LF loss
+    loss_w_over:      float = 0.3
+    loss_w_reg:       float = 5.0    # λ anti-saturation (stronger; wider lambda range)
+    loss_w_sparsity:  float = 0.5    # L1(z_thresh): force real sparsification
+    loss_w_ds:        float = 0.15   # deep supervision — guide gradient, don't dominate
+                                     # (0.5 caused DS to be 3.8× primary losses → plateau)
+    # g_fac floor penalty: prevents attenuative shortcut (g_fac collapsing toward 0)
+    # [FIX] gmax_factor_range expanded to (0.5, 2.0); floor lowered accordingly.
+    loss_w_gfac_floor: float = 3.0
+    loss_gfac_floor:   float = 0.5   # [FIX] must match new gmax_factor_range[0] = 0.5
+
+    # Early stopping
+    early_stop_patience: int = 15    # stop if val_loss doesn't improve for this many epochs
+
+    # ── v13 integration ───────────────────────────────────────────────────────
+    # lf_band_hz: match the LR split applied by HybridSPADEInference at inference.
+    # When > 0, FrameDataset applies an LP filter at this frequency before
+    # feeding the frame to the model, eliminating the distribution mismatch
+    # between training (full-bandwidth drums) and inference (0–lf_band_hz band).
+    # Set to 0.0 to disable (legacy behaviour: train on full-bandwidth signal).
+    lf_band_hz: float = 8000.0      # Hz — must match HybridSPADEInference.crossover_hz
+
+    # apply_mask_dilation: apply _dilate_masks_soft with each sample's release_ms
+    # so the training masks match the dilated masks used at inference.
+    apply_mask_dilation: bool = True
+
+    # loss_lf_cutoff_hz: frequency passed to SPADEUnrolledLoss.lf_cutoff_hz.
+    # Controls which DCT bins count as "LF" for loss_lf_coeff and loss_lf_energy.
+    # [FIX] Raised from 500 Hz → 2500 Hz. At 500 Hz, the primary LF losses
+    # (w=2.0) were blind to the bass+low-mid band (500–2000 Hz), leaving only
+    # the weak STFT loss (w=0.05) to cover that region — root cause of the
+    # persistent mid regression (ΔSDR mid ≈ −2.0 dB across all epochs).
+    # 2500 Hz covers sub-bass + bass + low-mids in the primary loss term.
+    loss_lf_cutoff_hz: float = 2500.0   # Hz — [FIX] was 500.0
+
+    # Device
+    device: str = "cuda"
+
+    # Resume
+    resume:       str = ""
+    ckpt_phase1:  str = ""
+
+    # Logging
+    log_every:    int = 50             # steps
+    val_every:    int = 1              # epochs
+    save_every:   int = 5             # epochs
+
+
+def _make_loss_fn(tc: "TrainConfig", w_transp: float,
+                  sample_rate: int, device: str) -> "SPADEUnrolledLoss":
+    """
+    Construct SPADEUnrolledLoss from TrainConfig.
+
+    Centralises loss construction so Phase 1 and Phase 2 are guaranteed
+    to use the same weights (except w_transp, which differs by design).
+    Also threads tc.loss_lf_cutoff_hz to SPADEUnrolledLoss.lf_cutoff_hz
+    so the loss targets the same frequency boundary that was applied to
+    training data via lf_band_hz.
+    """
+    return SPADEUnrolledLoss(
+        w_mask           = tc.loss_w_mask,
+        w_transp         = w_transp,
+        w_stft           = tc.loss_w_stft,
+        w_lf_coeff       = tc.loss_w_lf_coeff,
+        w_lf_energy      = tc.loss_w_lf_energy,
+        w_over           = tc.loss_w_over,
+        w_reg            = tc.loss_w_reg,
+        w_sparsity       = tc.loss_w_sparsity,
+        w_ds             = tc.loss_w_ds,
+        w_gfac_floor     = tc.loss_w_gfac_floor,
+        gfac_floor       = tc.loss_gfac_floor,
+        sample_rate      = sample_rate,
+        lf_cutoff_hz     = tc.loss_lf_cutoff_hz,
+    ).to(device)
+
+
+def _make_loaders(
+    samples_tr: List[AudioSample],
+    samples_val: List[AudioSample],
+    cfg_model:   UnrolledConfig,
+    tc:          TrainConfig,
+    phase:       int,
+    samples_p1_tr: Optional[List[AudioSample]] = None,
+) -> Tuple[DataLoader, DataLoader]:
+    """Build train and validation DataLoaders for a given phase."""
+
+    n_tr  = tc.frames_per_epoch if phase == 1 else tc.frames_per_epoch_p2
+    n_val = max(500, n_tr // 8)
+
+    # v13: pass lf_band_hz and apply_mask_dilation so training data
+    # matches the inference distribution (HybridSPADEInference LR split
+    # and _dilate_masks_soft).
+    ds_kwargs = dict(
+        lf_band_hz          = tc.lf_band_hz,
+        apply_mask_dilation = tc.apply_mask_dilation,
+    )
+
+    ds_val = FrameDataset(samples_val, cfg_model, n_virtual=n_val, rng_seed=999,
+                          **ds_kwargs)
+
+    if phase == 1:
+        ds_tr = FrameDataset(samples_tr, cfg_model, n_virtual=n_tr, rng_seed=0,
+                             **ds_kwargs)
+    else:
+        # Phase 2: mixed batching
+        if not samples_p1_tr:
+            raise ValueError("Phase 2 requires Phase-1 training samples (mixed batching)")
+        ds_p2 = FrameDataset(samples_tr,    cfg_model, n_virtual=n_tr,    rng_seed=1, **ds_kwargs)
+        ds_p1 = FrameDataset(samples_p1_tr, cfg_model, n_virtual=n_tr//2, rng_seed=2, **ds_kwargs)
+        ds_tr = MixedBatchDataset(ds_p1, ds_p2, p1_frac=tc.p1_mix_frac, n_virtual=n_tr)
+
+    loader_tr  = DataLoader(ds_tr,  batch_size=tc.batch_size, shuffle=True,
+                             num_workers=2, pin_memory=True, drop_last=True,
+                             persistent_workers=True)   # [FIX] prevents SIGSEGV at worker re-spawn between epochs
+    loader_val = DataLoader(ds_val, batch_size=tc.batch_size, shuffle=False,
+                             num_workers=1, pin_memory=True,
+                             persistent_workers=True)   # [FIX] idem
+    return loader_tr, loader_val
+
+
+def _diag_encoder_params(
+    model:   SPADEUnrolled,
+    loader:  DataLoader,
+    device:  str,
+    epoch:   int,
+    n_batches: int = 3,
+):
+    """
+    Stampa i valori mediani delle predizioni del ContextEncoder su un sottoinsieme
+    del validation set.  Serve per diagnosticare se il modello sta imparando a
+    variare i parametri o se collassa su valori costanti.
+
+    Output atteso dopo convergenza:
+      lambda_lf  ∈ [0.0001, 0.005]  — soglia LF bassa per recupero aggressivo
+      lambda_hf  ∈ [0.001,  0.010]  — soglia HF più permissiva
+      delta_fac  ∈ [0.8, 1.5]       — adatta il threshold del limiter al frame
+      gmax_fac   ∈ [1.0, 1.8]       — cap guadagno proporzionale al transiente
+    """
+    model.eval()
+    all_params = []
+    with torch.no_grad():
+        for i, batch in enumerate(loader):
+            if i >= n_batches:
+                break
+            yc_w, ctx, _, _, _, _ = [b.to(device) for b in batch]
+            _, params, _, _ = model(yc_w, ctx,
+                                    torch.zeros_like(yc_w, dtype=torch.bool),
+                                    torch.zeros_like(yc_w, dtype=torch.bool),
+                                    torch.zeros_like(yc_w, dtype=torch.bool))
+            all_params.append(params.cpu())
+
+    if not all_params:
+        return
+
+    p = torch.cat(all_params, dim=0)   # (N, 5)
+    med   = p.median(dim=0).values
+    lo    = p.quantile(0.1, dim=0)
+    hi    = p.quantile(0.9, dim=0)
+    names = ["λ_lf", "λ_hf", "δ_fac", "g_fac", "ε_fac"]
+
+    print(f"  [diag ep{epoch}] encoder params  (median | p10–p90 | std):")
+    for n, m, l, h in zip(names, med, lo, hi):
+        std = p[:, names.index(n)].std().item()
+        collapsed = "⚠ COLLAPSED" if std < 1e-5 else ""
+        print(f"    {n:6s}: {m:.5f}  [{l:.5f} – {h:.5f}]  std={std:.6f}  {collapsed}")
+
+    # Anche: gradient norm medio delle ultime epoche
+    total_gnorm = 0.0
+    n_params    = 0
+    for p_tensor in model.parameters():
+        if p_tensor.grad is not None:
+            total_gnorm += p_tensor.grad.norm().item() ** 2
+            n_params += 1
+    if n_params > 0:
+        print(f"    grad_norm_rms: {math.sqrt(total_gnorm / n_params):.5f}")
+
+
+def _train_epoch(
+    model:    SPADEUnrolled,
+    loader:   DataLoader,
+    optimizer: torch.optim.Optimizer,
+    scheduler: object,
+    loss_fn:  SPADEUnrolledLoss,
+    tc:       TrainConfig,
+    epoch:    int,
+    device:   str,
+) -> Dict[str, float]:
+    model.train()
+    running = {k: 0.0 for k in ["total", "mask", "transp", "stft",
+                                  "lf_coeff", "lf_energy", "over", "reg",
+                                  "sparsity", "ds", "gfac_floor"]}
+    n_steps = 0
+    t0 = time.time()
+
+    for step, batch in enumerate(loader):
+        yc_w, ctx, x_clean, Ir, Icp, Icm = [b.to(device) for b in batch]
+
+        optimizer.zero_grad(set_to_none=True)
+
+        x_hat, params, z_thresh, x_hat_mid = model(yc_w, ctx, Ir, Icp, Icm)
+        loss, details = loss_fn(x_hat, x_clean, yc_w, Ir, Icp, Icm,
+                                params=params, z_thresh=z_thresh, x_hat_mid=x_hat_mid)
+
+        loss.backward()
+        nn.utils.clip_grad_norm_(model.parameters(), tc.grad_clip)
+        optimizer.step()
+        if scheduler is not None:
+            scheduler.step()
+
+        for k, v in details.items():
+            running[k] += v
+        n_steps += 1
+
+        if step > 0 and step % tc.log_every == 0:
+            elapsed = time.time() - t0
+            sps = step * tc.batch_size / elapsed
+            r, n = running, n_steps
+            print(f"  [Ep {epoch:3d} | {step:4d}/{len(loader)}]  "
+                  f"loss={r['total']/n:.4f}  "
+                  f"mask={r['mask']/n:.4f}  "
+                  f"lf_c={r['lf_coeff']/n:.4f}  "
+                  f"lf_e={r['lf_energy']/n:.4f}  "
+                  f"stft={r['stft']/n:.4f}  "
+                  f"spar={r['sparsity']/n:.4f}  "
+                  f"ds={r['ds']/n:.4f}  "
+                  f"gf={r['gfac_floor']/n:.5f}  "
+                  f"reg={r['reg']/n:.5f}  "
+                  f"{sps:.0f} sa/s")
+
+    return {k: v / max(n_steps, 1) for k, v in running.items()}
+
+
+@torch.no_grad()
+def _validate_epoch(
+    model:   SPADEUnrolled,
+    loader:  DataLoader,
+    loss_fn: SPADEUnrolledLoss,
+    device:  str,
+) -> Dict[str, float]:
+    """
+    Validation loop.
+
+    Returns loss sub-components AND Delta SDR metrics (global + multiband):
+
+    Keys added beyond the standard loss dict
+    -----------------------------------------
+    gfac_floor    : floor-penalty value — should converge toward 0 as g_fac ≥ floor
+    dsdr_global   : ΔSDR averaged over all frames (dB)
+                    > 0  → model improves fidelity over the limited input
+                    < 0  → model HURTS the signal (regression / artefacts)
+    dsdr_low      : ΔSDR in 0–250 Hz   — kick body, bass fundamentals
+                    Flat/negative while dsdr_high grows → spectral LF bias
+                    → raise w_lf_coeff or increase lambda_lf range
+    dsdr_mid      : ΔSDR in 250–4 kHz  — snare body, tonal content
+    dsdr_high     : ΔSDR in 4–22 kHz   — transient attack, cymbals
+                    Negative → model smearing attacks / ice-pick artefacts
+                    → check g_fac floor, lower w_transp
+    """
+    model.eval()
+    running = {k: 0.0 for k in ["total", "mask", "transp", "stft",
+                                  "lf_coeff", "lf_energy", "over", "reg",
+                                  "sparsity", "ds", "gfac_floor"]}
+    dsdr_running = {"dsdr_global": 0.0,
+                    "dsdr_sub_bass": 0.0, "dsdr_bass": 0.0,
+                    "dsdr_low_mid": 0.0,  "dsdr_mid": 0.0,
+                    "cos_sim": 0.0}
+    n_steps = 0
+
+    for batch in loader:
+        yc_w, ctx, x_clean, Ir, Icp, Icm = [b.to(device) for b in batch]
+        x_hat, params_v, z_thresh_v, xm_v = model(yc_w, ctx, Ir, Icp, Icm)
+        _, details = loss_fn(x_hat, x_clean, yc_w, Ir, Icp, Icm,
+                             params=params_v, z_thresh=z_thresh_v, x_hat_mid=xm_v)
+        for k, v in details.items():
+            running[k] += v
+
+        # ── Delta SDR — global ────────────────────────────────────────────
+        dsdr_running["dsdr_global"] += _delta_sdr_batch(
+            x_clean, yc_w, x_hat).mean().item()
+
+        # ── Delta SDR — multiband ─────────────────────────────────────────
+        for k, v in _multiband_delta_sdr_batch(x_clean, yc_w, x_hat,
+                                               sr=SAMPLE_RATE).items():
+            dsdr_running[k] += v
+
+        # ── Cosine similarity (residual, DCT domain) ─────────────────────
+        # Mirrors the cosine_sim metric in run_smart_sweep.py:
+        # how well the estimated residual matches the GT residual in shape.
+        # 1.0 = perfect; 0.0 = orthogonal; target: > 0.20 by ep10.
+        gt_res  = (x_clean - yc_w).cpu().float()    # (B, M)
+        est_res = (x_hat   - yc_w).cpu().float()
+        eps_cos = 1e-10
+        from scipy.fft import dct as _dct_np
+        gt_np  = gt_res.numpy()
+        est_np = est_res.numpy()
+        # Vectorised DCT over rows
+        G = np.array([_dct_np(g, type=2, norm="ortho") for g in gt_np])
+        E = np.array([_dct_np(e, type=2, norm="ortho") for e in est_np])
+        cos_batch = (G * E).sum(-1) / (
+            np.sqrt((G**2).sum(-1)) * np.sqrt((E**2).sum(-1)) + eps_cos)
+        dsdr_running["cos_sim"] += float(cos_batch.mean())
+
+        n_steps += 1
+
+    metrics = {k: v / max(n_steps, 1) for k, v in running.items()}
+    metrics.update({k: v / max(n_steps, 1) for k, v in dsdr_running.items()})
+    return metrics
+
+
+def _save_checkpoint(model, optimizer, epoch, val_loss, path: Path, extra=None):
+    state = {
+        "epoch":      epoch,
+        "val_loss":   val_loss,
+        "model":      model.state_dict(),
+        "optimizer":  optimizer.state_dict(),
+        "cfg":        asdict(model.cfg),
+    }
+    if extra:
+        state.update(extra)
+    torch.save(state, path)
+    print(f"  ✓ Checkpoint saved → {path}  (val_loss={val_loss:.4f})")
+
+
+def _load_checkpoint(model, optimizer, path: Path, device: str):
+    ckpt = torch.load(path, map_location=device)
+    model.load_state_dict(ckpt["model"])
+    if optimizer is not None and "optimizer" in ckpt:
+        optimizer.load_state_dict(ckpt["optimizer"])
+    return ckpt.get("epoch", 0), ckpt.get("val_loss", float("inf"))
+
+
+# =============================================================================
+# Phase 1 training
+# =============================================================================
+
+def train_phase1(
+    model:      SPADEUnrolled,
+    tc:         TrainConfig,
+    device:     str,
+) -> Path:
+    """
+    Train Phase 1 on isolated drum samples + pink noise.
+    Returns path to best checkpoint.
+    """
+    print("\n" + "="*70)
+    print("PHASE 1 — Isolated drum samples + pink noise")
+    print("="*70)
+
+    drum_dir = Path(tc.drum_dir)
+    if not drum_dir.exists():
+        raise FileNotFoundError(f"Drum directory not found: {drum_dir}")
+
+    rng = np.random.default_rng(42)
+    print(f"  Loading drum corpus from {drum_dir} …")
+    all_samples = build_drum_corpus(drum_dir, rng, augment=True)
+
+    if not all_samples:
+        raise RuntimeError("No drum samples found — check --drum-dir path")
+
+    print(f"  Total samples: {len(all_samples)}")
+
+    # Train / val split (by file, not frame)
+    n_val = max(1, int(len(all_samples) * tc.val_frac))
+    rng.shuffle(all_samples)   # type: ignore
+    samples_val = all_samples[:n_val]
+    samples_tr  = all_samples[n_val:]
+    print(f"  Train: {len(samples_tr)}  Val: {len(samples_val)}")
+
+    cfg_model = model.cfg
+    loss_fn = _make_loss_fn(tc, w_transp=tc.loss_w_transp_p1,
+                            sample_rate=cfg_model.sample_rate, device=device)
+
+    loader_tr, loader_val = _make_loaders(samples_tr, samples_val, cfg_model, tc, phase=1)
+
+    optimizer = optim.AdamW(model.parameters(), lr=tc.lr_phase1,
+                             weight_decay=tc.weight_decay, betas=(0.9, 0.999))
+    total_steps = tc.epochs_p1 * len(loader_tr)
+    scheduler = optim.lr_scheduler.OneCycleLR(
+        optimizer, max_lr=tc.lr_phase1, total_steps=total_steps,
+        pct_start=0.1, anneal_strategy="cos",
+    )
+
+    ckpt_dir = Path(tc.ckpt_dir)
+    ckpt_dir.mkdir(parents=True, exist_ok=True)
+
+    # Resume support
+    start_epoch = 1
+    best_val    = float("inf")
+    if tc.resume:
+        ep, val = _load_checkpoint(model, optimizer, Path(tc.resume), device)
+        start_epoch = ep + 1
+        best_val    = val
+        print(f"  Resumed from epoch {ep}  (val={val:.4f})")
+
+    best_ckpt = ckpt_dir / "phase1_best.pt"
+    history   = []
+    no_improve = 0   # early stopping counter
+
+    for epoch in range(start_epoch, tc.epochs_p1 + 1):
+        t_ep = time.time()
+        tr_m = _train_epoch(model, loader_tr, optimizer, scheduler, loss_fn, tc, epoch, device)
+        val_m = _validate_epoch(model, loader_val, loss_fn, device)
+
+        elapsed = time.time() - t_ep
+
+        dsdr_g  = val_m.get("dsdr_global",   0.0)
+        dsdr_sb = val_m.get("dsdr_sub_bass", 0.0)
+        dsdr_ba = val_m.get("dsdr_bass",     0.0)
+        dsdr_lm = val_m.get("dsdr_low_mid",  0.0)
+        dsdr_hi = val_m.get("dsdr_mid",      0.0)   # "mid" = 2-8kHz = ceiling of LF model
+        gf      = val_m.get("gfac_floor",    0.0)
+
+        # Actionable flags
+        flag = ""
+        if dsdr_hi > 0.5 and dsdr_sb < 0.1:
+            flag = "  ⚠ SPECTRAL BIAS ↑mid/flat-sub-bass → raise w_lf_coeff or w_lf_energy"
+        elif dsdr_hi < -0.5:
+            flag = "  ⚠ mid regression → g_fac too low or w_transp too high"
+        elif dsdr_g < 0:
+            flag = "  ⚠ Global ΔSDR<0 → model degrading signal"
+        if gf > 1e-4:
+            flag += f"  ⚠ gfac_floor={gf:.5f} > 0 → g_fac still below floor"
+
+        print(f"Epoch {epoch:3d}/{tc.epochs_p1}  "
+              f"tr={tr_m['total']:.4f}  val={val_m['total']:.4f}  "
+              f"[mask={val_m['mask']:.4f} lf_c={val_m['lf_coeff']:.4f} "
+              f"lf_e={val_m['lf_energy']:.4f} stft={val_m['stft']:.4f} "
+              f"gf={gf:.5f} reg={val_m['reg']:.5f}]  "
+              f"({elapsed:.1f}s)")
+        print(f"         ΔSDR  global={dsdr_g:+.2f}dB  "
+              f"sub_bass={dsdr_sb:+.2f}dB  bass={dsdr_ba:+.2f}dB  "
+              f"low_mid={dsdr_lm:+.2f}dB  mid={dsdr_hi:+.2f}dB  "
+              f"cos_sim={val_m.get('cos_sim', 0.0):.3f}{flag}")
+
+        # ── Diagnostica parametri encoder ────────────────────────────────
+        if epoch % 2 == 0 or epoch == 1:
+            _diag_encoder_params(model, loader_val, device, epoch)
+
+        history.append({"epoch": epoch, "train": tr_m, "val": val_m,
+                         "dsdr_global": dsdr_g, "dsdr_sub_bass": dsdr_sb,
+                         "dsdr_bass": dsdr_ba,  "dsdr_low_mid": dsdr_lm,
+                         "dsdr_mid": dsdr_hi,
+                         "cos_sim": val_m.get("cos_sim", 0.0)})
+
+        if val_m["total"] < best_val:
+            best_val = val_m["total"]
+            no_improve = 0
+            _save_checkpoint(model, optimizer, epoch, best_val, best_ckpt,
+                             extra={"phase": 1, "history": history})
+        else:
+            no_improve += 1
+
+        if epoch % tc.save_every == 0:
+            ep_ckpt = ckpt_dir / f"phase1_epoch{epoch:03d}.pt"
+            _save_checkpoint(model, optimizer, epoch, val_m["total"], ep_ckpt)
+
+        # ── Early stopping ────────────────────────────────────────────────
+        if tc.early_stop_patience > 0 and no_improve >= tc.early_stop_patience:
+            print(f"\n  ⏹ Early stopping at epoch {epoch} "
+                  f"(no improvement for {no_improve} epochs).")
+            break
+
+    print(f"\n  Phase 1 complete.  Best val loss: {best_val:.4f}")
+    print(f"  Best checkpoint: {best_ckpt}")
+    return best_ckpt
+
+
+# =============================================================================
+# Phase 2 training
+# =============================================================================
+
+def train_phase2(
+    model:          SPADEUnrolled,
+    tc:             TrainConfig,
+    device:         str,
+    p1_ckpt:        Optional[Path] = None,
+    samples_p1_tr:  Optional[List[AudioSample]] = None,
+) -> Path:
+    """
+    Train Phase 2 on full-mix material with Phase-1 mixed batching.
+
+    If p1_ckpt is given, load Phase-1 weights first.
+    If samples_p1_tr is given, include them in mixed batching.
+    """
+    print("\n" + "="*70)
+    print("PHASE 2 — Full mix (Strategy A) + mixed batching")
+    print("="*70)
+
+    # ── Load Phase-1 weights ──────────────────────────────────────────────
+    if p1_ckpt and p1_ckpt.exists():
+        ep, val = _load_checkpoint(model, None, p1_ckpt, device)
+        print(f"  Loaded Phase-1 checkpoint: {p1_ckpt}  (epoch={ep}, val={val:.4f})")
+    elif tc.ckpt_phase1:
+        ep, val = _load_checkpoint(model, None, Path(tc.ckpt_phase1), device)
+        print(f"  Loaded Phase-1 checkpoint: {tc.ckpt_phase1}  (epoch={ep}, val={val:.4f})")
+    else:
+        print("  [WARNING] No Phase-1 checkpoint provided — training from scratch")
+
+    # ── Load full-mix corpus ──────────────────────────────────────────────
+    mix_dir = Path(tc.mix_dir) if tc.mix_dir else None
+    if mix_dir is None or not mix_dir.exists():
+        raise FileNotFoundError(
+            f"Full-mix directory not found: {tc.mix_dir}\n"
+            "Pass --mix-dir /path/to/full/mix/files  (Strategy A: pre-limiter stems)"
+        )
+
+    rng = np.random.default_rng(123)
+    print(f"  Loading full-mix corpus from {mix_dir} …")
+    all_mix = build_fullmix_corpus(mix_dir, rng, augment=True)
+
+    if not all_mix:
+        raise RuntimeError("No full-mix files found — check --mix-dir path")
+
+    print(f"  Full-mix samples: {len(all_mix)}")
+
+    n_val = max(1, int(len(all_mix) * tc.val_frac))
+    rng.shuffle(all_mix)  # type: ignore
+    mix_val = all_mix[:n_val]
+    mix_tr  = all_mix[n_val:]
+
+    # ── Also load Phase-1 drum corpus for mixed batching ─────────────────
+    if samples_p1_tr is None:
+        drum_dir = Path(tc.drum_dir)
+        if drum_dir.exists():
+            p1_rng = np.random.default_rng(42)
+            p1_all = build_drum_corpus(drum_dir, p1_rng, augment=True)
+            n_val_p1 = max(1, int(len(p1_all) * tc.val_frac))
+            p1_rng.shuffle(p1_all)  # type: ignore
+            samples_p1_val = p1_all[:n_val_p1]
+            samples_p1_tr  = p1_all[n_val_p1:]
+            print(f"  Phase-1 drum samples for mixed batching: {len(samples_p1_tr)}")
+        else:
+            print("  [WARNING] No drum directory for mixed batching — Phase-2 only training")
+            samples_p1_tr = mix_tr[:max(1, len(mix_tr)//5)]   # fallback: subset of mix
+
+    cfg_model = model.cfg
+
+    # Phase-2 uses higher transparency weight (Ir = majority in full mix).
+    # _make_loss_fn also threads tc.loss_lf_cutoff_hz so the LF coefficient
+    # loss targets the same frequency boundary as the training data LR split.
+    # NOTE: w_lf_coeff is intentionally kept equal to Phase-1 (2.0) — the
+    # sub-bass under-recovery problem requires strong LF gradient in both phases.
+    loss_fn_p2 = _make_loss_fn(tc, w_transp=tc.loss_w_transp_p2,
+                                sample_rate=cfg_model.sample_rate, device=device)
+
+    # Phase-1 loss function (used only for the catastrophic-forgetting probe
+    # on the Phase-1 validation set — must match Phase-1 training exactly).
+    loss_fn_p1 = _make_loss_fn(tc, w_transp=tc.loss_w_transp_p1,
+                                sample_rate=cfg_model.sample_rate, device=device)
+
+    loader_tr, loader_val_p2 = _make_loaders(
+        mix_tr, mix_val, cfg_model, tc, phase=2,
+        samples_p1_tr=samples_p1_tr,
+    )
+
+    # Phase-1 validation loader (forgetting monitor).
+    # ds_kwargs ensures masks + LR split match inference — same as Phase-1
+    # training datasets, so the forgetting probe is on a comparable distribution.
+    _p1_val_samples = p1_all[:n_val_p1] if 'p1_all' in dir() else mix_val
+    ds_val_p1      = FrameDataset(
+        _p1_val_samples, cfg_model, n_virtual=800, rng_seed=888,
+        **ds_kwargs,
+    )
+    loader_val_p1  = DataLoader(ds_val_p1, batch_size=tc.batch_size,
+                                 shuffle=False, num_workers=0)   # [FIX] single-thread: only 11 samples, avoids shared-mem SIGSEGV
+
+    optimizer = optim.AdamW(model.parameters(), lr=tc.lr_phase2,
+                             weight_decay=tc.weight_decay, betas=(0.9, 0.999))
+    total_steps = tc.epochs_p2 * len(loader_tr)
+    scheduler = optim.lr_scheduler.OneCycleLR(
+        optimizer, max_lr=tc.lr_phase2, total_steps=total_steps,
+        pct_start=0.05, anneal_strategy="cos",
+    )
+
+    ckpt_dir   = Path(tc.ckpt_dir)
+    best_ckpt  = ckpt_dir / "phase2_best.pt"
+    best_val   = float("inf")
+    p1_val_baseline = None    # set on first epoch
+    history    = []
+
+    for epoch in range(1, tc.epochs_p2 + 1):
+        t_ep = time.time()
+        tr_m = _train_epoch(model, loader_tr, optimizer, scheduler,
+                             loss_fn_p2, tc, epoch, device)
+
+        # Validate on Phase-2 val set
+        val_m_p2 = _validate_epoch(model, loader_val_p2, loss_fn_p2, device)
+
+        # Monitor Phase-1 forgetting
+        val_m_p1 = _validate_epoch(model, loader_val_p1, loss_fn_p1, device)
+        if p1_val_baseline is None:
+            p1_val_baseline = val_m_p1["total"]
+
+        forgetting = val_m_p1["total"] - p1_val_baseline
+        elapsed = time.time() - t_ep
+
+        dsdr_g    = val_m_p2.get("dsdr_global",   0.0)
+        dsdr_sb   = val_m_p2.get("dsdr_sub_bass", 0.0)
+        dsdr_ba   = val_m_p2.get("dsdr_bass",     0.0)
+        dsdr_lm   = val_m_p2.get("dsdr_low_mid",  0.0)
+        dsdr_hi   = val_m_p2.get("dsdr_mid",      0.0)   # 2-8kHz (LF model ceiling)
+        dsdr_g_p1 = val_m_p1.get("dsdr_global",   0.0)
+        dsdr_sb_p1 = val_m_p1.get("dsdr_sub_bass", 0.0)  # key forgetting indicator
+        gf        = val_m_p2.get("gfac_floor",    0.0)
+        cos_p2    = val_m_p2.get("cos_sim",       0.0)
+        cos_p1    = val_m_p1.get("cos_sim",       0.0)
+
+        flag = ""
+        if dsdr_hi > 0.5 and dsdr_sb < 0.1:
+            flag = "  ⚠ SPECTRAL BIAS ↑mid/flat-sub-bass → raise w_lf_coeff or w_lf_energy"
+        elif dsdr_hi < -0.5:
+            flag = "  ⚠ mid regression → g_fac too low or w_transp too high"
+        elif dsdr_g < 0:
+            flag = "  ⚠ Global ΔSDR<0 → model degrading signal"
+        if gf > 1e-4:
+            flag += f"  ⚠ gfac_floor={gf:.5f}>0"
+        if dsdr_sb_p1 < dsdr_sb - 1.5:
+            flag += "  ⚠ sub-bass forgetting P1 vs P2 >1.5dB"
+
+        print(f"Epoch {epoch:3d}/{tc.epochs_p2}  "
+              f"tr={tr_m['total']:.4f}  "
+              f"val_p2={val_m_p2['total']:.4f}  "
+              f"val_p1={val_m_p1['total']:.4f}  "
+              f"forgetting={forgetting:+.4f}  "
+              f"gf={gf:.5f}  ({elapsed:.1f}s)")
+        print(f"         ΔSDR(P2)  global={dsdr_g:+.2f}dB  "
+              f"sub_bass={dsdr_sb:+.2f}dB  bass={dsdr_ba:+.2f}dB  "
+              f"low_mid={dsdr_lm:+.2f}dB  mid={dsdr_hi:+.2f}dB  "
+              f"cos={cos_p2:.3f}{flag}")
+        print(f"         ΔSDR(P1)  global={dsdr_g_p1:+.2f}dB  "
+              f"sub_bass={dsdr_sb_p1:+.2f}dB  cos={cos_p1:.3f}  [forgetting probe]")
+
+        if forgetting > tc.forgetting_thr:
+            print(f"  ⚠ Catastrophic forgetting detected "
+                  f"(Δ={forgetting:.4f} > {tc.forgetting_thr})  "
+                  f"Consider increasing p1_mix_frac or reducing lr")
+
+        history.append({
+            "epoch":         epoch,
+            "train":         tr_m,
+            "val_p2":        val_m_p2,
+            "val_p1":        val_m_p1,
+            "forgetting":    forgetting,
+            "dsdr_global":   dsdr_g,
+            "dsdr_sub_bass": dsdr_sb,
+            "dsdr_bass":     dsdr_ba,
+            "dsdr_low_mid":  dsdr_lm,
+            "dsdr_mid":      dsdr_hi,
+            "cos_sim_p2":    cos_p2,
+            "dsdr_global_p1":  dsdr_g_p1,
+            "dsdr_sub_bass_p1": dsdr_sb_p1,
+            "cos_sim_p1":    cos_p1,
+        })
+
+        if val_m_p2["total"] < best_val:
+            best_val = val_m_p2["total"]
+            _save_checkpoint(model, optimizer, epoch, best_val, best_ckpt,
+                             extra={"phase": 2, "forgetting": forgetting,
+                                    "history": history})
+
+        if epoch % tc.save_every == 0:
+            ep_ckpt = ckpt_dir / f"phase2_epoch{epoch:03d}.pt"
+            _save_checkpoint(model, optimizer, epoch, val_m_p2["total"], ep_ckpt)
+
+    print(f"\n  Phase 2 complete.  Best P2 val loss: {best_val:.4f}")
+    print(f"  Best checkpoint: {best_ckpt}")
+    return best_ckpt
+
+
+# =============================================================================
+# CLI
+# =============================================================================
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        description="Train SPADE-Unrolled (two-phase curriculum)",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("--phase", choices=["1", "2", "both"], default="both",
+                   help="Training phase to run")
+    p.add_argument("--epochs-p1",    type=int,   default=50,    dest="epochs_p1")
+    p.add_argument("--epochs-p2",    type=int,   default=30,    dest="epochs_p2")
+    p.add_argument("--drum-dir",     type=str,   default="./Samples", dest="drum_dir",
+                   help="Root directory with Kicks / Snares / Perc / Tops subdirs")
+    p.add_argument("--mix-dir",      type=str,   default="",    dest="mix_dir",
+                   help="Directory with full-mix WAV/FLAC files (Phase 2)")
+    p.add_argument("--ckpt-dir",     type=str,   default="./checkpoints", dest="ckpt_dir")
+    p.add_argument("--ckpt-phase1",  type=str,   default="",    dest="ckpt_phase1",
+                   help="Phase-1 checkpoint to load at start of Phase 2")
+    p.add_argument("--resume",       type=str,   default="",
+                   help="Resume from checkpoint path")
+    p.add_argument("--batch-size",   type=int,   default=BATCH_SIZE, dest="batch_size")
+    p.add_argument("--lr-p1",        type=float, default=LR_PHASE1,  dest="lr_phase1")
+    p.add_argument("--lr-p2",        type=float, default=LR_PHASE2,  dest="lr_phase2")
+    p.add_argument("--p1-mix-frac",  type=float, default=PHASE1_MIX_FRAC, dest="p1_mix_frac",
+                   help="Fraction of Phase-1 samples in each Phase-2 batch")
+    p.add_argument("--device",       type=str,   default="cuda",
+                   help="PyTorch device: 'cuda', 'cuda:0', 'cpu', 'mps'")
+    p.add_argument("--window",       type=int,   default=2048,
+                   help="WOLA window length (samples). Default: 2048 (sweep rank-1)")
+    p.add_argument("--hop",          type=int,   default=512,
+                   help="WOLA hop length (samples). Default: 512 (sweep rank-1)")
+    p.add_argument("--k-unroll",     type=int,   default=4,    dest="k_unroll",
+                   help="Number of unrolled ADMM layers")
+    p.add_argument("--k-context",    type=int,   default=8,    dest="k_context",
+                   help="Number of context frames for the GRU encoder")
+    # ── Base SPADE parameters (sweep optima, encoder predicts multipliers of these) ─
+    p.add_argument("--base-delta-db",    type=float, default=3.5,  dest="base_delta_db",
+                   help="Base delta_db (sweep rank-1=3.5, rank-2=2.25, rank-3=2.75)")
+    p.add_argument("--base-max-gain-db", type=float, default=6.0,  dest="base_max_gain_db",
+                   help="Base max_gain_db. Default 6.0: g_fac=0.75→4.5dB (Phase-1 optimum). "
+                        "Sweep rank-1=9.0 led to g_fac collapsing to lower bound.")
+    p.add_argument("--base-eps",         type=float, default=0.05, dest="base_eps",
+                   help="Base eps (sweep rank-1=0.05, rank-2=0.05, rank-3=0.1)")
+    p.add_argument("--lf-delta-ratio",   type=float, default=0.286, dest="lf_delta_ratio",
+                   help="lf_delta_db / delta_db ratio for lambda_lf init (rank-1: 1.0/3.5≈0.286)")
+    p.add_argument("--early-stop",       type=int,   default=15,   dest="early_stop_patience",
+                   help="Early stopping patience (epochs without val improvement). 0 = disabled.")
+    # ── v13 integration ───────────────────────────────────────────────────────
+    p.add_argument("--lf-band-hz",       type=float, default=8000.0, dest="lf_band_hz",
+                   help="[v13] LP-filter training frames to this frequency (Hz) before "
+                        "feeding to the model. Must match HybridSPADEInference.crossover_hz "
+                        "to eliminate train/inference distribution mismatch. "
+                        "0 = disabled (full-bandwidth, legacy v12 behaviour).")
+    p.add_argument("--no-mask-dilation", action="store_true", dest="no_mask_dilation",
+                   help="[v13] Disable mask dilation with sample release_ms in FrameDataset. "
+                        "By default dilation is ON to match the dilated masks used at inference.")
+    p.add_argument("--loss-lf-cutoff",   type=float, default=2500.0, dest="loss_lf_cutoff_hz",
+                   help="[v13] Frequency (Hz) up to which DCT bins count as LF for "
+                        "loss_lf_coeff and loss_lf_energy. "
+                        "[FIX] Default raised 500→2500 Hz: at 500 Hz the primary LF losses "
+                        "were blind to the 500–2000 Hz mid band, causing persistent mid regression. "
+                        "2500 Hz covers sub-bass+bass+low-mids in the high-weight loss term (w=2.0).")
+    return p
+
+
+def main():
+    args = _build_parser().parse_args()
+
+    # ── Model config ──────────────────────────────────────────────────────
+    cfg = UnrolledConfig(
+        window_length=args.window,
+        hop_length=args.hop,
+        K_unroll=args.k_unroll,
+        K_context=args.k_context,
+        base_delta_db=args.base_delta_db,
+        base_max_gain_db=args.base_max_gain_db,
+        base_eps=args.base_eps,
+        lf_delta_ratio=args.lf_delta_ratio,
+    )
+    model  = build_model(cfg)
+    device = args.device
+
+    # Check device availability
+    if device.startswith("cuda") and not torch.cuda.is_available():
+        print("  [WARNING] CUDA not available — falling back to CPU")
+        device = "cpu"
+    model = model.to(device)
+
+    # ── Training config ───────────────────────────────────────────────────
+    tc = TrainConfig(
+        drum_dir    = args.drum_dir,
+        mix_dir     = args.mix_dir,
+        ckpt_dir    = args.ckpt_dir,
+        ckpt_phase1 = args.ckpt_phase1,
+        phase       = args.phase,
+        epochs_p1   = args.epochs_p1,
+        epochs_p2   = args.epochs_p2,
+        batch_size  = args.batch_size,
+        lr_phase1   = args.lr_phase1,
+        lr_phase2   = args.lr_phase2,
+        p1_mix_frac = args.p1_mix_frac,
+        device      = device,
+        resume      = args.resume,
+        early_stop_patience = args.early_stop_patience,
+        # v13 integration
+        lf_band_hz          = args.lf_band_hz,
+        apply_mask_dilation = not args.no_mask_dilation,
+        loss_lf_cutoff_hz   = args.loss_lf_cutoff_hz,
+    )
+
+    # ── Run phases ────────────────────────────────────────────────────────
+    p1_ckpt = None
+    p1_tr_samples = None
+
+    if args.phase in ("1", "both"):
+        p1_ckpt = train_phase1(model, tc, device)
+
+    if args.phase in ("2", "both"):
+        train_phase2(model, tc, device, p1_ckpt=p1_ckpt,
+                     samples_p1_tr=p1_tr_samples)
+
+    print("\n  ✓ Training complete.")
+
+
+if __name__ == "__main__":
+    main()

train_transient_net.py

@@ -0,0 +1,1509 @@
+"""
+train_transient_net.py  —  Two-phase training for TransientNet
+===============================================================
+
+Drop-in replacement for train_spade_unrolled.py.
+Reuses the same corpus pipeline (drum samples + full mix), same synthetic
+brickwall limiter, same evaluation metrics — but trains TransientNet
+(direct residual prediction) instead of SPADE-Unrolled.
+
+What changed vs train_spade_unrolled.py
+---------------------------------------
+  ✗ NO binary masks (Ir, Icp, Icm) — the limiter has no "reliable" samples
+  ✗ NO SPADE imports — no spade_declip_v13, no _compute_masks, no _dilate_masks
+  ✗ NO conflicting loss terms — 3 clean terms vs 9 with competing gradients
+  ✗ NO soft-thresholding dead zones — gradients flow freely through all layers
+  ✗ NO g_fac collapse — no gain parameter to get stuck at floor
+
+  ✓ Same corpus pipeline (drum samples + pink noise + full mix)
+  ✓ Same synthetic limiter (1-sample attack, exponential release)
+  ✓ Same WOLA frame extraction (sqrt-Hann windows)
+  ✓ Same two-phase curriculum (Phase 1: drums, Phase 2: full mix + mixed batching)
+  ✓ Same ΔSDR evaluation metrics (global + multiband)
+  ✓ Same CLI interface (--phase, --epochs-p1, --drum-dir, etc.)
+  ✓ LF band filtering for hybrid inference compatibility
+
+CLI
+---
+    # Phase 1 only
+    python train_transient_net.py --phase 1 --epochs-p1 50 --drum-dir ./Samples
+
+    # Full two-phase
+    python train_transient_net.py --phase both --epochs-p1 50 --epochs-p2 30 \
+        --drum-dir ./Samples --mix-dir ./FullMix
+
+    # Resume
+    python train_transient_net.py --phase 1 --resume checkpoints_tnet/phase1_best.pt \
+        --drum-dir ./Samples
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+import os
+import random
+import time
+import warnings
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import scipy.signal as sig
+
+try:
+    import soundfile as sf
+    _HAS_SF = True
+except ImportError:
+    _HAS_SF = False
+    warnings.warn("soundfile not found — pip install soundfile")
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from torch.utils.data import Dataset, DataLoader
+except ImportError:
+    raise ImportError("PyTorch required — pip install torch")
+
+from transient_net import (
+    TransientNet, TransientNetConfig, TransientLoss, build_model,
+)
+
+
+# =============================================================================
+# Constants
+# =============================================================================
+
+DRUM_DIRS      = ["Kicks", "Snares", "Perc", "Tops"]
+SAMPLE_RATE    = 44100
+
+# Limiter augmentation ranges
+AUG_THRESH_RANGE  = (-1.5, -4.5)   # dBFS
+AUG_RELEASE_RANGE = (40.0, 120.0)  # ms
+PINK_NOISE_DB     = -20.0          # dB relative to peak
+
+# Default training hyperparameters
+BATCH_SIZE   = 32
+LR_PHASE1    = 3e-4
+LR_PHASE2    = 3e-5
+WEIGHT_DECAY = 1e-4
+GRAD_CLIP    = 1.0
+
+PHASE1_MIX_FRAC     = 0.30
+FORGETTING_THR_DB   = 2.0
+
+
+# =============================================================================
+# Pink noise generator
+# =============================================================================
+
+def generate_pink_noise(n_samples: int, rng: np.random.Generator) -> np.ndarray:
+    """Voss-McCartney 5-pole IIR approximation of 1/f noise."""
+    b = np.array([ 0.049922035, -0.095993537,  0.050612699, -0.004408786])
+    a = np.array([ 1.0,         -2.494956002,  2.017265875, -0.522189400])
+    white = rng.standard_normal(n_samples)
+    pink  = sig.lfilter(b, a, white)
+    rms   = np.sqrt(np.mean(pink ** 2))
+    return pink / (rms + 1e-12)
+
+
+# =============================================================================
+# Synthetic brickwall limiter  (Numba-accelerated, Python fallback)
+# =============================================================================
+
+# Try to JIT-compile the inner loop with Numba for ~200× speedup.
+# Falls back transparently to pure Python if Numba is not installed.
+try:
+    from numba import njit as _njit
+
+    @_njit(cache=True, fastmath=True)
+    def _limiter_loop(audio: np.ndarray, thr_lin: float, rc: float) -> np.ndarray:
+        out = np.empty_like(audio)
+        env = 1.0
+        for n in range(len(audio)):
+            pk     = abs(audio[n])
+            target = thr_lin / pk if pk > thr_lin else 1.0
+            env    = target if target < env else rc * env + (1.0 - rc) * target
+            out[n] = audio[n] * env
+        return out
+
+    _NUMBA_OK = True
+
+except ImportError:
+    _NUMBA_OK = False
+
+    def _limiter_loop(audio: np.ndarray, thr_lin: float, rc: float) -> np.ndarray:  # type: ignore[misc]
+        """Pure-Python fallback (slow for large arrays)."""
+        out = np.empty_like(audio)
+        env = 1.0
+        for n in range(len(audio)):
+            pk     = abs(audio[n])
+            target = thr_lin / pk if pk > thr_lin else 1.0
+            env    = target if target < env else rc * env + (1.0 - rc) * target
+            out[n] = audio[n] * env
+        return out
+
+
+def apply_brickwall_limiter(
+    audio: np.ndarray,
+    sr:    int,
+    threshold_db: float,
+    release_ms:   float,
+) -> np.ndarray:
+    """
+    Brickwall limiter: 1-sample attack, exponential release.
+    Uses Numba JIT when available (install with: pip install numba).
+    """
+    thr_lin = 10 ** (-abs(threshold_db) / 20.0)
+    rc      = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9))
+    return _limiter_loop(audio.astype(np.float64), thr_lin, rc)
+
+
+# =============================================================================
+# Corpus preparation — LAZY LOADING
+# =============================================================================
+# Instead of loading all audio into RAM, we store lightweight metadata and
+# load/limit on-the-fly in __getitem__.  This reduces RAM from O(corpus_size)
+# to O(cache_size) — critical when expanding from 76 to 2000+ samples.
+#
+# Architecture:
+#   SampleMeta   — lightweight descriptor (path, chunk bounds, flags)
+#   AudioCache   — LRU cache for loaded audio files (avoids re-reading disk)
+#   FrameDataset — draws random frames, applies limiter on-the-fly
+
+from functools import lru_cache
+import threading
+
+@dataclass
+class SampleMeta:
+    """Lightweight sample descriptor — NO audio arrays, just metadata."""
+    path:         str          # file path
+    chunk_start:  int   = 0    # sample offset (for loop chunks)
+    chunk_end:    int   = -1   # -1 = entire file
+    add_pink:     bool  = True # one-shots get pink noise
+    is_fullmix:   bool  = False
+
+
+def _load_and_cache_audio(path: str, target_sr: int = SAMPLE_RATE) -> Optional[np.ndarray]:
+    """Load audio file to mono float64, normalised to 0 dBFS peak.
+    Results are cached by the AudioCache wrapper below."""
+    if not _HAS_SF:
+        return None
+    try:
+        audio, sr = sf.read(path, always_2d=True)
+        audio = audio.mean(axis=1)
+        if sr != target_sr:
+            try:
+                from scipy.signal import resample_poly
+                from math import gcd
+                g = gcd(target_sr, sr)
+                audio = resample_poly(audio, target_sr // g, sr // g)
+            except Exception:
+                pass
+        peak = np.max(np.abs(audio))
+        if peak < 1e-8:
+            return None
+        return audio.astype(np.float64) / peak
+    except Exception as e:
+        return None
+
+
+class AudioCache:
+    """
+    Thread-safe LRU cache for loaded audio files.
+
+    Holds at most `max_files` normalised audio arrays in RAM.
+    With max_files=64 and average file ~5 sec → ~64 × 220K × 8 bytes ≈ 110 MB.
+    Much less than the 8+ GB of the eager approach.
+    """
+
+    def __init__(self, max_files: int = 512):
+        self._max = max_files
+        self._cache: Dict[str, np.ndarray] = {}
+        self._order: List[str] = []  # LRU order (most recent at end)
+        self._lock = threading.Lock()
+
+    def get(self, path: str) -> Optional[np.ndarray]:
+        with self._lock:
+            if path in self._cache:
+                # Move to end (most recently used)
+                self._order.remove(path)
+                self._order.append(path)
+                return self._cache[path]
+
+        # Load outside lock (I/O bound)
+        audio = _load_and_cache_audio(path)
+        if audio is None:
+            return None
+
+        with self._lock:
+            if path not in self._cache:
+                # Evict oldest if full
+                while len(self._cache) >= self._max:
+                    oldest = self._order.pop(0)
+                    del self._cache[oldest]
+                self._cache[path] = audio
+                self._order.append(path)
+
+        return audio
+
+
+# Global cache shared by all datasets (avoids reloading same files
+# across train/val/p1/p2 datasets).
+# 512 files × ~5s average × 44100 × 8 bytes ≈ 880 MB — adjust via --cache-files CLI arg.
+_AUDIO_CACHE = AudioCache(max_files=512)
+
+
+class ChunkCache:
+    """
+    Thread-safe LRU cache for *preprocessed* clean audio chunks.
+
+    Stores the result of (_extract_chunk) — i.e. the chunk after:
+      - slicing, pink-noise mixing, and peak-normalisation.
+    Keyed by (path, chunk_start, chunk_end, add_pink).
+
+    This avoids re-reading the file AND re-generating pink noise on every
+    __getitem__ call.  Only the random limiter (fast with Numba) and the
+    random frame crop still run per-access.
+
+    Memory estimate: 512 chunks × 4 s avg × 44100 Hz × 4 bytes ≈ 360 MB.
+    Tune with --chunk-cache-size (default 512; set 0 to disable).
+    """
+
+    def __init__(self, max_chunks: int = 512):
+        self._max   = max_chunks
+        self._cache: Dict[tuple, np.ndarray] = {}
+        self._order: List[tuple] = []
+        self._lock  = threading.Lock()
+
+    def get(self, key: tuple) -> Optional[np.ndarray]:
+        if self._max == 0:
+            return None
+        with self._lock:
+            if key in self._cache:
+                self._order.remove(key)
+                self._order.append(key)
+                return self._cache[key]
+        return None
+
+    def put(self, key: tuple, chunk: np.ndarray) -> None:
+        if self._max == 0:
+            return
+        with self._lock:
+            if key not in self._cache:
+                while len(self._cache) >= self._max:
+                    oldest = self._order.pop(0)
+                    del self._cache[oldest]
+                self._cache[key] = chunk.copy()
+                self._order.append(key)
+
+
+_CHUNK_CACHE = ChunkCache(max_chunks=512)
+
+
+def _extract_chunk(
+    audio: np.ndarray,
+    meta:  SampleMeta,
+    rng:   np.random.Generator,
+) -> np.ndarray:
+    """
+    Extract the relevant chunk from a loaded audio file, with LRU caching.
+
+    For one-shots: returns full audio (with deterministic pink noise).
+    For loop chunks: returns the slice [chunk_start:chunk_end].
+
+    The result is cached in _CHUNK_CACHE — disk I/O and pink-noise synthesis
+    are skipped on repeated accesses to the same chunk.  The random limiter
+    (which is the remaining per-call work) is applied outside this function.
+    """
+    cache_key = (meta.path, meta.chunk_start, meta.chunk_end, meta.add_pink)
+    cached = _CHUNK_CACHE.get(cache_key)
+    if cached is not None:
+        return cached
+
+    # ── Compute ───────────────────────────────────────────────────────────
+    if meta.chunk_end > 0:
+        chunk = audio[meta.chunk_start : meta.chunk_end].copy()
+    else:
+        chunk = audio.copy()
+
+    # Truncate very long files (safety)
+    max_samples = int(_LOOP_MAX_SEC * SAMPLE_RATE)
+    if len(chunk) > max_samples:
+        chunk = chunk[:max_samples]
+
+    # Add pink noise for one-shots.
+    # Use a deterministic seed derived from the path so the cached chunk
+    # is always identical (the random limiter still varies every access).
+    if meta.add_pink:
+        seed_rng = np.random.default_rng(abs(hash(meta.path)) & 0xFFFFFFFF)
+        pink = generate_pink_noise(len(chunk), seed_rng)
+        gain = float(np.max(np.abs(chunk))) * (10 ** (PINK_NOISE_DB / 20.0))
+        chunk = chunk + pink * gain
+
+    # Re-normalise to 0 dBFS
+    peak = np.max(np.abs(chunk))
+    if peak > 1e-8:
+        chunk = chunk / peak
+
+    _CHUNK_CACHE.put(cache_key, chunk)
+    return chunk
+
+
+# =============================================================================
+# Corpus builders — now return List[SampleMeta] instead of List[SampleMeta]
+# =============================================================================
+
+AUDIO_EXTENSIONS = ["*.wav", "*.WAV", "*.flac", "*.FLAC", "*.aif", "*.aiff",
+                    "*.AIF", "*.AIFF", "*.mp3", "*.ogg"]
+
+
+def _collect_audio_files(directory: Path) -> List[Path]:
+    """Recursively collect audio files from a directory."""
+    files = []
+    if not directory.exists():
+        return files
+    for ext in AUDIO_EXTENSIONS:
+        files.extend(directory.rglob(ext))
+    return sorted(files)
+
+
+def _scan_audio_file(path: Path) -> Optional[int]:
+    """
+    Quick scan: get duration in samples without loading full audio.
+    Falls back to loading if sf.info is not available.
+    """
+    try:
+        info = sf.info(str(path))
+        return int(info.frames)
+    except Exception:
+        return None
+
+
+def build_drum_corpus(
+    base_dir: Path,
+    rng: np.random.Generator,
+    augment: bool = True,
+) -> List[SampleMeta]:
+    """Build corpus of drum one-shot metadata (lazy — no audio loaded)."""
+    metas = []
+    drum_dirs = [base_dir / d for d in DRUM_DIRS if (base_dir / d).exists()]
+    if not drum_dirs:
+        drum_dirs = [base_dir]
+
+    audio_files = []
+    for d in drum_dirs:
+        for ext in ["*.wav", "*.WAV", "*.flac", "*.FLAC", "*.aif", "*.aiff"]:
+            audio_files.extend(d.glob(ext))
+
+    if not audio_files:
+        warnings.warn(f"No audio files found in {base_dir}")
+        return metas
+
+    for path in audio_files:
+        # Quick existence check (don't load audio yet)
+        if not path.exists() or path.stat().st_size < 100:
+            continue
+        metas.append(SampleMeta(
+            path=str(path),
+            chunk_start=0,
+            chunk_end=-1,
+            add_pink=True,
+            is_fullmix=False,
+        ))
+
+    return metas
+
+
+def build_fullmix_corpus(
+    mix_dir: Path,
+    rng: np.random.Generator,
+    augment: bool = True,
+) -> List[SampleMeta]:
+    """Build corpus of full-mix metadata."""
+    metas = []
+    audio_files = []
+    for ext in ["*.wav", "*.WAV", "*.flac", "*.FLAC"]:
+        audio_files.extend(mix_dir.rglob(ext))
+
+    for path in audio_files:
+        if not path.exists() or path.stat().st_size < 100:
+            continue
+        metas.append(SampleMeta(
+            path=str(path),
+            chunk_start=0,
+            chunk_end=-1,
+            add_pink=False,
+            is_fullmix=True,
+        ))
+
+    return metas
+
+
+# =============================================================================
+# Extended corpus: drum loops + one-shots from additional directories
+# =============================================================================
+
+_ONESHOT_MAX_SEC  = 1.5
+_LOOP_MAX_SEC     = 30.0
+_LOOP_CHUNK_SEC   = 4.0
+_LOOP_N_AUG       = 3       # number of SampleMeta entries per chunk
+                             # (limiter params are randomised at access time,
+                             # so this just controls sampling weight)
+
+
+def parse_extra_dirs_csv(csv_path: Path) -> List[Tuple[Path, str]]:
+    """Parse CSV with columns: Percorso Directory, Tipo."""
+    import csv
+    entries = []
+    base = csv_path.parent
+
+    with open(csv_path, "r", encoding="utf-8") as f:
+        reader = csv.reader(f)
+        header = next(reader, None)
+        for row in reader:
+            if len(row) < 2:
+                continue
+            raw_path = row[0].strip().strip('"')
+            tipo     = row[1].strip().strip('"')
+            p = Path(raw_path)
+            if not p.is_absolute():
+                p = base / p
+            entries.append((p, tipo))
+
+    return entries
+
+
+def build_extended_corpus(
+    extra_entries: List[Tuple[Path, str]],
+    rng: np.random.Generator,
+) -> List[SampleMeta]:
+    """
+    Build lazy corpus from extended directories.
+
+    For loops: scan file duration, create chunk metas with start/end offsets.
+    For one-shots: single meta per file.
+
+    No audio is loaded — just file scanning for duration.
+    """
+    metas = []
+    n_files = 0
+    n_oneshots = 0
+    n_loops = 0
+    n_skipped = 0
+
+    chunk_samples = int(_LOOP_CHUNK_SEC * SAMPLE_RATE)
+    chunk_hop     = chunk_samples // 2    # 50% overlap
+
+    for directory, tipo in extra_entries:
+        if not directory.exists():
+            warnings.warn(f"Directory not found, skipping: {directory}")
+            n_skipped += 1
+            continue
+
+        files = _collect_audio_files(directory)
+        if not files:
+            continue
+
+        is_oneshot = ("one" in tipo.lower() and "shot" in tipo.lower())
+
+        for path in files:
+            if not path.exists() or path.stat().st_size < 100:
+                continue
+
+            # Get duration without loading audio
+            n_samples = _scan_audio_file(path)
+            if n_samples is None or n_samples < 1000:
+                continue
+
+            n_files += 1
+            duration_sec = n_samples / SAMPLE_RATE
+
+            if is_oneshot or duration_sec <= _ONESHOT_MAX_SEC:
+                # One-shot
+                metas.append(SampleMeta(
+                    path=str(path), chunk_start=0, chunk_end=-1,
+                    add_pink=True, is_fullmix=False,
+                ))
+                n_oneshots += 1
+            else:
+                # Loop: create chunk metas
+                max_samples = min(n_samples, int(_LOOP_MAX_SEC * SAMPLE_RATE))
+                pos = 0
+                while pos + chunk_samples <= max_samples:
+                    # Create N_AUG entries per chunk (increases sampling weight;
+                    # actual limiter params are randomised every access)
+                    for _ in range(_LOOP_N_AUG):
+                        metas.append(SampleMeta(
+                            path=str(path),
+                            chunk_start=pos,
+                            chunk_end=pos + chunk_samples,
+                            add_pink=False,
+                            is_fullmix=False,
+                        ))
+                    pos += chunk_hop
+
+                # Last partial chunk
+                remaining = max_samples - pos
+                if remaining > chunk_samples // 4:
+                    for _ in range(_LOOP_N_AUG):
+                        metas.append(SampleMeta(
+                            path=str(path),
+                            chunk_start=pos,
+                            chunk_end=max_samples,
+                            add_pink=False,
+                            is_fullmix=False,
+                        ))
+
+                n_loops += 1
+
+    print(f"  Extended corpus: {n_files} files scanned "
+          f"({n_oneshots} one-shots, {n_loops} loops) "
+          f"→ {len(metas)} SampleMeta entries  [lazy — 0 bytes audio in RAM]")
+    if n_skipped > 0:
+        print(f"  ⚠ {n_skipped} directories not found (skipped)")
+
+    return metas
+
+
+# =============================================================================
+# Frame Dataset — LAZY LOADING, no masks
+# =============================================================================
+
+class FrameDataset(Dataset):
+    """
+    Random-frame dataset for TransientNet with LAZY audio loading.
+
+    Returns (yc_w, ctx, x_clean_w) — no masks needed.
+
+    Audio is loaded from disk on-demand via AudioCache (LRU, ~110 MB).
+    Limiter is applied on-the-fly with random params per access.
+    This keeps RAM usage constant regardless of corpus size.
+
+    Augmentation (training only)
+    ----------------------------
+    - Random limiter params: threshold and release randomised every access
+    - Random gain: ±6 dB uniform
+    - Polarity flip: 50%
+    """
+
+    def __init__(
+        self,
+        samples:     List[SampleMeta],
+        cfg:         TransientNetConfig,
+        n_virtual:   int   = 10000,
+        rng_seed:    int   = 42,
+        lf_band_hz:  float = 0.0,
+        augment:     bool  = True,
+    ):
+        if not samples:
+            raise ValueError("Empty sample list")
+        self.samples    = samples
+        self.M          = cfg.window_length
+        self.a          = cfg.hop_length
+        self.K_ctx      = cfg.K_context
+        self.sr         = cfg.sample_rate
+        self.n_virtual  = n_virtual
+        self.rng        = np.random.default_rng(rng_seed)
+        self.lf_band_hz = lf_band_hz
+        self.augment    = augment
+        self.cache      = _AUDIO_CACHE
+
+        from scipy.signal.windows import hann
+        self.win = np.sqrt(hann(self.M, sym=False)).astype(np.float32)
+
+        self._lp_sos = None
+        if lf_band_hz > 0.0:
+            from scipy.signal import butter
+            fc = float(np.clip(lf_band_hz, 1.0, cfg.sample_rate / 2.0 - 1.0))
+            self._lp_sos = butter(2, fc, btype="low", fs=cfg.sample_rate, output="sos")
+
+    def __len__(self):
+        return self.n_virtual
+
+    def __getitem__(self, _idx: int):
+        # ── Pick a random sample meta ─────────────────────────────────────
+        meta = self.samples[self.rng.integers(len(self.samples))]
+
+        # ── Load audio from cache ─────────────────────────────────────────
+        raw_audio = self.cache.get(meta.path)
+        if raw_audio is None:
+            # File unreadable — pick another (rare)
+            for _ in range(10):
+                meta = self.samples[self.rng.integers(len(self.samples))]
+                raw_audio = self.cache.get(meta.path)
+                if raw_audio is not None:
+                    break
+            if raw_audio is None:
+                # Return zeros as last resort
+                return (torch.zeros(self.M), torch.zeros(self.K_ctx, self.M),
+                        torch.zeros(self.M))
+
+        # ── Extract chunk + add pink noise if needed ──────────────────────
+        clean_sig = _extract_chunk(raw_audio, meta, self.rng)
+
+        # ── Apply limiter with random params ──────────────────────────────
+        if self.augment:
+            thr_db = self.rng.uniform(*sorted(AUG_THRESH_RANGE))
+            rel_ms = self.rng.uniform(*AUG_RELEASE_RANGE)
+        else:
+            thr_db = -3.0
+            rel_ms = 80.0
+
+        limited_sig = apply_brickwall_limiter(clean_sig, self.sr, thr_db, rel_ms)
+
+        # ── Optional LF band filtering ────────────────────────────────────
+        if self._lp_sos is not None:
+            from scipy.signal import sosfiltfilt
+            clean_sig   = sosfiltfilt(self._lp_sos, clean_sig).astype(np.float64)
+            limited_sig = sosfiltfilt(self._lp_sos, limited_sig).astype(np.float64)
+
+        L = len(clean_sig)
+        if L < self.M:
+            pad = self.M - L
+            clean_sig   = np.pad(clean_sig,   (0, pad))
+            limited_sig = np.pad(limited_sig, (0, pad))
+            i = 0
+        else:
+            max_idx = max(0, (L - self.M) // self.a)
+            i = self.rng.integers(0, max_idx + 1) if max_idx > 0 else 0
+
+        # Current frame (windowed)
+        idx1    = i * self.a
+        idx2    = min(idx1 + self.M, L)
+        seg_len = idx2 - idx1
+
+        yc_w    = np.zeros(self.M, dtype=np.float32)
+        x_clean = np.zeros(self.M, dtype=np.float32)
+        yc_w[:seg_len]    = (limited_sig[idx1:idx2] * self.win[:seg_len]).astype(np.float32)
+        x_clean[:seg_len] = (clean_sig[idx1:idx2]   * self.win[:seg_len]).astype(np.float32)
+
+        # K context frames (strictly causal)
+        ctx = np.zeros((self.K_ctx, self.M), dtype=np.float32)
+        for k in range(self.K_ctx):
+            ci = i - (self.K_ctx - k)
+            if ci < 0:
+                continue
+            c_idx1 = ci * self.a
+            c_idx2 = min(c_idx1 + self.M, L)
+            c_seg  = c_idx2 - c_idx1
+            if c_seg <= 0:
+                continue
+            ctx[k, :c_seg] = (limited_sig[c_idx1:c_idx2] * self.win[:c_seg]).astype(np.float32)
+
+        # ── Augmentation ──────────────────────────────────────────────────
+        if self.augment:
+            gain_db  = self.rng.uniform(-6.0, 0.0)
+            gain_lin = np.float32(10 ** (gain_db / 20.0))
+            yc_w    *= gain_lin
+            x_clean *= gain_lin
+            ctx     *= gain_lin
+
+            if self.rng.random() < 0.5:
+                yc_w    *= -1
+                x_clean *= -1
+                ctx     *= -1
+
+        return (
+            torch.from_numpy(yc_w),
+            torch.from_numpy(ctx),
+            torch.from_numpy(x_clean),
+        )
+
+
+class MixedBatchDataset(Dataset):
+    """Phase-2 mixed batching: α% Phase-1 + (1−α)% Phase-2."""
+
+    def __init__(self, ds_p1, ds_p2, p1_frac=PHASE1_MIX_FRAC, n_virtual=20000):
+        self.ds_p1     = ds_p1
+        self.ds_p2     = ds_p2
+        self.p1_frac   = p1_frac
+        self.n_virtual = n_virtual
+        self.rng       = random.Random(0)
+
+    def __len__(self):
+        return self.n_virtual
+
+    def __getitem__(self, idx):
+        if self.rng.random() < self.p1_frac:
+            return self.ds_p1[idx % len(self.ds_p1)]
+        return self.ds_p2[idx % len(self.ds_p2)]
+
+
+# =============================================================================
+# Evaluation metrics (reused from train_spade_unrolled.py)
+# =============================================================================
+
+def _sdr_batch(ref, est, eps=1e-10):
+    return 10.0 * torch.log10(
+        ref.pow(2).sum(-1) / ((ref - est).pow(2).sum(-1) + eps) + eps)
+
+def _delta_sdr_batch(clean, limited, enhanced, eps=1e-10):
+    return _sdr_batch(clean, enhanced, eps) - _sdr_batch(clean, limited, eps)
+
+def _bandpass_fft(x, sr, f_lo, f_hi):
+    N = x.shape[-1]
+    X     = torch.fft.rfft(x, n=N)
+    freqs = torch.fft.rfftfreq(N, d=1.0 / sr)
+    X_filt = X * ((freqs >= f_lo) & (freqs < f_hi)).to(x.device)
+    return torch.fft.irfft(X_filt, n=N)
+
+_BANDS = {
+    "sub_bass": (0.0,    250.0),
+    "bass":     (250.0,  500.0),
+    "low_mid":  (500.0,  2000.0),
+    "mid":      (2000.0, 8000.0),
+}
+
+def _multiband_delta_sdr_batch(clean, limited, enhanced, sr=SAMPLE_RATE, eps=1e-10):
+    results = {}
+    for band_name, (f_lo, f_hi) in _BANDS.items():
+        c_b = _bandpass_fft(clean,    sr, f_lo, f_hi)
+        l_b = _bandpass_fft(limited,  sr, f_lo, f_hi)
+        e_b = _bandpass_fft(enhanced, sr, f_lo, f_hi)
+        if c_b.pow(2).mean().item() < 1e-12:
+            results[f"dsdr_{band_name}"] = 0.0
+        else:
+            results[f"dsdr_{band_name}"] = _delta_sdr_batch(
+                c_b, l_b, e_b, eps).mean().item()
+    return results
+
+
+# =============================================================================
+# Training config
+# =============================================================================
+
+@dataclass
+class TrainConfig:
+    """All training hyperparameters."""
+    # Directories
+    drum_dir:       str = "./Samples"
+    mix_dir:        str = ""
+    ckpt_dir:       str = "./checkpoints_tnet"
+    extra_dirs_csv: str = ""    # CSV with additional drum dirs (loops + one-shots)
+
+    # Phases
+    phase:        str = "both"
+    epochs_p1:    int = 50
+    epochs_p2:    int = 30
+
+    # Optimisation
+    batch_size:   int = BATCH_SIZE
+    lr_phase1:    float = LR_PHASE1
+    lr_phase2:    float = LR_PHASE2
+    weight_decay: float = WEIGHT_DECAY
+    grad_clip:    float = GRAD_CLIP
+
+    # Mixed batching
+    p1_mix_frac:  float = PHASE1_MIX_FRAC
+
+    # Virtual epoch sizes
+    frames_per_epoch:    int = 8000
+    frames_per_epoch_p2: int = 16000
+
+    # Validation
+    val_frac:      float = 0.15
+    forgetting_thr: float = FORGETTING_THR_DB
+
+    # Loss weights (4 terms, no conflicts)
+    loss_w_time:     float = 1.0
+    loss_w_stft:     float = 0.5
+    loss_w_residual: float = 0.01   # light anti-hallucination
+    loss_w_energy:   float = 0.1    # residual amplitude calibration (clamped + warmup)
+
+    # Early stopping
+    early_stop_patience: int = 15
+
+    # LF band filter (for hybrid inference compatibility)
+    lf_band_hz: float = 8000.0
+
+    # Device / resume
+    device:      str = "cuda"
+    resume:      str = ""
+    ckpt_phase1: str = ""
+
+    # Logging
+    log_every:   int = 50
+    save_every:  int = 5
+    num_workers: int = 4  # DataLoader worker processes
+
+
+# =============================================================================
+# Data loaders
+# =============================================================================
+
+def _make_loaders(
+    samples_tr:  List[SampleMeta],
+    samples_val: List[SampleMeta],
+    cfg:         TransientNetConfig,
+    tc:          TrainConfig,
+    phase:       int,
+    samples_p1_tr: Optional[List[SampleMeta]] = None,
+) -> Tuple[DataLoader, DataLoader]:
+
+    n_tr  = tc.frames_per_epoch if phase == 1 else tc.frames_per_epoch_p2
+    n_val = max(500, n_tr // 8)
+
+    ds_kw = dict(lf_band_hz=tc.lf_band_hz)
+
+    ds_val = FrameDataset(samples_val, cfg, n_virtual=n_val, rng_seed=999,
+                          augment=False, **ds_kw)
+
+    if phase == 1:
+        ds_tr = FrameDataset(samples_tr, cfg, n_virtual=n_tr, rng_seed=0,
+                             augment=True, **ds_kw)
+    else:
+        if not samples_p1_tr:
+            raise ValueError("Phase 2 requires Phase-1 samples (mixed batching)")
+        ds_p2 = FrameDataset(samples_tr,    cfg, n_virtual=n_tr,    rng_seed=1,
+                             augment=True, **ds_kw)
+        ds_p1 = FrameDataset(samples_p1_tr, cfg, n_virtual=n_tr//2, rng_seed=2,
+                             augment=True, **ds_kw)
+        ds_tr = MixedBatchDataset(ds_p1, ds_p2, p1_frac=tc.p1_mix_frac, n_virtual=n_tr)
+
+    loader_tr  = DataLoader(ds_tr,  batch_size=tc.batch_size, shuffle=True,
+                             num_workers=tc.num_workers, pin_memory=True, drop_last=True,
+                             persistent_workers=True)
+    loader_val = DataLoader(ds_val, batch_size=tc.batch_size, shuffle=False,
+                             num_workers=max(1, tc.num_workers // 2), pin_memory=True,
+                             persistent_workers=True)
+    return loader_tr, loader_val
+
+
+# =============================================================================
+# Diagnostics
+# =============================================================================
+
+def _diag_model(
+    model:     TransientNet,
+    loader:    DataLoader,
+    device:    str,
+    epoch:     int,
+    n_batches: int = 5,
+):
+    """
+    Print diagnostics: residual magnitude, gradient norms, parameter stats.
+
+    What to look for:
+      res_abs_mean ↑  → model is generating correction (good, if ΔSDR also ↑)
+      res_abs_mean → 0 → model collapsed to identity (bad)
+      grad_norm_rms → 0 → vanishing gradients (bad — but shouldn't happen here)
+      res_std/res_mean → diversity of corrections across frames
+    """
+    model.eval()
+    all_res = []
+    with torch.no_grad():
+        for i, batch in enumerate(loader):
+            if i >= n_batches:
+                break
+            yc_w, ctx, _ = [b.to(device) for b in batch]
+            _, residual = model(yc_w, ctx)
+            all_res.append(residual.cpu())
+
+    if not all_res:
+        return
+
+    R = torch.cat(all_res, dim=0)   # (N, M)
+    res_abs = R.abs()
+
+    print(f"  [diag ep{epoch}] residual stats:")
+    print(f"    mean|r̂|:   {res_abs.mean():.6f}")
+    print(f"    max|r̂|:    {res_abs.max():.6f}")
+    print(f"    std|r̂|:    {res_abs.std():.6f}")
+    print(f"    % > 0.001: {(res_abs > 0.001).float().mean():.3f}")
+    print(f"    % > 0.01:  {(res_abs > 0.01).float().mean():.3f}")
+
+    # Gradient norm
+    total_gnorm = 0.0
+    n_params    = 0
+    for p in model.parameters():
+        if p.grad is not None:
+            total_gnorm += p.grad.norm().item() ** 2
+            n_params += 1
+    if n_params > 0:
+        rms = math.sqrt(total_gnorm / n_params)
+        print(f"    grad_norm_rms: {rms:.6f}"
+              + ("  ⚠ WEAK" if rms < 1e-5 else ""))
+
+    # Check for collapsed output conv
+    oc_weight = model.frame_processor.output_conv.weight
+    print(f"    output_conv.weight norm: {oc_weight.norm():.6f}"
+          + ("  ⚠ NEAR-ZERO (identity mode)" if oc_weight.norm() < 1e-5 else ""))
+
+
+# =============================================================================
+# Training loop
+# =============================================================================
+
+def _train_epoch(
+    model:     TransientNet,
+    loader:    DataLoader,
+    optimizer: torch.optim.Optimizer,
+    scheduler: object,
+    loss_fn:   TransientLoss,
+    tc:        TrainConfig,
+    epoch:     int,
+    device:    str,
+) -> Dict[str, float]:
+    model.train()
+    running = {k: 0.0 for k in ["total", "time_mse", "stft", "res_l1", "energy_ratio", "w_energy_eff"]}
+    n_steps = 0
+    t0 = time.time()
+
+    for step, batch in enumerate(loader):
+        yc_w, ctx, x_clean = [b.to(device) for b in batch]
+
+        optimizer.zero_grad(set_to_none=True)
+
+        x_hat, residual = model(yc_w, ctx)
+        loss, details = loss_fn(x_hat, x_clean, yc_w, residual)
+
+        loss.backward()
+        nn.utils.clip_grad_norm_(model.parameters(), tc.grad_clip)
+        optimizer.step()
+        if scheduler is not None:
+            scheduler.step()
+
+        for k, v in details.items():
+            running[k] += v
+        n_steps += 1
+
+        if step > 0 and step % tc.log_every == 0:
+            elapsed = time.time() - t0
+            sps = step * tc.batch_size / elapsed
+            r, n = running, n_steps
+            print(f"  [Ep {epoch:3d} | {step:4d}/{len(loader)}]  "
+                  f"loss={r['total']/n:.4f}  "
+                  f"mse={r['time_mse']/n:.4f}  "
+                  f"stft={r['stft']/n:.4f}  "
+                  f"ergy={r['energy_ratio']/n:.3f}  "
+                  f"res={r['res_l1']/n:.5f}  "
+                  f"{sps:.0f} sa/s")
+
+    return {k: v / max(n_steps, 1) for k, v in running.items()}
+
+
+@torch.no_grad()
+def _validate_epoch(
+    model:   TransientNet,
+    loader:  DataLoader,
+    loss_fn: TransientLoss,
+    device:  str,
+) -> Dict[str, float]:
+    """
+    Validation loop.
+
+    Returns loss sub-components + ΔSDR metrics.
+
+    Keys
+    ----
+    total, time_mse, stft, res_l1  : loss components
+    dsdr_global                     : ΔSDR averaged over all frames (dB)
+    dsdr_sub_bass, dsdr_bass, dsdr_low_mid, dsdr_mid : per-band ΔSDR
+    cos_sim                         : cosine similarity of residual (DCT domain)
+    res_abs_mean                    : mean |residual| (identity-collapse indicator)
+    """
+    model.eval()
+    running = {k: 0.0 for k in ["total", "time_mse", "stft", "res_l1", "energy_ratio", "w_energy_eff"]}
+    dsdr_running = {
+        "dsdr_global": 0.0,
+        "dsdr_sub_bass": 0.0, "dsdr_bass": 0.0,
+        "dsdr_low_mid": 0.0,  "dsdr_mid": 0.0,
+        "cos_sim": 0.0, "res_abs_mean": 0.0,
+    }
+    n_steps = 0
+
+    for batch in loader:
+        yc_w, ctx, x_clean = [b.to(device) for b in batch]
+        x_hat, residual = model(yc_w, ctx)
+        _, details = loss_fn(x_hat, x_clean, yc_w, residual)
+
+        for k, v in details.items():
+            running[k] += v
+
+        # ΔSDR global
+        dsdr_running["dsdr_global"] += _delta_sdr_batch(
+            x_clean, yc_w, x_hat).mean().item()
+
+        # ΔSDR multiband
+        for k, v in _multiband_delta_sdr_batch(x_clean, yc_w, x_hat, sr=SAMPLE_RATE).items():
+            dsdr_running[k] += v
+
+        # Cosine similarity (DCT domain, residual vs GT residual)
+        gt_res  = (x_clean - yc_w).cpu().float()
+        est_res = residual.cpu().float()
+        eps = 1e-10
+        from scipy.fft import dct as _dct_np
+        G = np.array([_dct_np(g.numpy(), type=2, norm="ortho") for g in gt_res])
+        E = np.array([_dct_np(e.numpy(), type=2, norm="ortho") for e in est_res])
+        cos_batch = (G * E).sum(-1) / (
+            np.sqrt((G**2).sum(-1)) * np.sqrt((E**2).sum(-1)) + eps)
+        dsdr_running["cos_sim"] += float(cos_batch.mean())
+
+        # Identity-collapse indicator
+        dsdr_running["res_abs_mean"] += residual.abs().mean().item()
+
+        n_steps += 1
+
+    metrics = {k: v / max(n_steps, 1) for k, v in running.items()}
+    metrics.update({k: v / max(n_steps, 1) for k, v in dsdr_running.items()})
+    return metrics
+
+
+def _save_checkpoint(model, optimizer, epoch, val_loss, path: Path, extra=None):
+    state = {
+        "epoch":    epoch,
+        "val_loss": val_loss,
+        "model":    model.state_dict(),
+        "optimizer": optimizer.state_dict(),
+        "cfg":      asdict(model.cfg),
+        "arch":     "TransientNet",
+    }
+    if extra:
+        state.update(extra)
+    torch.save(state, path)
+    print(f"  ✓ Checkpoint saved → {path}  (val_loss={val_loss:.4f})")
+
+
+def _load_checkpoint(model, optimizer, path: Path, device: str):
+    ckpt = torch.load(path, map_location=device, weights_only=False)
+    model.load_state_dict(ckpt["model"])
+    if optimizer is not None and "optimizer" in ckpt:
+        optimizer.load_state_dict(ckpt["optimizer"])
+    return ckpt.get("epoch", 0), ckpt.get("val_loss", float("inf"))
+
+
+# =============================================================================
+# Phase 1
+# =============================================================================
+
+def train_phase1(
+    model:  TransientNet,
+    tc:     TrainConfig,
+    device: str,
+) -> Path:
+    print("\n" + "="*70)
+    print("PHASE 1 — Isolated drum samples + pink noise  [TransientNet]")
+    print("="*70)
+
+    drum_dir = Path(tc.drum_dir)
+    if not drum_dir.exists():
+        raise FileNotFoundError(f"Drum directory not found: {drum_dir}")
+
+    rng = np.random.default_rng(42)
+    print(f"  Loading drum corpus from {drum_dir} …")
+    all_samples = build_drum_corpus(drum_dir, rng, augment=True)
+
+    # ── Extended corpus (loops + extra one-shots) ─────────────────────────
+    if tc.extra_dirs_csv:
+        csv_path = Path(tc.extra_dirs_csv)
+        if csv_path.exists():
+            print(f"  Loading extended corpus from {csv_path} …")
+            extra_entries = parse_extra_dirs_csv(csv_path)
+            print(f"  Found {len(extra_entries)} directories in CSV")
+            extra_samples = build_extended_corpus(extra_entries, rng)
+            all_samples.extend(extra_samples)
+        else:
+            print(f"  ⚠ Extra dirs CSV not found: {csv_path}")
+
+    if not all_samples:
+        raise RuntimeError("No drum samples found — check --drum-dir and --extra-dirs")
+
+    print(f"  Total samples (original + extended): {len(all_samples)}")
+
+    # ── Scale virtual epoch size to corpus size ───────────────────────────
+    # With 76 samples, 8000 frames/epoch = ~105 frames/sample (reasonable).
+    # With 1000+ samples, keep the same ratio but cap at 40K to avoid
+    # excessively long epochs.
+    base_ratio = tc.frames_per_epoch / 76.0   # ~105
+    scaled_epoch = min(40000, max(tc.frames_per_epoch,
+                                  int(len(all_samples) * base_ratio)))
+    if scaled_epoch != tc.frames_per_epoch:
+        print(f"  Auto-scaled frames_per_epoch: {tc.frames_per_epoch} → {scaled_epoch}")
+        tc.frames_per_epoch = scaled_epoch
+
+    n_val = max(1, int(len(all_samples) * tc.val_frac))
+    rng.shuffle(all_samples)
+    samples_val = all_samples[:n_val]
+    samples_tr  = all_samples[n_val:]
+    print(f"  Train: {len(samples_tr)}  Val: {len(samples_val)}")
+
+    loss_fn = TransientLoss(
+        w_time=tc.loss_w_time,
+        w_stft=tc.loss_w_stft,
+        w_residual=tc.loss_w_residual,
+        w_energy=tc.loss_w_energy,
+    ).to(device)
+
+    loader_tr, loader_val = _make_loaders(samples_tr, samples_val, model.cfg, tc, phase=1)
+
+    optimizer = optim.AdamW(model.parameters(), lr=tc.lr_phase1,
+                             weight_decay=tc.weight_decay, betas=(0.9, 0.999))
+    total_steps = tc.epochs_p1 * len(loader_tr)
+    scheduler = optim.lr_scheduler.OneCycleLR(
+        optimizer, max_lr=tc.lr_phase1, total_steps=total_steps,
+        pct_start=0.1, anneal_strategy="cos",
+    )
+
+    ckpt_dir = Path(tc.ckpt_dir)
+    ckpt_dir.mkdir(parents=True, exist_ok=True)
+
+    start_epoch = 1
+    best_val    = float("inf")
+    if tc.resume:
+        ep, val = _load_checkpoint(model, optimizer, Path(tc.resume), device)
+        start_epoch = ep + 1
+        best_val    = val
+        print(f"  Resumed from epoch {ep}  (val={val:.4f})")
+
+    best_ckpt  = ckpt_dir / "phase1_best.pt"
+    history    = []
+    no_improve = 0
+
+    for epoch in range(start_epoch, tc.epochs_p1 + 1):
+        t_ep = time.time()
+        loss_fn._current_epoch = epoch    # warmup ramp for energy loss
+        tr_m  = _train_epoch(model, loader_tr, optimizer, scheduler, loss_fn, tc, epoch, device)
+        val_m = _validate_epoch(model, loader_val, loss_fn, device)
+        elapsed = time.time() - t_ep
+
+        dsdr_g  = val_m.get("dsdr_global",   0.0)
+        dsdr_sb = val_m.get("dsdr_sub_bass", 0.0)
+        dsdr_ba = val_m.get("dsdr_bass",     0.0)
+        dsdr_lm = val_m.get("dsdr_low_mid",  0.0)
+        dsdr_hi = val_m.get("dsdr_mid",      0.0)
+        cos_sim = val_m.get("cos_sim",       0.0)
+        res_abs = val_m.get("res_abs_mean",  0.0)
+
+        # Actionable flags
+        flag = ""
+        if dsdr_hi > 0.5 and dsdr_sb < 0.1:
+            flag = "  ⚠ SPECTRAL BIAS ↑mid/flat-sub"
+        elif dsdr_hi < -0.5:
+            flag = "  ⚠ mid regression"
+        elif dsdr_g < 0:
+            flag = "  ⚠ ΔSDR<0 → degrading signal"
+        if res_abs < 1e-5:
+            flag += "  ⚠ IDENTITY COLLAPSE (|r̂|→0)"
+
+        print(f"Epoch {epoch:3d}/{tc.epochs_p1}  "
+              f"tr={tr_m['total']:.4f}  val={val_m['total']:.4f}  "
+              f"[mse={val_m['time_mse']:.4f} stft={val_m['stft']:.4f} "
+              f"ergy={val_m['energy_ratio']:.3f}×{val_m.get('w_energy_eff',0):.2f} "
+              f"res={val_m['res_l1']:.5f}]  "
+              f"({elapsed:.1f}s)")
+        print(f"         ΔSDR  global={dsdr_g:+.2f}dB  "
+              f"sub_bass={dsdr_sb:+.2f}dB  bass={dsdr_ba:+.2f}dB  "
+              f"low_mid={dsdr_lm:+.2f}dB  mid={dsdr_hi:+.2f}dB  "
+              f"cos={cos_sim:.3f}  |r̂|={res_abs:.5f}{flag}")
+
+        # Diagnostics every 2 epochs
+        if epoch % 2 == 0 or epoch == 1:
+            _diag_model(model, loader_val, device, epoch)
+
+        history.append({
+            "epoch": epoch, "train": tr_m, "val": val_m,
+            "dsdr_global": dsdr_g, "dsdr_sub_bass": dsdr_sb,
+            "dsdr_bass": dsdr_ba, "dsdr_low_mid": dsdr_lm,
+            "dsdr_mid": dsdr_hi, "cos_sim": cos_sim,
+        })
+
+        if val_m["total"] < best_val:
+            best_val   = val_m["total"]
+            no_improve = 0
+            _save_checkpoint(model, optimizer, epoch, best_val, best_ckpt,
+                             extra={"phase": 1, "history": history})
+        else:
+            no_improve += 1
+
+        if epoch % tc.save_every == 0:
+            ep_ckpt = ckpt_dir / f"phase1_epoch{epoch:03d}.pt"
+            _save_checkpoint(model, optimizer, epoch, val_m["total"], ep_ckpt)
+
+        if tc.early_stop_patience > 0 and no_improve >= tc.early_stop_patience:
+            print(f"\n  ⏹ Early stopping at epoch {epoch} "
+                  f"(no improvement for {no_improve} epochs).")
+            break
+
+    print(f"\n  Phase 1 complete.  Best val loss: {best_val:.4f}")
+    print(f"  Best checkpoint: {best_ckpt}")
+    return best_ckpt
+
+
+# =============================================================================
+# Phase 2
+# =============================================================================
+
+def train_phase2(
+    model:         TransientNet,
+    tc:            TrainConfig,
+    device:        str,
+    p1_ckpt:       Optional[Path] = None,
+    samples_p1_tr: Optional[List[SampleMeta]] = None,
+) -> Path:
+    print("\n" + "="*70)
+    print("PHASE 2 — Full mix + mixed batching  [TransientNet]")
+    print("="*70)
+
+    # Load Phase-1 weights
+    if p1_ckpt and p1_ckpt.exists():
+        ep, val = _load_checkpoint(model, None, p1_ckpt, device)
+        print(f"  Loaded Phase-1 checkpoint: {p1_ckpt}  (epoch={ep}, val={val:.4f})")
+    elif tc.ckpt_phase1:
+        ep, val = _load_checkpoint(model, None, Path(tc.ckpt_phase1), device)
+        print(f"  Loaded Phase-1 checkpoint: {tc.ckpt_phase1}")
+    else:
+        print("  [WARNING] No Phase-1 checkpoint — training from scratch")
+
+    # Full-mix corpus
+    mix_dir = Path(tc.mix_dir) if tc.mix_dir else None
+    if mix_dir is None or not mix_dir.exists():
+        raise FileNotFoundError(f"Full-mix directory not found: {tc.mix_dir}")
+
+    rng = np.random.default_rng(123)
+    print(f"  Loading full-mix corpus from {mix_dir} …")
+    all_mix = build_fullmix_corpus(mix_dir, rng, augment=True)
+
+    if not all_mix:
+        raise RuntimeError("No full-mix files found")
+
+    print(f"  Full-mix samples: {len(all_mix)}")
+    n_val = max(1, int(len(all_mix) * tc.val_frac))
+    rng.shuffle(all_mix)
+    mix_val = all_mix[:n_val]
+    mix_tr  = all_mix[n_val:]
+
+    # Phase-1 drum corpus for mixed batching
+    if samples_p1_tr is None:
+        drum_dir = Path(tc.drum_dir)
+        if drum_dir.exists():
+            p1_rng = np.random.default_rng(42)
+            p1_all = build_drum_corpus(drum_dir, p1_rng, augment=True)
+            n_val_p1 = max(1, int(len(p1_all) * tc.val_frac))
+            p1_rng.shuffle(p1_all)
+            samples_p1_val = p1_all[:n_val_p1]
+            samples_p1_tr  = p1_all[n_val_p1:]
+            print(f"  Phase-1 drum samples for mixed batching: {len(samples_p1_tr)}")
+        else:
+            print("  [WARNING] No drum directory — Phase-2 only")
+            samples_p1_tr = mix_tr[:max(1, len(mix_tr)//5)]
+
+    loss_fn = TransientLoss(
+        w_time=tc.loss_w_time,
+        w_stft=tc.loss_w_stft,
+        w_residual=tc.loss_w_residual,
+        w_energy=tc.loss_w_energy,
+    ).to(device)
+
+    loader_tr, loader_val_p2 = _make_loaders(
+        mix_tr, mix_val, model.cfg, tc, phase=2, samples_p1_tr=samples_p1_tr)
+
+    # Phase-1 val loader (forgetting monitor)
+    _p1_val = samples_p1_val if 'samples_p1_val' in dir() else mix_val
+    ds_val_p1 = FrameDataset(
+        _p1_val, model.cfg, n_virtual=800, rng_seed=888,
+        lf_band_hz=tc.lf_band_hz, augment=False)
+    loader_val_p1 = DataLoader(ds_val_p1, batch_size=tc.batch_size,
+                                shuffle=False, num_workers=0)
+
+    optimizer = optim.AdamW(model.parameters(), lr=tc.lr_phase2,
+                             weight_decay=tc.weight_decay, betas=(0.9, 0.999))
+    total_steps = tc.epochs_p2 * len(loader_tr)
+    scheduler = optim.lr_scheduler.OneCycleLR(
+        optimizer, max_lr=tc.lr_phase2, total_steps=total_steps,
+        pct_start=0.05, anneal_strategy="cos",
+    )
+
+    ckpt_dir   = Path(tc.ckpt_dir)
+    best_ckpt  = ckpt_dir / "phase2_best.pt"
+    best_val   = float("inf")
+    p1_baseline = None
+    history    = []
+
+    for epoch in range(1, tc.epochs_p2 + 1):
+        t_ep = time.time()
+        # Phase 2: energy loss fully ramped (add warmup_epochs to ensure ramp=1.0)
+        loss_fn._current_epoch = epoch + loss_fn.energy_warmup_epochs
+        tr_m = _train_epoch(model, loader_tr, optimizer, scheduler, loss_fn, tc, epoch, device)
+
+        val_p2 = _validate_epoch(model, loader_val_p2, loss_fn, device)
+        val_p1 = _validate_epoch(model, loader_val_p1, loss_fn, device)
+
+        if p1_baseline is None:
+            p1_baseline = val_p1["total"]
+        forgetting = val_p1["total"] - p1_baseline
+        elapsed = time.time() - t_ep
+
+        dsdr_g  = val_p2.get("dsdr_global",   0.0)
+        dsdr_sb = val_p2.get("dsdr_sub_bass", 0.0)
+        dsdr_ba = val_p2.get("dsdr_bass",     0.0)
+        dsdr_lm = val_p2.get("dsdr_low_mid",  0.0)
+        dsdr_hi = val_p2.get("dsdr_mid",      0.0)
+        cos_p2  = val_p2.get("cos_sim",       0.0)
+        dsdr_g_p1 = val_p1.get("dsdr_global", 0.0)
+
+        flag = ""
+        if dsdr_g < 0:
+            flag = "  ⚠ ΔSDR<0"
+        if val_p2.get("res_abs_mean", 0.0) < 1e-5:
+            flag += "  ⚠ IDENTITY COLLAPSE"
+
+        print(f"Epoch {epoch:3d}/{tc.epochs_p2}  "
+              f"tr={tr_m['total']:.4f}  "
+              f"val_p2={val_p2['total']:.4f}  "
+              f"val_p1={val_p1['total']:.4f}  "
+              f"forgetting={forgetting:+.4f}  ({elapsed:.1f}s)")
+        print(f"         ΔSDR(P2)  global={dsdr_g:+.2f}dB  "
+              f"sub_bass={dsdr_sb:+.2f}dB  bass={dsdr_ba:+.2f}dB  "
+              f"low_mid={dsdr_lm:+.2f}dB  mid={dsdr_hi:+.2f}dB  "
+              f"cos={cos_p2:.3f}{flag}")
+        print(f"         ΔSDR(P1)  global={dsdr_g_p1:+.2f}dB  [forgetting probe]")
+
+        if forgetting > tc.forgetting_thr:
+            print(f"  ⚠ Catastrophic forgetting (Δ={forgetting:.4f} > {tc.forgetting_thr})")
+
+        history.append({
+            "epoch": epoch, "train": tr_m,
+            "val_p2": val_p2, "val_p1": val_p1,
+            "forgetting": forgetting,
+        })
+
+        if val_p2["total"] < best_val:
+            best_val = val_p2["total"]
+            _save_checkpoint(model, optimizer, epoch, best_val, best_ckpt,
+                             extra={"phase": 2, "forgetting": forgetting,
+                                    "history": history})
+
+        if epoch % tc.save_every == 0:
+            ep_ckpt = ckpt_dir / f"phase2_epoch{epoch:03d}.pt"
+            _save_checkpoint(model, optimizer, epoch, val_p2["total"], ep_ckpt)
+
+    print(f"\n  Phase 2 complete.  Best P2 val loss: {best_val:.4f}")
+    return best_ckpt
+
+
+# =============================================================================
+# CLI
+# =============================================================================
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        description="Train TransientNet (two-phase curriculum)",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("--phase", choices=["1", "2", "both"], default="both")
+    p.add_argument("--epochs-p1",    type=int,   default=50,   dest="epochs_p1")
+    p.add_argument("--epochs-p2",    type=int,   default=30,   dest="epochs_p2")
+    p.add_argument("--drum-dir",     type=str,   default="./Samples", dest="drum_dir")
+    p.add_argument("--extra-dirs",   type=str,   default="",   dest="extra_dirs_csv",
+                   help="CSV file listing additional drum directories (loops + one-shots). "
+                        "Format: 'Percorso Directory,Tipo' with types 'Drum Loop' or 'Drum One Shot'")
+    p.add_argument("--mix-dir",      type=str,   default="",   dest="mix_dir")
+    p.add_argument("--ckpt-dir",     type=str,   default="./checkpoints_tnet", dest="ckpt_dir")
+    p.add_argument("--ckpt-phase1",  type=str,   default="",   dest="ckpt_phase1")
+    p.add_argument("--resume",       type=str,   default="")
+    p.add_argument("--batch-size",   type=int,   default=BATCH_SIZE, dest="batch_size")
+    p.add_argument("--lr-p1",        type=float, default=LR_PHASE1,  dest="lr_phase1")
+    p.add_argument("--lr-p2",        type=float, default=LR_PHASE2,  dest="lr_phase2")
+    p.add_argument("--p1-mix-frac",  type=float, default=PHASE1_MIX_FRAC, dest="p1_mix_frac")
+    p.add_argument("--device",       type=str,   default="cuda")
+    p.add_argument("--window",       type=int,   default=2048)
+    p.add_argument("--hop",          type=int,   default=512)
+    p.add_argument("--k-context",    type=int,   default=8,    dest="k_context")
+    p.add_argument("--lf-band-hz",   type=float, default=8000.0, dest="lf_band_hz")
+    p.add_argument("--early-stop",   type=int,   default=15,   dest="early_stop_patience")
+
+    # Model architecture
+    p.add_argument("--conv-channels", type=int, default=48, dest="conv_channels")
+    p.add_argument("--gru-hidden",    type=int, default=128, dest="gru_hidden")
+    p.add_argument("--cond-dim",      type=int, default=64, dest="cond_dim")
+
+    # Loss weights
+    p.add_argument("--w-time",     type=float, default=1.0,  dest="loss_w_time")
+    p.add_argument("--w-stft",     type=float, default=0.5,  dest="loss_w_stft")
+    p.add_argument("--w-residual", type=float, default=0.01, dest="loss_w_residual")
+    p.add_argument("--w-energy",   type=float, default=0.1,  dest="loss_w_energy",
+                   help="Residual energy calibration weight (clamped log-ratio + warmup)")
+    p.add_argument("--audio-cache-files", type=int, default=512, dest="audio_cache_files",
+                   help="LRU audio file cache size (number of decoded files held in RAM). "
+                        "Increase on machines with >8 GB free RAM.")
+    p.add_argument("--chunk-cache-size",  type=int, default=512, dest="chunk_cache_size",
+                   help="LRU preprocessed-chunk cache size. "
+                        "Set 0 to disable. ~700 KB per 4-second chunk (≈ 350 MB default).")
+    p.add_argument("--num-workers",       type=int, default=4,   dest="num_workers",
+                   help="DataLoader worker processes (default 4; set 2 on low-core machines).")
+
+    return p
+
+
+def main():
+    args = _build_parser().parse_args()
+
+    # ── Configure caches from CLI args ────────────────────────────────────
+    global _AUDIO_CACHE, _CHUNK_CACHE
+    _AUDIO_CACHE = AudioCache(max_files=args.audio_cache_files)
+    _CHUNK_CACHE = ChunkCache(max_chunks=args.chunk_cache_size)
+
+    numba_status = "✓ Numba JIT" if _NUMBA_OK else "✗ no Numba (pip install numba for ~200× limiter speedup)"
+    print(f"  [cache] audio={args.audio_cache_files} files  "
+          f"chunk={args.chunk_cache_size} chunks  "
+          f"workers={args.num_workers}  limiter={numba_status}")
+
+    # Model config
+    cfg = TransientNetConfig(
+        window_length=args.window,
+        hop_length=args.hop,
+        K_context=args.k_context,
+        lf_cutoff_hz=args.lf_band_hz,
+        conv_channels=args.conv_channels,
+        gru_hidden=args.gru_hidden,
+        cond_dim=args.cond_dim,
+    )
+    model  = build_model(cfg)
+    device = args.device
+
+    if device.startswith("cuda") and not torch.cuda.is_available():
+        print("  [WARNING] CUDA not available — falling back to CPU")
+        device = "cpu"
+    model = model.to(device)
+
+    # Training config
+    tc = TrainConfig(
+        drum_dir        = args.drum_dir,
+        extra_dirs_csv  = args.extra_dirs_csv,
+        mix_dir         = args.mix_dir,
+        ckpt_dir    = args.ckpt_dir,
+        ckpt_phase1 = args.ckpt_phase1,
+        phase       = args.phase,
+        epochs_p1   = args.epochs_p1,
+        epochs_p2   = args.epochs_p2,
+        batch_size  = args.batch_size,
+        lr_phase1   = args.lr_phase1,
+        lr_phase2   = args.lr_phase2,
+        p1_mix_frac = args.p1_mix_frac,
+        device      = device,
+        resume      = args.resume,
+        early_stop_patience = args.early_stop_patience,
+        lf_band_hz  = args.lf_band_hz,
+        loss_w_time     = args.loss_w_time,
+        loss_w_stft     = args.loss_w_stft,
+        loss_w_residual = args.loss_w_residual,
+        loss_w_energy   = args.loss_w_energy,
+        num_workers     = args.num_workers,
+    )
+
+    # Run phases
+    p1_ckpt = None
+    if args.phase in ("1", "both"):
+        p1_ckpt = train_phase1(model, tc, device)
+
+    if args.phase in ("2", "both"):
+        train_phase2(model, tc, device, p1_ckpt=p1_ckpt)
+
+    print("\n  ✓ Training complete.")
+
+
+if __name__ == "__main__":
+    main()

transient_net.py

@@ -0,0 +1,815 @@
+"""
+transient_net.py  —  Limiter Transient Restoration via Learned Gain Inversion
+================================================================================
+
+Replaces the SPADE-Unrolled architecture with a direct residual prediction
+model.  No sparse priors, no ADMM, no binary masks — the model learns to
+invert the limiter's gain envelope from data.
+
+Why this works better than SPADE for limiters
+---------------------------------------------
+A brickwall limiter applies time-varying gain  g[n] ∈ (0, 1]:
+
+    y[n] = x[n] · g[n]
+
+The original signal is  x[n] = y[n] / g[n],  so the residual is:
+
+    r[n] = x[n] − y[n] = y[n] · (1/g[n] − 1)
+
+Key properties that SPADE cannot exploit:
+  • g[n] is a smooth envelope (attack/release dynamics) — NOT sparse in DCT
+  • All samples are affected during release (no "reliable" samples)
+  • The correction is multiplicative and proportional to |y[n]|
+
+This model directly predicts r̂[n] for each WOLA frame.
+
+Architecture
+------------
+
+  Input: limited audio frame y_w (B, M) + K context frames (B, K, M)
+       ↓
+  SpectralFeatureExtractor
+    • log-mel spectrogram (n_mels=32) per frame
+    • short-time loudness (RMS dB)
+    → (B, K+1, n_mels+1)
+       ↓
+  ContextEncoder (causal GRU)
+    • 2-layer GRU, hidden_size=128
+    • Last hidden state → Linear → h_cond (B, D_cond=64)
+    → Global conditioning vector capturing limiter dynamics
+       ↓
+  FrameProcessor (dilated 1D convolutions + FiLM conditioning)
+    • Input: y_w reshaped to (B, 1, M)
+    • 6 residual blocks with dilation  1, 2, 4, 8, 16, 32
+    • FiLM modulation injects h_cond every 2 blocks
+    • Output: r̂ (B, M)  — predicted residual
+       ↓
+  Output: x̂_w = y_w + r̂
+
+Loss function  (3 terms, no conflicts)
+---------------------------------------
+  1. Time MSE:        ‖x̂ − x_clean‖²  (auto-focuses on affected regions)
+  2. Multi-scale STFT: L1 on |STFT| at 3 scales  (spectral fidelity)
+  3. Residual L1:     α · ‖r̂‖₁  (light sparsity on correction, prevents hallucination)
+
+Total trainable parameters: ~265K
+
+References
+----------
+[1] Perraudin et al., "A fast Griffin-Lim algorithm", WASPAA 2013.
+[2] Défossez et al., "Real Time Speech Enhancement in the Waveform Domain", 2020.
+[3] Dumoulin et al., "FiLM: Visual Reasoning with a General Conditioning Layer", 2018.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Tuple
+
+import numpy as np
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    _TORCH_OK = True
+except ImportError:
+    raise ImportError("PyTorch is required  (pip install torch)")
+
+
+# =============================================================================
+# Config
+# =============================================================================
+
+@dataclass
+class TransientNetConfig:
+    """All hyperparameters for TransientNet."""
+
+    # ── Signal / WOLA ─────────────────────────────────────────────────────
+    window_length:  int   = 2048       # M — samples per WOLA frame
+    hop_length:     int   = 512        # WOLA hop
+    sample_rate:    int   = 44100
+
+    # ── Context encoder ───────────────────────────────────────────────────
+    K_context:    int = 8              # past frames fed to GRU
+    n_mels:       int = 32             # mel bands for feature extraction
+    gru_hidden:   int = 128            # GRU hidden size
+    gru_layers:   int = 2              # GRU depth
+    cond_dim:     int = 64             # conditioning vector dimension
+
+    # ── Frame processor ───────────────────────────────────────────────────
+    # Dilated conv stack with FiLM conditioning.
+    # Receptive field = 1 + 2*(k-1)*Σ(dilations) = 1 + 4*63 = 253 samples
+    # ≈ 5.7 ms at 44.1 kHz — captures limiter attack transients.
+    # Longer-scale release dynamics are handled by GRU conditioning.
+    conv_channels:    int = 48         # width of conv blocks
+    n_res_blocks:     int = 6          # residual blocks
+    kernel_size:      int = 3          # conv kernel size in res blocks
+    dilations:        Tuple[int, ...] = (1, 2, 4, 8, 16, 32)
+    film_every:       int = 2          # inject FiLM conditioning every N blocks
+
+    # ── LF/HF split (for hybrid inference) ────────────────────────────────
+    lf_cutoff_hz:     float = 8000.0   # crossover for hybrid processing
+
+
+# =============================================================================
+# Spectral Feature Extractor  (reused from spade_unrolled.py, identical)
+# =============================================================================
+
+def _dct2(x: torch.Tensor) -> torch.Tensor:
+    """Batched orthonormal DCT-II.  x: (..., N) → (..., N)."""
+    N = x.shape[-1]
+    v = torch.cat([x[..., ::2], x[..., 1::2].flip(-1)], dim=-1)
+    V = torch.fft.fft(v.double(), dim=-1)
+    k = torch.arange(N, device=x.device, dtype=torch.float64)
+    tw = torch.exp(-1j * math.pi * k / (2.0 * N))
+    C = (tw * V).real * math.sqrt(2.0 / N)
+    C = C.clone()
+    C[..., 0] /= math.sqrt(2.0)
+    return C.to(x.dtype)
+
+
+class SpectralFeatureExtractor(nn.Module):
+    """Converts raw audio frame → log-mel + loudness features.
+    Identical to the one in spade_unrolled.py — no trainable params."""
+
+    def __init__(self, cfg: TransientNetConfig):
+        super().__init__()
+        self.M      = cfg.window_length
+        self.sr     = cfg.sample_rate
+        self.n_mels = cfg.n_mels
+
+        mel_filters = self._build_mel_filterbank()
+        self.register_buffer("mel_filters", mel_filters)
+
+    def _build_mel_filterbank(self) -> torch.Tensor:
+        def hz_to_mel(f):
+            return 2595.0 * math.log10(1.0 + f / 700.0)
+        def mel_to_hz(m):
+            return 700.0 * (10.0 ** (m / 2595.0) - 1.0)
+
+        mel_lo  = hz_to_mel(0.0)
+        mel_hi  = hz_to_mel(self.sr / 2.0)
+        mels    = torch.linspace(mel_lo, mel_hi, self.n_mels + 2)
+        hz_pts  = torch.tensor([mel_to_hz(m) for m in mels])
+        bin_pts = (hz_pts / self.sr * self.M).long().clamp(0, self.M - 1)
+
+        filters = torch.zeros(self.n_mels, self.M)
+        for i in range(self.n_mels):
+            lo, mid, hi = bin_pts[i], bin_pts[i + 1], bin_pts[i + 2]
+            if mid > lo:
+                filters[i, lo:mid] = torch.linspace(0, 1, int(mid - lo))
+            if hi > mid:
+                filters[i, mid:hi] = torch.linspace(1, 0, int(hi - mid))
+
+        area = filters.sum(dim=1, keepdim=True).clamp(min=1e-8)
+        return filters / area
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """x: (B, M)  →  (B, n_mels+1)"""
+        dct_coeff  = _dct2(x.float())
+        power_spec = dct_coeff[:, :self.M] ** 2
+        mel_spec   = torch.matmul(power_spec, self.mel_filters.T)
+        log_mel    = torch.log(mel_spec.clamp(min=1e-10))
+
+        rms  = x.pow(2).mean(dim=-1, keepdim=True).clamp(min=1e-10).sqrt()
+        lufs = 20.0 * torch.log10(rms.clamp(min=1e-10))
+
+        return torch.cat([log_mel, lufs], dim=-1)
+
+
+# =============================================================================
+# Context Encoder  (GRU → conditioning vector)
+# =============================================================================
+
+class ContextEncoder(nn.Module):
+    """
+    Causal GRU that produces a global conditioning vector from K+1 frames.
+
+    Unlike the SPADE version (which output 5 constrained parameters), this
+    outputs a general D_cond-dimensional vector used for FiLM conditioning.
+    The FrameProcessor decides how to use this information.
+
+    ~190K parameters (GRU dominates).
+    """
+
+    def __init__(self, cfg: TransientNetConfig):
+        super().__init__()
+        n_feats  = cfg.n_mels + 1
+        proj_dim = 64
+
+        self.input_proj = nn.Sequential(
+            nn.Linear(n_feats, proj_dim),
+            nn.LayerNorm(proj_dim),
+            nn.GELU(),
+        )
+        self.gru = nn.GRU(
+            input_size=proj_dim,
+            hidden_size=cfg.gru_hidden,
+            num_layers=cfg.gru_layers,
+            batch_first=True,
+            dropout=0.1 if cfg.gru_layers > 1 else 0.0,
+        )
+        self.head = nn.Sequential(
+            nn.Linear(cfg.gru_hidden, cfg.cond_dim),
+            nn.GELU(),
+        )
+
+    def forward(self, feat_seq: torch.Tensor) -> torch.Tensor:
+        """
+        feat_seq: (B, K+1, n_feats)  — spectral features, last = current frame
+        returns:  (B, D_cond)         — conditioning vector
+        """
+        projected  = self.input_proj(feat_seq)
+        gru_out, _ = self.gru(projected)
+        h_t        = gru_out[:, -1, :]         # last step = current frame
+        return self.head(h_t)
+
+
+# =============================================================================
+# FiLM (Feature-wise Linear Modulation)
+# =============================================================================
+
+class FiLM(nn.Module):
+    """Condition feature maps on a global vector via affine transform.
+    γ, β = Linear(h_cond) → out = γ * x + β"""
+
+    def __init__(self, cond_dim: int, channels: int):
+        super().__init__()
+        self.gamma = nn.Linear(cond_dim, channels)
+        self.beta  = nn.Linear(cond_dim, channels)
+        # Init: γ=1, β=0  (identity at start)
+        nn.init.ones_(self.gamma.weight[:, 0])
+        nn.init.zeros_(self.gamma.weight[:, 1:])
+        nn.init.zeros_(self.gamma.bias)
+        nn.init.zeros_(self.beta.weight)
+        nn.init.zeros_(self.beta.bias)
+
+    def forward(self, x: torch.Tensor, h: torch.Tensor) -> torch.Tensor:
+        """
+        x: (B, C, T)     — feature maps
+        h: (B, D_cond)   — conditioning vector
+        """
+        g = self.gamma(h).unsqueeze(-1)   # (B, C, 1)
+        b = self.beta(h).unsqueeze(-1)    # (B, C, 1)
+        return g * x + b
+
+
+# =============================================================================
+# Residual Block (dilated 1D conv)
+# =============================================================================
+
+class ResBlock(nn.Module):
+    """Residual block: dilated depthwise-separable conv + pointwise + skip.
+
+    Depthwise-separable saves parameters while maintaining receptive field.
+    """
+
+    def __init__(self, channels: int, kernel_size: int = 3, dilation: int = 1):
+        super().__init__()
+        padding = dilation * (kernel_size - 1) // 2
+        self.net = nn.Sequential(
+            # Dilated depthwise conv (groups=channels for efficiency)
+            nn.Conv1d(channels, channels, kernel_size, padding=padding,
+                      dilation=dilation, groups=channels, bias=False),
+            nn.Conv1d(channels, channels, 1, bias=True),  # pointwise
+            nn.GELU(),
+            nn.Conv1d(channels, channels, 1, bias=True),  # second pointwise
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x + self.net(x)
+
+
+# =============================================================================
+# Frame Processor  (dilated TCN + FiLM)
+# =============================================================================
+
+class FrameProcessor(nn.Module):
+    """
+    Processes a single WOLA frame to predict the additive residual.
+
+    Architecture: dilated TCN with FiLM conditioning from the GRU.
+
+      y_w (B, 1, M)
+        → Conv1d(1, C, k=7)
+        → [ResBlock(C, d=1), ResBlock(C, d=2), FiLM, ...] × 3 groups
+        → Conv1d(C, 1, k=1)
+        → r̂ (B, M)
+
+    The dilated convolutions capture local transient structure.
+    FiLM conditioning injects global limiter-dynamics awareness.
+    The residual connection (x̂ = y + r̂) is handled outside this module.
+
+    ~75K parameters.
+    """
+
+    def __init__(self, cfg: TransientNetConfig):
+        super().__init__()
+        C = cfg.conv_channels
+        D = cfg.cond_dim
+
+        # Input projection
+        self.input_conv = nn.Sequential(
+            nn.Conv1d(1, C, kernel_size=7, padding=3, bias=True),
+            nn.GELU(),
+        )
+
+        # Residual blocks with interleaved FiLM
+        self.blocks = nn.ModuleList()
+        self.films  = nn.ModuleDict()
+
+        for i, d in enumerate(cfg.dilations):
+            self.blocks.append(ResBlock(C, kernel_size=cfg.kernel_size, dilation=d))
+            # FiLM every N blocks
+            if (i + 1) % cfg.film_every == 0:
+                self.films[str(i)] = FiLM(D, C)
+
+        # Output projection → residual
+        self.output_conv = nn.Conv1d(C, 1, kernel_size=1, bias=True)
+
+        # Init output near zero (start as identity: x̂ ≈ y)
+        nn.init.zeros_(self.output_conv.weight)
+        nn.init.zeros_(self.output_conv.bias)
+
+    def forward(self, y_w: torch.Tensor, h_cond: torch.Tensor) -> torch.Tensor:
+        """
+        y_w:    (B, M)       — windowed limited frame
+        h_cond: (B, D_cond)  — conditioning from GRU
+        returns: (B, M)      — predicted residual r̂
+        """
+        x = y_w.unsqueeze(1)           # (B, 1, M)
+        x = self.input_conv(x)        # (B, C, M)
+
+        for i, block in enumerate(self.blocks):
+            x = block(x)
+            if str(i) in self.films:
+                x = self.films[str(i)](x, h_cond)
+
+        r = self.output_conv(x)        # (B, 1, M)
+        return r.squeeze(1)            # (B, M)
+
+
+# =============================================================================
+# Full TransientNet model
+# =============================================================================
+
+class TransientNet(nn.Module):
+    """
+    Full transient restoration model.
+
+    Forward:  (y_w, ctx_frames) → x̂_w = y_w + r̂
+    """
+
+    def __init__(self, cfg: TransientNetConfig):
+        super().__init__()
+        self.cfg = cfg
+
+        self.feature_extractor = SpectralFeatureExtractor(cfg)
+        self.context_encoder   = ContextEncoder(cfg)
+        self.frame_processor   = FrameProcessor(cfg)
+
+    def forward(
+        self,
+        yc_w:       torch.Tensor,   # (B, M) — windowed limited frame
+        ctx_frames: torch.Tensor,   # (B, K, M) — K previous windowed frames
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Returns
+        -------
+        x_hat     : (B, M)  — restored frame
+        residual  : (B, M)  — predicted residual (for regularisation)
+        """
+        B, M = yc_w.shape
+        K    = ctx_frames.shape[1]
+
+        # ── Extract spectral features for all frames ──────────────────────
+        all_frames = torch.cat([ctx_frames, yc_w.unsqueeze(1)], dim=1)  # (B, K+1, M)
+        feats = torch.stack(
+            [self.feature_extractor(all_frames[:, t, :]) for t in range(K + 1)],
+            dim=1
+        )   # (B, K+1, n_feats)
+
+        # ── Context encoding → conditioning vector ────────────────────────
+        h_cond = self.context_encoder(feats)                # (B, D_cond)
+
+        # ── Frame processing → residual ───────────────────────────────────
+        residual = self.frame_processor(yc_w, h_cond)       # (B, M)
+
+        # ── Output: additive residual ─────────────────────────────────────
+        x_hat = yc_w + residual
+
+        return x_hat, residual
+
+    def parameter_count(self) -> int:
+        return sum(p.numel() for p in self.parameters() if p.requires_grad)
+
+
+# =============================================================================
+# Loss function  (3 terms — clean, no conflicts)
+# =============================================================================
+
+class TransientLoss(nn.Module):
+    """
+    4-term loss for transient restoration.
+
+    1. Time MSE:         ‖x̂ − x_clean‖²
+       PRIMARY signal. Auto-focuses on affected regions (unaffected regions
+       have near-zero error already, so gradient is negligible there).
+
+    2. Multi-scale STFT:  L1 on magnitude spectrograms
+       Captures spectral envelope fidelity across time-frequency resolutions.
+
+    3. Residual L1:       α · mean(|r̂|)
+       Light regularisation preventing the model from hallucinating energy
+       where no correction is needed.  Much weaker than SPADE's sparsity
+       loss because the physical prior is different: corrections are NOT
+       expected to be sparse in frequency — they are sparse in TIME.
+
+    4. Energy ratio:      β · mean(log²(E_pred / E_gt))
+       Penalises residual magnitude miscalibration.  The model can achieve
+       high cos_sim (correct shape) while over/under-shooting amplitude.
+       This term forces energy alignment between predicted and GT residual,
+       preventing the ΔSDR oscillation observed in early training where
+       cos_sim was 0.96+ but ΔSDR swung ±3 dB between epochs.
+    """
+
+    def __init__(
+        self,
+        w_time:     float = 1.0,
+        w_stft:     float = 0.5,
+        w_residual: float = 0.01,    # very light: just anti-hallucination
+        w_energy:   float = 0.1,     # residual energy calibration (ramped via warmup)
+        stft_wins:  Tuple[int, ...] = (512, 1024, 2048),
+        energy_warmup_epochs: int = 5,   # ramp energy loss over this many epochs
+        energy_log_clamp: float = 4.0,   # clamp |log(ratio)| to prevent init explosion
+    ):
+        super().__init__()
+        self.w_time     = w_time
+        self.w_stft     = w_stft
+        self.w_residual = w_residual
+        self.w_energy   = w_energy
+        self.stft_wins  = stft_wins
+        self.energy_warmup_epochs = energy_warmup_epochs
+        self.energy_log_clamp     = energy_log_clamp
+        self._current_epoch       = 0    # set by training loop
+
+    def forward(
+        self,
+        x_hat:     torch.Tensor,     # (B, M) — model output
+        x_clean:   torch.Tensor,     # (B, M) — ground truth
+        yc_w:      torch.Tensor,     # (B, M) — limited input (for diagnostics)
+        residual:  torch.Tensor,     # (B, M) — predicted residual
+    ) -> Tuple[torch.Tensor, dict]:
+
+        details = {}
+
+        # ── 1. Time-domain MSE ────────────────────────────────────────────
+        loss_time = F.mse_loss(x_hat, x_clean)
+        details["time_mse"] = loss_time.item()
+
+        # ── 2. Multi-scale STFT L1 ───────────────────────────────────────
+        loss_stft = x_hat.new_zeros(1)
+        for win in self.stft_wins:
+            if win > x_hat.shape[-1]:
+                continue
+            hop = win // 4
+            wnd = torch.hann_window(win, device=x_hat.device, dtype=x_hat.dtype)
+            S_hat   = torch.stft(x_hat.float(),   n_fft=win, hop_length=hop,
+                                  win_length=win, window=wnd, return_complex=True)
+            S_clean = torch.stft(x_clean.float(), n_fft=win, hop_length=hop,
+                                  win_length=win, window=wnd, return_complex=True)
+            loss_stft = loss_stft + F.l1_loss(S_hat.abs(), S_clean.abs())
+        loss_stft = loss_stft / max(1, len(self.stft_wins))
+        details["stft"] = loss_stft.item()
+
+        # ── 3. Residual L1 (anti-hallucination) ──────────────────────────
+        loss_res = residual.abs().mean()
+        details["res_l1"] = loss_res.item()
+
+        # ── 4. Residual energy ratio (amplitude calibration) ────────────���
+        # Clamped log²(E_pred / E_gt) with linear warmup.
+        #
+        # Problem solved: at init, residual ≈ 0 → E_pred ≈ ε → log → -∞.
+        # The unclamped version produced loss ≈ 130, saturating grad_clip
+        # and drowning the MSE/STFT signal.  The model learned to push
+        # energy in ANY direction (cos_sim < 0) instead of the right one.
+        #
+        # Fix: (a) clamp |log(ratio)| ≤ 4  (≈ ±35 dB, generous but bounded)
+        #      (b) warmup ramp: w_energy × min(1, epoch/warmup_epochs)
+        #          → first epochs: direction only (MSE+STFT)
+        #            later epochs: direction + amplitude (all 4 terms)
+        gt_residual = x_clean - yc_w
+        E_pred = residual.pow(2).sum(-1) + 1e-8       # (B,)
+        E_gt   = gt_residual.pow(2).sum(-1) + 1e-8    # (B,)
+        log_ratio = (E_pred / E_gt).log().clamp(-self.energy_log_clamp,
+                                                  self.energy_log_clamp)
+        loss_energy = log_ratio.pow(2).mean()
+        details["energy_ratio"] = loss_energy.item()
+
+        # Warmup ramp (0 at epoch 0, 1.0 at epoch >= warmup_epochs)
+        if self.energy_warmup_epochs > 0:
+            ramp = min(1.0, self._current_epoch / self.energy_warmup_epochs)
+        else:
+            ramp = 1.0
+        w_energy_eff = self.w_energy * ramp
+        details["w_energy_eff"] = w_energy_eff
+
+        # ── Total ─────────────────────────────────────────────────────────
+        total = (self.w_time     * loss_time
+               + self.w_stft     * loss_stft.squeeze()
+               + self.w_residual * loss_res
+               + w_energy_eff    * loss_energy)
+        details["total"] = total.item()
+
+        return total, details
+
+
+# =============================================================================
+# WOLA inference wrapper
+# =============================================================================
+
+class TransientNetInference:
+    """
+    Process a full audio signal via WOLA (Weighted Overlap-Add).
+
+    Usage
+    -----
+        model = TransientNet(cfg)
+        model.load_state_dict(...)
+        model.eval()
+
+        infer = TransientNetInference(model, device="cuda")
+        x_hat = infer.process(y_limited, sample_rate=44100)
+    """
+
+    def __init__(
+        self,
+        model:        TransientNet,
+        device:       str = "cuda",
+        batch_frames: int = 256,
+    ):
+        self.model = model.to(device)
+        self.model.eval()
+        self.cfg   = model.cfg
+        self.device = device
+        self.batch_frames = batch_frames
+
+    @torch.no_grad()
+    def process(self, y_limited: np.ndarray, sample_rate: int = 44100) -> np.ndarray:
+        """
+        y_limited : (N,) — limited mono audio (float32 or float64)
+        returns   : (N,) — restored audio (float64)
+        """
+        from scipy.signal.windows import hann as _hann
+
+        M = self.cfg.window_length
+        a = self.cfg.hop_length
+        K = self.cfg.K_context
+
+        y = y_limited.astype(np.float64)
+        dc = float(np.mean(y))
+        y -= dc
+
+        N_sig = len(y)
+
+        # Pad to full frames
+        n_frames = max(1, int(np.ceil(N_sig / a)))
+        N_pad    = (n_frames - 1) * a + M
+        y_pad    = np.zeros(N_pad, dtype=np.float64)
+        y_pad[:N_sig] = y
+
+        # WOLA window (sqrt-Hann for analysis + synthesis)
+        win = np.sqrt(_hann(M, sym=False)).astype(np.float64)
+
+        # Extract all frames
+        frames_np = np.array([
+            y_pad[i * a : i * a + M] * win
+            for i in range(n_frames)
+        ], dtype=np.float32)   # (F, M)
+
+        # Process in batches
+        out_frames = np.zeros_like(frames_np)
+        F_total = len(frames_np)
+
+        for b_start in range(0, F_total, self.batch_frames):
+            b_end   = min(b_start + self.batch_frames, F_total)
+            b_size  = b_end - b_start
+
+            # Current frames
+            yc_batch = torch.from_numpy(frames_np[b_start:b_end]).to(self.device)
+
+            # Context frames (K previous per frame)
+            ctx_list = []
+            for fi in range(b_start, b_end):
+                ctx = np.zeros((K, M), dtype=np.float32)
+                for k in range(K):
+                    ci = fi - (K - k)
+                    if 0 <= ci < F_total:
+                        ctx[k] = frames_np[ci]
+                ctx_list.append(ctx)
+            ctx_batch = torch.from_numpy(np.array(ctx_list)).to(self.device)
+
+            x_hat_batch, _ = self.model(yc_batch, ctx_batch)
+            out_frames[b_start:b_end] = x_hat_batch.cpu().numpy()
+
+        # WOLA synthesis (overlap-add with window)
+        output = np.zeros(N_pad, dtype=np.float64)
+        norm   = np.zeros(N_pad, dtype=np.float64)
+
+        for i in range(n_frames):
+            idx = i * a
+            output[idx:idx + M] += out_frames[i].astype(np.float64) * win
+            norm[idx:idx + M]   += win ** 2
+
+        norm = np.maximum(norm, 1e-12)
+        output /= norm
+        output[:N_sig] += dc
+
+        return output[:N_sig]
+
+
+# =============================================================================
+# Hybrid inference (LF: TransientNet, HF: classical SPADE)
+# =============================================================================
+
+class HybridTransientInference:
+    """
+    LR crossover split:
+      HF (> crossover_hz):  classical SPADE v11/v13 (unchanged, works well)
+      LF (< crossover_hz):  TransientNet (learned gain inversion)
+    """
+
+    def __init__(
+        self,
+        model:          TransientNet,
+        crossover_hz:   float = 8000.0,
+        delta_db:       float = 3.5,
+        device:         str   = "cuda",
+        # HF SPADE params (pass through to v11/v13)
+        hf_delta_db:      float = 3.5,
+        hf_max_gain_db:   float = 9.0,
+        hf_release_ms:    float = 80.0,
+        hf_max_iter:      int   = 200,
+        hf_window_length: int   = 2048,
+        hf_hop_length:    int   = 512,
+    ):
+        self.crossover_hz = crossover_hz
+        self.delta_db     = delta_db
+        self.device       = device
+        self._lf_infer    = TransientNetInference(model, device=device)
+
+        # Store HF params
+        self.hf_delta_db      = hf_delta_db
+        self.hf_max_gain_db   = hf_max_gain_db
+        self.hf_release_ms    = hf_release_ms
+        self.hf_max_iter      = hf_max_iter
+        self.hf_window_length = hf_window_length
+        self.hf_hop_length    = hf_hop_length
+
+    @staticmethod
+    def _lr_split(x, crossover_hz, sr):
+        from scipy.signal import butter, sosfiltfilt
+        fc  = float(np.clip(crossover_hz, 1.0, sr / 2.0 - 1.0))
+        sos = butter(2, fc, btype="low", fs=sr, output="sos")
+        lp  = sosfiltfilt(sos, x)
+        hp  = x - lp
+        return lp, hp
+
+    def _process_hf(self, hf_mono, sr):
+        try:
+            from spade_declip_v13 import declip as _declip, DeclipParams
+        except ImportError:
+            try:
+                from spade_declip_v11 import declip as _declip, DeclipParams
+            except ImportError:
+                # No SPADE available — return HF unchanged
+                return hf_mono
+
+        params = DeclipParams(
+            algo          = "sspade",
+            frame         = "rdft",
+            mode          = "soft",
+            delta_db      = self.hf_delta_db,
+            window_length = self.hf_window_length,
+            hop_length    = self.hf_hop_length,
+            max_gain_db   = self.hf_max_gain_db,
+            release_ms    = self.hf_release_ms,
+            max_iter      = self.hf_max_iter,
+            sample_rate   = sr,
+            use_gpu       = (self.device != "cpu"),
+            show_progress = False,
+            verbose       = False,
+        )
+        fixed, _ = _declip(hf_mono, params)
+        return fixed
+
+    @torch.no_grad()
+    def process(self, y_limited: np.ndarray, sample_rate: int = 44100) -> np.ndarray:
+        mono = y_limited.ndim == 1
+        if mono:
+            y_limited = y_limited[:, None]
+        _, C = y_limited.shape
+        out_channels = []
+
+        for ch in range(C):
+            yc = y_limited[:, ch].astype(np.float64)
+            lf, hf = self._lr_split(yc, self.crossover_hz, sample_rate)
+
+            hf_rec = self._process_hf(hf, sample_rate)
+            lf_rec = self._lf_infer.process(lf.astype(np.float32), sample_rate)
+
+            L = min(len(lf_rec), len(hf_rec))
+            combined = lf_rec[:L] + hf_rec[:L]
+            out_channels.append(combined)
+
+        result = np.column_stack(out_channels)
+        return result[:, 0] if mono else result
+
+
+# =============================================================================
+# Model factory
+# =============================================================================
+
+def build_model(cfg: Optional[TransientNetConfig] = None) -> TransientNet:
+    if cfg is None:
+        cfg = TransientNetConfig()
+    model = TransientNet(cfg)
+    n = model.parameter_count()
+    print(f"[TransientNet] Built model: {n:,} trainable parameters")
+    return model
+
+
+# =============================================================================
+# Smoke test
+# =============================================================================
+
+def _smoke_test():
+    print("=" * 60)
+    print("TransientNet — Smoke Test")
+    print("=" * 60)
+
+    cfg = TransientNetConfig(
+        window_length=512,
+        hop_length=128,
+        K_context=4,
+        n_mels=16,
+        gru_hidden=64,
+        gru_layers=1,
+        cond_dim=32,
+        conv_channels=32,
+        n_res_blocks=4,
+        dilations=(1, 2, 4, 8),
+    )
+    model = build_model(cfg)
+    model.eval()
+
+    B = 4
+    M = cfg.window_length
+    K = cfg.K_context
+
+    yc_w = torch.randn(B, M) * 0.3
+    ctx  = torch.randn(B, K, M) * 0.3
+
+    with torch.no_grad():
+        x_hat, residual = model(yc_w, ctx)
+
+    print(f"  Input  yc_w:     {tuple(yc_w.shape)}")
+    print(f"  Output x_hat:    {tuple(x_hat.shape)}")
+    print(f"  Residual:        {tuple(residual.shape)}")
+    print(f"  Residual range:  [{residual.min():.4f}, {residual.max():.4f}]")
+    print(f"  Residual mean:   {residual.mean():.6f}  (should be ~0 at init)")
+
+    # Loss test
+    x_clean = yc_w + torch.randn_like(yc_w) * 0.05
+    loss_fn = TransientLoss()
+    loss, details = loss_fn(x_hat, x_clean, yc_w, residual)
+    print(f"\n  Loss: {loss.item():.6f}")
+    for k, v in details.items():
+        print(f"    {k:12s}: {v:.6f}")
+
+    # Gradient test
+    model.train()
+    x_hat2, res2 = model(yc_w, ctx)
+    loss2, _ = loss_fn(x_hat2, x_clean, yc_w, res2)
+    loss2.backward()
+
+    grad_norms = {
+        name: p.grad.norm().item()
+        for name, p in model.named_parameters()
+        if p.grad is not None
+    }
+    print(f"\n  Gradient norms (first 6):")
+    for k, v in list(grad_norms.items())[:6]:
+        print(f"    {k:45s}: {v:.6f}")
+
+    zero_grad = sum(1 for v in grad_norms.values() if v < 1e-10)
+    print(f"\n  Zero-gradient params: {zero_grad}/{len(grad_norms)}  "
+          f"({'OK' if zero_grad == 0 else 'WARNING'})")
+
+    print("\n  ✓ Smoke test passed.")
+
+
+if __name__ == "__main__":
+    _smoke_test()