engine_v85.py

#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║   Audio Enhancement Engine v8.4 — "Source Tier Intelligence"              ║
║   المرجع: الشيخ ياسر الدوسري — 1425H                                        ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║  الأخطاء المُشخَّصة في v7.6 (Forensic Deep-Dive):                           ║
║                                                                              ║
║  🔴 BUG #1 — SPECTRAL_BIAS اتجاه معكوس في 3 نطاقات حرجة                   ║
║     250Hz: bias=+11 → cut بدل boost (output -7dB تحت ref!)                 ║
║     4kHz:  bias=-1.5 → boost بدل cut (output +5dB فوق ref!)                ║
║     8kHz:  bias=-4.0 → boost بدل cut (output +10dB فوق ref!)               ║
║     الإصلاح: SPECTRAL_BIAS_V8 بالاتفاقية الصحيحة (output-ref)              ║
║                                                                              ║
║  🔴 BUG #2 — Double Compand Stacking يسحق Crest                            ║
║     LRA compand + Main compand → ضغط مزدوج → Crest ينهار                  ║
║     الإصلاح: حذف LRA compand من Pass1 — Main compand وحيد                  ║
║                                                                              ║
║  🟠 BUG #3 — 5 تطبيقات alimiter تطحن Crest تراكمياً                        ║
║     P1(×2) + P2 + P3 + P4 = 5 مرات limit=0.891 → Crest ينخفض 0.8-1.5LU  ║
║     الإصلاح: WAV وسيطة = limit=0.9997 فقط | MP3 نهائي = 0.891             ║
║                                                                              ║
║  🟠 BUG #4 — build_compand_mds يستخدم DR بدل LRA                          ║
║     lra_delta = damage.dr - TARGET['dr'] ← خطأ نوع!                        ║
║     الإصلاح: lra_delta = inp_lra - ref_fp.lra_clip (صحيح)                 ║
║                                                                              ║
║  🟡 BUG #5 — Quality Gate لا يحمي Crest بشكل منفصل                        ║
║     عتبة 1.0 نقطة تتجاهل انهيار Crest 3+LU                                ║
║     الإصلاح: حارس مستقل Crest < P1-1.5LU AND < target-0.8                 ║
║                                                                              ║
║  المحافظ عليه من v7.6 (Architecture سليم):                                  ║
║  ✅ MDS System (SFM + DR + Spectral Distance + Per-Band SNR)               ║
║  ✅ SFM-Adaptive NR                                                          ║
║  ✅ Full-File LRA Target 4.19 (v7.6 fix)                                    ║
║  ✅ Dual LRA: lra_clip للـ compand | lra للـ quality score                  ║
║  ✅ 9-Segment Full-File Spectral Average                                    ║
║  ✅ 4-Pass WAV Pipeline (lossless حتى Pass4)                               ║
║  ✅ Crest-Aware Warmth Nodes                                                ║
║  ✅ Scipy Perceptual EQ (Bark + A-weight)                                   ║
║  ✅ Arabic Filename Safety                                                   ║
║                                                                              ║
║  الهدف: LUFS=-6.29 RMS=-10.01 Crest=10.25 LRA=4.19 ≥96/100               ║
║                                                                              ║
║  إصلاحات v8.1 — Android Subprocess Hardening:                               ║
║  🔴 PATCH #1 — REF_CACHE: /tmp → Path.home()/.tilawa_cache/ (persistent)   ║
║  🔴 PATCH #2 — REF_FILES: hardcoded → env var + ~/.tilawa_ref/ + legacy     ║
║  🔴 PATCH #3 — ALL /tmp/ refs → tempfile.gettempdir() (Android-safe)        ║
║  🟠 PATCH #4 — Adaptive EQ scale: tiered → linear ramp (+3 quality pts)    ║
║  🟡 PATCH #5 — 64K_FLOOR label: honest Crest ceiling for 64kbps sources    ║
╚══════════════════════════════════════════════════════════════════════════════╝
"""
from __future__ import annotations
import argparse, json, os, shutil, subprocess, sys, warnings, time, tempfile as _tempfile
from dataclasses import dataclass, field
from pathlib import Path
from typing import Dict, List, Optional, Tuple
warnings.filterwarnings('ignore')

# v8.1 PATCH #3: platform/context-aware temp dir
# Termux shell:       /data/data/com.termux/files/usr/tmp/
# Android subprocess: /data/local/tmp/ or app cache dir
# Linux desktop:      /tmp/
_TMP = _tempfile.gettempdir()

try:
    import numpy as np
    from scipy.fft import rfft, rfftfreq
    from scipy.optimize import minimize
    from scipy.interpolate import CubicSpline
    NUMPY_OK = SCIPY_OK = True
except ImportError:
    NUMPY_OK = SCIPY_OK = False

# ══════════════════════════════════════════════════════════════════════════════
#  CONSTANTS
# ══════════════════════════════════════════════════════════════════════════════
SR = 48000

TARGET = {
    'lufs':      -6.29,
    'rms':      -10.01,
    'crest':     10.25,
    'lra':        4.19,   # full-file measurement (corrected in v7.6, kept in v8)
    'true_peak':  -1.0,
    'bitrate':  '320k',
    'sfm':        0.0444,
    'dr':          7.9,
}

# ── v8.1 PATCH #2: REF_FILES — env var → home dir → legacy (dev only) ─────
def _resolve_ref_files() -> List[str]:
    """
    Resolution order:
      1. TILAWA_REF_DIR env var (set by Flutter before spawning subprocess)
      2. ~/.tilawa_ref/ (user-populated in Termux home)
      3. Legacy /mnt/user-data/uploads/ (Claude.ai sandbox — dev only)
    Returns [] if nothing found; get_reference_fingerprint() handles empty list.
    """
    # 1. Flutter sets this env var before Process.start()
    env_dir = os.environ.get('TILAWA_REF_DIR', '')
    if env_dir and os.path.isdir(env_dir):
        found = sorted([str(p) for p in Path(env_dir).glob('*.mp3')])
        if found: return found
    # 2. Termux home ref directory (user populates this once)
    home_ref = Path.home() / '.tilawa_ref'
    if home_ref.is_dir():
        found = sorted([str(p) for p in home_ref.glob('*.mp3')])
        if found: return found
    # 3. v8.2: Docker /app/reference_audio/ self-location
    container_ref = Path(__file__).parent / "reference_audio"
    if container_ref.is_dir():
        found = sorted([
            str(p) for p in container_ref.glob("*.mp3")
            if p.stat().st_size > 10_000
        ])
        if found:
            return found
    # 4. Legacy Claude.ai sandbox paths (development only)
    legacy = [
        "/mnt/user-data/uploads/ref_araf_1425h.mp3",
        "/mnt/user-data/uploads/ref_fath_1425h.mp3",
        "/mnt/user-data/uploads/ref_fatir_1425h.mp3",
    ]
    found = [p for p in legacy if os.path.exists(p)]
    return found

REF_FILES = _resolve_ref_files()

# ── v8.1 PATCH #1: REF_CACHE — persistent home-dir path ─────────────────────
# /tmp/ does NOT exist in Android's app subprocess sandbox.
# Path.home() resolves correctly in both Termux shell and Flutter subprocess.
_CACHE_DIR = Path.home() / '.tilawa_cache'
REF_CACHE   = str(_CACHE_DIR / 'ref_fp.v85.json')   # v8.5: cache version bump

CENTERS_31 = [
    20,25,31.5,40,50,63,80,100,125,160,
    200,250,315,400,500,630,800,1000,1250,1600,
    2000,2500,3150,4000,5000,6300,8000,10000,12500,16000,20000,
]

A_WEIGHT: Dict[float,float] = {
    20:-50.5,25:-44.7,31.5:-39.4,40:-34.6,50:-30.2,
    63:-26.2,80:-22.5,100:-19.1,125:-16.1,160:-13.4,
    200:-10.9,250:-8.6,315:-6.6,400:-4.8,500:-3.2,
    630:-1.9,800:-0.8,1000:0.0,1250:0.6,1600:1.0,
    2000:1.2,2500:1.3,3150:1.2,4000:1.0,5000:0.5,
    6300:-0.1,8000:-1.1,10000:-2.5,12500:-4.3,16000:-6.6,20000:-9.3,
}

# ══════════════════════════════════════════════════════════════════════════════
#  v8 BUG #1 FIX — SPECTRAL_BIAS_V8: اتفاقية صحيحة موحدة
#
#  الاتفاقية: bias = (output - ref)
#    سالب  = output تحت ref   → g = -(-)*scale = موجب (boost) ✅
#    موجب  = output فوق ref   → g = -(+)*scale = سالب (cut)  ✅
#
#  v7.6 كان يستخدم "رغبة في التصحيح" بدل "الخطأ المُقاس":
#    250Hz: +11 → يقطع بدل رفع (output -7dB تحت ref) ❌
#    4kHz:  -1.5 → يرفع بدل قطع (output +5dB فوق ref) ❌
#    8kHz:  -4.0 → يرفع بدل قطع (output +10dB فوق ref) ❌
# ══════════════════════════════════════════════════════════════════════════════
SPECTRAL_BIAS_V8: Dict[int,float] = {
    # النطاقات الدنيا — محتاج رفع (output تحت ref في ملفات 64kbps)
    80:    -2.50,   # output -2.5dB تحت ref → g=+0.625dB boost
    100:   -4.00,   # output -4dB تحت ref  → g=+1.00dB boost
    125:   +3.50,   # output +3.5dB فوق ref → g=-0.875dB cut
    200:   -4.00,   # output -4dB تحت ref  → g=+1.00dB boost
    # ↓ إصلاح v8 الحرج: كان +11.00 → يقطع عوضاً عن الرفع!
    250:   -7.00,   # output -7dB تحت ref  → g=+1.75dB boost ← v8 FIX الأكبر
    315:   +6.00,   # output +6dB فوق ref  → g=-1.50dB cut
    400:   -1.50,   # output تحت ref      → g=+0.375dB boost
    500:   +1.50,   # output فوق ref      → g=-0.375dB cut
    630:   -2.50,   # output تحت ref      → g=+0.625dB boost
    800:   +1.50,   # output فوق ref      → g=-0.375dB cut
    1000:  -1.00,   # output تحت ref      → g=+0.25dB boost (v7.55: كان يعطي قطع)
    1250:  +0.40,   # صغير جداً → تأثير ضئيل
    2000:  +0.50,   # صغير جداً → تأثير ضئيل
    2500:  +1.80,   # output فوق ref      → g=-0.45dB cut
    3150:  +1.20,   # output فوق ref      → g=-0.30dB cut
    # ↓ إصلاح v8 الحرج: كان -1.50 → يرفع عوضاً عن القطع!
    4000:  +5.00,   # output +5dB فوق ref  → g=-1.25dB cut ← v8 FIX
    # ↓ إصلاح v8: كان -0.80 و-0.90 → يرفع في منطقة مرتفعة أصلاً
    5000:  +0.80,   # output فوق ref      → g=-0.20dB cut ← v8 FIX (was -0.80)
    6300:  +0.90,   # output فوق ref      → g=-0.225dB cut ← v8 FIX (was -0.90)
    # ↓ إصلاح v8 الحرج: كان -4.00 → يرفع عوضاً عن القطع!
    8000:  +8.00,   # output +8-10dB فوق ref → g=-2.00dB cut ← v8 FIX الأكبر
    10000: -2.00,   # output تحت ref (rolloff) → g=+0.50dB boost
}
BIAS_SCALE = 0.25   # الصيغة: g = round(-bias_db * BIAS_SCALE, 2)

# ══════════════════════════════════════════════════════════════════════════════
#  DATA CLASSES
# ══════════════════════════════════════════════════════════════════════════════

@dataclass
class ReferenceFingerprint:
    third_oct:     Dict[float,float] = field(default_factory=dict)
    a_weighted:    Dict[float,float] = field(default_factory=dict)
    rms:           float = TARGET['rms']
    peak:          float = TARGET['true_peak']
    crest:         float = TARGET['crest']
    lra:           float = TARGET['lra']
    lra_clip:      float = 2.94
    tilt_slope:    float = 0.0
    warmth_ratio:  float = 0.0
    sfm:           float = TARGET['sfm']
    dr:            float = TARGET['dr']
    n_files:       int   = 0
    # ── v8.45: DeepReferenceModel fields ─────────────────────────────────────
    phrase_lra_p10:       float = 2.50   # LRA at 10th percentile of phrases
    phrase_lra_p50:       float = 3.37   # LRA at 50th percentile (compand target)
    phrase_lra_p90:       float = 4.20   # LRA at 90th percentile
    silence_floor_db:     float = -73.0  # measured ref noise floor (NR ceiling = this - 3dB)
    ref_codec_cutoff_hz:  float = 14000.0 # highest freq with real content in refs
    peak_distribution:    str   = 'uniform'  # front_loaded / uniform / back_loaded

@dataclass
class DamageProfile:
    """v7.6 Multi-Metric Damage Score (MDS) — محافَظ عليه في v8"""
    snr:            float = 30.0
    sfm:            float = 0.05
    dr:             float = 8.0
    hf_deficit:     float = 0.0
    spectral_dist:  float = 0.0
    crest:          float = 10.0
    src_br:         int   = 128000
    band_snr:       Dict[float,float] = field(default_factory=dict)
    mds:            float = 0.0
    nr_intensity:   float = 0.0
    compand_score:  float = 0.0
    has_ringing:    bool  = False
    rolloff_hz:     float = 20000.0
    quality_label:  str   = 'GOOD'

@dataclass
class QualityReport:
    score:       float = 0.0
    spectral:    float = 0.0
    lufs:        float = 0.0
    crest:       float = 0.0
    lra:         float = 0.0
    warmth:      float = 0.0
    hf:          float = 0.0
    avg_err:     float = 99.0
    warmth_tilt: float = 0.0
    warmth_ref:  float = 0.0
    lra_target:  float = TARGET['lra']
    notes:       List[str] = field(default_factory=list)
    # ── v8.5: TierAdjustedScoring fields ─────────────────────────────────────
    score_absolute: float = 0.0   # scored vs original 1425H targets (always)
    score_tier:     float = 0.0   # scored vs tier-achievable targets (displayed)
    ceiling_reason: str   = ''    # e.g. "TIER_COMPRESSED: Crest≤9.8LU  LRA≤4.0LU

# ══════════════════════════════════════════════════════════════════════════════
#  v8.4 — SOURCE TIER DETECTOR
#  SourceTierProfile + 6 detection functions
#  يُشغَّل مرة واحدة في enhance() بعد DamageProfile وقبل NR
# ══════════════════════════════════════════════════════════════════════════════

@dataclass
class SourceTierProfile:
    """
    نتيجة تصنيف جودة المصدر — تُحدَّد قبل أي معالجة.
    تُمرَّر لكل وحدة في الـ pipeline لتضبط حدود التدخل.
    """
    # ── نتائج القياس ──────────────────────────────────────────────────
    tier:             str   = 'TIER_PRISTINE'
    input_cutoff_hz:  float = 20000.0   # تردد قطع الكودك المُقاس
    noise_type:       str   = 'none'    # none|hiss|hum_50hz|hum_60hz|broadband|hiss+hum
    clip_tier:        str   = 'none'    # none|mild|moderate|severe
    clip_ratio:       float = 0.0       # نسبة العينات المقطوعة 0–1
    hum_freq_hz:      float = 0.0       # 50.0 أو 60.0 إذا وُجد hum
    sfm_silence:      float = 0.0       # SFM في مقاطع الصمت
    snr_effective:    float = 30.0      # SNR الفعلي
    # ── معاملات التوجيه — تُشتق من الـ tier ──────────────────────────
    bias_cutoff_hz:   float = 20000.0   # لا BIAS g>0 فوق هذا التردد
    eq_ramp_scale:    float = 1.0       # مضاعف على scale في adaptive EQ
    nr_mandatory:     bool  = False     # أجبر NR حتى لو SFM يقول لا
    lra_expand_gate:  bool  = True      # اسمح بتوسيع LRA في Pass 3
    achievable_crest: float = 10.25     # سقف Crest الفيزيائي
    achievable_lra:   float = 4.19      # هدف LRA القابل للتحقيق
    achievable_lufs:  float = -6.29     # هدف LUFS القابل للتحقيق


def detect_codec_cutoff(inp_b: Dict[float, float]) -> float:
    """
    يمسح CENTERS_31 من 20kHz نزولاً.
    أول نطاق فيه طاقة > (noise_floor_p10 + 6dB) = تردد القطع.

    الفيزياء: ضوضاء التكميم طيفها شبه مسطح تحت الإشارة.
    فوق تردد القطع: إشارة تسقط تحت ضوضاء التكميم.
    Bypass: inp_b فارغة → 20000.0
    """
    if not inp_b:
        return 20000.0
    all_vals = sorted(inp_b.values())
    noise_floor = float(np.percentile(all_vals, 10)) if len(all_vals) >= 4 else -70.0
    threshold = noise_floor + 6.0
    for fc in sorted(inp_b.keys(), reverse=True):
        if inp_b[fc] > threshold:
            return float(fc)
    return float(min(inp_b.keys(), default=20000.0))


def detect_noise_type(audio: 'np.ndarray',
                      sr: int = SR) -> Tuple[str, float, float]:
    """
    يحدد نوع الضوضاء من مقاطع الصمت (إطارات 200ms).

    الخوارزمية:
      1. إطارات الصمت: (overall_rms-18dB) > frame_rms > -62dBFS
      2. SFM على الصمت المُدمج — SFM>0.65 = broadband noise
      3. طاقة 50Hz / 60Hz مقابل الجيران +25Hz — +15dB = hum

    Bypass: audio قصير جداً (<3 إطارات صمت) → ('unknown', 0.0, 0.0)
    Returns: (noise_type, sfm_silence, hum_freq_hz)
    """
    frame_n = int(0.2 * sr)
    if len(audio) < frame_n * 3:
        return ('unknown', 0.0, 0.0)
    overall_rms_db = rms_db(audio)
    silence_thresh = overall_rms_db - 18.0
    silence_floor  = -62.0
    frames = [audio[i:i+frame_n]
              for i in range(0, len(audio) - frame_n, frame_n)]
    silence_frames = [f for f in frames
                      if silence_floor < rms_db(f) < silence_thresh]
    if len(silence_frames) < 3:
        return ('unknown', 0.0, 0.0)
    silence_audio = np.concatenate(silence_frames)
    sfm_sil = compute_sfm(silence_audio, sr, f_lo=200.0, f_hi=8000.0)
    hum_freq = 0.0
    N_sil = len(silence_audio)
    spec_sil = np.abs(rfft(silence_audio)) ** 2
    freqs_sil = rfftfreq(N_sil, 1.0 / sr)
    def _band_e(fc: float, bw: float = 3.0) -> float:
        mask = (freqs_sil >= fc - bw) & (freqs_sil <= fc + bw)
        return float(np.mean(spec_sil[mask])) if mask.sum() > 0 else 1e-30
    for test_hz in [50.0, 60.0]:
        ratio_db = 10 * np.log10(
            _band_e(test_hz) /
            (np.mean([_band_e(test_hz-25.0), _band_e(test_hz+25.0)]) + 1e-30)
            + 1e-30
        )
        if ratio_db > 15.0:
            hum_freq = test_hz
            break
    has_hiss = sfm_sil > 0.65
    has_hum  = hum_freq > 0.0
    if has_hiss and has_hum:   noise_type = 'hiss+hum'
    elif has_hiss:             noise_type = 'hiss' if sfm_sil < 0.85 else 'broadband'
    elif has_hum:              noise_type = f'hum_{int(hum_freq)}hz'
    else:                      noise_type = 'none'
    return (noise_type, float(sfm_sil), float(hum_freq))


def detect_clip_tier_v84(audio: 'np.ndarray') -> Tuple[str, float]:
    """يُصنّف مستوى القطع — wrapper على count_clips()."""
    n_clips = count_clips(audio, thr=0.99)
    ratio = n_clips / max(len(audio), 1)
    if ratio < 0.001:   tier = 'none'
    elif ratio < 0.02:  tier = 'mild'
    elif ratio < 0.20:  tier = 'moderate'
    else:               tier = 'severe'
    return tier, float(ratio)


def _classify_source_tier(src_br: int, cutoff_hz: float,
                          snr_db: float, noise_type: str) -> str:
    """
    تصنيف فئة المصدر — أول قاعدة تنطبق تُحدد الفئة.

    TIER_PRISTINE:   128kbps+ AND cutoff>14kHz AND SNR>25dB AND noise=none
    TIER_COMPRESSED: 64kbps+  AND cutoff>10kHz AND SNR>15dB
    TIER_DEGRADED:   32kbps+  AND cutoff>7kHz  AND SNR>8dB
    TIER_DAMAGED:    كل ما تبقى
    """
    if (src_br >= 128_000 and cutoff_hz > 14_000.0
            and snr_db > 25.0 and noise_type == 'none'):
        return 'TIER_PRISTINE'
    if src_br >= 64_000 and cutoff_hz > 10_000.0 and snr_db > 15.0:
        return 'TIER_COMPRESSED'
    if src_br >= 32_000 and cutoff_hz > 7_000.0 and snr_db > 8.0:
        return 'TIER_DEGRADED'
    return 'TIER_DAMAGED'


def _build_routing_params(tier: str, cutoff_hz: float,
                          noise_type: str, inp_lra: float,
                          ref_lra_clip: float) -> dict:
    """يُنتج معاملات التوجيه من الـ tier — مُنفصل للاختبار."""
    lra_deficit = ref_lra_clip - inp_lra
    if tier == 'TIER_PRISTINE':
        return dict(
            bias_cutoff_hz=20_000.0, eq_ramp_scale=1.0,
            nr_mandatory=False,      lra_expand_gate=True,
            achievable_crest=10.25,  achievable_lra=4.19,  achievable_lufs=-6.29,
        )
    if tier == 'TIER_COMPRESSED':
        return dict(
            bias_cutoff_hz=cutoff_hz * 0.90, eq_ramp_scale=0.70,
            nr_mandatory=(noise_type != 'none'), lra_expand_gate=True,
            achievable_crest=9.5,  achievable_lra=4.0,  achievable_lufs=-6.29,
        )
    if tier == 'TIER_DEGRADED':
        return dict(
            bias_cutoff_hz=min(8_000.0, cutoff_hz * 0.85), eq_ramp_scale=0.40,
            nr_mandatory=True,  lra_expand_gate=(lra_deficit > 0.8),
            achievable_crest=8.5,  achievable_lra=3.6,  achievable_lufs=-6.5,
        )
    # TIER_DAMAGED
    return dict(
        bias_cutoff_hz=4_000.0, eq_ramp_scale=0.20,
        nr_mandatory=True,      lra_expand_gate=False,
        achievable_crest=7.5,   achievable_lra=3.2,   achievable_lufs=-7.0,
    )


def build_source_tier_profile(audio: 'np.ndarray',
                              inp_b: Dict[float, float],
                              src_br: int,
                              snr_db: float,
                              inp_lra: float,
                              ref_lra_clip: float,
                              sr: int = SR) -> SourceTierProfile:
    """
    الدالة الرئيسية — تُشغّل جميع المستشعرات وتُجمّع SourceTierProfile.
    يُستدعى مرة واحدة في enhance() بعد DamageProfile وقبل NR.
    """
    cutoff_hz = detect_codec_cutoff(inp_b)
    noise_type, sfm_sil, hum_freq = detect_noise_type(audio, sr)
    effective_noise = noise_type if noise_type != 'unknown' else 'none'
    clip_tier, clip_ratio = detect_clip_tier_v84(audio)
    tier    = _classify_source_tier(src_br, cutoff_hz, snr_db, effective_noise)
    routing = _build_routing_params(tier, cutoff_hz, effective_noise,
                                    inp_lra, ref_lra_clip)
    return SourceTierProfile(
        tier=tier, input_cutoff_hz=cutoff_hz,
        noise_type=noise_type, clip_tier=clip_tier, clip_ratio=clip_ratio,
        hum_freq_hz=hum_freq, sfm_silence=sfm_sil, snr_effective=snr_db,
        **routing,
    )


# ══════════════════════════════════════════════════════════════════════════════
#  AUDIO I/O
# ══════════════════════════════════════════════════════════════════════════════

def _safe(path:str) -> Tuple[str,Optional[str]]:
    """v8.1 PATCH #3: use _TMP (platform-aware) instead of hardcoded /tmp/"""
    try: path.encode('ascii'); return path,None
    except UnicodeEncodeError:
        import uuid as _u
        ext=os.path.splitext(path)[1] or '.mp3'
        tmp=os.path.join(_TMP, f'v81_safe_{_u.uuid4().hex[:8]}{ext}')
        try:
            shutil.copy2(path,tmp)
        except OSError:
            # last resort: write beside the output in cwd
            tmp=os.path.join(os.getcwd(), f'v81_safe_{_u.uuid4().hex[:8]}{ext}')
            shutil.copy2(path,tmp)
        return tmp,tmp

def load_audio(path:str,sr:int=SR,mono:bool=True,
               skip:int=0,duration:Optional[int]=None) -> 'np.ndarray':
    sp,tc=_safe(path)
    cmd=['ffmpeg','-i',sp]
    if skip>0:   cmd+=['-ss',str(skip)]
    if duration: cmd+=['-t',str(duration)]
    cmd+=['-f','s16le','-ac','1' if mono else '2',
          '-ar',str(sr),'-loglevel','error','-']
    r=subprocess.run(cmd,capture_output=True)
    if tc:
        try: os.remove(tc)
        except: pass
    if not r.stdout: raise RuntimeError(f'فشل تحميل: {path}')
    return np.frombuffer(r.stdout,np.int16).astype(np.float32)/32768.0

def probe(path:str) -> Dict:
    sp,tc=_safe(path)
    r=subprocess.run(['ffprobe','-v','quiet','-print_format','json',
                      '-show_streams','-show_format',sp],
                     capture_output=True,text=True)
    if tc:
        try: os.remove(tc)
        except: pass
    return json.loads(r.stdout) if r.returncode==0 else {}

def measure_lufs(path:str) -> float:
    sp,tc=_safe(path)
    r=subprocess.run(['ffmpeg','-i',sp,'-af','ebur128=peak=true',
                      '-f','null','-','-loglevel','info'],
                     capture_output=True,text=True)
    if tc:
        try: os.remove(tc)
        except: pass
    for line in r.stderr.split('\n'):
        s=line.strip()
        if s.startswith('I:') and 'LUFS' in s and 'LRA' not in s:
            try: return float(s.split('I:')[1].strip().split()[0])
            except: pass
    return -99.0

# ══════════════════════════════════════════════════════════════════════════════
#  SIGNAL METRICS
# ══════════════════════════════════════════════════════════════════════════════

def rms_db(a:'np.ndarray') -> float:
    return float(20*np.log10(np.sqrt(np.mean(a**2))+1e-10))

def peak_db(a:'np.ndarray') -> float:
    return float(20*np.log10(np.max(np.abs(a))+1e-10))

def crest_factor(a:'np.ndarray') -> float:
    return float(peak_db(a)-rms_db(a))

def lra_estimate(a:'np.ndarray',sr:int=SR) -> float:
    n=int(0.4*sr); step=n//2
    lvls=np.array([20*np.log10(np.sqrt(np.mean(a[i:i+n]**2))+1e-10)
                   for i in range(0,len(a)-n,step)])
    if len(lvls)<2: return 0.0
    active=lvls[lvls>np.max(lvls)-30]
    return float(np.percentile(active,95)-np.percentile(active,10)) if len(active)>=2 else 0.0

def snr_estimate(a:'np.ndarray',sr:int=SR) -> float:
    n=int(0.1*sr)
    blocks=np.array([np.sqrt(np.mean(a[i:i+n]**2)) for i in range(0,len(a)-n,n)])
    if len(blocks)<4: return 30.0
    return float(20*np.log10(np.percentile(blocks,85)/(np.percentile(blocks,3)+1e-10)))

def count_clips(a:'np.ndarray',thr:float=0.99) -> int:
    return int(np.sum(np.abs(a)>=thr))

def declip(audio:'np.ndarray',thr:float=0.98) -> Tuple['np.ndarray',int]:
    clipped=np.abs(audio)>=thr; nc=int(np.sum(clipped))
    if nc==0: return audio,0
    out=audio.copy(); n=len(audio)
    diff=np.diff(clipped.astype(int))
    starts=np.where(diff==1)[0]+1; ends=np.where(diff==-1)[0]+1
    if clipped[0]:  starts=np.insert(starts,0,0)
    if clipped[-1]: ends=np.append(ends,n)
    for s,e in zip(starts,ends):
        ctx=40; pre=np.arange(max(0,s-ctx),s); post=np.arange(e,min(n,e+ctx))
        good=np.concatenate([pre,post])
        if len(good)<4: continue
        try:
            cs=CubicSpline(good,audio[good],extrapolate=True)
            out[np.arange(s,e)]=cs(np.arange(s,e))
        except: pass
    return out,nc

# ══════════════════════════════════════════════════════════════════════════════
#  SPECTRAL ANALYSIS
# ══════════════════════════════════════════════════════════════════════════════

def third_octave(audio:'np.ndarray',sr:int=SR,
                 chunk_sec:int=45,a_weighted:bool=False) -> Dict[float,float]:
    chunk=audio[:sr*chunk_sec] if len(audio)>sr*chunk_sec else audio
    N=len(chunk); spec=np.abs(rfft(chunk)); freqs=rfftfreq(N,1.0/sr)
    out:Dict[float,float]={}
    for fc in CENTERS_31:
        if fc>=sr/2: continue
        fl=fc/(2**(1/6)); fh=fc*(2**(1/6))
        mask=(freqs>=fl)&(freqs<fh)
        if mask.sum()>0:
            v=float(20*np.log10(np.mean(spec[mask])+1e-10))
            if a_weighted and fc in A_WEIGHT: v+=A_WEIGHT[fc]
            out[fc]=v
    return out

def hf_status(bands:Dict[float,float]) -> str:
    hfk=[f for f in bands if f>=8000]
    if not hfk: return 'absent'
    avg=float(np.mean([bands[f] for f in hfk]))
    return 'good' if avg>10 else 'weak' if avg>-5 else 'absent'

def detect_hf_rolloff(bands:Dict[float,float],drop:float=12.0) -> float:
    fs=sorted([f for f in bands if 1600<=f<=20000])
    if not fs: return 20000.0
    prev=bands[fs[0]]
    for fc in fs[1:]:
        curr=bands[fc]
        if prev-curr>drop: return float(fc)
        prev=curr
    return 20000.0

def spectral_tilt(bands:Dict[float,float],lo:float=100.0,hi:float=10000.0) -> float:
    fc_arr=np.array([fc for fc in CENTERS_31 if lo<=fc<=hi and fc in bands],dtype=float)
    if len(fc_arr)<3: return 0.0
    return float(np.polyfit(np.log2(fc_arr/1000.0),
                            np.array([bands[fc] for fc in fc_arr]),1)[0])

def warmth_tilt(bands:Dict[float,float]) -> float:
    return spectral_tilt(bands,200.0,2000.0)

def merge_eq(nodes:List[Tuple],gap:float=50.0) -> List[Tuple]:
    if not nodes: return nodes
    nodes=sorted(nodes,key=lambda x:x[0]); merged=[list(nodes[0])]
    for f0,g,Q in nodes[1:]:
        pf,pg,pq=merged[-1]
        if abs(f0-pf)<gap:
            total=float(np.clip(pg+g,-16,16))
            avg_f=(pf*abs(pg)+f0*abs(g))/(abs(pg)+abs(g)+1e-6)
            merged[-1]=[round(avg_f,0),round(total,2),round((pq+Q)/2,2)]
        else: merged.append([f0,g,Q])
    return [tuple(x) for x in merged]

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1a — SPECTRAL FLATNESS MEASURE (SFM)
# ══════════════════════════════════════════════════════════════════════════════

def compute_sfm(audio:'np.ndarray',sr:int=SR,
                f_lo:float=100.0,f_hi:float=8000.0) -> float:
    """Wiener entropy — مقياس نظافة الطيف | REF 1425H: 0.044"""
    chunk=audio[:sr*30] if len(audio)>sr*30 else audio
    N=len(chunk); spec=np.abs(rfft(chunk))**2; freqs=rfftfreq(N,1.0/sr)
    mask=(freqs>=f_lo)&(freqs<=f_hi)
    s=spec[mask]
    if len(s)<10: return 0.1
    eps=1e-10
    geo=float(np.exp(np.mean(np.log(s+eps))))
    arith=float(np.mean(s))
    return float(np.clip(geo/(arith+eps),0.0,1.0))

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1b — DYNAMIC RANGE SCORE
# ══════════════════════════════════════════════════════════════════════════════

def compute_dynamic_range(audio:'np.ndarray',sr:int=SR) -> float:
    """نطاق الديناميك الفعلي (20ms frames) | REF: 7.9dB"""
    n=int(0.020*sr)
    frames=np.array([float(np.sqrt(np.mean(audio[i:i+n]**2)))
                     for i in range(0,len(audio)-n,n)])
    if len(frames)<10: return 8.0
    frames_db=20*np.log10(frames+1e-10)
    return float(np.percentile(frames_db,95)-np.percentile(frames_db,5))

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1c — SPECTRAL SHAPE DISTANCE FROM REFERENCE
# ══════════════════════════════════════════════════════════════════════════════

def compute_spectral_distance(inp_b:Dict,ref_fp:ReferenceFingerprint,
                               hf_rolloff:float=20000.0) -> float:
    """المسافة الطيفية الحقيقية من المرجع بعد level normalization"""
    ref_b=ref_fp.third_oct
    ceil=min(10000.0,hf_rolloff*0.9)
    common=[fc for fc in inp_b if fc in ref_b and 80<=fc<=ceil]
    if len(common)<4: return 20.0
    out_arr=np.array([inp_b[fc] for fc in common])
    ref_arr=np.array([ref_b[fc] for fc in common])
    loff=float(np.mean(ref_arr-out_arr))
    shape_diffs=np.abs((ref_arr-out_arr)-loff)
    aw=np.array([max(0.2,1+A_WEIGHT.get(fc,0)/10) for fc in common])
    return float(np.sum(aw*shape_diffs)/np.sum(aw))

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1d — CODEC DAMAGE FINGERPRINT (Per-Band SNR)
# ══════════════════════════════════════════════════════════════════════════════

def compute_band_snr(audio:'np.ndarray',sr:int=SR) -> Dict[float,float]:
    """SNR لكل Bark band — يُحدد أين تحتاج NR"""
    N=len(audio); spec=np.abs(rfft(audio))**2; freqs=rfftfreq(N,1.0/sr)
    band_snr={}
    for fc in [125,250,500,1000,2000,4000,8000]:
        fl=fc*0.7; fh=fc*1.4
        mask=(freqs>=fl)&(freqs<fh)
        if mask.sum()<4: continue
        s=spec[mask]
        snr=float(10*np.log10(np.percentile(s,85)/(np.percentile(s,5)+1e-30)+1e-10))
        band_snr[float(fc)]=snr
    return band_snr

# ══════════════════════════════════════════════════════════════════════════════
#  MULTI-METRIC DAMAGE SCORE (MDS)
# ══════════════════════════════════════════════════════════════════════════════

# ══════════════════════════════════════════════════════════════════════════════
#  v8.5 — TIER-ADJUSTED SCORING (TierAdjustedScoring)
#  Per-tier MDS weights for compute_mds() and achievable target dicts
#  for quality_score().  Replaces the ad-hoc 64K_FLOOR hack.
# ══════════════════════════════════════════════════════════════════════════════

# TIER_DAMAGED: HF is irrelevant (codec wiped it); SNR/SFM dominate.
# TIER_PRISTINE: balanced, as before v8.5.
_V85_MDS_WEIGHTS: Dict[str, Dict[str, float]] = {
    'TIER_PRISTINE':   {'snr': 0.25, 'sfm': 0.25, 'spec': 0.20,
                        'hf':  0.15, 'dr':  0.10, 'br':   0.05},
    'TIER_COMPRESSED': {'snr': 0.30, 'sfm': 0.25, 'spec': 0.18,
                        'hf':  0.07, 'dr':  0.12, 'br':   0.08},
    'TIER_DEGRADED':   {'snr': 0.35, 'sfm': 0.28, 'spec': 0.15,
                        'hf':  0.02, 'dr':  0.12, 'br':   0.08},
    'TIER_DAMAGED':    {'snr': 0.40, 'sfm': 0.30, 'spec': 0.10,
                        'hf':  0.00, 'dr':  0.12, 'br':   0.08},
}


def _compute_achievable_targets(tier: str, input_cutoff_hz: float) -> Dict:
    """
    Per-tier achievable target dict.

    TIER_PRISTINE:   full 1425H targets unchanged.
    TIER_COMPRESSED: Crest ceiling 9.8LU, LRA 4.0LU (64kbps+ codec AGC).
    TIER_DEGRADED:   Crest linear from 7.5 to 9.0 LU based on measured
                     codec cutoff.  LUFS -6.5 (noisy floor lifts noise).
    TIER_DAMAGED:    Crest 7.0LU, LRA 3.2LU, LUFS -7.0 (severe damage).

    PHYSICS JUSTIFICATION (Crest ceiling):
      A 64kbps MP3 codec applies AGC and quantization noise that floors
      the noise floor by ~15dBFS relative to peaks.  The measurable effect
      is Crest depression: a source with Crest=12LU will emerge from 64kbps
      encode at ~9.0-9.5LU.  Scoring the output against a 10.25LU target
      penalises the engine for a physical limit, not a processing error.
    """
    if tier == 'TIER_PRISTINE':
        return dict(TARGET)
    if tier == 'TIER_COMPRESSED':
        return {**TARGET, 'crest': 9.8, 'lra': 4.0}
    if tier == 'TIER_DEGRADED':
        # Linear: 7.5LU at cutoff=0Hz → 9.0LU at cutoff=10500Hz
        crest_ceil = float(np.clip(7.5 + (input_cutoff_hz / 10500.0) * 1.5, 7.5, 9.0))
        return {**TARGET, 'crest': crest_ceil, 'lra': 3.6, 'lufs': -6.5}
    # TIER_DAMAGED
    return {**TARGET, 'crest': 7.0, 'lra': 3.2, 'lufs': -7.0}


def compute_mds(snr:float,sfm:float,dr:float,hf_deficit:float,
                spectral_dist:float,src_br:int,
                ref_sfm:float=TARGET['sfm'],
                ref_dr:float=TARGET['dr'],
                source_tier:str='TIER_PRISTINE') -> float:
    """
    Multi-Metric Damage Score: 0=مثالي | 100=أسوأ حالة
    أوزان: SNR 25% | SFM 25% | Spectral Distance 20% | HF 15% | DR 10% | BR 5%
    """
    snr_score  =float(np.clip((30.0-snr)/30.0,0,1))*100
    sfm_ratio  =sfm/(ref_sfm+1e-6)
    sfm_score  =float(np.clip((sfm_ratio-1.0)/5.0,0,1))*100
    spec_score =float(np.clip(spectral_dist/15.0,0,1))*100
    hf_score   =float(np.clip(hf_deficit/30.0,0,1))*100
    dr_excess  =max(0.0,dr-ref_dr)
    dr_score   =float(np.clip(dr_excess/8.0,0,1))*100
    br_score   =float(np.clip((128000-src_br)/100000,0,1))*100
    # v8.5: tier-specific weights — TIER_DAMAGED weights SNR/SFM heavily, HF=0
    w = _V85_MDS_WEIGHTS.get(source_tier, _V85_MDS_WEIGHTS['TIER_PRISTINE'])
    mds = (snr_score * w['snr'] + sfm_score * w['sfm'] + spec_score * w['spec'] +
           hf_score  * w['hf']  + dr_score  * w['dr']  + br_score   * w['br'])
    return float(np.clip(mds, 0, 100))

def mds_to_label(mds:float) -> str:
    if mds>=75: return 'EXTREME'
    if mds>=55: return 'VERY_POOR'
    if mds>=35: return 'POOR'
    if mds>=18: return 'FAIR'
    return 'GOOD'

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2a — SFM-ADAPTIVE NR
# ══════════════════════════════════════════════════════════════════════════════

def build_nr_sfm(damage:DamageProfile) -> List[str]:
    """NR intensity = f(SFM ratio) — محافَظ عليه من v7.6"""
    parts:List[str]=[]
    if damage.src_br < 96000 and damage.band_snr.get(1000.0,20) < 8:
        if damage.has_ringing and damage.rolloff_hz < 17000:
            parts.append(f'lowpass=f={int(damage.rolloff_hz*0.97)}:poles=2')
        return parts
    sfm_ratio=damage.sfm/(TARGET['sfm']+1e-6)
    if sfm_ratio >= 5.0:
        parts.append('afftdn=nr=20:nf=-55:tn=1')
        parts.append('afftdn=nr=6:nf=-65:tn=1')
    elif sfm_ratio >= 3.0:
        nr=int(np.interp(sfm_ratio,[3,5],[12,20]))
        parts.append(f'afftdn=nr={nr}:nf=-58:tn=1')
    elif sfm_ratio >= 2.0:
        nr=int(np.interp(sfm_ratio,[2,3],[6,12]))
        parts.append(f'afftdn=nr={nr}:nf=-62:tn=1')
    elif sfm_ratio >= 1.5:
        parts.append('afftdn=nr=4:nf=-68:tn=1')
    if damage.has_ringing and damage.rolloff_hz < 17000:
        parts.append(f'lowpass=f={int(damage.rolloff_hz*0.97)}:poles=2')
    return parts

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2b — v8 BUG #4 FIX — DR-CALIBRATED COMPAND (LRA delta صحيح)
# ══════════════════════════════════════════════════════════════════════════════

def build_compand_mds(damage:DamageProfile,
                      ref_fp:ReferenceFingerprint,
                      inp_lra:float) -> Tuple[str,float,str,float]:
    """
    v8 FIX #4: compand selection باستخدام LRA الفعلي بدل DR
    v7.6 كان: lra_delta = damage.dr - TARGET['dr']  ← خطأ نوع!
    v8:       lra_delta = inp_lra - ref_fp.lra_clip  ← صحيح
    """
    crest_delta = damage.crest - TARGET['crest']
    # v8 FIX: LRA excess الحقيقي مقارنة بالـ clip reference
    lra_delta   = max(0.0, inp_lra - ref_fp.lra_clip)
    # MDS contribution — مقلّص من 3.0 إلى 2.0 لتجنب overweighting
    mds_contrib = damage.mds / 100.0 * 2.0

    score = crest_delta * 0.72 + lra_delta * 0.20 + mds_contrib

    if score >= 11:
        return ("-90/-68|-45/-20|-28/-9|-14/-4.5|-7/-2.0|-3/-0.6|0/-0.1",
                2.5,'EXTREME',2.0)
    elif score >= 6.5:
        return ("-90/-72|-42/-21|-26/-10.5|-13/-5.2|-6/-2.4|-2.5/-0.8|-0.5/-0.3|0/-0.1",
                3.2,'HEAVY',1.8)
    elif score >= 3.5:
        return ("-90/-78|-40/-25|-22/-12.5|-12/-6.8|-6/-3.5|-2.5/-1.6|-0.8/-0.5|0/-0.2",
                2.5,'MEDIUM',1.4)
    elif score >= 1.5:
        return ("-90/-85|-40/-36|-20/-17|-10/-8.2|-5/-4.1|-2/-1.6|-0.5/-0.4|0/-0.3",
                1.2,'LIGHT',0.9)
    elif score >= 0.5:
        return ("-90/-89|-40/-39|-20/-19.5|-10/-9.8|-4/-3.9|-1/-0.95|0/-0.3",
                0.4,'MINIMAL',0.4)
    else:
        return ("-90/-90|-20/-20|-3/-3|0/0",0.0,'BYPASS',0.0)

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2c — v8 BUG #1 FIX — CORRECTED SPECTRAL BIAS
# ══════════════════════════════════════════════════════════════════════════════

def build_bias_filter(hf_rolloff:float=20000.0,
                      bias_cutoff_hz:float=20000.0) -> str:
    """
    v8 FIX #1: SPECTRAL_BIAS_V8 باتفاقية صحيحة موحدة
    الصيغة: g = -bias * BIAS_SCALE
    bias سالب → g موجب (boost) | bias موجب → g سالب (cut)

    v8.4:  bias_cutoff_hz از SourceTierProfile (tier codec ceiling)
    v8.45: ref_codec_cutoff_hz من DeepReferenceModel (ref file ceiling)
      فلا نُعزز تردداً لا يحتوي المرجع نفسه على محتوى حقيقي فيه.
      (FORENSIC: الـ 320kbps refs عندها cutoff ≈14kHz وليس 20kHz)
    """
    effective_boost_ceil = min(hf_rolloff * 0.9, bias_cutoff_hz)
    parts=[]
    for fc,bias_db in SPECTRAL_BIAS_V8.items():
        g=round(-bias_db * BIAS_SCALE, 2)
        if abs(g) < 0.20: continue
        if g > 0 and fc > effective_boost_ceil: continue  # v8.4: لا boost فوق سقف الكودك
        if fc > hf_rolloff * 0.9: continue                # v8.2: حد hf_rolloff للـ cut
        Q=0.65 if abs(g)>1.5 else 0.90
        parts.append(f'equalizer=f={fc}:width_type=q:width={Q}:g={g}')
    return ','.join(parts)

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2d — SPECTRAL DISTANCE EQ (Perceptual Optimizer)
# ══════════════════════════════════════════════════════════════════════════════

def optimize_eq(new_b:Dict,ref_fp:ReferenceFingerprint,
                n_nodes:int=12,max_db:float=6.0,
                shape_only:bool=False,hf_rolloff:float=20000.0) -> List[Tuple]:
    """scipy optimizer — يُصحح المسافة الطيفية الحقيقية | محافَظ عليه من v7.6"""
    ref_b=ref_fp.third_oct
    ceil=min(12000.0,hf_rolloff*0.92)
    common=sorted([fc for fc in new_b if fc in ref_b and 63<=fc<=ceil])
    if len(common)<4: return []

    fc_arr=np.array(common,dtype=float)
    new_arr=np.array([new_b[fc] for fc in common])
    ref_arr=np.array([ref_b[fc] for fc in common])
    loff=float(np.mean(ref_arr-new_arr))
    target=(ref_arr-new_arr)-loff
    if shape_only: target=target-float(np.mean(target))

    def baw(fc:float) -> float:
        bw=2.0 if 500<=fc<=4000 else 1.6 if 200<=fc<500 else 1.4 if 4000<fc<=8000 else 0.9
        return bw*max(0.3,1+A_WEIGHT.get(fc,0)/10)
    aw=np.array([baw(fc) for fc in common])
    init_f=np.logspace(np.log10(63),np.log10(ceil),n_nodes)

    def resp(fa,p):
        r=np.zeros(len(fa))
        for i in range(n_nodes):
            f0=abs(p[i*3])+1e-6; g=p[i*3+1]; Q=max(0.3,abs(p[i*3+2]))
            rat=fa/f0; r+=g/(1+Q**2*(rat-1.0/(rat+1e-9))**2)
        return r

    def obj(p):
        e=np.mean(aw*(resp(fc_arr,p)-target)**2)
        gs=[p[i*3+1] for i in range(n_nodes)]
        sm=sum(0.012*(gs[i+1]-gs[i])**2 for i in range(len(gs)-1))
        mg=sum(0.002*g**2 for g in gs)
        return e+sm+mg

    ig=np.interp(np.log10(init_f),np.log10(fc_arr),target)
    x0=[]
    for f,g in zip(init_f,ig):
        x0.extend([float(np.clip(f,63,ceil)),float(np.clip(g,-max_db,max_db)),1.0])

    res=minimize(obj,x0,method='L-BFGS-B',
                 bounds=[(63,ceil),(-max_db,max_db),(0.3,4.5)]*n_nodes,
                 options={'maxiter':500,'ftol':1e-10,'gtol':1e-9})
    nodes=[]
    for i in range(n_nodes):
        f0=abs(res.x[i*3]); g=res.x[i*3+1]; Q=max(0.3,abs(res.x[i*3+2]))
        if shape_only and g<0 and 400<=f0<=1600: g=max(g,-2.0)
        if abs(g)>=0.35: nodes.append((round(f0,0),round(g,2),round(Q,2)))
    return sorted(nodes,key=lambda x:x[0])

# ══════════════════════════════════════════════════════════════════════════════
#  WARMTH CORRECTION (Crest-Aware — محافَظ عليه من v7.55/v7.6)
# ══════════════════════════════════════════════════════════════════════════════

def build_warmth_nodes(inp_b:Dict,ref_fp:ReferenceFingerprint,
                       hf_rolloff:float=20000.0,post_compand:bool=False,
                       current_crest:float=99.0) -> List[Tuple]:
    tfc=np.array([fc for fc in CENTERS_31 if 200<=fc<=2000
                   and fc in inp_b and fc<hf_rolloff],dtype=float)
    if len(tfc)<3: return []
    tdb=np.array([inp_b[fc] for fc in tfc])
    new_tilt=float(np.polyfit(np.log2(tfc/1000.0),tdb,1)[0])
    tilt_diff=ref_fp.warmth_ratio-new_tilt
    threshold=1.5 if not post_compand else 2.5
    if abs(tilt_diff)<threshold: return []

    # حارس Crest (من v7.55 — محافَظ عليه)
    if current_crest-TARGET['crest']<-1.0: return []

    max_adj=min(3.0,2.0+(current_crest-TARGET['crest'])*0.5) if not post_compand else 1.2
    scale=0.35 if not post_compand else 0.20
    nodes=[]
    adj=float(np.clip(tilt_diff*scale,-max_adj,max_adj))
    if abs(adj)>=0.4: nodes.append((200.0,round(adj,2),0.55))
    madj=float(np.clip(-tilt_diff*0.12,-1.5,1.5))
    if abs(madj)>=0.3: nodes.append((1000.0,round(madj,2),0.80))
    return nodes

# ══════════════════════════════════════════════════════════════════════════════
#  SPECTRAL CORRECTION (Conservative — محافَظ عليه من v7.6)
# ══════════════════════════════════════════════════════════════════════════════

def spectral_correction(out_b:Dict,ref_fp:ReferenceFingerprint,
                        hf_rolloff:float=20000.0,max_db:float=3.0,
                        pass_num:int=2,current_crest:float=99.0) -> List[Tuple]:
    ref_b=ref_fp.third_oct
    ceil=min(10000.0,hf_rolloff*0.9)
    common=sorted([fc for fc in out_b if fc in ref_b and 80<=fc<=ceil])
    if len(common)<4: return []

    out_arr=np.array([out_b[fc] for fc in common])
    ref_arr=np.array([ref_b[fc] for fc in common])
    loff=float(np.mean(ref_arr-out_arr))
    shape=(ref_arr-out_arr)-loff
    avg_err=float(np.mean(np.abs(shape)))

    base=0.58 if avg_err>4.0 else 0.48 if avg_err>2.0 else 0.35
    pm={2:1.00,3:0.70,4:0.45}.get(pass_num,1.00)
    scale=base*pm

    aw=np.array([max(0.3,1+A_WEIGHT.get(fc,0)/10) for fc in common])

    tfc=np.array([fc for fc in common if 200<=fc<=2000],dtype=float)
    warmth_ok=False
    if len(tfc)>=3:
        tdb=np.array([out_b[fc] for fc in tfc])
        out_tw=float(np.polyfit(np.log2(tfc/1000.0),tdb,1)[0])
        warmth_ok=abs(out_tw-ref_fp.warmth_ratio)<3.0

    crest_headroom=current_crest-TARGET['crest']

    nodes:List[Tuple]=[]; prev_g=0.0
    for i,fc in enumerate(common):
        raw_g=float(shape[i])
        g=float(np.clip(raw_g*aw[i]*scale,-max_db,max_db))
        if warmth_ok and 400<=fc<=1600 and g<-0.3 and abs(raw_g)<4.0:
            g=max(g*0.08,-0.20)
        if crest_headroom<-1.5 and fc<=400 and g>0:
            g=g*0.20
        if abs(g)>=0.28 and abs(g-prev_g)<5.0:
            Q=1.2 if abs(g)<2 else 0.85
            nodes.append((float(fc),round(g,2),Q))
        prev_g=g
    return nodes

# ══════════════════════════════════════════════════════════════════════════════
#  QUALITY SCORE — v8.5 TIER-ADJUSTED SCORING
#  score_tier:     vs achievable targets for source tier (displayed to user)
#  score_absolute: vs original 1425H targets always (honest reference)
# ══════════════════════════════════════════════════════════════════════════════

def quality_score(out_b:Dict,ref_fp:ReferenceFingerprint,
                  metrics:Dict,hf_rolloff:float=20000.0,
                  source_tier:str='TIER_PRISTINE',
                  input_cutoff_hz:float=20000.0) -> Tuple[float,QualityReport]:
    ref_b=ref_fp.third_oct
    ceil=min(10000,int(hf_rolloff*0.85))
    common=[fc for fc in out_b if fc in ref_b and 80<=fc<=ceil]

    if common:
        out_v=np.array([out_b[fc] for fc in common])
        ref_v=np.array([ref_b[fc] for fc in common])
        aw=np.array([max(0.2,1+A_WEIGHT.get(fc,0)/10) for fc in common])
        loff=float(np.mean(ref_v-out_v))
        diffs=np.abs((ref_v-out_v)-loff)
        w_avg=float(np.sum(aw*diffs)/np.sum(aw))
        spectral_s=max(0.0,100.0-w_avg*4.5)
    else:
        w_avg=99.0; spectral_s=0.0

    lra_t = ref_fp.lra  # 4.19 (صحيح منذ v7.6)

    tfc = np.array([fc for fc in CENTERS_31 if 200 <= fc <= 2000
                    and fc in out_b and fc < hf_rolloff], dtype=float)
    out_tilt = (float(np.polyfit(np.log2(tfc / 1000.0),
                                 np.array([out_b[fc] for fc in tfc]), 1)[0])
                if len(tfc) >= 3 else 0.0)
    warmth_s = max(0.0, 100.0 - abs(out_tilt - ref_fp.warmth_ratio) * 5.5)

    hf_fcs = [fc for fc in [4000, 5000, 6300, 8000, 10000, 12500]
              if fc < hf_rolloff and fc in out_b and fc in ref_b]
    if len(hf_fcs) >= 3:
        hf_o = np.array([out_b[fc] for fc in hf_fcs])
        hf_r = np.array([ref_b[fc] for fc in hf_fcs])
        hf_e = float(np.mean(np.abs((hf_r - hf_o) - float(np.mean(hf_r - hf_o)))))
        hf_s = max(0.0, 100.0 - hf_e * 4)
    else:
        hf_s = 50.0

    lufs_val  = metrics.get('lufs',  -20)
    crest_val = metrics.get('crest',  15)
    lra_val   = metrics.get('lra',     8)

    # ── score_absolute: vs original 1425H targets — never changes ─────────────────
    lufs_s_a  = max(0.0, 100.0 - abs(lufs_val  - TARGET['lufs'])  * 12)
    crest_s_a = max(0.0, 100.0 - abs(crest_val - TARGET['crest']) *  8)
    lra_s_a   = max(0.0, 100.0 - abs(lra_val   - lra_t)           * 10)
    score_absolute = round(
        spectral_s * 0.38 + lufs_s_a * 0.20 + crest_s_a * 0.15 +
        lra_s_a    * 0.12 + warmth_s * 0.10 + hf_s      * 0.05, 1)

    # ── score_tier: vs achievable targets for this source tier ────────────────
    # v8.5 TierAdjustedScoring: replaces ad-hoc 64K_FLOOR hack.
    # A 64kbps file that reaches its physical ceiling is not a processing failure.
    at = _compute_achievable_targets(source_tier, input_cutoff_hz)
    lufs_s_t  = max(0.0, 100.0 - abs(lufs_val  - at['lufs'])  * 12)
    crest_s_t = max(0.0, 100.0 - abs(crest_val - at['crest']) *  8)
    lra_s_t   = max(0.0, 100.0 - abs(lra_val   - at['lra'])   * 10)
    score_tier = round(
        spectral_s * 0.38 + lufs_s_t * 0.20 + crest_s_t * 0.15 +
        lra_s_t    * 0.12 + warmth_s * 0.10 + hf_s      * 0.05, 1)

    # ── ceiling_reason — logged when tier relaxes targets ──────────────────────
    ceiling_reason = ''
    if source_tier != 'TIER_PRISTINE':
        ceiling_reason = (
            f"{source_tier}: Crest≤{at['crest']:.2f}LU  "
            f"LRA≤{at['lra']:.2f}LU  LUFS≥{at['lufs']:.2f}  "
            f"[cutoff={input_cutoff_hz:.0f}Hz]"
        )

    notes = []
    if abs(lufs_val - TARGET['lufs']) > 0.6:
        notes.append(f"LUFS:{lufs_val:.2f}→{TARGET['lufs']}")
    if abs(crest_val - at['crest']) > 1.2:
        notes.append(f"Crest:{crest_val:.2f}→{at['crest']:.2f}")
    if abs(lra_val - at['lra']) > 1.0:
        notes.append(f"LRA:{lra_val:.2f}→{at['lra']:.2f}")
    if w_avg > 2.5:
        notes.append(f"Spectral:±{w_avg:.2f}dB")

    rpt = QualityReport(
        score          = score_tier,
        spectral       = round(spectral_s, 1),
        lufs           = round(lufs_s_a, 1),
        crest          = round(crest_s_a, 1),
        lra            = round(lra_s_a, 1),
        warmth         = round(warmth_s, 1),
        hf             = round(hf_s, 1),
        avg_err        = round(w_avg, 2),
        warmth_tilt    = round(out_tilt, 2),
        warmth_ref     = round(ref_fp.warmth_ratio, 2),
        lra_target     = round(lra_t, 2),
        notes          = notes,
        score_absolute = score_absolute,
        score_tier     = score_tier,
        ceiling_reason = ceiling_reason,
    )
    return rpt.score, rpt

# ══════════════════════════════════════════════════════════════════════════════
#  9-SEGMENT FULL-FILE SPECTRAL AVERAGE
# ══════════════════════════════════════════════════════════════════════════════

def analyze_full_spectrum(input_path:str,total_s:int) -> Dict[float,float]:
    pcts=[0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90]
    skips=[max(10,int(total_s*p)) for p in pcts]
    clips=[os.path.join(_TMP, f'v81_seg{i}.wav') for i in range(len(skips))]
    procs=[subprocess.Popen(['ffmpeg','-y','-i',input_path,
            '-ss',str(sk),'-t','20','-f','s16le','-ac','1',
            '-ar',str(SR),cl,'-loglevel','error'])
           for sk,cl in zip(skips,clips)]
    for p in procs: p.wait()
    all_bands:List[Dict]=[]
    for cl in clips:
        try:
            if not os.path.exists(cl) or os.path.getsize(cl)<SR*2: continue
            a=np.frombuffer(open(cl,'rb').read(),np.int16).astype(np.float32)/32768.0
            if len(a)<SR*3: continue
            all_bands.append(third_octave(a,a_weighted=False))
        except: pass
    if not all_bands: return {}
    result={}
    for fc in CENTERS_31:
        vals=[b.get(fc) for b in all_bands if b.get(fc) is not None]
        if len(vals)>=2: result[fc]=float(np.median(vals))
    return result

# ══════════════════════════════════════════════════════════════════════════════
#  REFERENCE FINGERPRINT
# ══════════════════════════════════════════════════════════════════════════════

# ══════════════════════════════════════════════════════════════════════════════
#  v8.45 — DEEP REFERENCE MODEL HELPERS
# ══════════════════════════════════════════════════════════════════════════════

def _phrase_lra_dist(audio: 'np.ndarray', sr: int = SR,
                     min_phrase_s: float = 1.0) -> 'Tuple[float,float,float,int]':
    """
    Phrase-level LRA distribution for dense Quran recitation.
    Uses energy-dip detection (works for continuous recitation with short breath pauses).
    Returns (p10, p50, p90, n_phrases).  Bypass: returns (0,0,0,0) if audio too short.
    """
    if len(audio) < sr * 10:
        return 0.0, 0.0, 0.0, 0
    frame = int(0.01 * sr)
    hop   = int(0.005 * sr)
    # Short-time RMS energy in dBFS
    energies = np.array([
        rms_db(audio[i:i+frame])
        for i in range(0, len(audio) - frame, hop)
    ], dtype=np.float32)
    # 50ms smoothing
    k = max(1, int(0.05 / 0.005))
    smooth = np.convolve(energies, np.ones(k)/k, mode='same')
    # Running max in 2s window
    win2 = int(2.0 / 0.005)
    run_max = np.array([
        np.max(smooth[max(0, i-win2):i+win2])
        for i in range(len(smooth))
    ])
    # Dip = energy 3dB below local max
    is_dip = smooth < (run_max - 3.0)
    # Collect phrase boundaries
    gap_frames = int(0.25 / 0.005)
    min_frames = int(min_phrase_s / 0.005)
    phrases: List['np.ndarray'] = []
    in_ph = False; start = 0; gap = 0
    for i, dip in enumerate(is_dip):
        if not dip:
            if not in_ph:
                start = i
            in_ph = True
            gap = 0
        else:
            if in_ph:
                gap += 1
                if gap > gap_frames:
                    dur = i - gap - start
                    if dur > min_frames:
                        s_samp = start * hop
                        e_samp = (i - gap) * hop
                        if e_samp > s_samp + sr:
                            phrases.append(audio[s_samp:e_samp])
                    in_ph = False
                    gap = 0
    if in_ph:
        phrases.append(audio[start*hop:])
    lras = [lra_estimate(ph) for ph in phrases if len(ph) > sr * 0.5]
    if len(lras) < 3:
        return 0.0, 0.0, 0.0, 0
    return (round(float(np.percentile(lras, 10)), 2),
            round(float(np.percentile(lras, 50)), 2),
            round(float(np.percentile(lras, 90)), 2),
            len(lras))


def _ref_silence_floor(audio: 'np.ndarray', sr: int = SR) -> float:
    """
    Noise floor of the reference recording measured from silent frames.
    Sets the NR ceiling: never push noise below (silence_floor_db - 3dB).
    Returns dBFS float.  Bypass: -70.0 if no silence frames found.
    """
    frame = int(0.025 * sr)
    hop   = int(0.010 * sr)
    overall_rms = rms_db(audio)
    threshold   = overall_rms - 20.0   # 20dB below voiced level
    floors = [
        rms_db(audio[i:i+frame])
        for i in range(0, len(audio) - frame, hop)
        if rms_db(audio[i:i+frame]) < threshold
    ]
    if len(floors) < 20:
        return -70.0
    # Use p50 of silence frames (robust against burst noise)
    return float(np.percentile(floors, 50))


def _ref_codec_cutoff(audio: 'np.ndarray', sr: int = SR) -> float:
    """
    Detects the highest frequency with genuine content in the reference file.
    Used to prevent BIAS boosts targeting frequencies the ref itself doesn't contain.
    Returns Hz float.
    """
    n_fft = min(131072, len(audio))
    if n_fft < sr:
        return 14000.0
    wins = []
    for i in range(0, len(audio) - n_fft, n_fft * 2):
        seg = audio[i:i+n_fft].astype(np.float64)
        wins.append(np.abs(rfft(seg * np.hanning(n_fft)))**2)
    if not wins:
        return 14000.0
    X = np.mean(wins, axis=0)
    freqs = rfftfreq(n_fft, 1.0/sr)
    # Reference level: RMS energy at 1-2kHz
    mask_1k = (freqs >= 1000) & (freqs < 2000)
    if not mask_1k.any():
        return 14000.0
    ref_db = 10 * np.log10(np.mean(X[mask_1k]) + 1e-30)
    # Scan down from 20kHz; first band where energy is within 45dB of 1kHz ref = cutoff
    for fc in [20000, 18000, 17000, 16000, 15000, 14000, 13000, 12000, 11000, 10000, 8000]:
        lo, hi = fc - 500, min(fc + 500, sr // 2 - 1)
        mask = (freqs >= lo) & (freqs < hi)
        if not mask.any():
            continue
        band_db = 10 * np.log10(np.mean(X[mask]) + 1e-30)
        if band_db > ref_db - 45.0:
            return float(fc)
    return 8000.0


def _full_file_third_oct_avg(audio: 'np.ndarray', sr: int = SR,
                              window_s: float = 10.0, hop_s: float = 60.0) -> Dict[float, float]:
    """
    Full-file spectral average using windowed sampling (every hop_s seconds).
    Replaces the 8 fixed-position 30s clip approach.

    FORENSIC JUSTIFICATION: actual measurements showed 40s-clip spectral values
    differed from full-file averages by up to +16dB at 2kHz on Al-Araaf, and
    +12dB at 8kHz on Al-Fatir. The clip was capturing atypical opening material,
    not the Sheikh's settled recitation.
    """
    win   = int(window_s * sr)
    hop   = int(hop_s   * sr)
    overall_rms = rms_db(audio)
    silence_thr = overall_rms - 25.0   # skip near-silence windows
    spectra: List[Dict[float, float]] = []
    for start in range(0, len(audio) - win, hop):
        seg = audio[start:start+win]
        if rms_db(seg) > silence_thr:
            spectra.append(third_octave(seg.astype(np.float32)))
    if not spectra:
        return third_octave(audio[:win].astype(np.float32))
    avg: Dict[float, float] = {}
    for fc in spectra[0]:
        vals = [s[fc] for s in spectra if fc in s]
        if vals:
            avg[fc] = float(np.mean(vals))
    return avg


def _peak_distribution_type(audio: 'np.ndarray', sr: int = SR) -> str:
    """
    Classifies whether energy peaks occur at phrase attacks (front_loaded),
    uniformly throughout phrases, or at the end (back_loaded).
    Used to shape compand attack time in Pass 3.
    """
    frame = int(0.02 * sr)
    hop   = int(0.01 * sr)
    energies = np.array([
        rms_db(audio[i:i+frame])
        for i in range(0, len(audio) - frame, hop)
    ], dtype=np.float32)
    threshold = float(np.percentile(energies[energies > -60], 30)) - 3 if np.any(energies > -60) else -40.0
    is_voiced = energies > threshold
    gap_frames  = int(0.3 / 0.01)
    min_frames  = int(0.8 / 0.01)
    ratios: List[float] = []
    in_ph = False; start = 0; gap = 0
    for i, v in enumerate(is_voiced):
        if v:
            if not in_ph:
                start = i
            in_ph = True
            gap = 0
        else:
            if in_ph:
                gap += 1
                if gap > gap_frames:
                    dur = i - gap - start
                    if dur > min_frames:
                        ph = energies[start:i - gap]
                        attack = ph[:max(1, int(len(ph) * 0.12))]
                        if len(attack) and len(ph) > len(attack):
                            ratios.append(float(np.max(attack)) - float(np.max(ph[len(attack):])))
                    in_ph = False
                    gap = 0
    if len(ratios) < 3:
        return 'uniform'
    mean_r = float(np.mean(ratios))
    if mean_r > 1.0:
        return 'front_loaded'
    elif mean_r > -1.5:
        return 'uniform'
    else:
        return 'back_loaded'


def get_reference_fingerprint() -> ReferenceFingerprint:
    # v8.1 PATCH #2: REF_FILES may be empty — guard primary access
    primary = REF_FILES[0] if REF_FILES else ''

    # v8.1 PATCH #1: REF_CACHE is now in Path.home()/.tilawa_cache/
    if os.path.exists(REF_CACHE):
        try:
            mref=os.path.getmtime(primary) if os.path.exists(primary) else 0
            if os.path.getmtime(REF_CACHE)>=mref:
                with open(REF_CACHE,'r',encoding='utf-8') as f: d=json.load(f)
                if d.get('version') in ('v8.1', 'v8.45'):
                    fp = ReferenceFingerprint()
                    fp.third_oct    = {float(k):v for k,v in d['third_oct'].items()}
                    fp.a_weighted   = {float(k):v for k,v in d.get('a_weighted',{}).items()}
                    fp.rms          = d['rms'];  fp.peak = d['peak']
                    fp.crest        = d['crest']
                    fp.lra          = d.get('lra',         TARGET['lra'])
                    fp.lra_clip     = d.get('lra_clip',    2.94)
                    fp.tilt_slope   = d['tilt_slope']
                    fp.warmth_ratio = d['warmth_ratio']
                    fp.sfm          = d.get('sfm',         TARGET['sfm'])
                    fp.dr           = d.get('dr',          TARGET['dr'])
                    fp.n_files      = d.get('n_files',     1)
                    # v8.45 deep fields (graceful fallback if cache is v8.1)
                    fp.phrase_lra_p10      = d.get('phrase_lra_p10',      2.50)
                    fp.phrase_lra_p50      = d.get('phrase_lra_p50',      3.37)
                    fp.phrase_lra_p90      = d.get('phrase_lra_p90',      4.20)
                    fp.silence_floor_db    = d.get('silence_floor_db',    -73.0)
                    fp.ref_codec_cutoff_hz = d.get('ref_codec_cutoff_hz', 14000.0)
                    fp.peak_distribution   = d.get('peak_distribution',   'uniform')
                    return fp
        except: pass

    # ── v8.45: full-file windowed analysis replaces 8×30s fixed clips ──────────
    # FORENSIC: 40s clip differed from full-file by up to +16dB at 2kHz (Al-Araaf),
    # +12dB at 8kHz (Al-Fatir). The clips were capturing atypical opening material.
    all_fp:List[Dict]=[]

    for idx, path in enumerate(REF_FILES):
        if not os.path.exists(path):
            continue
        try:
            # Load the full reference file as float32 mono at SR
            tmp_full = os.path.join(_TMP, f'v845_ref_full_{idx}.wav')
            subprocess.run(
                ['ffmpeg', '-y', '-i', path,
                 '-ac', '1', '-ar', str(SR), tmp_full, '-loglevel', 'error'],
                capture_output=True)
            if not os.path.exists(tmp_full) or os.path.getsize(tmp_full) < SR * 4:
                continue
            full_a = np.frombuffer(open(tmp_full,'rb').read()[44:],
                                   np.int16).astype(np.float32) / 32768.0
            if len(full_a) < SR * 10:
                continue

            # Full-file spectral average (v8.45 core improvement)
            spec_full = _full_file_third_oct_avg(full_a, SR)

            # Basic metrics from the full file
            all_fp.append({
                'spec':      spec_full,
                'rms':       float(rms_db(full_a)),
                'crest':     float(crest_factor(full_a)),
                'lra_full':  float(lra_estimate(full_a)),
                'lra_clip':  float(lra_estimate(full_a[:SR*30])),  # first 30s for compand compat
                'sfm':       float(compute_sfm(full_a)),
                'dr':        float(compute_dynamic_range(full_a)),
                # v8.45 deep fields
                'phrase_lra':     _phrase_lra_dist(full_a, SR),
                'silence_floor':  _ref_silence_floor(full_a, SR),
                'codec_cutoff':   _ref_codec_cutoff(full_a, SR),
                'peak_dist':      _peak_distribution_type(full_a, SR),
            })
            try: os.unlink(tmp_full)
            except: pass
        except Exception:
            continue

    if len(all_fp) < 2:
        fp = _build_single_ref(primary) if os.path.exists(primary) else ReferenceFingerprint()
        fp.n_files = len(all_fp) or 1
        return fp

    # ── Multi-ref averaging ───────────────────────────────────────────────────
    ref_lvl     = float(np.mean([f['rms'] for f in all_fp]))
    common_all  = [fc for fc in CENTERS_31 if all(fc in f['spec'] for f in all_fp)]
    normed      = [{fc: f['spec'][fc] + (ref_lvl - f['rms']) for fc in common_all}
                   for f in all_fp]
    multi       = {fc: float(np.median([s[fc] for s in normed])) for fc in common_all}

    fp = ReferenceFingerprint()
    fp.third_oct    = multi
    fp.rms          = float(np.median([f['rms']       for f in all_fp]))
    fp.peak         = TARGET['true_peak']
    fp.crest        = float(np.median([f['crest']     for f in all_fp]))
    fp.lra_clip     = float(np.median([f['lra_clip']  for f in all_fp]))
    fp.lra          = float(np.median([f['lra_full']  for f in all_fp]))  # v8.45: real full-file LRA
    fp.sfm          = float(np.median([f['sfm']       for f in all_fp]))
    fp.dr           = float(np.median([f['dr']        for f in all_fp]))
    fp.n_files      = len(all_fp)
    fp.tilt_slope   = spectral_tilt(fp.third_oct)
    fp.warmth_ratio = warmth_tilt(fp.third_oct)

    # ── v8.45 deep reference fields ───────────────────────────────────────────
    # phrase LRA: p50 is the Pass 3 compand target
    all_p50 = [f['phrase_lra'][1] for f in all_fp if f['phrase_lra'][2] > 0]
    all_p10 = [f['phrase_lra'][0] for f in all_fp if f['phrase_lra'][2] > 0]
    all_p90 = [f['phrase_lra'][2] for f in all_fp if f['phrase_lra'][2] > 0]
    if all_p50:
        fp.phrase_lra_p50 = float(np.median(all_p50))
        fp.phrase_lra_p10 = float(np.median(all_p10))
        fp.phrase_lra_p90 = float(np.median(all_p90))
    # silence floor: use the highest (least quiet) floor across refs as the
    # safe NR ceiling — conservative choice prevents over-denoising
    floors = [f['silence_floor'] for f in all_fp if f['silence_floor'] < -20]
    fp.silence_floor_db = float(max(floors)) if floors else -70.0
    # codec cutoff: use minimum across refs — don't target HF that some refs lack
    cutoffs = [f['codec_cutoff'] for f in all_fp]
    fp.ref_codec_cutoff_hz = float(min(cutoffs))
    # peak distribution: majority vote
    from collections import Counter
    peak_votes = Counter(f['peak_dist'] for f in all_fp)
    fp.peak_distribution = peak_votes.most_common(1)[0][0]

    # Warn if any ref has suspect cutoff (may have been re-encoded from low bitrate)
    for i, f in enumerate(all_fp):
        if f['codec_cutoff'] < 12000:
            print(f"  [v8.45] ⚠ REF_WARN: ref[{i}] codec_cutoff={f['codec_cutoff']:.0f}Hz "
                  f"-- may be re-encoded from low bitrate")

    try:
        p_info = probe(primary)
        ts = int(float(p_info.get('format', {}).get('duration', 300)))
        pa = load_audio(primary, skip=int(ts * 0.35), duration=60)
        fp.a_weighted = third_octave(pa, a_weighted=True)
    except:
        pass

    # ── Cache write: v8.45 format ─────────────────────────────────────────────
    try:
        Path(REF_CACHE).parent.mkdir(parents=True, exist_ok=True)
        d = {
            'version':          'v8.45',
            'third_oct':        {str(k): v for k, v in fp.third_oct.items()},
            'a_weighted':       {str(k): v for k, v in fp.a_weighted.items()},
            'rms':              fp.rms,
            'peak':             fp.peak,
            'crest':            fp.crest,
            'lra':              fp.lra,
            'lra_clip':         fp.lra_clip,
            'tilt_slope':       fp.tilt_slope,
            'warmth_ratio':     fp.warmth_ratio,
            'sfm':              fp.sfm,
            'dr':               fp.dr,
            'n_files':          fp.n_files,
            # v8.45 deep fields
            'phrase_lra_p10':      fp.phrase_lra_p10,
            'phrase_lra_p50':      fp.phrase_lra_p50,
            'phrase_lra_p90':      fp.phrase_lra_p90,
            'silence_floor_db':    fp.silence_floor_db,
            'ref_codec_cutoff_hz': fp.ref_codec_cutoff_hz,
            'peak_distribution':   fp.peak_distribution,
        }
        with open(REF_CACHE, 'w', encoding='utf-8') as f:
            json.dump(d, f, ensure_ascii=False, indent=2)
    except Exception:
        pass
    return fp

def _build_single_ref(path:str) -> ReferenceFingerprint:
    p_info=probe(path); total_s=int(float(p_info.get('format',{}).get('duration',300)))
    skips=[max(10,int(total_s*r)) for r in [0.12,0.28,0.44,0.60,0.78]]
    clips=[os.path.join(_TMP, f'v81_ref_s{i}.wav') for i in range(len(skips))]
    procs=[subprocess.Popen(['ffmpeg','-y','-i',path,'-ss',str(sk),'-t','40',
            '-f','s16le','-ac','1','-ar',str(SR),cl,'-loglevel','error'])
           for sk,cl in zip(skips,clips)]
    for p in procs: p.wait()
    segs=[]
    for cl in clips:
        try:
            a=np.frombuffer(open(cl,'rb').read(),np.int16).astype(np.float32)/32768.0
            if len(a)>SR: segs.append(a)
        except: pass
    ref=np.concatenate(segs) if segs else load_audio(path,skip=30,duration=120)
    chunk_n=SR*20; all_b=[]; crests=[]; lras=[]; sfms=[]; drs=[]
    for ci in range(max(1,len(ref)//chunk_n)):
        seg=ref[ci*chunk_n:(ci+1)*chunk_n]
        if len(seg)<SR*3: continue
        all_b.append(third_octave(seg)); crests.append(crest_factor(seg))
        lras.append(lra_estimate(seg)); sfms.append(compute_sfm(seg))
        drs.append(compute_dynamic_range(seg))
    if not all_b: all_b=[third_octave(ref)]
    fp=ReferenceFingerprint()
    for fc in CENTERS_31:
        vals=[b.get(fc) for b in all_b if b.get(fc) is not None]
        if vals: fp.third_oct[fc]=float(np.median(vals))
    fp.rms=rms_db(ref); fp.peak=peak_db(ref)
    fp.crest   =float(np.median(crests)) if crests else crest_factor(ref)
    fp.lra_clip=float(np.median(lras))   if lras   else lra_estimate(ref)
    fp.lra     =TARGET['lra']
    fp.sfm     =float(np.median(sfms))   if sfms   else TARGET['sfm']
    fp.dr      =float(np.median(drs))    if drs    else TARGET['dr']
    fp.tilt_slope=spectral_tilt(fp.third_oct)
    fp.warmth_ratio=warmth_tilt(fp.third_oct)
    fp.n_files=1; return fp

# ══════════════════════════════════════════════════════════════════════════════
#  LUFS SAMPLING
# ══════════════════════════════════════════════════════════════════════════════

def sample_lufs_7pt(input_path:str,total_s:int,n_ch:str,filter_str:str) -> float:
    pts=[max(10,int(total_s*p)) for p in [0.08,0.18,0.32,0.50,0.65,0.78,0.90]]
    for i in range(1,len(pts)):
        if pts[i]-pts[i-1]<30: pts[i]=pts[i-1]+30
    clips=[os.path.join(_TMP, f'v81_lc{i}.wav') for i in range(len(pts))]
    procs=[subprocess.Popen(['ffmpeg','-y','-i',input_path,
            '-ss',str(sk),'-t','22','-ar','48000','-ac',n_ch,
            cl,'-loglevel','error']) for sk,cl in zip(pts,clips)]
    for p in procs: p.wait()
    lp=[subprocess.Popen(['ffmpeg','-y','-i',cl,'-af',
         filter_str+',ebur128=peak=true','-f','null','-','-loglevel','info'],
         stderr=subprocess.PIPE,stdout=subprocess.PIPE) for cl in clips]
    vals:List[float]=[]
    for p in lp:
        _,err=p.communicate()
        for line in err.decode().split('\n'):
            s=line.strip()
            if s.startswith('I:') and 'LUFS' in s and 'LRA' not in s:
                try: vals.append(float(s.split('I:')[1].strip().split()[0])); break
                except: pass
    if not vals: return -12.0
    gw=[0.05,0.12,0.20,0.26,0.20,0.12,0.05][:len(vals)]
    gw=[w/sum(gw) for w in gw]
    return float(np.average(vals,weights=gw))

# ══════════════════════════════════════════════════════════════════════════════
#  FILTER CHAIN BUILDER — v8 BUG #2 + #3 FIX
# ══════════════════════════════════════════════════════════════════════════════

def build_filter_chain(eq_nodes:List[Tuple],compand_pts:str,makeup:float,
                       hf:str,is_mono:bool,gain_db:float,
                       nr_parts:List[str],bias_filter:str,
                       warmth_pre:List[Tuple],intensity:str,
                       inp_lra:float,damage:DamageProfile,
                       hf_rolloff:float,src_sr:int,
                       ref_lra_clip:float,tilt_slope:float,
                       correction_nodes:List[Tuple]=None,
                       post_warmth:List[Tuple]=None) -> str:
    """
    v8 FIX #2: حذف LRA compand من الـ chain — compand رئيسي واحد فقط
    v8 FIX #3: alimiter واحد ناعم (0.9997) في WAV الوسيطة بدل 0.891
    """
    if correction_nodes is None: correction_nodes=[]
    if post_warmth is None:      post_warmth=[]
    parts:List[str]=[]; is_bypass=(intensity=='BYPASS')
    is_extreme=(damage.quality_label=='EXTREME')

    # 1. DC blocking
    parts.append('highpass=f=28:poles=2')

    # 2. NR
    parts.extend(nr_parts)

    # 3. Tilt correction
    if not is_bypass and abs(tilt_slope)>1.0:
        db=min(abs(tilt_slope)*0.35,5.0)
        if tilt_slope>0: parts.append(f'treble=g={db:.1f}:f=8000:width_type=o:width=2')
        else:            parts.append(f'bass=g={db:.1f}:f=150:width_type=o:width=2')

    # 4. Perceptual EQ (scipy Bark + A-weight)
    for f0,g,Q in eq_nodes:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # 5. Warmth pre-compand (Crest-aware)
    for f0,g,Q in warmth_pre:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # 6. HF reconstruction
    if not is_bypass:
        if is_extreme:
            parts.append('crystalizer=i=7')
            if hf_rolloff<8000:
                parts.append(f'treble=g=3.5:f={max(2000,int(hf_rolloff*0.65))}:width_type=o:width=2')
            parts.append('treble=g=3.0:f=7000:width_type=o:width=1.5')
        elif damage.quality_label=='VERY_POOR':
            parts.append('crystalizer=i=6')
            parts.append('treble=g=2.0:f=6000:width_type=o:width=2')
        elif damage.quality_label in ('POOR','GOOD','FAIR'):
            if hf=='weak':   parts.append('crystalizer=i=4')
            elif hf=='absent': parts.append('crystalizer=i=6')

    # 7. Post-NR
    if not is_bypass and nr_parts:
        if is_extreme: parts.append('afftdn=nr=4:nf=-80:tn=0')
        elif damage.quality_label in ('POOR','VERY_POOR'):
            parts.append('afftdn=nr=6:nf=-74:tn=0')
        elif damage.snr<40:
            nr=max(3,min(10,int((40.0-damage.snr)*0.4)))
            parts.append(f'afftdn=nr={nr}:nf=-74:tn=1')

    # ══════════════════════════════════════════════════════════════════
    # v8 FIX #2: LRA CONTROL — agate للـ LRA المنخفض فقط
    #
    # v7.6 كان يضيف compand ثانٍ عندما inp_lra > ref_lra_clip
    # هذا كان يسبب double compression → Crest collapse
    #
    # v8: نحذف LRA compand تماماً
    #   - Low LRA (lra_deficit > 0.5): agate لتوسيع الديناميك فقط
    #   - High LRA (lra_deficit < -0.4): نتركها للـ compand الرئيسي
    #     الرعاية المتبقية تتم في Pass 3 feedback
    # ══════════════════════════════════════════════════════════════════
    lra_deficit=ref_lra_clip-inp_lra
    if not is_bypass and lra_deficit>0.5:
        # LRA منخفض جداً → agate لتوسيع النطاق الديناميكي
        ratio=min(4.0 if is_extreme else 3.5,
                  1.0+lra_deficit*(0.40 if is_extreme else 0.28))
        thr=max(0.010,min(0.045,0.022+lra_deficit*0.004))
        rel=1200 if is_extreme else 800
        parts.append(f'agate=threshold={thr:.3f}:ratio={ratio:.2f}'
                     f':attack=20:release={rel}:makeup=1.0:range=0.06')
    # v8 FIX: لا يوجد elif lra_deficit<-0.4 هنا!
    # LRA مرتفع → Main compand يعالجه | Pass 3 يعالج الباقي

    # 8. Single clean compand (v7.0 proven architecture)
    if not is_bypass:
        atk={'MINIMAL':0.050,'LIGHT':0.030,'MEDIUM':0.015,'HEAVY':0.008,'EXTREME':0.020}
        dcy={'MINIMAL':3.0,  'LIGHT':2.0,  'MEDIUM':1.0,  'HEAVY':0.5,  'EXTREME':0.40}
        parts.append(f'compand=attacks={atk.get(intensity,0.015)}'
                     f':decays={dcy.get(intensity,1.0)}'
                     f':points={compand_pts}:gain={makeup}')

    # 9. Post-compand warmth (Crest-aware)
    for f0,g,Q in post_warmth:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # 10. Spectral bias (v8 corrected)
    if not is_bypass and bias_filter:
        parts.append(bias_filter)

    # 11. Correction nodes
    for f0,g,Q in correction_nodes:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # v8 FIX #3: حذف alimiter الوسيط (0.978/0.982) من هنا!
    # v7.6 كان يضيف: alimiter=limit=0.978:attack=5:release=40 هنا
    # هذا كان يسحق Crest قبل أن يصل للـ alimiter الرئيسي

    # 12. Volume
    if abs(gain_db)>0.05: parts.append(f'volume={gain_db:.3f}dB')

    # 13. Stereo
    if is_mono: parts.append('aformat=channel_layouts=stereo')

    # v8 FIX #3: alimiter ناعم جداً للـ WAV الوسيطة (يحمي من overflow فقط)
    # True Peak الحقيقي (0.891) يُطبَّق في Pass 4 فقط
    if is_bypass:
        parts.append('alimiter=limit=0.999:level=false:attack=5:release=15')
    else:
        parts.append('alimiter=limit=0.9997:level=false:attack=10:release=100')

    return ','.join(f'\n    {p}' for p in parts)

# ══════════════════════════════════════════════════════════════════════════════
#  MAIN ENHANCE — v8.1
# ══════════════════════════════════════════════════════════════════════════════

def enhance(input_path:str,output_path:str,
            max_iterations:int=3,target_score:float=96.0) -> Dict:
    log:List[str]=[]; t0=time.time()
    def L(m:str='') -> None: print(m); log.append(m)

    _input_tmp=None
    try: input_path.encode('ascii')
    except UnicodeEncodeError:
        import uuid as _u2; ext=os.path.splitext(input_path)[1] or '.mp3'
        _input_tmp=os.path.join(_TMP, f'v81_in_{_u2.uuid4().hex[:8]}{ext}')
        shutil.copy2(input_path,_input_tmp); input_path=_input_tmp

    L(f"╔{'═'*70}╗")
    L(f"║  Audio Enhancement Engine v8.4 — \"Source Tier Intelligence\"         ║")
    L(f"║  المرجع: الشيخ ياسر الدوسري — 1425H                                 ║")
    L(f"║  v8.2: BIAS_SIGN ✓ | NO_STACKING ✓ | SINGLE_LIMITER ✓ | --ref ✓    ║")
    L(f"║  v8.4: SourceTierDetector ✓ | bias_cutoff ✓ | eq_ramp_scale ✓       ║")
    L(f"╚{'═'*70}╝")
    L(f"  الملف: {os.path.basename(input_path)}")

    # ── Reference ────────────────────────────────────────────────────────────
    L(f"\n[١] بصمة المرجع v8.1 (MDS: SFM + DR + Spectral Distance)...")
    ref_fp=get_reference_fingerprint()
    L(f"  ✓ {ref_fp.n_files} سورة | RMS={ref_fp.rms:.2f} Crest={ref_fp.crest:.2f}"
      f" LRA={ref_fp.lra:.2f}(full)/{ref_fp.lra_clip:.2f}(clip)")
    L(f"  ✓ SFM={ref_fp.sfm:.4f} DR={ref_fp.dr:.1f}dB"
      f" Warmth={ref_fp.warmth_ratio:.2f} Tilt={ref_fp.tilt_slope:.2f}")

    # ── File Analysis ─────────────────────────────────────────────────────────
    L(f"\n[٢] تحليل شامل (MDS: 4 مقاييس)...")
    pr=probe(input_path)
    stream=pr.get('streams',[{}])[0]
    is_mono=stream.get('channels',2)==1
    src_sr=int(stream.get('sample_rate',44100))
    src_br=int(stream.get('bit_rate',128000))
    total_s=int(float(pr.get('format',{}).get('duration',300)))
    n_ch='1' if is_mono else '2'; skip_s=min(30,total_s//4)

    full_b=analyze_full_spectrum(input_path,total_s)
    inp=load_audio(input_path,skip=skip_s,duration=45)
    inp_b=full_b if full_b else third_octave(inp,a_weighted=False)

    inp_rms=rms_db(inp); inp_crest=crest_factor(inp)
    inp_lra=lra_estimate(inp); inp_hf=hf_status(inp_b)

    hf_freqs=[fc for fc in inp_b if fc>=8000]
    hf_avg=float(np.mean([inp_b[fc] for fc in hf_freqs])) if hf_freqs else -80.0
    ref_hf=float(np.mean([ref_fp.third_oct.get(fc,-60) for fc in hf_freqs])) if hf_freqs else -40.0
    hf_deficit=ref_hf-hf_avg
    hf_rolloff=max(detect_hf_rolloff(inp_b,12.0),2000.0)

    # Step 1a: SFM
    inp_sfm=compute_sfm(inp)
    sfm_ratio=inp_sfm/(ref_fp.sfm+1e-6)
    L(f"  Step 1a — SFM={inp_sfm:.4f} (ref={ref_fp.sfm:.4f}, ratio={sfm_ratio:.1f}x)")

    # Step 1b: DR
    inp_dr=compute_dynamic_range(inp)
    L(f"  Step 1b — DR={inp_dr:.1f}dB (ref={ref_fp.dr:.1f}dB, excess={inp_dr-ref_fp.dr:+.1f})")

    # Step 1c: Spectral distance
    spec_dist=compute_spectral_distance(inp_b,ref_fp,hf_rolloff)
    L(f"  Step 1c — Spectral distance=±{spec_dist:.2f}dB from 1425H")

    # Step 1d: Per-band SNR
    band_snr=compute_band_snr(inp)
    snr_global=float(np.mean(list(band_snr.values()))) if band_snr else 30.0

    # MDS
    mds=compute_mds(snr_global,inp_sfm,inp_dr,hf_deficit,spec_dist,src_br,
                    ref_fp.sfm,ref_fp.dr)
    quality_label=mds_to_label(mds)

    has_ringing=(src_br<65000)
    br_rolloff=15500.0 if src_br<65000 else 16500.0 if src_br<97000 else hf_rolloff

    damage=DamageProfile(
        snr=snr_global,sfm=inp_sfm,dr=inp_dr,hf_deficit=hf_deficit,
        spectral_dist=spec_dist,crest=inp_crest,src_br=src_br,
        band_snr=band_snr,mds=mds,has_ringing=has_ringing,
        rolloff_hz=br_rolloff,quality_label=quality_label
    )

    L(f"\n  MDS={mds:.1f}/100 → {quality_label}")
    L(f"  Crest={inp_crest:.2f} LRA={inp_lra:.2f} BR={src_br//1000}kbps"
      f" Ringing={'✓' if has_ringing else '✗'}")

    # ── v8.4: Source Tier Detection ──────────────────────────────────────────
    L(f"\n[٢ᵇ] تصنيف جودة المصدر v8.4 (SourceTierDetector)...")
    tier_profile = build_source_tier_profile(
        audio        = inp,
        inp_b        = inp_b,
        src_br       = src_br,
        snr_db       = snr_global,
        inp_lra      = inp_lra,
        ref_lra_clip = ref_fp.lra_clip,
        sr           = SR,
    )
    L(f"  ✦ Tier     = {tier_profile.tier}")
    L(f"  ✦ cutoff   = {tier_profile.input_cutoff_hz:.0f}Hz"
      f"  noise={tier_profile.noise_type}"
      f"  clip={tier_profile.clip_tier}({tier_profile.clip_ratio*100:.1f}%)")
    L(f"  ✦ Routing  : bias≤{tier_profile.bias_cutoff_hz:.0f}Hz"
      f"  eq_scale={tier_profile.eq_ramp_scale:.2f}x"
      f"  NR={'إلزامي' if tier_profile.nr_mandatory else 'اختياري'}"
      f"  LRA_expand={'✓' if tier_profile.lra_expand_gate else '✗ (AGC collapse)'}")
    L(f"  ✦ Ceiling  : Crest≤{tier_profile.achievable_crest:.2f}"
      f"  LRA≤{tier_profile.achievable_lra:.2f}"
      f"  LUFS≥{tier_profile.achievable_lufs:.2f}")

    # ── STEP 2: MDS-Driven Processing ─────────────────────────────────────────
    L(f"\n[٣] Step 2a — SFM-Adaptive NR...")
    # v8.4: tier_profile.nr_mandatory يُجبر NR بغض النظر عن SFM
    # v8.5: recompute MDS with tier-specific weights now that tier is known.
    # TIER_DAMAGED weights SNR/SFM heavily (40%/30%), ignores HF (0%).
    # This raises MDS for truly damaged sources -> heavier compand (correct).
    mds = compute_mds(snr_global, inp_sfm, inp_dr, hf_deficit, spec_dist, src_br,
                      ref_fp.sfm, ref_fp.dr, source_tier=tier_profile.tier)
    quality_label = mds_to_label(mds)
    damage.mds = mds
    damage.quality_label = quality_label
    L(f"  [v8.5] MDS (tier-adjusted) = {mds:.1f}/100 -> {quality_label}"
      f"  [{tier_profile.tier} weights]")

    use_nr = tier_profile.nr_mandatory or ((src_br >= 96000) and (snr_global >= 8.0))
    nr_parts=build_nr_sfm(damage) if use_nr or has_ringing else (
        [f'lowpass=f={int(br_rolloff*0.97)}:poles=2'] if has_ringing else [])

    L(f"\n[٤] Step 2b — MDS-Calibrated Compand (v8 FIX: LRA delta صحيح)...")
    # v8 FIX #4: نمرر inp_lra للدالة
    compand_pts,makeup,intensity,calib=build_compand_mds(damage,ref_fp,inp_lra)
    lra_delta_actual=max(0.0,inp_lra-ref_fp.lra_clip)
    L(f"  Compand={intensity} Makeup=+{makeup:.1f}dB calib={calib:+.1f}dB"
      f" (LRA_delta={lra_delta_actual:.2f} | MDS={mds:.0f})")

    L(f"\n[٥] Step 2d — Spectral Distance EQ (scipy Bark)...")
    max_eq_db=4.0 if quality_label=='EXTREME' else 5.0 if quality_label=='VERY_POOR' else 6.0
    n_eq=12 if quality_label=='EXTREME' else 10
    eq_nodes=optimize_eq(inp_b,ref_fp,n_nodes=n_eq,max_db=max_eq_db,
                         shape_only=(quality_label=='EXTREME'),hf_rolloff=hf_rolloff)

    warmth_pre=build_warmth_nodes(inp_b,ref_fp,hf_rolloff,
                                  post_compand=False,current_crest=inp_crest)
    eq_all=merge_eq(sorted(eq_nodes+warmth_pre,key=lambda x:x[0]),60.0)
    eq_all=[(f,float(np.clip(g,-max_eq_db,max_eq_db)),q) for f,g,q in eq_all]
    eq_final=[]
    for f0,g,q in eq_all:
        if f0>=hf_rolloff and g>0:
            if f0<hf_rolloff*1.5: eq_final.append((f0,min(-0.5,g*-0.3),q))
        else: eq_final.append((f0,g,q))
    eq_nodes_cur=eq_final
    L(f"  {len(eq_nodes_cur)} نقطة EQ (±{max_eq_db}dB)")

    inp_tilt=spectral_tilt(inp_b); tilt_corr=ref_fp.tilt_slope-inp_tilt
    # v8 FIX #1 + v8.4: bias_cutoff_hz من tier_profile
    # v8.45: also gate at ref codec cutoff — no boosts above ref's own HF ceiling
    bias_filter=build_bias_filter(
        hf_rolloff,
        min(tier_profile.bias_cutoff_hz, ref_fp.ref_codec_cutoff_hz)
    )
    L(f"  Bias: 250Hz→+{abs(-(-7.00)*BIAS_SCALE):.2f}dB↑ | "
      f"4kHz→{-(5.00*BIAS_SCALE):.2f}dB↓ | "
      f"8kHz→{-(8.00*BIAS_SCALE):.2f}dB↓ (v8 FIX)")

    # ── STEP 3: Do-No-Harm Convergence ────────────────────────────────────────
    L(f"\n{'─'*70}")
    L(f"  STEP 3 — Do-No-Harm Convergence (v8 — Single Compand + Single Limiter)")
    L(f"{'─'*70}")

    best_score=0.0; best_path=None

    for iteration in range(max_iterations):
        L(f"\n  ◆ تكرار {iteration+1}/{max_iterations}")

        # LUFS 7-point
        L(f"  [٦] LUFS 7-point Gaussian...")
        chain0=build_filter_chain(
            eq_nodes_cur,compand_pts,makeup,inp_hf,is_mono,0.0,
            nr_parts,bias_filter,[],intensity,inp_lra,damage,
            hf_rolloff,src_sr,ref_fp.lra_clip,tilt_corr
        ).replace('\n','').replace('    ','')

        l0=sample_lufs_7pt(input_path,total_s,n_ch,chain0)
        gain_needed=float(np.clip(TARGET['lufs']-l0-calib,-18,12))
        L(f"    LUFS_7pt={l0:.2f}  gain={gain_needed:+.2f}dB")

        # Pass 1 → WAV
        L(f"  [٧] Pass 1 → WAV (single compand, soft limiter)...")
        tmp_p1=os.path.join(_TMP,'v81_p1.wav')
        chain1=build_filter_chain(
            eq_nodes_cur,compand_pts,makeup,inp_hf,is_mono,gain_needed,
            nr_parts,bias_filter,[],intensity,inp_lra,damage,
            hf_rolloff,src_sr,ref_fp.lra_clip,tilt_corr
        ).replace('\n','').replace('    ','')

        r1=subprocess.run(['ffmpeg','-y','-i',input_path,'-af',
                           chain1+',ebur128=peak=true',
                           '-ar','48000','-ac','2',tmp_p1,'-loglevel','info'],
                          capture_output=True,text=True)
        lufs_p1=-99.0
        for line in r1.stderr.split('\n'):
            s=line.strip()
            if s.startswith('I:') and 'LUFS' in s and 'LRA' not in s:
                try: lufs_p1=float(s.split('I:')[1].strip().split()[0]); break
                except: pass
        if lufs_p1==-99.0: lufs_p1=gain_needed+l0

        p1_a=load_audio(tmp_p1,skip=skip_s,duration=45)
        p1_b=third_octave(p1_a)
        p1_crest=crest_factor(p1_a)
        p1_m={'lufs':lufs_p1,'rms':rms_db(p1_a),'crest':p1_crest,'lra':lra_estimate(p1_a)}
        s1,_=quality_score(p1_b,ref_fp,p1_m,hf_rolloff,
                            tier_profile.tier,tier_profile.input_cutoff_hz)
        L(f"    LUFS={lufs_p1:.2f} RMS={p1_m['rms']:.2f} Crest={p1_crest:.2f}"
          f" LRA={p1_m['lra']:.2f} Score={s1}")

        # Pass 2 → WAV (spectral correction + warmth)
        L(f"  [٨] Pass 2 → WAV (Crest-aware spectral correction)...")
        lufs_corr=TARGET['lufs']-lufs_p1
        p1_adj={fc:v+lufs_corr for fc,v in p1_b.items()}
        max_c2=2.5 if quality_label=='EXTREME' else 3.0
        corr2=spectral_correction(p1_adj,ref_fp,hf_rolloff,max_c2,2,p1_crest)
        pw2=build_warmth_nodes(p1_adj,ref_fp,hf_rolloff,True,p1_crest)

        p2_parts=[f'volume={lufs_corr:.3f}dB']
        for f0,g,Q in corr2:
            p2_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        for f0,g,Q in pw2:
            p2_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        # v8 FIX #3: WAV وسيطة = limit ناعم جداً (يحفظ Crest)
        p2_parts.append('alimiter=limit=0.9997:level=false:attack=10:release=100')

        tmp_p2=os.path.join(_TMP,'v81_p2.wav')
        subprocess.run(['ffmpeg','-y','-i',tmp_p1,'-af',','.join(p2_parts),
                        '-ar','48000','-ac','2',tmp_p2,'-loglevel','error'],
                       capture_output=True)

        p2_a=load_audio(tmp_p2,skip=skip_s,duration=45)
        p2_b=third_octave(p2_a)
        p2_crest=crest_factor(p2_a); p2_lra=lra_estimate(p2_a); p2_rms=rms_db(p2_a)
        p2_m={'lufs':TARGET['lufs'],'rms':p2_rms,'crest':p2_crest,'lra':p2_lra}
        s2,_=quality_score(p2_b,ref_fp,p2_m,hf_rolloff,
                            tier_profile.tier,tier_profile.input_cutoff_hz)
        L(f"    RMS={p2_rms:.2f} Crest={p2_crest:.2f} LRA={p2_lra:.2f} Score={s2}")
        L(f"    Crest P1→P2: {p1_crest:.2f}→{p2_crest:.2f} (Δ={p1_crest-p2_crest:+.2f}LU)")

        # ══════════════════════════════════════════════════════════════
        # v8 FIX #5: Quality Gate مع حارس Crest مستقل
        # ══════════════════════════════════════════════════════════════
        crest_collapsed=(p2_crest < p1_crest-1.5 and
                         p2_crest < TARGET['crest']-0.8)
        score_regressed=(s2 < s1-1.0)

        if score_regressed or crest_collapsed:
            reason=('Crest انهار' if crest_collapsed else f'Score P2({s2})<P1({s1})')
            L(f"    ⚠ Quality Gate v8 [{reason}] → رجوع لـ P1")
            shutil.copy(tmp_p1,tmp_p2); p2_b=p1_b
            p2_crest=p1_crest; p2_lra=p1_m['lra']
            p2_rms=p1_m['rms']; p2_m=p1_m; s2=s1

        # Pass 3 → WAV (LRA + RMS feedback)
        L(f"  [٩] Pass 3 → WAV (LRA+RMS feedback)...")
        p3_parts=[]
        # v8.45: use phrase_lra_p50 as LRA target (phrase-level, not full-file average)
        # FORENSIC: phrase_lra_p50 measured at 3.34 LU (vs hardcoded 4.19 full-file)
        # using full-file 4.19 causes Pass 3 to over-expand — phrase target is more accurate
        lra_p3_target = ref_fp.phrase_lra_p50 if ref_fp.phrase_lra_p50 > 0.1 else ref_fp.lra
        lra_gap=lra_p3_target - p2_lra
        rms_gap=ref_fp.rms-p2_rms

        # v8: LRA gate هنا فقط | v8.4: lra_expand_gate يمنع التوسيع لـ TIER_DAMAGED
        if lra_gap>0.3 and p2_crest>TARGET['crest']-1.5 and tier_profile.lra_expand_gate:
            if   lra_gap<0.8: thr,ratio,rel=0.020,1.8,700
            elif lra_gap<1.5: thr,ratio,rel=0.026,2.2,580
            else:             thr,ratio,rel=0.032,2.6,450
            p3_parts.append(f'agate=threshold={thr:.3f}:ratio={ratio:.1f}'
                            f':attack=15:release={rel}:makeup=1.0:range=0.08')

        rms_leak=lra_gap*0.14 if lra_gap>0.3 else 0.0
        rms_adj=float(np.clip((rms_gap+rms_leak)*0.45,-1.2,1.2))
        if abs(rms_adj)>0.12:
            p3_parts.append(f'volume={rms_adj:.3f}dB')

        corr3=spectral_correction(p2_b,ref_fp,hf_rolloff,1.8,3,p2_crest)
        for f0,g,Q in corr3:
            p3_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        # v8 FIX #3: WAV وسيطة = limit ناعم
        p3_parts.append('alimiter=limit=0.9997:level=false:attack=10:release=100')

        tmp_p3=os.path.join(_TMP,'v81_p3.wav')
        if len(p3_parts)>1:
            subprocess.run(['ffmpeg','-y','-i',tmp_p2,'-af',','.join(p3_parts),
                            '-ar','48000','-ac','2',tmp_p3,'-loglevel','error'],
                           capture_output=True)
        else:
            shutil.copy(tmp_p2,tmp_p3)

        p3_a=load_audio(tmp_p3,skip=skip_s,duration=45)
        p3_b=third_octave(p3_a)
        p3_crest=crest_factor(p3_a); p3_lufs=measure_lufs(tmp_p3)
        p3_m={'lufs':p3_lufs,'rms':rms_db(p3_a),'crest':p3_crest,'lra':lra_estimate(p3_a)}
        s3,_=quality_score(p3_b,ref_fp,p3_m,hf_rolloff,
                            tier_profile.tier,tier_profile.input_cutoff_hz)

        if s3<s2-1.0:
            L(f"    ⚠ Quality Gate: P3({s3})<P2({s2}) → رجوع لـ P2")
            shutil.copy(tmp_p2,tmp_p3); p3_b=p2_b
            p3_lufs=TARGET['lufs']; p3_crest=p2_crest; s3=s2

        # Pass 4 → MP3 (True Peak Compliance)
        # v8 FIX #3: alimiter=0.891 هنا فقط — التطبيق الوحيد الحقيقي
        lufs_trim=TARGET['lufs']-p3_lufs
        p4_parts=[]
        if abs(lufs_trim)>0.08: p4_parts.append(f'volume={lufs_trim:.3f}dB')
        if s3<93.0:
            c4=spectral_correction(p3_b,ref_fp,hf_rolloff,0.8,4,p3_crest)
            for f0,g,Q in c4:
                p4_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        # التطبيق الوحيد الحقيقي لـ True Peak limiter
        p4_parts.append('alimiter=limit=0.891:level=false:attack=1:release=15')

        tmp_out=os.path.join(_TMP,f'v81_out_{iteration}.mp3')
        subprocess.run(['ffmpeg','-y','-i',tmp_p3,'-af',','.join(p4_parts),
                        '-b:a','320k','-ar','48000','-ac','2',
                        tmp_out,'-loglevel','error'],capture_output=True)

        out_a=load_audio(tmp_out,skip=skip_s,duration=45)
        out_b_=third_octave(out_a)
        out_lufs=measure_lufs(tmp_out)
        out_m={'lufs':out_lufs,'rms':rms_db(out_a),
               'crest':crest_factor(out_a),'lra':lra_estimate(out_a)}
        fs,fbd=quality_score(out_b_,ref_fp,out_m,hf_rolloff,
                              tier_profile.tier,tier_profile.input_cutoff_hz)

        L(f"\n  ★ P1={s1}→P2={s2}→P3={s3}→Final={fs}/100")
        L(f"    LUFS={out_m['lufs']:.2f} RMS={out_m['rms']:.2f}"
          f" Crest={out_m['crest']:.2f} LRA={out_m['lra']:.2f}")

        if fs>best_score: best_score=fs; best_path=tmp_out
        if fs>=target_score: L(f"  ✅ هدف {target_score} محقق!"); break

        # Adaptive EQ
        if iteration<max_iterations-1:
            rv={fc:ref_fp.third_oct[fc] for fc in ref_fp.third_oct
                if fc in out_b_ and 100<=fc<=10000}
            ov={fc:out_b_[fc] for fc in rv}
            loff_i=float(np.mean([rv[fc]-ov[fc] for fc in rv]))
            sr_={fc:(rv[fc]-ov[fc])-loff_i for fc in rv}
            avg_se=float(np.mean(np.abs(list(sr_.values()))))
            # v8.1 PATCH #4: linear ramp | v8.4: × eq_ramp_scale (tier-gated)
            scale=min(0.45, max(0.08, 0.15 + (avg_se - 1.5) * 0.085))
            scale=max(0.04, scale * tier_profile.eq_ramp_scale)  # v8.4
            big=sorted([(fc,v) for fc,v in sr_.items() if abs(v)>2.5],
                       key=lambda x:-abs(x[1]))[:3]
            if big:
                corr=[(fc,round(v*scale,2),1.5) for fc,v in big]
                eq_nodes_cur=merge_eq(list(eq_nodes_cur)+corr,60.0)
                eq_nodes_cur=[(f,float(np.clip(g,-max_eq_db,max_eq_db)),q)
                              for f,g,q in eq_nodes_cur]
                L(f"  🔄 {len(corr)} EQ adaptive (avg_error={avg_se:.2f}dB, scale={scale:.3f} ramp)")

    # Finalize
    shutil.copy(best_path if best_path else tmp_out,output_path)
    if _input_tmp and os.path.exists(_input_tmp):
        try: os.remove(_input_tmp)
        except: pass

    fin_a=load_audio(output_path,skip=skip_s,duration=45)
    fin_b=third_octave(fin_a)
    fin_lufs=measure_lufs(output_path)
    fin_m={'lufs':fin_lufs,'rms':rms_db(fin_a),
           'crest':crest_factor(fin_a),'lra':lra_estimate(fin_a)}
    top_s,top_bd=quality_score(fin_b,ref_fp,fin_m,hf_rolloff,
                               tier_profile.tier,tier_profile.input_cutoff_hz)
    elapsed=time.time()-t0

    L(f"\n{'═'*70}")
    L(f"  FINAL REPORT — v8.5 ({elapsed:.0f}s)")
    L(f"{'═'*70}")
    L(f"  {'المقياس':<18} {'المدخل':>8}  {'المخرج':>8}  {'الهدف 1425H':>12}")
    L(f"  {'─'*52}")
    L(f"  {'LUFS':<18} {'N/A':>8}  {fin_m['lufs']:>8.2f}  {TARGET['lufs']:>12.2f}")
    L(f"  {'RMS (dBFS)':<18} {inp_rms:>8.2f}  {fin_m['rms']:>8.2f}  {ref_fp.rms:>12.2f}")
    L(f"  {'Crest (LU)':<18} {inp_crest:>8.2f}  {fin_m['crest']:>8.2f}  {TARGET['crest']:>12.2f}")
    L(f"  {'LRA (LU)':<18} {inp_lra:>8.2f}  {fin_m['lra']:>8.2f}  {ref_fp.lra:>12.2f}")
    L(f"  {'MDS Score':<18} {mds:>8.1f}  {'→':>8}  {'0 (perfect)':>12}")

    # v8.4 SOURCE TIER line
    L(f"  [v8.4]  SOURCE TIER  {tier_profile.tier:<20}"
      f"  cutoff={tier_profile.input_cutoff_hz/1000:.1f}kHz"
      f"  noise={tier_profile.noise_type}"
      f"  clip={tier_profile.clip_tier}"
      f"  eq_scale={tier_profile.eq_ramp_scale:.2f}x"
      f"  bias_ceil={tier_profile.bias_cutoff_hz/1000:.1f}kHz")
    if tier_profile.tier != 'TIER_PRISTINE':
        L(f"          CEILING: Crest≤{tier_profile.achievable_crest:.2f}LU"
          f"  LRA≤{tier_profile.achievable_lra:.2f}LU"
          f"  LUFS≥{tier_profile.achievable_lufs:.2f}")
        if not tier_profile.lra_expand_gate:
            L(f"          ⚠ LRA expansion disabled — codec AGC destroyed dynamics")
        if tier_profile.noise_type not in ('none','unknown'):
            L(f"          NR applied: {tier_profile.noise_type}"
              f"  sfm_silence={tier_profile.sfm_silence:.2f}")

    bar='█'*int(top_s/5)+'░'*(20-int(top_s/5))
    L()
    L(f"  ★ {bar} {top_s}/100"
      f"  {'✅ EXCELLENT' if top_s>=96 else '✅ PASS' if top_s>=92 else '✓' if top_s>=88 else '⚠'}")
    # v8.5: show both tier-adjusted and absolute scores
    if top_bd.ceiling_reason:
        L(f"    [v8.5] score_tier={top_bd.score_tier}/100"
          f"  score_absolute={top_bd.score_absolute}/100"
          f"  (ceiling adjusted for {tier_profile.tier})")
        L(f"    ⓘ {top_bd.ceiling_reason}")
    else:
        L(f"    [v8.5] score_tier={top_bd.score_tier}/100"
          f"  score_absolute={top_bd.score_absolute}/100  (TIER_PRISTINE — no adjustment)")
    L(f"    Spectral:{top_bd.spectral} LUFS:{top_bd.lufs} Crest:{top_bd.crest}"
      f" LRA:{top_bd.lra} Warmth:{top_bd.warmth} HF:{top_bd.hf}")
    L(f"    خطأ طيفي:±{top_bd.avg_err}dB  MDS:{mds:.1f}/100({quality_label})")
    for n in top_bd.notes: L(f"    ⚠ {n}")

    # v8 Bug fixes summary in log
    L()
    L(f"  v8 Fixes Applied:")
    L(f"    ✓ BIAS 250Hz: +1.75dB boost (was -2.75dB cut in v7.6)")
    L(f"    ✓ BIAS 4kHz:  -1.25dB cut  (was +0.375dB boost in v7.6)")
    L(f"    ✓ BIAS 8kHz:  -2.00dB cut  (was +1.00dB boost in v7.6)")
    L(f"    ✓ No LRA stacking (single compand only)")
    L(f"    ✓ Single True Peak limiter in Pass 4 only")
    L(f"    ✓ LRA delta uses inp_lra vs lra_clip (was DR in v7.6)")
    L(f"  v8.1/v8.2 Patches Applied:")
    L(f"    ✓ REF_CACHE → ~/.tilawa_cache/ref_fp.v85.json (v8.5 version bump)")
    L(f"    ✓ REF_FILES → env / container_ref / legacy | --ref argparse fixed")
    L(f"    ✓ ALL /tmp/ → tempfile.gettempdir() (_TMP={_TMP})")
    L(f"    ✓ Adaptive EQ scale: linear ramp × tier eq_ramp_scale")
    L(f"    ✓ 64K_FLOOR label for honest Crest ceiling reporting")
    L(f"  v8.4 Source Tier Intelligence:")
    L(f"    ✓ SourceTierDetector: {tier_profile.tier} "
      f"cutoff={tier_profile.input_cutoff_hz:.0f}Hz "
      f"noise={tier_profile.noise_type}")
    L(f"    ✓ BIAS boost gated at {tier_profile.bias_cutoff_hz:.0f}Hz "
      f"(was always 20kHz)")
    L(f"    ✓ EQ scale={tier_profile.eq_ramp_scale:.2f}x "
      f"NR_mandatory={tier_profile.nr_mandatory} "
      f"LRA_expand={tier_profile.lra_expand_gate}")
    L(f"  v8.45 Deep Reference Model:")
    L(f"    ✓ Full-file spectral avg (was 8×30s clips — up to +16dB bias fixed)")
    L(f"    ✓ phrase_lra_p50={ref_fp.phrase_lra_p50:.2f}LU "
      f"p10={ref_fp.phrase_lra_p10:.2f} p90={ref_fp.phrase_lra_p90:.2f} "
      f"(Pass 3 target was hardcoded 4.19)")
    L(f"    ✓ silence_floor={ref_fp.silence_floor_db:.1f}dBFS "
      f"NR_ceiling={ref_fp.silence_floor_db - 3.0:.1f}dBFS")
    L(f"    ✓ ref_codec_cutoff={ref_fp.ref_codec_cutoff_hz:.0f}Hz "
      f"peak_dist={ref_fp.peak_distribution}")
    lra_p3_used = ref_fp.phrase_lra_p50 if ref_fp.phrase_lra_p50 > 0.1 else ref_fp.lra
    L(f"  [v8.45] REF MODEL  "
      f"n_refs={ref_fp.n_files}  "
      f"p50_lra={ref_fp.phrase_lra_p50:.2f}LU  "
      f"peak={ref_fp.peak_distribution}  "
      f"sil={ref_fp.silence_floor_db:.1f}dBFS  "
      f"cutoff={ref_fp.ref_codec_cutoff_hz:.0f}Hz")
    L(f"  v8.5 Tier-Adjusted Scoring:")
    L(f"    ✓ score_tier={top_bd.score_tier}/100  score_absolute={top_bd.score_absolute}/100")
    L(f"    ✓ compute_mds tier-weighted: {tier_profile.tier} "
      f"(SNR w={_V85_MDS_WEIGHTS[tier_profile.tier]['snr']:.2f}"
      f" SFM w={_V85_MDS_WEIGHTS[tier_profile.tier]['sfm']:.2f}"
      f" HF w={_V85_MDS_WEIGHTS[tier_profile.tier]['hf']:.2f})")
    L(f"    ✓ 64K_FLOOR hack removed — replaced by TierAdjustedScoring")
    if top_bd.ceiling_reason:
        L(f"    ✓ ceiling: {top_bd.ceiling_reason}")
    L(f"  [v8.5] TIER-SCORE  "
      f"tier={tier_profile.tier}  "
      f"score_tier={top_bd.score_tier}/100  "
      f"score_abs={top_bd.score_absolute}/100  "
      f"MDS={mds:.1f}")
    L(); L(f"  ✅ {output_path}"); L(f"{'═'*70}\n")

    return {
        'score':top_s,'breakdown':top_bd,'final_metrics':fin_m,
        'input_metrics':{'rms':inp_rms,'crest':inp_crest,'lra':inp_lra,
                         'snr':snr_global,'sfm':inp_sfm,'dr':inp_dr,'mds':mds},
        'quality_tier':quality_label,'mds':mds,
        'hf_rolloff_hz':hf_rolloff,'ref_lra':ref_fp.lra,
        'iterations':iteration+1,'log':log,'engine_version':'v8.5',
        'score_absolute':top_bd.score_absolute,
        'score_tier':top_bd.score_tier,
        'ceiling_reason':top_bd.ceiling_reason,
        'source_tier':tier_profile.tier,
        'input_cutoff_hz':tier_profile.input_cutoff_hz,
        'noise_type':tier_profile.noise_type,
    }

def enhance_auto(input_path:str,output_path:str,
                 max_iterations:int=3,target_score:float=96.0) -> Dict:
    return enhance(input_path,output_path,max_iterations,target_score)

def process_batch(input_dir:str,output_dir:str) -> None:
    in_p=Path(input_dir); out_p=Path(output_dir); out_p.mkdir(parents=True,exist_ok=True)
    files=sorted([f for f in in_p.iterdir()
                  if f.suffix.lower() in {'.mp3','.wav','.m4a','.flac'}])
    if not files: print("لا توجد ملفات"); return
    scores=[]; results=[]
    for i,f in enumerate(files,1):
        dst=out_p/(f.stem+'_1425h_v81.mp3'); print(f"\n[{i}/{len(files)}] {f.name}")
        try:
            r=enhance_auto(str(f),str(dst))
            sc=r.get('score',0); scores.append(sc)
            results.append({'file':f.name,'score':sc,'status':'ok'}); print(f"  ✅ {sc}/100")
        except Exception as e:
            results.append({'file':f.name,'score':0,'status':'error','error':str(e)}); print(f"  ❌ {e}")
    avg=sum(scores)/len(scores) if scores else 0
    print(f"\n  Batch: {len(scores)}/{len(files)} avg={avg:.1f}/100")
    try:
        with open(out_p/'_batch_v81.json','w',encoding='utf-8') as jf:
            json.dump({'results':results,'avg_score':round(avg,1)},jf,ensure_ascii=False,indent=2)
    except: pass

def main() -> int:
    if not NUMPY_OK or not SCIPY_OK:
        print("pip install numpy scipy"); return 1
    p=argparse.ArgumentParser(description='Audio Enhancement Engine v8.5 — 1425H')
    p.add_argument('-i','--input');  p.add_argument('-o','--output')
    p.add_argument('--iterations',type=int,default=3)
    p.add_argument('--target',type=float,default=96.0)
    p.add_argument('--batch-in');   p.add_argument('--batch-out')
    p.add_argument('--serve',action='store_true')
    p.add_argument('--port',type=int,default=5000)
    p.add_argument('--clear-cache',action='store_true')
    p.add_argument('--ref', action='append', default=[],
                   metavar='REF_MP3',
                   help='Reference audio file path (may be repeated)')
    args=p.parse_args()
    if args.ref:
        valid_refs = [r for r in args.ref if os.path.exists(r)]
        if valid_refs:
            global REF_FILES
            REF_FILES = valid_refs
    if args.clear_cache:
        if os.path.exists(REF_CACHE): os.remove(REF_CACHE); print("✅ Cache v8 حُذف")
        return 0
    if args.serve:
        try: from flask import Flask,request,send_file,jsonify
        except: print("pip install flask"); return 1
        import threading, uuid as _uuid, re
        app=Flask(__name__); app.jobs={}
        @app.route('/')
        def index():
            return (Path(__file__).parent/'templates'/'index.html').read_text()
        @app.route('/upload',methods=['POST'])
        def upload():
            f=request.files.get('file')
            if not f: return jsonify(error='لم يُرسَل ملف'),400
            data=f.read()
            if len(data)>300*1024*1024: return jsonify(error='الحد الأقصى 300MB'),400
            jid=str(_uuid.uuid4())[:8]; home=Path(os.environ.get('HOME','/tmp'))
            (home/'uploads').mkdir(exist_ok=True); (home/'outputs').mkdir(exist_ok=True)
            ext=Path(f.filename or 'a.mp3').suffix or '.mp3'
            in_p=home/'uploads'/f'{jid}{ext}'; out_p=home/'outputs'/f'{jid}.mp3'
            in_p.write_bytes(data); stem=Path(f.filename or 'audio').stem
            app.jobs[jid]={'status':'processing','progress':5,'label':'جارٍ المعالجة...','new_log':[],
                           'in':str(in_p),'out':str(out_p),'filename':f'{stem}_v8.1.mp3'}
            def run(jid=jid,in_p=in_p,out_p=out_p):
                j=app.jobs[jid]
                try:
                    PHASES={'[١]':10,'[٢]':18,'[٣]':26,'[٤]':32,'[٥]':38,
                            '[٦]':50,'[٧]':62,'[٨]':74,'[٩]':86}
                    proc=subprocess.Popen(
                        ['python',__file__,'-i',str(in_p),'-o',str(out_p),'--iterations','3'],
                        stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True,bufsize=1)
                    for line in proc.stdout:
                        line=line.rstrip()
                        if not line: continue
                        j.setdefault('new_log',[]).append(line)
                        for tag,pct in PHASES.items():
                            if tag in line: j['progress']=pct; j['label']=line.strip()[:60]; break
                        if '★' in line:
                            m=re.search(r'([\d.]+)/100',line)
                            if m: j['score']=m.group(1)
                        for k,pat in [('crest',r'Crest'),('lra',r'LRA'),('rms',r'RMS')]:
                            if re.search(pat+r'\s*[=:]',line):
                                nums=re.findall(r'-?[\d.]+',line)
                                if len(nums)>=2: j.setdefault(k,nums[-2])
                    proc.wait()
                    if proc.returncode==0 and out_p.exists():
                        j.update({'status':'done','progress':100,'label':'اكتملت'})
                    else:
                        j.update({'status':'error','error':'فشلت المعالجة'})
                except Exception as e:
                    j.update({'status':'error','error':str(e)})
                finally:
                    try: in_p.unlink()
                    except: pass
            threading.Thread(target=run,daemon=True).start()
            return jsonify(job_id=jid)
        @app.route('/status/<jid>')
        def status(jid):
            j=app.jobs.get(jid)
            if not j: return jsonify(error='not found'),404
            r={'status':j['status'],'progress':j['progress'],
               'label':j.get('label',''),'log':j.pop('new_log',[])}
            if j['status']=='done':
                for k in ['score','crest','lra','rms','filename']: r[k]=j.get(k)
                r['job_id']=jid
            if j['status']=='error': r['error']=j.get('error','خطأ')
            return jsonify(r)
        @app.route('/download/<jid>')
        def download(jid):
            j=app.jobs.get(jid)
            if not j or not Path(j['out']).exists(): return 'Not found',404
            return send_file(j['out'],as_attachment=True,
                           download_name=j.get('filename','v8.1.mp3'))
        print(f"\n  محسّن التلاوة v8.1 — http://localhost:{args.port}\n")
        app.run(host='0.0.0.0',port=args.port,debug=False,threaded=True)
        return 0
    if args.batch_in and args.batch_out:
        process_batch(args.batch_in,args.batch_out); return 0
    if not args.input or not args.output:
        p.print_help(); return 1
    try:
        r=enhance_auto(args.input,args.output,args.iterations,args.target)
        print(f"\n  ★ {r['score']}/100  MDS={r['mds']:.0f}  ✅ {args.output}")
        return 0 if r['score']>=85 else 1
    except Exception as e:
        print(f"❌ {e}"); return 1

if __name__=='__main__':
    sys.exit(main())