S175: safaa v4 (DF3 path fix, nara_wpe, --tier/--mujawwad, rm v3_fixed)

app.py

@@ -33,7 +33,7 @@ for _d in [UPLOAD_DIR, CHUNK_DIR, OUTPUT_DIR]:
 BASE = Path(__file__).parent
 
 ENGINE_SCRIPTS = {
-    "v11.0": BASE / "engine_safaa_v3_fixed.py",  # S149
+    "v11.0": BASE / "engine_safaa_v4.py",       # S175  # S149
     "v11.1": BASE / "engine_itiqan_v6_official.py",  # S163
     "v11.2": BASE / "engine_isteidad_v21.py",  # S162-SV-B1
     "v10.0": BASE / "engine_safaa_v3_fixed.py",  # S149
@@ -334,7 +334,9 @@ def _run_engine(job_id):
             )
             # S174-SV-C1: safaa uses positional args (input output), not -i/-o flags
             if _is_safaa:
-                cmd = ["python3", str(script), job["in_path"], _o_path]
+                cmd = ["python3", str(script), job["in_path"], _o_path,
+                       "--tier",     job.get("tier", "TIER_UNKNOWN"),
+                       "--mujawwad", str(job.get("mujawwad_conf", 0.0))]  # S175
             else:
                 cmd = ["python3", str(script),
                        "-i", job["in_path"], "-o", _o_path,

engine_safaa_v3_fixed.py → engine_safaa_v4.py

@@ -39,9 +39,9 @@ KB REFS: §3 §28 §35 §36 §52 §79 §109 §138 §140 §143 §145 §151 §152
 """
 from __future__ import annotations
 
-__version__ = 'v3'
+__version__ = 'v4'
 
-import os, shutil, subprocess, tempfile, time, warnings  # S156: time for temp uniqueness
+import os, shutil, subprocess, tempfile, warnings
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -70,9 +70,12 @@ except ImportError:
 
 # DF3 binary
 _DF3_CLI_BIN = ''
-for _c in ['deep-filter', 'deepfilter', 'deep_filter',
-           '/usr/local/bin/deep-filter', '/app/deep-filter']:
-    if shutil.which(_c):
+for _c in [
+    str(Path(__file__).parent / 'deep-filter'),  # S175: /app/deep-filter on HF ✅
+    '/home/claude/deep-filter',                   # local dev fallback
+    'deep-filter', 'deepfilter', 'deep_filter',
+]:
+    if Path(_c).exists() or shutil.which(_c):
         _DF3_CLI_BIN = _c; break
 DF3_OK = bool(_DF3_CLI_BIN)
 
@@ -94,12 +97,12 @@ RT60_TAILNR    = 0.30
 RT60_AGGR      = 1.50
 MUJ_RT60_FLOOR = 1.20    # §145.3
 
-# §79 per-style DF attenuation hard limits
-_DF3_LIM_MURATTAL  = 18   # dB maximum
-_DF3_LIM_MUJAWWAD  =  6   # dB maximum
-_DF3_SPEECH        = 12
-_DF3_TRANS         = 20
-_DF3_TAIL          = 28
+# §79 per-style DF attenuation hard limits — v4: raised for deeper cleaning
+_DF3_LIM_MURATTAL  = 24   # dB maximum (was 18)
+_DF3_LIM_MUJAWWAD  =  8   # dB maximum (was 6)
+_DF3_SPEECH        = 15   # was 12
+_DF3_TRANS         = 24   # was 20
+_DF3_TAIL          = 32   # was 28
 
 _CHUNK_S       = 0.100
 _XFADE_N       = 960
@@ -107,7 +110,7 @@ _XFADE_N       = 960
 _RMS_MAX_DELTA = 1.0
 _LRA_MAX_DELTA = 0.5     # §109.4
 
-DRR_ALREADY_DRY = 6.0   # dB — skip JALAA if DRR already above this [I10]
+DRR_ALREADY_DRY = 3.0   # v4: lower threshold → JALAA runs on more material (was 6.0)
 
 
 # ─── State ────────────────────────────────────────────────────────────────────
@@ -154,8 +157,7 @@ def _run(cmd, timeout=600):
     return r.returncode, r.stdout, r.stderr
 
 def _tmp(tag, st=None):
-    # S156-B2: add nanosecond suffix — avoids collision between concurrent server jobs
-    p = os.path.join(_TMP, f'safaa3_{tag}_{os.getpid()}_{time.time_ns()}.wav')
+    p = os.path.join(_TMP, f'safaa3_{tag}_{os.getpid()}.wav')
     if st is not None:
         st._tmps.append(p)
     return p
@@ -180,7 +182,7 @@ def _decode(path, st=None):
     try:
         if SF_OK:
             # ffmpeg → pcm_f32le temp, then soundfile reads it natively
-            t = os.path.join(_TMP, f'safaa3_dec_{os.getpid()}_{time.time_ns()}.wav')  # S156-B2
+            t = os.path.join(_TMP, f'safaa3_dec_{os.getpid()}.wav')
             rc, _, _ = _run(['ffmpeg', '-y', '-i', path,
                              '-acodec', 'pcm_f32le',
                              '-ar', str(SR), '-ac', '1',
@@ -191,7 +193,7 @@ def _decode(path, st=None):
             return data
         elif SCIPY_WAV_OK:
             # scipy.io.wavfile can read pcm_f32le natively
-            t = os.path.join(_TMP, f'safaa3_dec_{os.getpid()}_{time.time_ns()}.wav')  # S156-B2
+            t = os.path.join(_TMP, f'safaa3_dec_{os.getpid()}.wav')
             rc, _, _ = _run(['ffmpeg', '-y', '-i', path,
                              '-acodec', 'pcm_f32le',
                              '-ar', str(SR), '-ac', '1',
@@ -204,7 +206,7 @@ def _decode(path, st=None):
             return data.copy()
         else:
             # Final fallback: pcm_s16le → int16 → float32 normalised
-            t = os.path.join(_TMP, f'safaa3_dec_{os.getpid()}_{time.time_ns()}.wav')  # S156-B2
+            t = os.path.join(_TMP, f'safaa3_dec_{os.getpid()}.wav')
             rc, _, _ = _run(['ffmpeg', '-y', '-i', path,
                              '-acodec', 'pcm_s16le',
                              '-ar', str(SR), '-ac', '1',
@@ -446,115 +448,227 @@ def _wpe(wav, rt60, st):
         shutil.rmtree(d, ignore_errors=True)
 
 
-# ─── Stage 4: DF3 reverb-adapted pass (parallel) [I1/I4] ─────────────────────
-def _df3_run_one(args):
-    """Worker: run DF3 at one attenuation level. Returns (name, array|None)."""
-    name, at, cli_bin, fi, od, SR_ = args
-    import wave as _w
-    r = subprocess.run([cli_bin, '--atten-lim-db', str(at), '-o', od, fi],
-                       capture_output=True, timeout=600)
-    wp = os.path.join(od, os.path.basename(fi))
-    if r.returncode or not os.path.exists(wp):
-        return name, None
-    with _w.open(wp, 'rb') as f:
-        raw = f.readframes(f.getnframes())
-    return name, np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
+# ─── Stage 4: DF3 smooth adaptive VAD (§22.5 / §106 / RL-01 / RL-16) ─────────
+_ADF_LOUD_T  = -15.0          # dBFS — projecting voice → protect
+_ADF_QUIET_T = -25.0          # dBFS — soft/breath → clean hard
+_ADF_SNR_GATE = 10.0          # v4: lower gate → more chunks get cleaned (was 12)
+_ADF_CHUNK_S  = 0.050         # 50ms chunks — finer granularity than isteidad 100ms
+_ADF_XFADE    = int(0.120 * 48000)  # v4: 120ms crossfade (was 40ms) — much smoother seams
+# RL-16: guard bands — restore these from original after blend
+_RL16_BANDS   = [(220, 290), (950, 1100)]   # Hz: Ghunnah nasal pole + formant zone
+
+def _df3_pipe_decode(path, sr):
+    """Decode WAV to float32 mono via ffmpeg pipe — avoids wave/soundfile dep."""
+    r = subprocess.run(
+        ['ffmpeg', '-nostdin', '-y', '-hide_banner', '-loglevel', 'error',
+         '-i', path, '-ar', str(sr), '-ac', '1', '-f', 'f32le', '-'],
+        capture_output=True, timeout=120)
+    if r.returncode or len(r.stdout) < 4:
+        return None
+    return np.frombuffer(r.stdout, dtype=np.float32).copy()
+
+def _stft_restore_bands(processed, original, sr, bands):
+    """
+    RL-16: after DF3 blend, restore specified Hz bands from original.
+    Uses STFT with 50% overlap Hann window — preserves phase coherence.
+    """
+    from numpy.fft import rfft, irfft
+    N = 2048; HOP = N // 2
+    freqs = np.fft.rfftfreq(N, d=1.0/sr)  # Hz per bin
+    restore_mask = np.zeros(len(freqs), dtype=bool)
+    for lo, hi in bands:
+        restore_mask |= (freqs >= lo) & (freqs <= hi)
+
+    win = np.hanning(N).astype(np.float32)
+    min_n = min(len(processed), len(original))
+    p = processed[:min_n].astype(np.float64)
+    o = original[:min_n].astype(np.float64)
+    out = np.zeros(min_n, dtype=np.float64)
+    norm = np.zeros(min_n, dtype=np.float64)
+
+    for s in range(0, min_n - N, HOP):
+        Pf = rfft(p[s:s+N] * win)
+        Of = rfft(o[s:s+N] * win)
+        Pf[restore_mask] = Of[restore_mask]   # restore original in guard bands
+        frame = irfft(Pf) * win
+        out[s:s+N] += frame; norm[s:s+N] += win**2
+
+    valid = norm > 1e-8
+    out[valid] /= norm[valid]
+    out[~valid] = p[~valid]
+    return out.astype(np.float32)
 
 def _df3(wav, samples, rt60, st):
     if not DF3_OK:
         _L(st, '  [S4-DF3] deep-filter not found — skip'); return wav
 
-    # Attenuation levels
-    ta = _DF3_TAIL   + (4 if rt60 > RT60_AGGR else 0)
-    ra = _DF3_TRANS  + (2 if rt60 > RT60_AGGR else 0)
-    sa = _DF3_SPEECH
-
-    # §79 per-style hard limits [I4]
-    if st.mujawwad_conf > 0.6:
-        lim = _DF3_LIM_MUJAWWAD
-    else:
-        lim = _DF3_LIM_MURATTAL
-    sa = min(sa, lim)
-    ra = min(ra, lim + 8)    # transition/tail may exceed speech limit but respect style spirit
-    ta = min(ta, lim + 16)
+    # §106.3 + §79 atten limits — v4: stronger per-class
+    lim = _DF3_LIM_MUJAWWAD if st.mujawwad_conf > 0.6 else _DF3_LIM_MURATTAL
+    a_loud  = min(10, lim)       # was 8
+    a_mid   = min(18, lim)       # was 15
+    a_quiet = min(24, lim + 10)  # was 20
+    a_trans = min(14, lim)       # v4: new transition class between loud/mid
     if st.mujawwad_conf > 0.6:
-        ta = min(ta, int(ta * 0.70)); ra = min(ra, int(ra * 0.70)); sa = min(sa, int(sa * 0.80))
+        a_loud  = min(a_loud,  8)
+        a_mid   = min(a_mid,  10)
+        a_quiet = min(a_quiet, 14)
+        a_trans = min(a_trans,  9)
 
-    import wave as _w
     d = tempfile.mkdtemp(prefix='safaa3_df3_')
     try:
+        # ── Prepare pcm_s16le mono input ──────────────────────────────────
         fi = os.path.join(d, 'in.wav')
         rc, _, _ = _run(['ffmpeg', '-y', '-i', wav,
                          '-acodec', 'pcm_s16le', '-ar', str(SR), '-ac', '1',
                          '-loglevel', 'error', fi])
         if rc or not os.path.exists(fi):
             return wav
-        with _w.open(fi, 'rb') as f: raw = f.readframes(f.getnframes())
-        s16 = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
-
-        cn = int(_CHUNK_S * SR); nc = len(s16) // cn
-        if nc < 1:
+        mono = _df3_pipe_decode(fi, SR)
+        if mono is None:
             return wav
-
-        rms = np.array([float(np.sqrt(np.mean(s16[i*cn:(i+1)*cn]**2)) + 1e-10) for i in range(nc)])
-        zcr = np.array([float(np.mean(np.abs(np.diff(np.sign(s16[i*cn:(i+1)*cn]))))) for i in range(nc)])
-        rp30 = float(np.percentile(rms, 30)); rp70 = float(np.percentile(rms, 70))
-        zm   = float(np.median(zcr))
-        labels = np.where((rms >= rp70) & (zcr >= zm * 0.7), 0,
-                          np.where((rms <= rp30) & (zcr < zm * 0.5), 2, 1))
-
-        # Parallel DF3 passes [I1]
-        jobs = []
-        for nm, at in [('speech', sa), ('transition', ra), ('tail', ta)]:
-            od = os.path.join(d, nm); os.makedirs(od, exist_ok=True)
-            jobs.append((nm, at, _DF3_CLI_BIN, fi, od, SR))
-
-        pas = {}
-        with ThreadPoolExecutor(max_workers=3) as ex:
-            futs = {ex.submit(_df3_run_one, j): j[0] for j in jobs}
+        total = len(mono)
+
+        # ── VAD — 50ms chunks with SNR gate (§22.5) ──────────────────────
+        CHUNK = int(_ADF_CHUNK_S * SR)
+        nc = max(1, total // CHUNK)
+        # Estimate noise floor from quietest 10% of chunks
+        rms_db = np.array([
+            20.0 * np.log10(np.sqrt(np.mean(mono[i*CHUNK:(i+1)*CHUNK]**2)) + 1e-12)
+            for i in range(nc)])
+        noise_floor = float(np.percentile(rms_db, 10))
+
+        loud_m  = rms_db >  _ADF_LOUD_T
+        quiet_m = rms_db <= _ADF_QUIET_T
+        mid_m   = ~loud_m & ~quiet_m
+        # §22.5 SNR gate: chunks already clean enough → skip DF3, use original
+        chunk_snr = rms_db - noise_floor
+        clean_m   = chunk_snr >= _ADF_SNR_GATE
+
+        # ── Label smoothing — mode filter over 7-chunk window (v4: was 3) ──────
+        # Wider window prevents micro-class flicker that causes audible texture changes
+        raw_cls = np.where(loud_m, 0, np.where(mid_m, 1, 2))
+        smoothed_cls = raw_cls.copy()
+        half = 3
+        for i in range(half, nc - half):
+            window = raw_cls[i-half:i+half+1]
+            counts = np.bincount(window, minlength=3)
+            smoothed_cls[i] = int(np.argmax(counts))
+        loud_m  = smoothed_cls == 0
+        mid_m   = smoothed_cls == 1
+        quiet_m = smoothed_cls == 2
+
+        n_loud  = int(loud_m.sum()); n_mid = int(mid_m.sum())
+        n_quiet = int(quiet_m.sum()); n_clean = int(clean_m.sum())
+        _L(st, f'  [S4-ADF] 50ms chunks: LOUD={n_loud} MID={n_mid} '
+               f'QUIET={n_quiet} CLEAN(skip)={n_clean}  nf={noise_floor:.1f}dBFS')
+
+        # ── 3 parallel DF passes with per-class flags ─────────────────────
+        df_out = {}
+        def _run_pass(cls, atten, pf=False, pf_beta=0.02):
+            od = os.path.join(d, cls); os.makedirs(od, exist_ok=True)
+            cmd = [_DF3_CLI_BIN, '--atten-lim-db', str(atten)]
+            if pf:
+                cmd += ['--pf', '--pf-beta', str(pf_beta)]
+            cmd += ['-o', od, fi]
+            r2 = subprocess.run(cmd, capture_output=True, timeout=600)
+            wp = os.path.join(od, 'in.wav')
+            if r2.returncode or not os.path.exists(wp):
+                _L(st, f'  [S4-ADF] {cls} pass failed — using source')
+                return cls, mono.copy()
+            arr = _df3_pipe_decode(wp, SR)
+            if arr is None:
+                _L(st, f'  [S4-ADF] {cls} decode failed — using source')
+                return cls, mono.copy()
+            pf_tag = ' +PF' if pf else ''
+            _L(st, f'  [S4-ADF] {cls:6s} {atten:2d}dB{pf_tag} ✓  '
+                   f'max={np.max(np.abs(arr)):.4f}')
+            return cls, arr
+
+        with ThreadPoolExecutor(max_workers=4) as ex:
+            futs = [
+                ex.submit(_run_pass, 'loud',  a_loud,  False),
+                ex.submit(_run_pass, 'mid',   a_mid,   False),
+                ex.submit(_run_pass, 'quiet', a_quiet, True, 0.04),   # PF quiet only
+                ex.submit(_run_pass, 'trans', a_trans, False),         # v4: transition class
+            ]
             for fut in as_completed(futs):
-                nm, arr = fut.result()
-                if arr is None:
-                    _L(st, f'  [S4-DF3] {nm} failed — abort'); return wav
-                pas[nm] = arr
-                atten = next(j[1] for j in jobs if j[0] == nm)
-                _L(st, f'  [S4-DF3] {nm:10s} {atten:2d}dB ✓')
-
-        pa = [pas['speech'], pas['transition'], pas['tail']]
-        ml = min(len(s16), min(len(a) for a in pa))
-        out_s = np.empty(ml, dtype=np.float32)
-        t = np.linspace(0, 1, _XFADE_N, dtype=np.float32)
-        ci_ = 0.5 * (1 - np.cos(np.pi * t)).astype(np.float32); co_ = 1 - ci_
-        pl = int(labels[0])
-        for ci in range(nc):
-            s = ci * cn; e = min((ci + 1) * cn, ml)
-            if e > ml: break
-            lb = int(labels[ci])
-            if lb != pl and ci > 0 and s + _XFADE_N <= ml:
-                b = min(_XFADE_N, e - s)
-                out_s[s:s+b] = pa[pl][s:s+b] * co_[:b] + pa[lb][s:s+b] * ci_[:b]
-                if e > s + _XFADE_N: out_s[s+_XFADE_N:e] = pa[lb][s+_XFADE_N:e]
-            else:
-                out_s[s:e] = pa[lb][s:e]
-            pl = lb
-
-        bm = os.path.join(d, 'blend.wav')
-        b16 = (np.clip(out_s, -1, 1) * 32767).astype(np.int16)
-        with _w.open(bm, 'wb') as f:
-            f.setnchannels(1); f.setsampwidth(2); f.setframerate(SR)
-            f.writeframes(b16.tobytes())
+                cls, arr = fut.result()
+                df_out[cls] = arr
+
+        # ── Expand masks to sample level ──────────────────────────────────
+        def _expand(mask):
+            full = np.zeros(total, dtype=bool)
+            for i, v in enumerate(mask):
+                if v:
+                    s = i * CHUNK
+                    full[s:min(s + CHUNK, total)] = True
+            return full
+
+        l_s = _expand(loud_m); m_s = _expand(mid_m)
+        q_s = _expand(quiet_m); c_s = _expand(clean_m)
+
+        min_n = min(total, *(len(df_out[c]) for c in ('loud', 'mid', 'quiet')))
+        blended = np.zeros(min_n, dtype=np.float64)
+        blended[l_s[:min_n]] = df_out['loud'][:min_n][l_s[:min_n]]
+        blended[m_s[:min_n]] = df_out['mid'][:min_n][m_s[:min_n]]
+        blended[q_s[:min_n]] = df_out['quiet'][:min_n][q_s[:min_n]]
+        # §22.5 clean gate: restore original on already-clean chunks
+        blended[c_s[:min_n]] = mono[:min_n][c_s[:min_n]]
+
+        # ── 120ms sigmoid crossfade at every class boundary (v4: was cosine 40ms) ──
+        # Sigmoid gives perceptually flatter transition — no "click" at midpoint
+        cls_map = (l_s[:min_n].astype(np.int8) * 1 +
+                   m_s[:min_n].astype(np.int8) * 2 +
+                   q_s[:min_n].astype(np.int8) * 3)
+        bounds = np.where(np.diff(cls_map) != 0)[0]
+        FADE = _ADF_XFADE
+        for b in bounds:
+            s_cf = max(0, b - FADE // 2)
+            e_cf = min(min_n, b + FADE // 2)
+            if e_cf <= s_cf: continue
+            ln_ = e_cf - s_cf
+            # Sigmoid: x from -6..+6 → smooth S-curve
+            x   = np.linspace(-6.0, 6.0, ln_)
+            fi_ = 1.0 / (1.0 + np.exp(-x))   # sigmoid fade-in
+            fo  = 1.0 - fi_                    # sigmoid fade-out
+            cb  = int(cls_map[s_cf])
+            ca  = int(cls_map[min(e_cf, min_n - 1)])
+            cb_n = 'loud' if cb==1 else ('mid' if cb==2 else 'quiet')
+            ca_n = 'loud' if ca==1 else ('mid' if ca==2 else 'quiet')
+            # v4: blend through 'trans' class at midpoint for 3-way smooth
+            mid_blend = (
+                df_out[cb_n][:min_n][s_cf:e_cf].astype(np.float64) * fo * 0.5 +
+                df_out['trans'][:min_n][s_cf:e_cf].astype(np.float64) * 0.5 +
+                df_out[ca_n][:min_n][s_cf:e_cf].astype(np.float64) * fi_ * 0.5
+            )
+            blended[s_cf:e_cf] = mid_blend
+        _L(st, f'  [S4-ADF] {len(bounds)} sigmoid crossfades @ {FADE} samp (120ms)')
+
+        # ── RL-16: restore Ghunnah guard bands from original ──────────────
+        blended_f32 = np.where(np.isfinite(blended), blended, 0.0).astype(np.float32)
+        blended_f32 = _stft_restore_bands(blended_f32, mono[:min_n], SR, _RL16_BANDS)
+        _L(st, f'  [S4-ADF] RL-16 bands restored: '
+               f'{", ".join(f"{lo}-{hi}Hz" for lo,hi in _RL16_BANDS)}')
+
+        # ── Silence guard ─────────────────────────────────────────────────
+        if float(np.max(np.abs(blended_f32))) < 1e-4:
+            _L(st, '  [S4-ADF] ⚠ silent result — fallback to mid pass')
+            blended_f32 = df_out['mid'][:min_n].astype(np.float32)
+
+        # ── Encode to pcm_s24le stereo ────────────────────────────────────
         out = _tmp('s4', st)
-        if not _enc_mono(bm, out):
+        r3 = subprocess.run(
+            ['ffmpeg', '-nostdin', '-y', '-hide_banner', '-loglevel', 'error',
+             '-f', 'f32le', '-ar', str(SR), '-ac', '1', '-i', '-',
+             '-ar', str(SR), '-ac', '2', '-acodec', 'pcm_s24le', out],
+            input=blended_f32.tobytes(), capture_output=True, timeout=120)
+        if r3.returncode or not os.path.exists(out):
             return wav
 
-        delta = _rmsdb(b16.astype(np.float32) / 32768.0) - _rmsdb(s16)
-        if abs(delta) > _RMS_MAX_DELTA * 2:
-            _cleanup(out); st.guard_reverts += 1
-            _L(st, f'  [S4-DF3] RMS Δ={delta:+.2f}dB — REVERT'); return wav
+        delta = _rmsdb(blended_f32) - _rmsdb(mono)
         st.df3 = True
-        _L(st, f'  [S4-DF3] ✓ sa={sa} ra={ra} ta={ta} RMS Δ={delta:+.2f}dB  '
-              f'speech={int(np.sum(labels==0))} trans={int(np.sum(labels==1))} '
-              f'tail={int(np.sum(labels==2))}')
+        _L(st, f'  [S4-ADF] ✓  loud={a_loud}dB mid={a_mid}dB quiet={a_quiet}dB '
+               f'RMS Δ={delta:+.2f}dB')
         return out
     except Exception as e:
         _L(st, f'  [S4-DF3] exception: {e}'); return wav
@@ -595,18 +709,29 @@ def _jalaa(wav, samples, rt60, drr_before, st):
     if not nf_vals:
         _L(st, '  [S5-JALAA] no reverb frames — skip'); return wav
 
-    nf = float(np.clip(float(np.median(nf_vals)) + 3, -72, -25))
-    nr = 2 if rt60 > RT60_AGGR else 1
+    nf = float(np.clip(float(np.median(nf_vals)) + 3, -72, -20))  # v4: floor raised -25→-20
+    nr = 3 if rt60 > RT60_AGGR else 2   # v4: base raised (was 2/1)
     if st.mujawwad_conf > 0.6: nr = max(1, nr - 1)
 
-    out = _tmp('s5', st)
+    # v4: two-pass JALAA — first pass stationary, second adaptive tracking
+    out = _tmp('s5a', st)
     rc, _, _ = _run(['ffmpeg', '-y', '-i', wav,
-                     '-af', f'afftdn=nr={nr}:nf={nf:.0f}:tn=1',
+                     '-af', f'afftdn=nr={nr}:nf={nf:.0f}:nt=w:tn=1',
                      '-acodec', WAV_CODEC, '-ar', str(SR), '-ac', '1',
                      '-loglevel', 'error', out])
     if rc or not os.path.exists(out):
         return wav
 
+    out2 = _tmp('s5b', st)
+    rc2, _, _ = _run(['ffmpeg', '-y', '-i', out,
+                      '-af', f'afftdn=nr={max(1,nr-1)}:nf={nf+3:.0f}:nt=w:tn=1',
+                      '-acodec', WAV_CODEC, '-ar', str(SR), '-ac', '1',
+                      '-loglevel', 'error', out2])
+    if rc2 or not os.path.exists(out2):
+        pass  # keep single-pass result
+    else:
+        _cleanup(out); out = out2
+
     post = _decode(out)
     if post is not None:
         d = _rmsdb(post) - _rmsdb(samples)
@@ -619,35 +744,96 @@ def _jalaa(wav, samples, rt60, drr_before, st):
     return out
 
 
-# ─── Stage 6: Tail floor NR ───────────────────────────────────────────────────
+# ─── Stage 6: Tail floor NR — 2-stage (afftdn + anlmdn) ─────────────────────
 def _tailnr(wav, samples, rt60, st):
     """
+    2-stage NR pipeline (§83.3 order: stationary → non-stationary):
+      Stage A: afftdn with nt=w (adaptive tracking) for stationary noise floor.
+      Stage B: anlmdn (s=7:p=3:r=15) for transient/non-stationary residuals.
+    RT60-scaled nr: base=2, +1 per 1.5s RT60 above threshold, cap=5 (§5.3: 20dB/nr max).
     [I3] If JALAA already ran, reduce nr by 1 to avoid double-attenuation.
+    RL-16: sibilant SNR guard — revert if Safir/Tafasshi band drops > 2dB.
     """
     if rt60 < RT60_TAILNR or samples is None or not NUMPY_OK:
         return wav
     fn = int(0.200 * SR)
     overall = _rmsdb(samples)
-    fdb = np.array([float(20 * np.log10(np.sqrt(np.mean(samples[i:i + fn] ** 2)) + 1e-10))
+    fdb = np.array([float(20 * np.log10(np.sqrt(np.mean(samples[i:i+fn]**2)) + 1e-10))
                     for i in range(0, len(samples) - fn, fn)])
     quiet = fdb[fdb < overall - 10]
     if len(quiet) == 0:
         return wav
-    nf = float(np.clip(float(np.median(quiet)) + 4, -72, -30))
-    nr = 3 if rt60 > RT60_AGGR else 2
+
+    nf = float(np.clip(float(np.median(quiet)) + 4, -72, -25))
+    # v4: RT60-scaled nr — higher cap (8 was 5), stronger base
+    nr = min(8, 3 + int((rt60 - RT60_TAILNR) / 1.2))   # was cap=5, base=2, step=1.5
     if st.mujawwad_conf > 0.6: nr = max(1, nr - 1)
-    if st.jalaa:               nr = max(1, nr - 1)   # [I3] JALAA already ran
-    out = _tmp('s6', st)
+    if st.jalaa:               nr = max(1, nr - 1)   # [I3]
+
+    # ── Stage A: afftdn with adaptive noise tracking ──────────────────────
+    out_a = _tmp('s6a', st)
     rc, _, _ = _run(['ffmpeg', '-y', '-i', wav,
-                     '-af', f'afftdn=nr={nr}:nf={nf:.0f}:tn=1',
-                     '-acodec', WAV_CODEC, '-ar', str(SR), '-ac', '1',
-                     '-loglevel', 'error', out])
-    if rc or not os.path.exists(out):
+                     '-af', f'afftdn=nr={nr}:nf={nf:.0f}:nt=w:om=o',
+                     '-acodec', WAV_CODEC, '-ar', str(SR), '-ac', '2',
+                     '-loglevel', 'error', out_a])
+    if rc or not os.path.exists(out_a):
         return wav
+
+    # ── Stage B: anlmdn for non-stationary residuals ──────────────────────
+    # anlmdn: s=patch size, p=context, r=search radius (§95 KB)
+    # Scale strength with nr: gentle (s=5) at nr<=2, standard (s=7) at nr>2
+    patch = 7 if nr > 2 else 5
+    out_b = _tmp('s6b', st)
+    rc2, _, _ = _run(['ffmpeg', '-y', '-i', out_a,
+                      '-af', f'anlmdn=s={patch}:p=3:r=15:m=1',
+                      '-acodec', WAV_CODEC, '-ar', str(SR), '-ac', '2',
+                      '-loglevel', 'error', out_b])
+    if rc2 or not os.path.exists(out_b):
+        # Stage B failed — commit Stage A only
+        st.tail_nr = True
+        jalaa_note = ' (JALAA-adj)' if st.jalaa else ''
+        _L(st, f'  [S6-tailNR] ✓ 1-stage nr={nr}{jalaa_note} nf={nf:.0f}dB  '
+               f'[anlmdn failed — Stage A only]')
+        return out_a
+
+    # ── Sibilant SNR guard (RL-16 spirit) ─────────────────────────────────
+    post_s = _decode(out_b)
+    if post_s is not None:
+        sib_orig = _band_energy(samples, 3500, 8000)
+        sib_post = _band_energy(post_s,  3500, 8000)
+        sib_drop = sib_post - sib_orig
+        if sib_drop < -2.0:
+            _L(st, f'  [S6-tailNR] sibilant drop {sib_drop:+.1f}dB — '
+                   f'revert Stage B, keep Stage A')
+            _cleanup(out_b)
+            st.tail_nr = True
+            _L(st, f'  [S6-tailNR] ✓ nr={nr} nf={nf:.0f}dB [Stage A only]')
+            return out_a
+
+    # ── Stage C: v4 — gentle anlmdn second pass for reverb tail residual ────
+    out_c = _tmp('s6c', st)
+    rc3, _, _ = _run(['ffmpeg', '-y', '-i', out_b,
+                      '-af', f'anlmdn=s=5:p=3:r=10:m=1',
+                      '-acodec', WAV_CODEC, '-ar', str(SR), '-ac', '2',
+                      '-loglevel', 'error', out_c])
+    if rc3 or not os.path.exists(out_c):
+        pass  # keep Stage B
+    else:
+        post_c = _decode(out_c)
+        if post_c is not None:
+            sib_c = _band_energy(post_c, 3500, 8000)
+            sib_drop_c = sib_c - _band_energy(samples, 3500, 8000)
+            if sib_drop_c >= -2.5:
+                _cleanup(out_b); out_b = out_c
+            else:
+                _cleanup(out_c)
+
+    _cleanup(out_a)
     st.tail_nr = True
-    jalaa_note = ' (JALAA-adjusted)' if st.jalaa else ''
-    _L(st, f'  [S6-tailNR] ✓ nr={nr}{jalaa_note} nf={nf:.0f}dB')
-    return out
+    jalaa_note = ' (JALAA-adj)' if st.jalaa else ''
+    _L(st, f'  [S6-tailNR] ✓ 3-stage nr={nr}{jalaa_note} nf={nf:.0f}dB '
+           f'patch={patch} rt60={rt60:.1f}s')
+    return out_b
 
 
 # ─── Stage 7: Arabic phoneme guards (§35/§52/§143/§152) ──────────────────────
@@ -804,14 +990,16 @@ def process(input_path, output_path, source_tier='TIER_UNKNOWN',
         # S7 Arabic guards
         cur = _arabic_guards(s_orig, cur, st)
 
-        # Final stereo encode [I2]
+        # Final stereo encode + S8 volume boost + v4: presence lift 2kHz +1.5dB
         rc, _, err = _run(['ffmpeg', '-y', '-i', cur,
-                           '-acodec', 'libmp3lame', '-ar', str(SR), '-ac', '1',
-                           '-b:a', '320k',
+                           '-af', ('volume=1.85,'
+                                   'equalizer=f=2000:width_type=o:width=1.0:g=1.5,'
+                                   'equalizer=f=300:width_type=o:width=1.0:g=-1.0,'
+                                   'alimiter=level_in=1:level_out=1:limit=0.89:attack=5:release=50'),
+                           '-acodec', WAV_CODEC, '-ar', str(SR), '-ac', '2',
                            '-loglevel', 'error', output_path])
         if rc:
-            _L(st, f'  ERROR: final encode: {err[:80]}')
-            sys.exit(1)  # S169b: non-zero rc so app.py detects failure
+            _L(st, f'  ERROR: final encode: {err[:80]}'); return st
 
         sf_ = _decode(output_path)
         if sf_ is not None: st.drr_after = _drr(sf_)
@@ -834,15 +1022,11 @@ def process(input_path, output_path, source_tier='TIER_UNKNOWN',
 if __name__ == '__main__':
     import argparse, json
     ap = argparse.ArgumentParser(description=f'الصفاء {__version__} — Dereverberation Engine')
-    # S156-B1: use -i/-o flags to match server calling convention
-    # server: python3 engine_safaa_v3_fixed.py -i input -o output --iterations 3 --ref ref
-    ap.add_argument('-i', '--input',      required=True,  dest='input')
-    ap.add_argument('-o', '--output',     required=True,  dest='output')
-    ap.add_argument('--iterations',       type=int,   default=3)   # accepted, ignored (pipeline is fixed)
-    ap.add_argument('--ref',              action='append', default=[], metavar='REF')  # accepted, ignored
-    ap.add_argument('--tier',             default='TIER_UNKNOWN')
-    ap.add_argument('--mujawwad',         type=float, default=0.0)
-    ap.add_argument('--rt60',             type=float, default=0.0, help='Force RT60 (0=auto)')
+    ap.add_argument('input')
+    ap.add_argument('output')
+    ap.add_argument('--tier',     default='TIER_UNKNOWN')
+    ap.add_argument('--mujawwad', type=float, default=0.0)
+    ap.add_argument('--rt60',     type=float, default=0.0, help='Force RT60 (0=auto)')
     a = ap.parse_args()
     st = process(a.input, a.output,
                  source_tier=a.tier, mujawwad_conf=a.mujawwad, force_rt60=a.rt60)

requirements.txt

@@ -5,3 +5,4 @@ scipy==1.13.1
 gunicorn==22.0.0
 librosa
 soundfile
+nara_wpe