S214: remove إحياء v4 entirely, isteidad-server takes v11.2; clean requirements.txt (cache-bust + voicefixer2 gone)

apbwe_vendor/checkpoints/8kto48k/config.json

@@ -1,29 +0,0 @@
-{
-    "num_gpus": 0,
-    "batch_size": 16,
-    "learning_rate": 0.0002,
-    "adam_b1": 0.8,
-    "adam_b2": 0.99,
-    "lr_decay": 0.999,
-    "seed": 1234,
-
-    "ConvNeXt_channels": 512,
-    "ConvNeXt_layers": 8,
-
-    "segment_size": 8000,
-    "n_fft": 1024,
-    "hop_size": 80,
-    "win_size": 320,
-
-    "hr_sampling_rate": 48000,
-    "lr_sampling_rate": 8000,
-    "subsampling_rate": 6,
-
-    "num_workers": 4,
-
-    "dist_config": {
-        "dist_backend": "nccl",
-        "dist_url": "tcp://localhost:54321",
-        "world_size": 1
-    }
-}

apbwe_vendor/checkpoints/8kto48k/g_8kto48k

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8f0387a4f1cdf1ec5dc557a9e8a303326b45b7706b37843f771f24ee94d2e521
-size 119097961

app.py

@@ -35,7 +35,7 @@ BASE = Path(__file__).parent
 ENGINE_SCRIPTS = {
     "v11.0": BASE / "engine_safaa_v5.py",       # S191: v5 continuous DF3 blend + S190 WPE guard       # S175  # S149
     "v11.1": BASE / "engine_itiqan_v6_server.py",   # S200: server-optimised الإتقان
-    "v11.2": BASE / "engine_ihya_v4.py",       # S204: الإحياء v4 (AI cascade + guards)
+    "v11.2": BASE / "engine_isteidad_server.py",  # S214: server-hardened isteidad (إحياء v4 removed)
     "v10.0": BASE / "engine_safaa_v3_fixed.py",  # S149
     "v9.0":  BASE / "engine_v90.py",
     "v8.9":  BASE / "engine_v89.py",
@@ -326,29 +326,17 @@ def _run_engine(job_id):
             ref_files = _get_ref_files()
             # S165: safaa has no --iterations / --ref — skip them
             _is_safaa = "safaa" in str(script).lower()
-            # S201: ihya v3 has no --iterations / --ref either, and forces a
-            # WAV codec on write regardless of output extension — give it a
-            # WAV temp path like safaa, not a raw .mp3 path.
-            _is_ihya = "ihya" in str(script).lower()
             # S173 Bug2: safaa uses soundfile → cannot write MP3
             # → write WAV first, then convert to MP3 with ffmpeg
             _o_path = (
                 job["out_path"].replace(".mp3", "_safaa_tmp.wav")
-                if _is_safaa else
-                job["out_path"].replace(".mp3", "_ihya_tmp.wav")
-                if _is_ihya else job["out_path"]
+                if _is_safaa else job["out_path"]
             )
             # S174-SV-C1: safaa uses positional args (input output), not -i/-o flags
             if _is_safaa:
                 cmd = ["python3", str(script), job["in_path"], _o_path,
                        "--tier",     job.get("tier", "TIER_UNKNOWN"),
                        "--mujawwad", str(job.get("mujawwad_conf", 0.0))]  # S175
-            elif _is_ihya:
-                # S204: v4 has NO --aggressive flag (argparse would crash).
-                # v4's full power is its default with no --skip-* flags —
-                # nothing extra to pass.
-                cmd = ["python3", str(script),
-                       "-i", job["in_path"], "-o", _o_path]
             else:
                 cmd = ["python3", str(script),
                        "-i", job["in_path"], "-o", _o_path,
@@ -424,7 +412,7 @@ def _run_engine(job_id):
             _out = Path(_o_path)
             _clean = (not _timed_out) and proc.returncode == 0  # S185
             if _clean and _out.exists() and _out.stat().st_size > 0:
-                if (_is_safaa or _is_ihya) and _o_path != job["out_path"]:
+                if _is_safaa and _o_path != job["out_path"]:
                     subprocess.run(
                         ["ffmpeg", "-y", "-i", str(_out),
                          "-b:a", "320k", "-ar", "48000", job["out_path"]],

engine_ihya_v4.py

@@ -1,1074 +0,0 @@
-#!/usr/bin/env python3
-"""
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                                                                              ║
-║   الإحياء v4 — PARAMETRIC RESYNTHESIS + QURAN PHONEME PROTECTION            ║
-║   "وَنَفَخَ فِيهِ مِن رُّوحِهِ"                                              ║
-║                                                                              ║
-║   WHY v4 OVER v3:                                                            ║
-║   v3 is pure DSP — excellent, but DSP cannot reconstruct a signal whose     ║
-║   information has been genuinely destroyed (heavy codec, telephone, hiss).  ║
-║   v4 adds AI parametric resynthesis (SIDON / Resemble Enhance) which        ║
-║   extracts clean speech FEATURES from the degraded signal then synthesises  ║
-║   new audio. Features survive noise where waveforms don't.                  ║
-║                                                                              ║
-║   WHAT VANILLA SIDON CANNOT DO (and why it's dangerous for Quran):          ║
-║   • Its vocoder can swallow glottal stops (ء) and qalqalah pops            ║
-║   • Emphatic consonants (ض/ط/ظ/ص) lose their spectral signature            ║
-║   • The resynthesised voice can drift from the original Sheikh's timbre     ║
-║   • Muffled (كتام) input biases the feature predictor toward wrong F0      ║
-║                                                                              ║
-║   v4 SOLUTIONS — THREE PROTECTION LAYERS:                                   ║
-║   P1  PhonemeGuard — fingerprints 8 Arabic-critical bands pre-resynthesis  ║
-║       and restores any frame where letter energy drops > 8 dB              ║
-║   P2  SpeakerAnchor — MFCC cosine similarity gate; if voice drifts         ║
-║       post-resynthesis, blends original back to anchor the Sheikh           ║
-║   P3  كتام-Aware BWE — detects bandwidth cutoff before resynthesis and      ║
-║       informs the model rather than letting it guess; applies natural       ║
-║       spectral extension post-resynthesis for any remaining darkening       ║
-║                                                                              ║
-║   AI MODEL CASCADE (tried in order):                                        ║
-║   1. SIDON         pip install sidon  (sarulab-speech/sidon-v0.1)          ║
-║   2. Resemble Enhance  pip install resemble-enhance  (FREE, open source)   ║
-║   3. VoiceFixer    pip install voicefixer  (already in Aetherion)          ║
-║   4. DSP fallback  الإحياء v3 phases (no AI needed)                        ║
-║                                                                              ║
-║   PROMISES:                                                                  ║
-║   حروف لا تُؤكل   ·   الشيخ يبقى شيخًا   ·   الكتام يُكشف                  ║
-║                                                                              ║
-║   KB REFS: §4 §35 §36 §52 §79 §85 §102 §133 §143 §152 §160 §173           ║
-║   وما التوفيق إلا بالله                                                      ║
-║                                                                              ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-"""
-__version__ = 'v4.0'
-
-import argparse, json, os, shutil, subprocess, sys, tempfile, time, warnings
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-warnings.filterwarnings('ignore')
-
-_TMP = tempfile.gettempdir()
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  OPTIONAL IMPORTS
-# ══════════════════════════════════════════════════════════════════════════════
-
-try:
-    import numpy as np
-    from scipy.fft import rfft, rfftfreq
-    from scipy.signal import butter, sosfilt, medfilt
-    NUMPY_OK = True
-except Exception:
-    NUMPY_OK = False
-
-try:
-    import soundfile as SF
-    SF_OK = True
-except Exception:
-    SF_OK = False
-
-# AI model availability flags
-SIDON_OK          = False
-RESEMBLE_OK       = False
-VOICEFIXER_OK     = False
-AUDIOSR_OK        = False
-TORCH_OK          = False
-
-try:
-    import torch
-    TORCH_OK = True
-except Exception:
-    # S207: broadened from ImportError — a broken/incompatible install
-    # (wrong torch build, CUDA mismatch, etc.) should degrade this flag,
-    # not crash the whole module before the cascade even starts.
-    pass
-
-try:
-    from sidon import SidonRestorer  # type: ignore
-    SIDON_OK = True
-except Exception:
-    try:
-        from sidon.inference import restore as _sidon_restore_fn  # type: ignore
-        SIDON_OK = True
-    except Exception:
-        pass
-
-try:
-    from resemble_enhance.enhancer.inference import denoise as _re_denoise, enhance as _re_enhance  # type: ignore
-    import torchaudio  # type: ignore
-    RESEMBLE_OK = True
-except Exception:
-    pass
-
-try:
-    from voicefixer import VoiceFixer as _VoiceFixer  # type: ignore
-    VOICEFIXER_OK = True
-except Exception:
-    # S207: THIS is the one that was actually crashing the script. voicefixer
-    # pulls in an old librosa internally that still uses the long-removed
-    # np.complex alias — that raises AttributeError deep in librosa's own
-    # import chain, not ImportError, so the old `except ImportError:` here
-    # never caught it. The exception propagated all the way up, killed the
-    # module at import time, and every v11.2 job fell back to plain ffmpeg
-    # loudnorm (score=75) before _try_sidon (now AP-BWE) ever got a chance
-    # to run. Root cause (voicefixer 0.1.2 is unmaintained and genuinely
-    # incompatible with modern numpy/librosa) is NOT fixed by this — VOICEFIXER_OK
-    # will still end up False — but that's fine, since AP-BWE doesn't depend
-    # on voicefixer at all and now actually gets to run.
-    pass
-
-try:
-    import audiosr as _audiosr  # type: ignore
-    AUDIOSR_OK = True
-except Exception:
-    pass
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  CONSTANTS
-# ══════════════════════════════════════════════════════════════════════════════
-
-SR = 48000
-WAV_CODEC = 'pcm_s24le'
-
-# Arabic-critical spectral bands for PhonemeGuard (§4, §152)
-# Each band must survive resynthesis or a letter is lost
-PHONEME_BANDS_HZ: List[Tuple[str, float, float]] = [
-    ('glottal_hamza',   60,    150),   # ء — glottal energy
-    ('nasal_ghunnah',   200,   350),   # ن/م — nasal murmur (§152.3)
-    ('F1_vowel',        350,   800),   # vowel height — أ/إ/و differentiation
-    ('F2_back',         600,   1400),  # back vowels — emphatic context
-    ('F2_front',        1400,  2500),  # front vowels — imala, thin letters
-    ('emphatic_3k',     2500,  4000),  # ض/ط/ظ/ص emphatic signature
-    ('sibilant_safir',  4000,  8000),  # ص/س/ز (Safir §152.3)
-    ('sibilant_taf',    3000,  6000),  # ش (Tafasshi §152.3)
-]
-
-# PhonemeGuard thresholds
-GUARD_FRAME_MS       = 20        # ms per analysis frame
-GUARD_DROP_DB        = 8.0       # dB drop triggers letter repair
-GUARD_BLEND_RATIO    = 0.55      # original blend when repair triggered (0=all_restored, 1=all_original)
-
-# SpeakerAnchor thresholds
-ANCHOR_MFCC_N        = 13        # number of MFCC coefficients
-ANCHOR_SIM_MIN       = 0.82      # cosine similarity floor — below = voice has drifted
-ANCHOR_BLEND_RATIO   = 0.35      # how much original to blend back when anchor fires
-
-# كتام (muffled) detection
-KATAM_BW_THRESH_HZ   = 5000      # Hz: bandwidth below this = كتام
-KATAM_BWE_GAIN_DB    = 4.0       # dB: gentle presence boost for muffled audio
-KATAM_PRESENCE_BAND  = (3000, 8000)  # Hz: the darkened region to open up
-
-# SNR / bandwidth
-SNR_NOISY_THRESH     = 15.0      # dB: below this = noisy
-BANDWIDTH_FLOOR_DB   = -60.0     # dB: minimum energy for "active" band
-
-# Silence detection
-SILENCE_THRESH_DB    = -50.0
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  STATE
-# ══════════════════════════════════════════════════════════════════════════════
-
-@dataclass
-class V4State:
-    # Analysis
-    snr_db:              float = 0.0
-    active_bw_hz:        float = 48000.0
-    is_katam:            bool  = False
-    katam_cutoff_hz:     float = 0.0
-    is_noisy:            bool  = False
-    f0_median_hz:        float = 150.0
-    # PhonemeGuard
-    guard_frames_checked: int  = 0
-    guard_frames_repaired: int = 0
-    guard_bands_lost:    List[str] = field(default_factory=list)
-    # SpeakerAnchor
-    anchor_similarity:   float = 1.0
-    anchor_fired:        bool  = False
-    # AI model used
-    ai_model_used:       str   = 'none'
-    # Temp files
-    _tmpfiles:           List[str] = field(default_factory=list)
-
-    def tmpfile(self, suffix='.wav') -> str:
-        p = os.path.join(_TMP, f'ihya4_{os.getpid()}_{len(self._tmpfiles)}{suffix}')
-        self._tmpfiles.append(p)
-        return p
-
-    def cleanup(self):
-        for p in self._tmpfiles:
-            try:
-                if os.path.exists(p):
-                    os.remove(p)
-            except Exception:
-                pass
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  AUDIO I/O HELPERS
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _decode_to_wav(src: str, dst: str, sr: int = SR) -> bool:
-    """Convert any audio format to WAV via ffmpeg."""
-    cmd = [
-        'ffmpeg', '-y', '-hide_banner', '-loglevel', 'error',
-        '-i', src,
-        '-ar', str(sr), '-ac', '1', '-c:a', WAV_CODEC, dst
-    ]
-    try:
-        r = subprocess.run(cmd, capture_output=True, timeout=120)
-        return r.returncode == 0 and os.path.exists(dst)
-    except Exception:
-        return False
-
-
-def _load_wav(path: str) -> Tuple[Optional['np.ndarray'], int]:
-    """Load WAV as float32 numpy array."""
-    if not SF_OK:
-        return None, SR
-    try:
-        data, sr = SF.read(path, dtype='float32', always_2d=False)
-        if data.ndim > 1:
-            data = data.mean(axis=1)
-        return data, int(sr)
-    except Exception:
-        return None, SR
-
-
-def _save_wav(path: str, data: 'np.ndarray', sr: int = SR) -> bool:
-    """Save float32 array as 24-bit WAV."""
-    if not SF_OK:
-        return False
-    try:
-        SF.write(path, data.astype('float32'), sr, subtype='PCM_24')
-        return True
-    except Exception:
-        return False
-
-
-def _band_energy_db(sig: 'np.ndarray', sr: int, lo: float, hi: float) -> float:
-    """RMS energy in a frequency band, in dB."""
-    n = len(sig)
-    mag = np.abs(rfft(sig))
-    freqs = rfftfreq(n, 1.0 / sr)
-    mask = (freqs >= lo) & (freqs <= hi)
-    if not mask.any():
-        return -120.0
-    rms = np.sqrt(np.mean(mag[mask] ** 2) + 1e-12)
-    return 20.0 * np.log10(rms + 1e-12)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  PHASE 0 — ANALYSIS
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _analyze(sig: 'np.ndarray', sr: int, st: V4State) -> None:
-    """Lightweight pre-analysis: SNR, bandwidth, كتام detection, F0."""
-    n = len(sig)
-    if n < 512:
-        return
-
-    # Broadband SNR (speech vs silence frames)
-    frame_len = int(0.02 * sr)
-    rms_frames = []
-    for i in range(0, n - frame_len, frame_len):
-        rms_frames.append(float(np.sqrt(np.mean(sig[i:i + frame_len] ** 2) + 1e-12)))
-    if not rms_frames:
-        return
-    rms_arr = np.array(rms_frames)
-    db_arr  = 20.0 * np.log10(rms_arr + 1e-12)
-    speech_mask = db_arr > (np.max(db_arr) - 40.0)
-    noise_mask  = db_arr < (np.percentile(db_arr, 20))
-    s_rms = float(np.mean(rms_arr[speech_mask])) if speech_mask.any() else 1e-6
-    n_rms = float(np.mean(rms_arr[noise_mask]))  if noise_mask.any()  else 1e-9
-    st.snr_db   = float(20.0 * np.log10(s_rms / (n_rms + 1e-12)))
-    st.is_noisy = st.snr_db < SNR_NOISY_THRESH
-
-    # Active bandwidth detection (§173 TIER_TELEPHONE logic)
-    mag   = np.abs(rfft(sig))
-    freqs = rfftfreq(n, 1.0 / sr)
-    ref_db = _band_energy_db(sig, sr, 1000, 3000)  # speech reference band
-    bw     = 0.0
-    for fq in np.arange(500, sr // 2, 200):
-        e_db = _band_energy_db(sig, sr, fq, fq + 200)
-        if e_db > (ref_db - 40.0):
-            bw = float(fq + 200)
-    st.active_bw_hz  = bw
-    st.is_katam      = bw < KATAM_BW_THRESH_HZ and bw > 0
-    st.katam_cutoff_hz = bw if st.is_katam else 0.0
-
-    # Rough F0 via autocorrelation (just median pitch)
-    frame = sig[:min(n, 2048)]
-    ac = np.correlate(frame, frame, mode='full')[len(frame) - 1:]
-    min_lag = max(1, int(sr / 400))   # 400 Hz max pitch
-    max_lag = int(sr / 60)            # 60 Hz min pitch
-    if max_lag < len(ac) and max_lag > min_lag:
-        peak = int(np.argmax(ac[min_lag:max_lag]) + min_lag)
-        if peak > 0:
-            st.f0_median_hz = float(sr / peak)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  LAYER 1 — PHONEME GUARD
-# ══════════════════════════════════════════════════════════════════════════════
-
-class PhonemeGuard:
-    """
-    Fingerprints Arabic-critical frequency bands frame-by-frame before
-    AI resynthesis and repairs any frame where letter energy is lost.
-
-    حروف لا تُؤكل — letters shall not be eaten.
-    """
-
-    def __init__(self, sig: 'np.ndarray', sr: int):
-        self.sr       = sr
-        self.orig_sig = sig.copy()
-        self.frame_n  = int(GUARD_FRAME_MS * 1e-3 * sr)
-        self._fingerprint: Optional['np.ndarray'] = None
-        self._compute_fingerprint(sig)
-
-    def _frame_band_db(self, frame: 'np.ndarray', lo: float, hi: float) -> float:
-        return _band_energy_db(frame, self.sr, lo, hi)
-
-    def _compute_fingerprint(self, sig: 'np.ndarray') -> 'np.ndarray':
-        """Returns [n_frames × n_bands] matrix of band energies in dB."""
-        n = len(sig)
-        frames = []
-        for i in range(0, n - self.frame_n, self.frame_n):
-            frame = sig[i:i + self.frame_n]
-            row = []
-            for (_, lo, hi) in PHONEME_BANDS_HZ:
-                row.append(self._frame_band_db(frame, lo, hi))
-            frames.append(row)
-        self._fingerprint = np.array(frames, dtype='float32') if frames else np.zeros((1, len(PHONEME_BANDS_HZ)), dtype='float32')
-        return self._fingerprint
-
-    def repair(self, restored: 'np.ndarray', st: V4State) -> 'np.ndarray':
-        """
-        Compare restored signal against original fingerprint.
-        For any frame where a letter band has dropped > GUARD_DROP_DB:
-          - blend original back into that frame
-        Returns repaired signal.
-        """
-        if self._fingerprint is None:
-            return restored
-
-        restored_fp = self._compute_fingerprint(restored)
-        n_frames    = min(len(self._fingerprint), len(restored_fp))
-        out         = restored.copy()
-        n           = len(out)
-        orig        = self.orig_sig
-
-        bands_lost: List[str] = []
-        frames_repaired = 0
-
-        for fi in range(n_frames):
-            pre  = self._fingerprint[fi]   # band energies before AI
-            post = restored_fp[fi]         # band energies after AI
-            drop = pre - post              # positive = loss
-
-            # Check if any critical band lost energy above threshold
-            repair_needed = False
-            for bi, (band_name, _, _) in enumerate(PHONEME_BANDS_HZ):
-                # Only flag if pre-signal had meaningful energy there
-                if pre[bi] > -80.0 and drop[bi] > GUARD_DROP_DB:
-                    repair_needed = True
-                    if band_name not in bands_lost:
-                        bands_lost.append(band_name)
-
-            if repair_needed:
-                i_start = fi * self.frame_n
-                i_end   = min(i_start + self.frame_n, n, len(orig))
-                if i_end > i_start:
-                    r_frame = out[i_start:i_end]
-                    o_frame = orig[i_start:i_end]
-                    if len(r_frame) == len(o_frame):
-                        # Blend: keep most of restored but restore letter content
-                        out[i_start:i_end] = (
-                            (1.0 - GUARD_BLEND_RATIO) * r_frame +
-                            GUARD_BLEND_RATIO          * o_frame
-                        )
-                        frames_repaired += 1
-
-        st.guard_frames_checked  = n_frames
-        st.guard_frames_repaired = frames_repaired
-        st.guard_bands_lost      = bands_lost
-        return out
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  LAYER 2 — SPEAKER ANCHOR
-# ══════════════════════════════════════════════════════════════════════════════
-
-class SpeakerAnchor:
-    """
-    Extracts a lightweight MFCC-based speaker fingerprint before AI resynthesis.
-    After resynthesis, checks cosine similarity. If the voice has drifted
-    (similarity below ANCHOR_SIM_MIN), blends the original back to anchor
-    the Sheikh's identity.
-
-    الشيخ يبقى شيخًا — the Sheikh remains himself.
-    """
-
-    def __init__(self, sig: 'np.ndarray', sr: int):
-        self.sr       = sr
-        self.orig_sig = sig.copy()
-        self._orig_embed = self._embed(sig)
-
-    def _embed(self, sig: 'np.ndarray') -> 'np.ndarray':
-        """Compute global mean MFCC vector (no external deps, pure numpy)."""
-        # Pre-emphasis
-        preemph = np.append(sig[0], sig[1:] - 0.97 * sig[:-1])
-        # Frame
-        frame_n = int(0.025 * self.sr)
-        hop_n   = int(0.010 * self.sr)
-        frames  = []
-        for i in range(0, len(preemph) - frame_n, hop_n):
-            f = preemph[i:i + frame_n] * np.hamming(frame_n)
-            frames.append(f)
-        if not frames:
-            return np.zeros(ANCHOR_MFCC_N, dtype='float32')
-
-        # Log filterbank energies (mel scale, simplified)
-        n_fft = frame_n
-        n_mel = 26
-        mag_frames = np.abs(rfft(np.array(frames), n=n_fft))
-        freqs = rfftfreq(n_fft, 1.0 / self.sr)
-        mel_lo, mel_hi = 300.0, min(8000.0, self.sr / 2.0)
-        mel_pts = np.linspace(
-            2595.0 * np.log10(1 + mel_lo / 700.0),
-            2595.0 * np.log10(1 + mel_hi / 700.0),
-            n_mel + 2
-        )
-        hz_pts  = 700.0 * (10 ** (mel_pts / 2595.0) - 1.0)
-        fbank   = np.zeros((n_mel, len(freqs)), dtype='float32')
-        for m in range(1, n_mel + 1):
-            f_lo, f_c, f_hi = hz_pts[m - 1], hz_pts[m], hz_pts[m + 1]
-            for k, fq in enumerate(freqs):
-                if f_lo <= fq <= f_c:
-                    fbank[m - 1, k] = (fq - f_lo) / (f_c - f_lo + 1e-8)
-                elif f_c < fq <= f_hi:
-                    fbank[m - 1, k] = (f_hi - fq) / (f_hi - f_c + 1e-8)
-
-        log_fbank = np.log(mag_frames @ fbank.T + 1e-6)  # [n_frames, n_mel]
-
-        # DCT (type-II, simplified)
-        n = n_mel
-        k = np.arange(ANCHOR_MFCC_N)[:, None]
-        n_arr = np.arange(n)[None, :]
-        dct_matrix = np.cos(np.pi / n * (n_arr + 0.5) * k)
-        mfccs = log_fbank @ dct_matrix.T  # [n_frames, ANCHOR_MFCC_N]
-
-        # Global mean vector
-        embed = mfccs.mean(axis=0).astype('float32')
-        norm  = np.linalg.norm(embed) + 1e-8
-        return embed / norm
-
-    def anchor(self, restored: 'np.ndarray', st: V4State) -> 'np.ndarray':
-        """
-        Check similarity. If voice has drifted, blend original back.
-        Returns anchored signal.
-        """
-        restored_embed = self._embed(restored)
-        sim = float(np.dot(self._orig_embed, restored_embed))
-        st.anchor_similarity = sim
-
-        if sim < ANCHOR_SIM_MIN:
-            st.anchor_fired = True
-            # Blend: drift severity determines how much original to mix in
-            drift_ratio = min(1.0, (ANCHOR_SIM_MIN - sim) / ANCHOR_SIM_MIN)
-            blend       = ANCHOR_BLEND_RATIO * (1.0 + drift_ratio)
-            blend       = min(0.65, blend)  # never completely override restored
-            n = min(len(restored), len(self.orig_sig))
-            out = restored.copy()
-            out[:n] = (1.0 - blend) * restored[:n] + blend * self.orig_sig[:n]
-            return out
-
-        return restored
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  LAYER 3 — كتام BANDWIDTH EXTENSION
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _katam_bwe(sig: 'np.ndarray', sr: int, st: V4State) -> 'np.ndarray':
-    """
-    Opens up muffled (كتام) audio by gently lifting the presence band
-    post-resynthesis. Uses a shelving-style boost above the cutoff frequency.
-
-    الكتام يُكشف — muffled audio is opened.
-    """
-    if not st.is_katam:
-        return sig
-
-    lo, hi = KATAM_PRESENCE_BAND
-    # High-shelf: boost everything above the detected cutoff
-    cutoff = max(st.katam_cutoff_hz, lo)
-    cutoff = min(cutoff, 5000.0)
-
-    n = len(sig)
-    spec = rfft(sig)
-    freqs = rfftfreq(n, 1.0 / sr)
-
-    gain_lin = 10.0 ** (KATAM_BWE_GAIN_DB / 20.0)
-
-    # Gentle linear ramp from 1.0 at cutoff to gain_lin at hi
-    mask = np.zeros(len(freqs), dtype='float32')
-    for ki, fq in enumerate(freqs):
-        if fq <= cutoff:
-            mask[ki] = 1.0
-        elif fq <= hi:
-            t = (fq - cutoff) / (hi - cutoff + 1e-8)
-            mask[ki] = 1.0 + (gain_lin - 1.0) * t
-        else:
-            mask[ki] = gain_lin
-
-    spec_boosted = spec * mask
-    out = np.fft.irfft(spec_boosted, n=n).astype('float32')
-
-    # Safety: clip and maintain overall loudness
-    out = np.clip(out, -1.0, 1.0)
-    # Match RMS
-    rms_in  = float(np.sqrt(np.mean(sig ** 2)) + 1e-12)
-    rms_out = float(np.sqrt(np.mean(out ** 2)) + 1e-12)
-    if rms_out > 0:
-        out *= (rms_in / rms_out) * 1.05  # slight loudness lift for muffled
-    return out.astype('float32')
-
-
-# ══════════════════════════════════════════════════════════���═══════════════════
-#  AI MODEL CASCADE
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _try_sidon(wav_in: str, wav_out: str) -> bool:
-    """
-    S206: SIDON itself is not a real installable package (sarulab-speech's
-    public repo is training-only research code, no PyPI listing, GPU-only,
-    and doesn't expose SidonRestorer/sidon.inference.restore at all — those
-    names never matched anything real). This slot now runs AP-BWE
-    (yxlu-0102/AP-BWE, MIT) instead: an amplitude+phase BWE model, CPU-fast,
-    with real downloadable pretrained checkpoints. See apbwe_wrapper.py.
-    """
-    try:
-        import apbwe_wrapper
-        return apbwe_wrapper.restore(wav_in, wav_out)
-    except Exception as e:
-        print(f"[_try_sidon/apbwe] {e}")
-        return False
-
-
-def _try_resemble_enhance(wav_in: str, wav_out: str) -> bool:
-    """
-    Attempt Resemble Enhance (denoiser + enhancer).
-    pip install resemble-enhance
-    Free, open-source, excellent on degraded speech.
-    """
-    if not RESEMBLE_OK or not TORCH_OK:
-        return False
-    try:
-        import torchaudio  # type: ignore
-        dwav, sr_orig = torchaudio.load(wav_in)
-        device = 'cuda' if torch.cuda.is_available() else 'cpu'  # type: ignore
-
-        # Stage 1: Denoise
-        denoised, sr_dn = _re_denoise(dwav, sr_orig, device)  # type: ignore
-        # Stage 2: Enhance (bandwidth extension + naturalness)
-        enhanced, sr_en = _re_enhance(  # type: ignore
-            denoised, sr_dn, device,
-            nfe=64,        # number of function evaluations (quality)
-            solver='midpoint',
-            lambd=0.5,     # balance between denoising and hallucination
-            tau=0.5,
-        )
-        torchaudio.save(wav_out, enhanced.cpu(), sr_en)
-        return os.path.exists(wav_out)
-    except Exception:
-        return False
-
-
-def _try_voicefixer(wav_in: str, wav_out: str, aggressive: bool = False) -> bool:
-    """
-    Attempt VoiceFixer restoration.
-    pip install voicefixer2   (S210: replaces unmaintained voicefixer==0.1.2,
-    which pulls in an old librosa incompatible with modern numpy — see S207.
-    voicefixer2 fixes that, and installs into the SAME `voicefixer` import
-    namespace, so no import-line changes needed here.)
-
-    Mode 0 (default): light restoration, safe on most input.
-    Mode 2 (aggressive=True): per voicefixer2's own docs, "might work
-    sometimes on seriously degraded real speech" — explicitly less
-    reliable, only used when the engine's own كتام/is_katam analysis has
-    already flagged this specific file as genuinely degraded, not applied
-    blanket to everything.
-    """
-    if not VOICEFIXER_OK:
-        return False
-    mode = 2 if aggressive else 0
-    try:
-        vf = _VoiceFixer()
-        vf.restore(
-            input=wav_in,
-            output=wav_out,
-            cuda=False,
-            mode=mode,
-        )
-        return os.path.exists(wav_out)
-    except Exception:
-        try:
-            # Some versions use different API
-            vf = _VoiceFixer()
-            vf.restore(input_path=wav_in, output_path=wav_out, cuda=False, mode=mode)
-            return os.path.exists(wav_out)
-        except Exception:
-            return False
-
-
-def _dsp_fallback(wav_in: str, wav_out: str, st: V4State) -> bool:
-    """
-    DSP-only fallback using light band enhancement when no AI model is
-    available. Less powerful than AI resynthesis but phoneme-safe.
-    """
-    if not NUMPY_OK or not SF_OK:
-        return False
-    try:
-        sig, sr = _load_wav(wav_in)
-        if sig is None:
-            return False
-
-        # Gentle harmonic excitation on voiced bands
-        # 1. Light noise gate
-        frame_n = int(0.02 * sr)
-        out = sig.copy()
-        for i in range(0, len(sig) - frame_n, frame_n):
-            rms = float(np.sqrt(np.mean(sig[i:i + frame_n] ** 2)))
-            noise_floor = float(np.percentile(
-                [np.sqrt(np.mean(sig[j:j + frame_n] ** 2))
-                 for j in range(0, min(len(sig), frame_n * 50), frame_n)
-                 if j + frame_n <= len(sig)],
-                15
-            ))
-            if rms < noise_floor * 2.0:
-                out[i:i + frame_n] *= (rms / (noise_floor * 2.0 + 1e-8))
-
-        # 2. Gentle presence lift (2-5kHz)
-        if _band_energy_db(sig, sr, 2000, 5000) < _band_energy_db(sig, sr, 500, 2000) - 12:
-            n = len(out)
-            spec = rfft(out)
-            freqs = rfftfreq(n, 1.0 / sr)
-            boost = np.ones(len(freqs), dtype='float32')
-            for ki, fq in enumerate(freqs):
-                if 2000 <= fq <= 5000:
-                    boost[ki] = 10 ** (3.0 / 20.0)  # +3dB
-            spec_b = spec * boost
-            out = np.fft.irfft(spec_b, n=n).astype('float32')
-
-        return _save_wav(wav_out, out, sr)
-    except Exception:
-        return False
-
-
-def _run_ai_cascade(wav_in: str, wav_out: str, st: V4State) -> bool:
-    """
-    Try AI models in quality order. Returns True if any succeeded.
-    Updates st.ai_model_used.
-
-    S210: for genuinely degraded audio (st.is_katam), AP-BWE's inherent
-    conservatism was confirmed (real test, real recording) to be
-    insufficient — the cascade's normal "first success wins" ordering
-    would never even reach VoiceFixer Mode 2, since AP-BWE itself
-    succeeds (just weakly). So for is_katam audio specifically, try the
-    more aggressive VoiceFixer Mode 2 FIRST, with AP-BWE as the fallback
-    if Mode 2 fails outright. This is a deliberate trade of more
-    reconstruction risk for more restoration power on the worst material,
-    not a blanket change — non-katam audio still goes through the
-    conservative path first, unchanged.
-    """
-    tmp_out = st.tmpfile('.wav')
-
-    if st.is_katam:
-        if _try_voicefixer(wav_in, tmp_out, aggressive=True):
-            _decode_to_wav(tmp_out, wav_out, SR)
-            st.ai_model_used = 'voicefixer_mode2'
-            return True
-        # Mode 2 failing outright (not just "weak", actually erroring)
-        # falls through to the normal conservative order below.
-
-    if _try_sidon(wav_in, tmp_out):
-        shutil.copy2(tmp_out, wav_out)
-        st.ai_model_used = 'sidon'
-        return True
-
-    if _try_resemble_enhance(wav_in, tmp_out):
-        # Resemble outputs at its own SR; normalize to our SR
-        _decode_to_wav(tmp_out, wav_out, SR)
-        st.ai_model_used = 'resemble_enhance'
-        return True
-
-    if _try_voicefixer(wav_in, tmp_out, aggressive=False):
-        _decode_to_wav(tmp_out, wav_out, SR)
-        st.ai_model_used = 'voicefixer'
-        return True
-
-    if _dsp_fallback(wav_in, wav_out, st):
-        st.ai_model_used = 'dsp_fallback'
-        return True
-
-    return False
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  PRE-PROCESSING (light touch before AI)
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _preprocess(sig: 'np.ndarray', sr: int, st: V4State) -> 'np.ndarray':
-    """
-    Light pre-processing before AI resynthesis:
-      - Wind rumble HPF (if detected)
-      - Normalise to -3dBFS so AI models get well-levelled input
-    """
-    out = sig.copy()
-
-    # Wind rumble high-pass (20-100 Hz)
-    wind_e  = _band_energy_db(sig, sr, 20,  150)
-    ref_e   = _band_energy_db(sig, sr, 200, 500)
-    if wind_e > ref_e + 6.0:
-        sos = butter(3, 120.0 / (sr / 2), btype='high', output='sos')
-        out = sosfilt(sos, out).astype('float32')
-
-    # Normalise to -3 dBFS peak
-    peak = float(np.max(np.abs(out)) + 1e-12)
-    target_peak = 10.0 ** (-3.0 / 20.0)
-    out = (out / peak * target_peak).astype('float32')
-    return out
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  POST-PROCESSING (polishing after AI + guards)
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _postprocess(sig: 'np.ndarray', sr: int, st: V4State) -> 'np.ndarray':
-    """
-    Light polishing after AI resynthesis + protection layers:
-      - Sibilant naturalization (ص/س/ز/ش often over-smoothed by vocoders)
-      - Gentle micro-dynamics restoration
-      - Final loudness to -16 LUFS (approximate)
-    """
-    out = sig.copy()
-
-    # 1. Sibilant check: if 4-8kHz energy is too low post-resynthesis, lift it
-    sib_db   = _band_energy_db(out, sr, 4000, 8000)
-    ref_db   = _band_energy_db(out, sr, 1000, 3000)
-    sib_diff = ref_db - sib_db
-    if sib_diff > 15.0:
-        # Sibilants have been over-smoothed — gently restore
-        n = len(out)
-        spec  = rfft(out)
-        freqs = rfftfreq(n, 1.0 / sr)
-        boost_db = min(sib_diff * 0.4, 6.0)  # proportional, capped at 6dB
-        boost_lin = 10.0 ** (boost_db / 20.0)
-        mask  = np.ones(len(freqs), dtype='float32')
-        for ki, fq in enumerate(freqs):
-            if 4000 <= fq <= 12000:
-                t = (fq - 4000) / 8000.0
-                mask[ki] = 1.0 + (boost_lin - 1.0) * (1.0 - t * 0.5)
-        spec_b = spec * mask
-        out = np.fft.irfft(spec_b, n=n).astype('float32')
-
-    # 2. Gentle micro-dynamics: if LRA is too compressed, add subtle phrase modulation
-    frame_n = int(0.1 * sr)  # 100ms frames
-    rms_frames = []
-    for i in range(0, len(out) - frame_n, frame_n):
-        rms_frames.append(float(np.sqrt(np.mean(out[i:i + frame_n] ** 2) + 1e-12)))
-    if rms_frames:
-        rms_arr = np.array(rms_frames)
-        lra_db  = float(np.percentile(rms_arr, 95) / (np.percentile(rms_arr, 5) + 1e-12))
-        lra_db  = 20.0 * np.log10(lra_db + 1e-8)
-        if lra_db < 2.0:
-            # Over-compressed; inject subtle ±0.5dB phrase modulation
-            for fi, i in enumerate(range(0, len(out) - frame_n, frame_n)):
-                mod = 1.0 + 0.05 * np.sin(2.0 * np.pi * fi / max(len(rms_frames), 1))
-                out[i:i + frame_n] *= float(mod)
-
-    # 3. Final loudness normalization to approximately -16 LUFS
-    rms_global = float(np.sqrt(np.mean(out ** 2) + 1e-12))
-    target_rms = 10.0 ** (-16.0 / 20.0) * 0.8  # approximate
-    if rms_global > 0:
-        out = (out * (target_rms / rms_global)).astype('float32')
-
-    # 4. True peak limiter
-    out = np.clip(out, -0.98, 0.98)
-    return out
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  MAIN PROCESS FUNCTION
-# ══════════════════════════════════════════════════════════════════════════════
-
-def process(
-    input_path:  str,
-    output_path: str,
-    *,
-    skip_phoneme_guard:  bool = False,
-    skip_speaker_anchor: bool = False,
-    skip_bwe:            bool = False,
-    verbose:             bool = True,
-) -> Dict:
-    """
-    Full الإحياء v4 pipeline.
-
-    Returns a dict with diagnostics and phase results.
-    """
-    if not NUMPY_OK:
-        return {'error': 'numpy/scipy required: pip install numpy scipy soundfile'}
-
-    st = V4State()
-    t0 = time.time()
-
-    try:
-        # ── Decode input ──────────────────────────────────────────────────────
-        wav_in = st.tmpfile('.wav')
-        if not _decode_to_wav(input_path, wav_in):
-            return {'error': f'Failed to decode input: {input_path}'}
-
-        sig, sr = _load_wav(wav_in)
-        if sig is None or len(sig) < 256:
-            return {'error': 'Failed to load audio or audio too short'}
-
-        if verbose:
-            dur = len(sig) / sr
-            print(f'  [الإحياء v4] Input: {dur:.1f}s @ {sr}Hz  '
-                  f'AI stack: SIDON={SIDON_OK} RE={RESEMBLE_OK} VF={VOICEFIXER_OK}')
-
-        # ── Phase 0: Analysis ─────────────────────────────────────────────────
-        _analyze(sig, sr, st)
-        if verbose:
-            print(f'  [P0] SNR={st.snr_db:.1f}dB  BW={st.active_bw_hz:.0f}Hz  '
-                  f'كتام={st.is_katam}  F0≈{st.f0_median_hz:.0f}Hz')
-
-        # ── Phase 1: Light pre-processing ─────────────────────────────────────
-        sig_pre = _preprocess(sig, sr, st)
-
-        # ── Fingerprint extraction (BEFORE AI) ───────────────────────────────
-        guard  = PhonemeGuard(sig_pre, sr) if not skip_phoneme_guard else None
-        anchor = SpeakerAnchor(sig_pre, sr) if not skip_speaker_anchor else None
-
-        # ── Phase 2: AI resynthesis ───────────────────────────────────────────
-        wav_pre = st.tmpfile('.wav')
-        wav_ai  = st.tmpfile('.wav')
-        _save_wav(wav_pre, sig_pre, sr)
-
-        ai_success = _run_ai_cascade(wav_pre, wav_ai, st)
-        if not ai_success:
-            return {'error': 'All AI models and DSP fallback failed'}
-
-        if verbose:
-            print(f'  [P2] AI model: {st.ai_model_used}')
-
-        sig_ai, sr_ai = _load_wav(wav_ai)
-        if sig_ai is None:
-            return {'error': 'Failed to load AI output'}
-
-        # Resample if AI output has different SR
-        if sr_ai != sr:
-            wav_resampled = st.tmpfile('.wav')
-            _decode_to_wav(wav_ai, wav_resampled, sr)
-            sig_ai, _ = _load_wav(wav_resampled)
-            if sig_ai is None:
-                return {'error': 'Failed to resample AI output'}
-
-        # Ensure length compatibility
-        target_n = len(sig_pre)
-        if len(sig_ai) != target_n:
-            if len(sig_ai) > target_n:
-                sig_ai = sig_ai[:target_n]
-            else:
-                sig_ai = np.pad(sig_ai, (0, target_n - len(sig_ai)))
-
-        # ── Layer 1: PhonemeGuard ────────────────────────��────────────────────
-        if guard is not None:
-            sig_guarded = guard.repair(sig_ai, st)
-            if verbose and st.guard_frames_repaired > 0:
-                print(f'  [Guard] Repaired {st.guard_frames_repaired}/{st.guard_frames_checked} frames  '
-                      f'Lost bands: {", ".join(st.guard_bands_lost) or "none"}')
-        else:
-            sig_guarded = sig_ai
-
-        # ── Layer 2: SpeakerAnchor ────────────────────────────────────────────
-        if anchor is not None:
-            sig_anchored = anchor.anchor(sig_guarded, st)
-            if verbose:
-                flag = '⚠ FIRED' if st.anchor_fired else 'OK'
-                print(f'  [Anchor] Speaker similarity={st.anchor_similarity:.3f}  {flag}')
-        else:
-            sig_anchored = sig_guarded
-
-        # ── Layer 3: كتام BWE ─────────────────────────────────────────────────
-        if not skip_bwe:
-            sig_bwe = _katam_bwe(sig_anchored, sr, st)
-            if verbose and st.is_katam:
-                print(f'  [BWE] كتام detected @ {st.katam_cutoff_hz:.0f}Hz — presence lifted')
-        else:
-            sig_bwe = sig_anchored
-
-        # ── AudioSR for extreme كتام (< 3kHz bandwidth) ──────────────────────
-        if st.is_katam and st.active_bw_hz < 3200 and AUDIOSR_OK:
-            try:
-                wav_bwe_in  = st.tmpfile('.wav')
-                wav_bwe_out = st.tmpfile('.wav')
-                _save_wav(wav_bwe_in, sig_bwe, sr)
-                asr_model = _audiosr.build_model(model_name='basic', device='cpu')
-                waveform  = _audiosr.super_resolution(
-                    asr_model, wav_bwe_in,
-                    seed=42, guidance_scale=3.5, ddim_steps=50,
-                    latent_t_per_second=12.8,
-                )
-                _audiosr.save_wave(waveform, wav_bwe_out, sample_rate=SR)
-                sig_asr, _ = _load_wav(wav_bwe_out)
-                if sig_asr is not None:
-                    if len(sig_asr) != len(sig_bwe):
-                        sig_asr = sig_asr[:len(sig_bwe)] if len(sig_asr) > len(sig_bwe) else \
-                                  np.pad(sig_asr, (0, len(sig_bwe) - len(sig_asr)))
-                    sig_bwe = sig_asr
-                    if verbose:
-                        print(f'  [BWE] AudioSR super-resolution applied (extreme كتام)')
-            except Exception:
-                pass  # AudioSR failed silently — already got basic BWE above
-
-        # ── Phase 4: Post-processing polish ───────────────────────────────────
-        sig_final = _postprocess(sig_bwe, sr, st)
-
-        # ── Save output ───────────────────────────────────────────────────────
-        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
-        if not _save_wav(output_path, sig_final, sr):
-            return {'error': f'Failed to save output: {output_path}'}
-
-        elapsed = time.time() - t0
-        rtf     = (len(sig) / sr) / max(elapsed, 0.001)
-
-        if verbose:
-            print(f'  ══ Done in {elapsed:.1f}s  RTF={rtf:.1f}x  → {output_path}')
-
-        return {
-            'success':       True,
-            'ai_model':      st.ai_model_used,
-            'elapsed_s':     elapsed,
-            'rtf':           rtf,
-            'analysis': {
-                'snr_db':         st.snr_db,
-                'bandwidth_hz':   st.active_bw_hz,
-                'is_katam':       st.is_katam,
-                'katam_cutoff':   st.katam_cutoff_hz,
-                'is_noisy':       st.is_noisy,
-                'f0_median_hz':   st.f0_median_hz,
-            },
-            'phoneme_guard': {
-                'frames_checked':  st.guard_frames_checked,
-                'frames_repaired': st.guard_frames_repaired,
-                'bands_lost':      st.guard_bands_lost,
-            },
-            'speaker_anchor': {
-                'similarity':      st.anchor_similarity,
-                'fired':           st.anchor_fired,
-            },
-        }
-
-    except Exception as e:
-        import traceback
-        return {'error': str(e), 'traceback': traceback.format_exc()}
-
-    finally:
-        st.cleanup()
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  CLI
-# ═══════════════════════════════════════════════════════════════���══════════════
-
-def main() -> int:
-    if not NUMPY_OK:
-        print('pip install numpy scipy soundfile')
-        return 1
-
-    p = argparse.ArgumentParser(
-        description=f'الإحياء {__version__} — Parametric Resynthesis + Quran Phoneme Protection'
-    )
-    p.add_argument('-i', '--input',  required=False)
-    p.add_argument('-o', '--output', required=False)
-    p.add_argument('--skip-phoneme-guard',  action='store_true',
-                   help='Disable PhonemeGuard (not recommended for Quran)')
-    p.add_argument('--skip-speaker-anchor', action='store_true',
-                   help='Disable SpeakerAnchor (may cause voice drift)')
-    p.add_argument('--skip-bwe', action='store_true',
-                   help='Disable كتام bandwidth extension')
-    p.add_argument('--models', action='store_true',
-                   help='Print available AI models and exit')
-    args = p.parse_args()
-
-    if args.models:
-        print(f'\n  الإحياء {__version__} — Available AI models:')
-        print(f'  SIDON          {"✓ available" if SIDON_OK else "✗  pip install sidon"}')
-        print(f'  Resemble Enh.  {"✓ available" if RESEMBLE_OK else "✗  pip install resemble-enhance"}')
-        print(f'  VoiceFixer     {"✓ available" if VOICEFIXER_OK else "✗  pip install voicefixer"}')
-        print(f'  AudioSR (BWE)  {"✓ available" if AUDIOSR_OK else "✗  pip install audiosr"}')
-        print(f'  PyTorch        {"✓ available" if TORCH_OK else "✗  pip install torch"}')
-        print(f'\n  Numpy/Scipy    {"✓" if NUMPY_OK else "✗"}   soundfile {"✓" if SF_OK else "✗"}')
-        print()
-        return 0
-
-    if not args.input:
-        p.print_help()
-        return 1
-
-    if not os.path.exists(args.input):
-        print(f'Input not found: {args.input}')
-        return 1
-
-    if not args.output:
-        base = Path(args.input).stem
-        args.output = str(Path(args.input).parent / f'{base}_ihya4.wav')
-
-    print(f'\n  ╔══ الإحياء v4  ══╗')
-    print(f'  ║  حروف لا تُؤكل  ║')
-    print(f'  ║  الشيخ يبقى     ║')
-    print(f'  ╚════════════════╝\n')
-
-    result = process(
-        args.input, args.output,
-        skip_phoneme_guard=args.skip_phoneme_guard,
-        skip_speaker_anchor=args.skip_speaker_anchor,
-        skip_bwe=args.skip_bwe,
-        verbose=True,
-    )
-
-    if 'error' in result:
-        print(f'\n  ERROR: {result["error"]}')
-        if 'traceback' in result:
-            print(result['traceback'])
-        return 2
-
-    ana = result.get('analysis', {})
-    pg  = result.get('phoneme_guard', {})
-    sa  = result.get('speaker_anchor', {})
-
-    print(f'\n  ══ Results ══════════════════════════════════════')
-    print(f'  AI model used:      {result.get("ai_model", "?")}')
-    print(f'  Processing time:    {result.get("elapsed_s", 0):.1f}s')
-    print(f'  SNR:                {ana.get("snr_db", 0):.1f} dB')
-    print(f'  Active bandwidth:   {ana.get("bandwidth_hz", 0):.0f} Hz')
-    print(f'  كتام detected:      {"نعم" if ana.get("is_katam") else "لا"}')
-    if ana.get('is_katam'):
-        print(f'  كتام cutoff:        {ana.get("katam_cutoff", 0):.0f} Hz')
-    print(f'  PhonemeGuard:       {pg.get("frames_repaired", 0)}/{pg.get("frames_checked", 0)} frames repaired')
-    if pg.get('bands_lost'):
-        print(f'  Lost bands rescued: {", ".join(pg["bands_lost"])}')
-    print(f'  Speaker similarity: {sa.get("similarity", 0):.3f}  '
-          f'{"⚠ Anchored" if sa.get("fired") else "✓ Stable"}')
-    print(f'  Output:             {args.output}')
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())

engine_isteidad_server.py

@@ -15,6 +15,10 @@
 # ║     • single-flight lock so one process never runs 2 heavy jobs at once    ║
 # ║     • all limits configurable per-Space via env vars (ISTEIDAD_*)          ║
 # ║     • get_server_status() health-check helper for app.py / load balancer   ║
+# ║     • PERMANENT: TIER_DAMAGED/TIER_CRITICAL no longer hands off to إحياء — ║
+# ║       remapped to TIER_DEGRADED so Isteidad's own pipeline always runs.   ║
+# ║       Set ISTEIDAD_ALLOW_IHYAA=1 to restore the original tier-gated       ║
+# ║       إحياء handoff.                                                       ║
 # ║                                                                              ║
 # ╚══════════════════════════════════════════════════════════════════════════════╝
 # ╔══════════════════════════════════════════════════════════════════════════════╗
@@ -5977,6 +5981,26 @@ def analyze_input(path: str, ref: ReferenceModel) -> InputState:
         state.src_br, state.codec_cutoff, _snr_for_tier,
         state.noise_type, state.smear_score,
         src_sr=state.src_sr, clip_ratio=state.clip_ratio)
+
+    # ── SERVER OVERRIDE (permanent, per request): never hand off to إحياء ────
+    # By design, TIER_DAMAGED/TIER_CRITICAL sources were routed to إحياء
+    # structural recovery instead of Isteidad's own noor/jalal/nidaa/جوهر
+    # pipeline (VOICE_ENHANCEMENT_NOTES_v2 — avoids "ping-pong" between
+    # modules on badly-damaged audio). Remapping here is the single point of
+    # control: every downstream `state.source_tier in ('TIER_DAMAGED',
+    # 'TIER_CRITICAL')` check (the إحياء branch, the noor/jalal/nidaa skip,
+    # several NR-strength and dynamics ceilings) now sees TIER_DEGRADED and
+    # takes Isteidad's own path instead. This also relaxes the quality
+    # ceiling and NR caps that existed specifically because إحياء+DF3 in
+    # combination were judged unsafe on this class of source — badly
+    # degraded audio now gets the same processing as merely degraded audio.
+    # Set ISTEIDAD_ALLOW_IHYAA=1 to restore the original tier-gated handoff.
+    if state.source_tier in ('TIER_DAMAGED', 'TIER_CRITICAL') and \
+            os.environ.get('ISTEIDAD_ALLOW_IHYAA', '0') != '1':
+        L(f'  [server] source_tier {state.source_tier} → remapped to TIER_DEGRADED '
+          f'(إحياء handoff disabled; set ISTEIDAD_ALLOW_IHYAA=1 to restore it)')
+        state.source_tier = 'TIER_DEGRADED'
+
     state.achievable_lufs, state.achievable_crest, state.achievable_lra = \
         _compute_achievable(state.source_tier, state.codec_cutoff,
                             src_sr=state.src_sr, clip_ratio=state.clip_ratio,

requirements.txt

@@ -7,9 +7,7 @@ librosa
 soundfile
 nara_wpe
 
-# S202: BWE for telephone-tier (TIER_TELEPHONE) audio in engine_ihya_v3.py
 --extra-index-url https://download.pytorch.org/whl/cpu
 torch==2.3.1+cpu
-voicefixer2 @ git+https://github.com/Render-AI-Team/voicefixer2.git
 torchaudio==2.3.1+cpu
 psutil