Replace phase vocoder with guarded WSOLA

README.md

@@ -293,7 +293,7 @@ independent full-large-v3 與 final whole-waveform gate 全部維持 exact endpo
 不超過 6 個 speech units 的短句會使用最低 CFG 3.0；stop threshold 只在預估進度 75% 後逐步降低，並於 95% 進度降至 0.05，以捕捉句末弱 stop 訊號而不影響前段內容。
 一至兩個 speech units 的極短普通文字若原本會以 1.0 倍速輸出，會從未經處理的 model waveform
 直接做一次保音高的 0.95 倍重繪，再接受完整 semantic、SQUIM、endpoint 與 PCM16 gate；
-不會串接多次 phase-vocoder，也不會放寬任何候選門檻。
+不會串接多次 time-scale modification，也不會放寬任何候選門檻。
 80 字內的 request 不再為了 onset 額外切段；長文才依自然標點與 80 字上限切段，避免人工
 endpoint、孤立引號與不必要的局部 prefix/suffix gate。Release
 profile 鎖定 primary CFG 3.0 / alternate CFG 2.0 交錯候選排程、NFE 10、
@@ -304,12 +304,18 @@ pause 不會稀釋 CPS。逐 active interval 的 stretcher 曾在固定 root abl
 回退，因此仍不切開 active intervals；production 會先在 model 的 raw completed waveform 上合併
 total-duration 與 active-union 的 bounded rate，再量測一次 probe waveform。若 probe active pace
 仍高於 3.95，會把 residual rate 乘回原 combined rate，並從 untouched model waveform 重新 render；
-最後交給 verifier 與使用者的 samples 因此仍只經過一層 librosa phase vocoder。一般文字
-固定 `n_fft=1536`、`hop_length=384`，URL/email code-switch chunk 使用 `2048/512` 保留較細的
-network lexical distinction，總 stretch rate 不低於 0.80。這替最高 1.05 playback speed 與
-chunk join 保留 4.3 CPS gate 的安全餘量；任何仍過快或被 stretch 破壞的候選照常由後續完整 gate
-fail closed。Median-F0 只對實際具備 DP coverage eligibility 的 multi-chunk rows 計算，single/K32、
-semantic reject、joined 與 final waveform 不再支付無用的 pYIN latency。
+最後交給 verifier 與使用者的 samples 因此只經過一層 deterministic mono WSOLA。自動 stretch
+rate 的硬下限固定為 0.90，過去 long-text `0.76` escape 已移除；若 0.90 仍無法通過 4.3 CPS
+gate，必須改選候選或 fail closed，不得再拉長。公開的後處理語速固定為 1.0，避免第二次
+time-scale modification 與隱性的 rate 相乘。
+
+所有不少於 1.0 秒的 local、joined 與 final waveform 另通過 deterministic no-reference
+echo/smearing gate。Gate 聚合多個 active windows 的 24–180 ms 長 quefrency cepstrum，拒絕固定
+delayed-copy comb peak 或 dense smearing signature；無效、非有限或缺少足夠 active-window
+evidence 都 fail closed。短於 1.0 秒時 estimator 不適用，仍由原有 strict semantic、endpoint
+與 SQUIM gate 負責。任何仍過快、被 stretch 破壞或具有可量測回音的候選均不會回傳。
+Median-F0 只對實際具備 DP coverage eligibility 的 multi-chunk rows 計算，single/K32、semantic
+reject、joined 與 final waveform 不再支付無用的 pYIN latency。
 
 Generation work 以實際產生的 chunks 與其 speech units 累計：初始 trajectory 花費
 `chunk count` 與全文 speech units；每次 refill 再加 1 chunk 與該段 units。任一 request 最多

app.py

@@ -92,6 +92,11 @@ torch.backends.cudnn.deterministic = CUDNN_DETERMINISTIC
 torch.backends.cuda.matmul.allow_tf32 = CUDA_MATMUL_ALLOW_TF32
 torch.backends.cudnn.allow_tf32 = CUDNN_ALLOW_TF32
 
+from audio_wsola import wsola_time_stretch
+from audio_artifact_gate import (
+    DEFAULT_ECHO_SMEARING_GATE_CONFIG,
+    evaluate_echo_smearing,
+)
 from bluemagpie import BlueMagpieModel
 from glyph_ascii_v1 import GLYPH_ASCII_V1_SYMBOLS
 from glyph_assets import (
@@ -244,15 +249,11 @@ STOP_LATE_THRESHOLD = 0.05
 STOP_LATE_START_RATIO = 0.75
 STOP_LATE_FULL_RATIO = 0.95
 STOP_CONSECUTIVE = 1
-MIN_PACE_SPEED = 0.80
+MIN_PACE_SPEED = 0.90
 EXTREME_SHORT_MAX_UNITS = 2
 EXTREME_SHORT_MAX_SPEED = 0.95
-PACE_ONLY_FALLBACK_MIN_SPEED = 0.76
+PACE_ONLY_FALLBACK_MIN_SPEED = MIN_PACE_SPEED
 PACE_ONLY_FALLBACK_MIN_UNITS = 30
-PACE_STRETCH_N_FFT = 1536
-PACE_STRETCH_HOP_LENGTH = 384
-NETWORK_PACE_STRETCH_N_FFT = 2048
-NETWORK_PACE_STRETCH_HOP_LENGTH = 512
 MAX_TEXT_CHARS = 360
 QUALITY_MAX_GENERATED_CHUNKS = 32
 QUALITY_MAX_GENERATED_TEXT_UNITS = 800
@@ -530,24 +531,112 @@ def _apply_speed(
     *,
     network_conditioned: bool = False,
 ) -> np.ndarray:
-    speed = float(speed or 1.0)
+    del network_conditioned
+    try:
+        speed = float(speed)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise ValueError("speed must be finite and positive") from error
+    if not np.isfinite(speed) or speed <= 0.0:
+        raise ValueError("speed must be finite and positive")
+    if speed < MIN_PACE_SPEED:
+        raise ValueError(
+            f"speed is below the production WSOLA floor {MIN_PACE_SPEED:.2f}"
+        )
     if abs(speed - 1.0) < 1.0e-3:
-        return audio
-    n_fft = (
-        NETWORK_PACE_STRETCH_N_FFT
-        if network_conditioned
-        else PACE_STRETCH_N_FFT
+        return np.asarray(audio, dtype=np.float32)
+    return wsola_time_stretch(
+        audio,
+        rate=speed,
+        sample_rate=SR,
     )
-    hop_length = (
-        NETWORK_PACE_STRETCH_HOP_LENGTH
-        if network_conditioned
-        else PACE_STRETCH_HOP_LENGTH
+
+
+def _apply_echo_smearing_gate(
+    verification,
+    waveforms: tuple[np.ndarray | None, ...],
+):
+    """Reject analyzable candidates with fixed echo or smearing evidence.
+
+    The no-reference metric needs at least one second of waveform evidence.
+    Shorter utterances remain governed by the existing semantic, endpoint and
+    SQUIM contracts instead of being rejected by an inapplicable estimator.
+    Every analyzable waveform is fail-closed: missing/non-finite/insufficient
+    active-window evidence becomes an acoustic rejection.
+    """
+
+    if len(waveforms) != len(verification.candidate_results):
+        raise ValueError("audio artifact evidence does not align")
+    updated_results = []
+    for index, (waveform, result) in enumerate(
+        zip(waveforms, verification.candidate_results, strict=True)
+    ):
+        if waveform is None:
+            updated_results.append(result)
+            continue
+        duration_seconds = waveform.size / float(SR)
+        if (
+            duration_seconds
+            < DEFAULT_ECHO_SMEARING_GATE_CONFIG.min_duration_seconds
+        ):
+            print(
+                "[BlueMagpie] audio artifact gate "
+                f"chunk={index} applicable=false "
+                f"duration={duration_seconds:.6f}"
+            )
+            updated_results.append(result)
+            continue
+
+        diagnostics = evaluate_echo_smearing(waveform, SR)
+        print(
+            "[BlueMagpie] audio artifact gate "
+            f"chunk={index} applicable=true passed={diagnostics.passed} "
+            f"delayed_score={diagnostics.delayed_copy_score:.6f} "
+            f"smearing_score={diagnostics.smearing_score:.6f} "
+            f"delay_ms={diagnostics.dominant_delay_ms:.3f} "
+            f"peak_ratio={diagnostics.cepstral_peak_ratio:.6f} "
+            f"windows={diagnostics.analysis_window_count} "
+            f"reasons={diagnostics.rejection_reasons}"
+        )
+        if diagnostics.passed:
+            updated_results.append(result)
+            continue
+        artifact_reasons = tuple(
+            f"audio_artifact_{reason}"
+            for reason in diagnostics.rejection_reasons
+        ) or ("audio_artifact_unavailable",)
+        updated_results.append(
+            replace(
+                result,
+                passed=False,
+                score=float("inf"),
+                rejection_reasons=tuple(
+                    dict.fromkeys(
+                        (*result.rejection_reasons, *artifact_reasons)
+                    )
+                ),
+            )
+        )
+
+    candidate_results = tuple(updated_results)
+    passed = bool(candidate_results) and all(
+        result.passed for result in candidate_results
     )
-    return librosa.effects.time_stretch(
-        np.asarray(audio, dtype=np.float32),
-        rate=speed,
-        n_fft=n_fft,
-        hop_length=hop_length,
+    score = (
+        sum(result.score for result in candidate_results)
+        if passed
+        else float("inf")
+    )
+    rejection_reasons = tuple(
+        f"chunk_{index}:{reason}"
+        for index, result in enumerate(candidate_results)
+        for reason in result.rejection_reasons
+    )
+    return replace(
+        verification,
+        passed=passed,
+        candidate_results=candidate_results,
+        score=score,
+        rejection_reasons=rejection_reasons,
     )
 
 
@@ -737,7 +826,7 @@ def _generate_chunk(
             f"total_rate={final_speed:.6f}"
         )
         # Re-render from the untouched model waveform so the returned samples
-        # have exactly one pitch-preserving phase-vocoder pass.
+        # have exactly one pitch-preserving WSOLA pass.
         final_audio = _apply_speed(
             audio,
             final_speed,
@@ -1122,6 +1211,11 @@ def _verify_trajectory_audio(
         min_squim_stoi=QUALITY_MIN_SQUIM_STOI,
         min_squim_pesq=QUALITY_MIN_SQUIM_PESQ,
     )
+    if not semantic_only:
+        verification = _apply_echo_smearing_gate(
+            verification,
+            tuple(prepared_waveforms),
+        )
     return _attach_transition_f0(
         verification,
         tuple(prepared_waveforms),
@@ -2035,8 +2129,8 @@ def _synthesize(
         raise gr.Error("輸入必須包含可發音的文字或數字。")
     if normalized_units > QUALITY_MAX_GENERATED_TEXT_UNITS:
         raise gr.Error("正規化後的語音單位超過安全生成上限，請分段合成。")
-    if not np.isfinite(float(speed)) or not 0.85 <= float(speed) <= 1.05:
-        raise gr.Error("後處理語速必須介於 0.85 與 1.05。")
+    if not np.isfinite(float(speed)) or float(speed) != 1.0:
+        raise gr.Error("後處理語速固定為 1.0；減速已由品質管線控制。")
 
     chunk_specs: tuple[GenerationChunkSpec, ...] | None = None
     try:
@@ -3377,7 +3471,8 @@ HEADER = f"""
 不額外切開 80 字內的首段，長文才依自然標點與 80 字上限切段。每個 request 只生成一次
 same-seed 完整 trajectory；失敗後只補低覆蓋 chunks，再以 speaker/RMS/F0 ragged DP 選出最多三條
 culprit-diverse exact paths。NFE 固定為已驗證的 10，且每個 request 最多生成 32 個 TTS chunks
-與 800 speech units。
+與 800 speech units。語速校正使用 deterministic WSOLA，總 rate 不低於 0.90；不少於 1 秒的
+候選與最終波形另須通過 echo/smearing gate。
 """
 
 
@@ -3397,7 +3492,11 @@ with gr.Blocks(title="BlueMagpie-TTS Demo", theme=gr.themes.Soft()) as demo:
                 interactive=False,
                 label="NFE steps（已驗證固定值）",
             )
-            speed_input = gr.Slider(0.85, 1.05, value=1.0, step=0.05, label="後處理語速")
+            speed_input = gr.Number(
+                value=1.0,
+                interactive=False,
+                label="後處理語速（已驗證固定值）",
+            )
 
     with gr.Tab("內建語者"):
         with gr.Row():

audio_artifact_gate.py

@@ -0,0 +1,439 @@
+"""Deterministic, no-reference echo and smearing gate.
+
+The gate is intentionally conservative.  It looks for a *time-invariant*
+comb/echo signature that survives across several active analysis windows:
+
+* a narrow long-quefrency cepstral peak is evidence of a delayed copy; and
+* a dense set of long-quefrency peaks is a proxy for reverberant smearing.
+
+Content-dependent pitch and formants move between windows, while a fixed echo
+path does not.  Taking the median cepstrum across windows therefore avoids most
+of the false positives produced by a plain waveform autocorrelation.  This is
+not a room-acoustics measurement and should be used as a fail-closed candidate
+gate, not as a perceptual quality score.
+
+Only NumPy is required and the analysis is deterministic for identical input.
+"""
+
+from __future__ import annotations
+
+import math
+import operator
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class EchoSmearingGateConfig:
+    """Configuration for :func:`evaluate_echo_smearing`.
+
+    The defaults reject only pronounced delayed-copy or dense-comb artifacts.
+    Scores are normalized to ``[0, 1]`` before the two gate thresholds are
+    applied.
+    """
+
+    min_sample_rate: int = 8_000
+    max_sample_rate: int = 192_000
+    min_duration_seconds: float = 1.0
+    window_seconds: float = 0.60
+    candidate_window_count: int = 27
+    max_analysis_windows: int = 9
+    min_analysis_windows: int = 3
+    min_rms: float = 1.0e-5
+    relative_active_rms: float = 0.12
+    min_delay_ms: float = 24.0
+    max_delay_ms: float = 180.0
+    frequency_smoothing_hz: float = 70.0
+    # A raw median-cepstral peak ratio of 8.965 maps to the default rejection
+    # boundary.  Calibration controls topped out at 6.61, while the deployed
+    # echo-like smoke output measured 10.34.
+    delayed_ratio_floor: float = 5.5
+    delayed_ratio_ceiling: float = 16.0
+    smear_q99_ratio_floor: float = 3.0
+    smear_q99_ratio_ceiling: float = 6.0
+    smear_density_floor: float = 0.008
+    smear_density_ceiling: float = 0.035
+    delayed_copy_threshold: float = 0.33
+    smearing_threshold: float = 0.40
+
+
+DEFAULT_ECHO_SMEARING_GATE_CONFIG = EchoSmearingGateConfig()
+
+
+@dataclass(frozen=True)
+class EchoSmearingDiagnostics:
+    """Finite diagnostics and the fail-closed gate decision."""
+
+    passed: bool
+    rejection_reasons: tuple[str, ...]
+    delayed_copy_score: float
+    smearing_score: float
+    dominant_delay_ms: float
+    cepstral_peak_ratio: float
+    cepstral_q99_ratio: float
+    cepstral_dense_fraction: float
+    duration_seconds: float
+    input_rms: float
+    analysis_window_count: int
+
+
+def _bounded(value: float, lower: float, upper: float) -> float:
+    if not math.isfinite(value) or upper <= lower:
+        return 0.0
+    return float(np.clip((value - lower) / (upper - lower), 0.0, 1.0))
+
+
+def _finite_nonnegative(value: Any) -> float:
+    try:
+        converted = float(value)
+    except (TypeError, ValueError, OverflowError):
+        return 0.0
+    if not math.isfinite(converted) or converted < 0.0:
+        return 0.0
+    return converted
+
+
+def _rejected(
+    reason: str,
+    *,
+    duration_seconds: float = 0.0,
+    input_rms: float = 0.0,
+) -> EchoSmearingDiagnostics:
+    return EchoSmearingDiagnostics(
+        passed=False,
+        rejection_reasons=(reason,),
+        delayed_copy_score=0.0,
+        smearing_score=0.0,
+        dominant_delay_ms=0.0,
+        cepstral_peak_ratio=0.0,
+        cepstral_q99_ratio=0.0,
+        cepstral_dense_fraction=0.0,
+        duration_seconds=_finite_nonnegative(duration_seconds),
+        input_rms=_finite_nonnegative(input_rms),
+        analysis_window_count=0,
+    )
+
+
+def _valid_config(config: EchoSmearingGateConfig) -> bool:
+    integer_fields = (
+        config.min_sample_rate,
+        config.max_sample_rate,
+        config.candidate_window_count,
+        config.max_analysis_windows,
+        config.min_analysis_windows,
+    )
+    if any(
+        isinstance(value, (bool, np.bool_))
+        or not isinstance(value, (int, np.integer))
+        for value in integer_fields
+    ):
+        return False
+    if not (
+        1 <= config.min_sample_rate <= config.max_sample_rate
+        and config.candidate_window_count >= config.max_analysis_windows
+        and config.max_analysis_windows >= config.min_analysis_windows >= 1
+    ):
+        return False
+
+    finite_fields = (
+        config.min_duration_seconds,
+        config.window_seconds,
+        config.min_rms,
+        config.relative_active_rms,
+        config.min_delay_ms,
+        config.max_delay_ms,
+        config.frequency_smoothing_hz,
+        config.delayed_ratio_floor,
+        config.delayed_ratio_ceiling,
+        config.smear_q99_ratio_floor,
+        config.smear_q99_ratio_ceiling,
+        config.smear_density_floor,
+        config.smear_density_ceiling,
+        config.delayed_copy_threshold,
+        config.smearing_threshold,
+    )
+    try:
+        finite = all(math.isfinite(float(value)) for value in finite_fields)
+    except (TypeError, ValueError, OverflowError):
+        return False
+    if not finite:
+        return False
+    return bool(
+        config.min_duration_seconds > 0.0
+        and config.window_seconds > 0.0
+        and config.min_rms > 0.0
+        and 0.0 < config.relative_active_rms <= 1.0
+        and 0.0 < config.min_delay_ms < config.max_delay_ms
+        and config.frequency_smoothing_hz > 0.0
+        and config.delayed_ratio_floor < config.delayed_ratio_ceiling
+        and config.smear_q99_ratio_floor < config.smear_q99_ratio_ceiling
+        and config.smear_density_floor < config.smear_density_ceiling
+        and 0.0 <= config.delayed_copy_threshold <= 1.0
+        and 0.0 <= config.smearing_threshold <= 1.0
+    )
+
+
+def _moving_average(values: np.ndarray, width: int) -> np.ndarray:
+    """Return an edge-padded centered moving average in linear time."""
+
+    width = max(1, min(int(width), int(values.size)))
+    if width % 2 == 0:
+        width = max(1, width - 1)
+    if width == 1:
+        return values.copy()
+    radius = width // 2
+    padded = np.pad(values, (radius, radius), mode="edge")
+    cumulative = np.concatenate(
+        (np.zeros(1, dtype=np.float64), np.cumsum(padded, dtype=np.float64))
+    )
+    return (cumulative[width:] - cumulative[:-width]) / float(width)
+
+
+def _analysis_starts(
+    waveform: np.ndarray,
+    window_samples: int,
+    config: EchoSmearingGateConfig,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Select deterministic high-energy windows distributed over the input."""
+
+    last_start = waveform.size - window_samples
+    candidate_count = min(
+        config.candidate_window_count,
+        max(1, last_start // max(1, window_samples // 3) + 1),
+    )
+    starts = np.unique(
+        np.linspace(0, last_start, num=candidate_count, dtype=np.int64)
+    )
+    rms_values_list: list[float] = []
+    for start in starts:
+        window = np.asarray(
+            waveform[int(start) : int(start) + window_samples],
+            dtype=np.float64,
+        )
+        centered = window - float(np.mean(window))
+        rms_values_list.append(
+            math.sqrt(
+                float(
+                    np.mean(
+                        np.square(centered, dtype=np.float64),
+                        dtype=np.float64,
+                    )
+                )
+            )
+        )
+    rms_values = np.asarray(rms_values_list, dtype=np.float64)
+    active_floor = max(config.min_rms, config.relative_active_rms * float(rms_values.max()))
+    active_indices = np.flatnonzero(rms_values >= active_floor)
+    if active_indices.size > config.max_analysis_windows:
+        # Keep the strongest windows.  Sorting their positions afterwards
+        # makes the output independent of NumPy's tie ordering.
+        ranked = sorted(
+            active_indices.tolist(),
+            key=lambda index: (-float(rms_values[index]), int(starts[index])),
+        )
+        active_indices = np.asarray(
+            sorted(ranked[: config.max_analysis_windows]), dtype=np.int64
+        )
+    return starts[active_indices], rms_values[active_indices]
+
+
+def _window_cepstrum(
+    window: np.ndarray,
+    sample_rate: int,
+    config: EchoSmearingGateConfig,
+    max_delay_samples: int,
+) -> np.ndarray:
+    centered = np.asarray(window, dtype=np.float64) - float(np.mean(window))
+    emphasized = np.empty_like(centered)
+    emphasized[0] = centered[0]
+    emphasized[1:] = centered[1:] - 0.97 * centered[:-1]
+    emphasized *= np.hanning(emphasized.size)
+
+    fft_size = 1 << max(1, (2 * emphasized.size - 1).bit_length())
+    magnitude = np.abs(np.fft.rfft(emphasized, n=fft_size))
+    magnitude_floor = max(
+        np.finfo(np.float64).tiny,
+        float(magnitude.max()) * 1.0e-6,
+    )
+    log_magnitude = np.log(np.maximum(magnitude, magnitude_floor))
+    bin_hz = sample_rate / float(fft_size)
+    smoothing_bins = max(3, int(round(config.frequency_smoothing_hz / bin_hz)))
+    if smoothing_bins % 2 == 0:
+        smoothing_bins += 1
+    residual = log_magnitude - _moving_average(log_magnitude, smoothing_bins)
+    residual -= float(np.mean(residual))
+    cepstrum = np.abs(np.fft.irfft(residual, n=fft_size))
+    return np.asarray(cepstrum[: max_delay_samples + 1], dtype=np.float64)
+
+
+def evaluate_echo_smearing(
+    audio: Any,
+    sample_rate: Any,
+    *,
+    config: EchoSmearingGateConfig = DEFAULT_ECHO_SMEARING_GATE_CONFIG,
+) -> EchoSmearingDiagnostics:
+    """Measure delayed-copy and smearing proxies and fail closed.
+
+    Invalid, silent, clipped-to-nonfinite, too-short, or analytically
+    insufficient inputs return a rejected result rather than raising.  Every
+    floating-point field in the result is finite.
+    """
+
+    if not isinstance(config, EchoSmearingGateConfig) or not _valid_config(config):
+        return _rejected("invalid_config")
+    if isinstance(sample_rate, (bool, np.bool_)):
+        return _rejected("invalid_sample_rate")
+    try:
+        rate = operator.index(sample_rate)
+    except (TypeError, ValueError, OverflowError):
+        return _rejected("invalid_sample_rate")
+    rate = int(rate)
+    if not config.min_sample_rate <= rate <= config.max_sample_rate:
+        return _rejected("invalid_sample_rate")
+
+    try:
+        waveform = np.asarray(audio)
+    except (TypeError, ValueError, OverflowError):
+        return _rejected("invalid_audio")
+    if (
+        waveform.ndim != 1
+        or waveform.size == 0
+        or waveform.dtype.kind not in "fiu"
+    ):
+        return _rejected("invalid_audio")
+    try:
+        waveform = waveform.astype(np.float64, copy=False)
+    except (TypeError, ValueError, OverflowError):
+        return _rejected("invalid_audio")
+    duration = float(waveform.size / rate)
+    if not np.isfinite(waveform).all():
+        return _rejected("nonfinite_audio", duration_seconds=duration)
+    input_rms = math.sqrt(
+        float(np.mean(np.square(waveform, dtype=np.float64), dtype=np.float64))
+    )
+    if not math.isfinite(input_rms) or input_rms < config.min_rms:
+        return _rejected(
+            "silent_audio",
+            duration_seconds=duration,
+            input_rms=input_rms,
+        )
+    if duration < config.min_duration_seconds:
+        return _rejected(
+            "insufficient_duration",
+            duration_seconds=duration,
+            input_rms=input_rms,
+        )
+
+    window_samples = max(8, int(round(config.window_seconds * rate)))
+    min_delay_samples = max(1, int(round(config.min_delay_ms * rate / 1000.0)))
+    max_delay_samples = int(round(config.max_delay_ms * rate / 1000.0))
+    if (
+        waveform.size < window_samples
+        or max_delay_samples <= min_delay_samples
+        or max_delay_samples >= window_samples // 2
+    ):
+        return _rejected(
+            "invalid_analysis_geometry",
+            duration_seconds=duration,
+            input_rms=input_rms,
+        )
+
+    starts, _window_rms = _analysis_starts(waveform, window_samples, config)
+    if starts.size < config.min_analysis_windows:
+        return _rejected(
+            "insufficient_active_windows",
+            duration_seconds=duration,
+            input_rms=input_rms,
+        )
+
+    cepstra = np.asarray(
+        [
+            _window_cepstrum(
+                waveform[int(start) : int(start) + window_samples],
+                rate,
+                config,
+                max_delay_samples,
+            )
+            for start in starts
+        ],
+        dtype=np.float64,
+    )
+    aggregate = np.median(
+        cepstra[:, min_delay_samples : max_delay_samples + 1],
+        axis=0,
+    )
+    if aggregate.size == 0 or not np.isfinite(aggregate).all():
+        return _rejected(
+            "nonfinite_analysis",
+            duration_seconds=duration,
+            input_rms=input_rms,
+        )
+
+    baseline = max(float(np.median(aggregate)), np.finfo(np.float64).eps)
+    peak_index = int(np.argmax(aggregate))
+    peak_ratio = float(aggregate[peak_index] / baseline)
+    q99_ratio = float(np.percentile(aggregate, 99.0) / baseline)
+    dense_fraction = float(np.mean(aggregate > (3.0 * baseline)))
+    dominant_delay_ms = float(
+        (min_delay_samples + peak_index) * 1000.0 / rate
+    )
+    if not all(
+        math.isfinite(value)
+        for value in (
+            peak_ratio,
+            q99_ratio,
+            dense_fraction,
+            dominant_delay_ms,
+        )
+    ):
+        return _rejected(
+            "nonfinite_analysis",
+            duration_seconds=duration,
+            input_rms=input_rms,
+        )
+
+    delayed_score = _bounded(
+        peak_ratio,
+        config.delayed_ratio_floor,
+        config.delayed_ratio_ceiling,
+    )
+    q99_component = _bounded(
+        q99_ratio,
+        config.smear_q99_ratio_floor,
+        config.smear_q99_ratio_ceiling,
+    )
+    density_component = _bounded(
+        dense_fraction,
+        config.smear_density_floor,
+        config.smear_density_ceiling,
+    )
+    smearing_score = float(math.sqrt(q99_component * density_component))
+
+    reasons: list[str] = []
+    if delayed_score >= config.delayed_copy_threshold:
+        reasons.append("delayed_copy")
+    if smearing_score >= config.smearing_threshold:
+        reasons.append("smearing")
+    return EchoSmearingDiagnostics(
+        passed=not reasons,
+        rejection_reasons=tuple(reasons),
+        delayed_copy_score=_finite_nonnegative(delayed_score),
+        smearing_score=_finite_nonnegative(smearing_score),
+        dominant_delay_ms=_finite_nonnegative(dominant_delay_ms),
+        cepstral_peak_ratio=_finite_nonnegative(peak_ratio),
+        cepstral_q99_ratio=_finite_nonnegative(q99_ratio),
+        cepstral_dense_fraction=_finite_nonnegative(dense_fraction),
+        duration_seconds=_finite_nonnegative(duration),
+        input_rms=_finite_nonnegative(input_rms),
+        analysis_window_count=int(starts.size),
+    )
+
+
+__all__ = [
+    "DEFAULT_ECHO_SMEARING_GATE_CONFIG",
+    "EchoSmearingDiagnostics",
+    "EchoSmearingGateConfig",
+    "evaluate_echo_smearing",
+]

audio_wsola.py

@@ -0,0 +1,271 @@
+"""Deterministic mono WSOLA time-scale modification for production speech.
+
+The implementation deliberately has no optional native dependency.  It keeps
+pitch by moving and overlap-adding waveform frames in the time domain, while a
+bounded similarity search aligns each new frame to the already synthesized
+waveform.  The public ``rate`` follows the librosa convention: values below
+one make audio longer and values above one make it shorter.
+"""
+
+from __future__ import annotations
+
+import math
+import operator
+from typing import Sequence
+
+import numpy as np
+
+
+WSOLA_MIN_RATE = 0.50
+WSOLA_MAX_RATE = 2.00
+WSOLA_FRAME_MS = 40.0
+WSOLA_SYNTHESIS_HOP_MS = 10.0
+WSOLA_SEARCH_MS = 6.0
+WSOLA_MIN_SAMPLES = 256
+WSOLA_CORRELATION_FLOOR = 0.05
+
+
+def _positive_sample_count(value: object, name: str) -> int:
+    if isinstance(value, (bool, np.bool_)):
+        raise ValueError(f"{name} must be a positive integer")
+    try:
+        parsed = operator.index(value)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise ValueError(f"{name} must be a positive integer") from error
+    if parsed <= 0:
+        raise ValueError(f"{name} must be a positive integer")
+    return int(parsed)
+
+
+def _finite_positive(value: object, name: str) -> float:
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError, OverflowError) as error:
+        raise ValueError(f"{name} must be finite and positive") from error
+    if not math.isfinite(parsed) or parsed <= 0.0:
+        raise ValueError(f"{name} must be finite and positive")
+    return parsed
+
+
+def _mono_waveform(audio: np.ndarray | Sequence[float]) -> np.ndarray:
+    waveform = np.asarray(audio)
+    if waveform.ndim == 2 and 1 in waveform.shape:
+        waveform = waveform.reshape(-1)
+    if waveform.ndim != 1:
+        raise ValueError("audio must be mono")
+    waveform = np.ascontiguousarray(waveform, dtype=np.float32)
+    if waveform.size < WSOLA_MIN_SAMPLES:
+        raise ValueError("audio is too short for WSOLA")
+    if not np.isfinite(waveform).all():
+        raise ValueError("audio must contain only finite samples")
+    return waveform
+
+
+def _frame_positions(target_length: int, frame_length: int, hop: int) -> tuple[int, ...]:
+    final_start = target_length - frame_length
+    if final_start <= 0:
+        return (0,)
+    positions = list(range(0, final_start + 1, hop))
+    if positions[-1] != final_start:
+        positions.append(final_start)
+    return tuple(positions)
+
+
+def _best_source_position(
+    signal: np.ndarray,
+    synthesized: np.ndarray,
+    weight: np.ndarray,
+    *,
+    output_start: int,
+    current_end: int,
+    predicted_start: int,
+    previous_start: int,
+    predicted_step: int,
+    frame_length: int,
+    search_radius: int,
+) -> int:
+    """Return a monotonic, waveform-similar source position."""
+
+    source_limit = signal.size - frame_length
+    lower = max(
+        0,
+        predicted_start - search_radius,
+        previous_start + max(1, int(round(0.35 * predicted_step))),
+    )
+    upper = min(source_limit, predicted_start + search_radius)
+    if lower > upper:
+        return int(np.clip(predicted_start, 0, source_limit))
+
+    overlap = min(frame_length, max(0, current_end - output_start))
+    if overlap < 32 or lower == upper:
+        return int(np.clip(predicted_start, lower, upper))
+
+    overlap_weights = weight[output_start : output_start + overlap]
+    usable = overlap_weights > 1.0e-4
+    if int(np.count_nonzero(usable)) < 32:
+        return int(np.clip(predicted_start, lower, upper))
+    first = int(np.flatnonzero(usable)[0])
+    last = int(np.flatnonzero(usable)[-1]) + 1
+    if last - first < 32:
+        return int(np.clip(predicted_start, lower, upper))
+
+    reference = (
+        synthesized[output_start + first : output_start + last]
+        / np.maximum(
+            weight[output_start + first : output_start + last],
+            np.float32(1.0e-7),
+        )
+    )
+    # Pre-emphasis makes the search follow speech fine structure rather than
+    # matching only the slowly changing loudness envelope.
+    reference = np.diff(reference, prepend=reference[0]).astype(
+        np.float64,
+        copy=False,
+    )
+    reference -= float(np.mean(reference))
+    reference_norm = float(np.linalg.norm(reference))
+    if not math.isfinite(reference_norm) or reference_norm <= 1.0e-7:
+        return int(np.clip(predicted_start, lower, upper))
+
+    segment_length = last - first
+    search = signal[
+        lower + first : upper + first + segment_length
+    ].astype(np.float64, copy=False)
+    search = np.diff(search, prepend=search[0])
+    candidate_count = upper - lower + 1
+    if search.size < segment_length + candidate_count - 1:
+        return int(np.clip(predicted_start, lower, upper))
+
+    dots = np.correlate(search, reference, mode="valid")
+    if dots.size != candidate_count:
+        return int(np.clip(predicted_start, lower, upper))
+    squared = np.square(search, dtype=np.float64)
+    cumulative = np.concatenate(
+        (np.zeros(1, dtype=np.float64), np.cumsum(squared, dtype=np.float64))
+    )
+    norms = np.sqrt(
+        np.maximum(
+            cumulative[segment_length:] - cumulative[:-segment_length],
+            0.0,
+        )
+    )
+    scores = dots / np.maximum(norms * reference_norm, 1.0e-12)
+    finite = np.isfinite(scores)
+    if not finite.any():
+        return int(np.clip(predicted_start, lower, upper))
+    scores = np.where(finite, scores, -np.inf)
+    best_offset = int(np.argmax(scores))
+    if float(scores[best_offset]) < WSOLA_CORRELATION_FLOOR:
+        return int(np.clip(predicted_start, lower, upper))
+    return lower + best_offset
+
+
+def wsola_time_stretch(
+    audio: np.ndarray | Sequence[float],
+    *,
+    rate: float,
+    sample_rate: int,
+    frame_ms: float = WSOLA_FRAME_MS,
+    synthesis_hop_ms: float = WSOLA_SYNTHESIS_HOP_MS,
+    search_ms: float = WSOLA_SEARCH_MS,
+) -> np.ndarray:
+    """Return a deterministic, pitch-preserving WSOLA time stretch.
+
+    The output length is exactly ``round(input_samples / rate)``.  Invalid,
+    non-finite, multi-channel or pathologically short inputs raise instead of
+    falling back to a lower-quality transform.
+    """
+
+    waveform = _mono_waveform(audio)
+    source_rate = _positive_sample_count(sample_rate, "sample_rate")
+    stretch_rate = _finite_positive(rate, "rate")
+    if not WSOLA_MIN_RATE <= stretch_rate <= WSOLA_MAX_RATE:
+        raise ValueError(
+            f"rate must be between {WSOLA_MIN_RATE:.2f} and {WSOLA_MAX_RATE:.2f}"
+        )
+    frame_duration = _finite_positive(frame_ms, "frame_ms")
+    hop_duration = _finite_positive(synthesis_hop_ms, "synthesis_hop_ms")
+    search_duration = _finite_positive(search_ms, "search_ms")
+    if abs(stretch_rate - 1.0) < 1.0e-3:
+        return waveform.copy()
+
+    target_length = max(1, int(round(waveform.size / stretch_rate)))
+    minimum_extent = min(waveform.size, target_length)
+    if minimum_extent < WSOLA_MIN_SAMPLES:
+        raise ValueError("stretched audio is too short for WSOLA")
+
+    default_frame = max(
+        64,
+        int(round(frame_duration * source_rate / 1000.0)),
+    )
+    # Keep at least two synthesis frames even for unusually short utterances.
+    frame_length = min(default_frame, max(128, minimum_extent // 2))
+    frame_length = min(frame_length, minimum_extent)
+    default_hop = max(
+        16,
+        int(round(hop_duration * source_rate / 1000.0)),
+    )
+    synthesis_hop = min(default_hop, max(16, frame_length // 3))
+    if synthesis_hop >= frame_length:
+        synthesis_hop = max(1, frame_length // 4)
+    search_radius = max(
+        1,
+        int(round(search_duration * source_rate / 1000.0)),
+    )
+
+    output_positions = _frame_positions(
+        target_length,
+        frame_length,
+        synthesis_hop,
+    )
+    source_limit = waveform.size - frame_length
+    output_limit = target_length - frame_length
+    window = np.hanning(frame_length + 2)[1:-1].astype(np.float32)
+    synthesized = np.zeros(target_length, dtype=np.float32)
+    weight = np.zeros(target_length, dtype=np.float32)
+
+    previous_source = -1
+    previous_predicted = 0
+    current_end = 0
+    for frame_index, output_start in enumerate(output_positions):
+        if frame_index == 0:
+            predicted_source = 0
+            source_start = 0
+        elif frame_index + 1 == len(output_positions):
+            predicted_source = source_limit
+            source_start = source_limit
+        else:
+            predicted_source = int(
+                round(output_start * source_limit / max(1, output_limit))
+            )
+            predicted_step = max(1, predicted_source - previous_predicted)
+            source_start = _best_source_position(
+                waveform,
+                synthesized,
+                weight,
+                output_start=output_start,
+                current_end=current_end,
+                predicted_start=predicted_source,
+                previous_start=previous_source,
+                predicted_step=predicted_step,
+                frame_length=frame_length,
+                search_radius=search_radius,
+            )
+
+        output_end = output_start + frame_length
+        source_end = source_start + frame_length
+        synthesized[output_start:output_end] += (
+            waveform[source_start:source_end] * window
+        )
+        weight[output_start:output_end] += window
+        current_end = max(current_end, output_end)
+        previous_source = source_start
+        previous_predicted = predicted_source
+
+    valid = weight > 1.0e-7
+    if not valid.all():
+        raise RuntimeError("WSOLA overlap-add left uncovered output samples")
+    output = synthesized / weight
+    if not np.isfinite(output).all():
+        raise RuntimeError("WSOLA produced non-finite output")
+    return np.ascontiguousarray(output, dtype=np.float32)

tests/test_audio_artifact_gate.py

@@ -0,0 +1,205 @@
+import math
+
+import numpy as np
+import pytest
+
+from audio_artifact_gate import (
+    EchoSmearingGateConfig,
+    evaluate_echo_smearing,
+)
+
+
+SAMPLE_RATE = 16_000
+
+
+def _speech_proxy(*, seed=7, seconds=3.0):
+    sample_count = int(SAMPLE_RATE * seconds)
+    time = np.arange(sample_count, dtype=np.float64) / SAMPLE_RATE
+    rng = np.random.default_rng(seed)
+    fundamental = (
+        128.0
+        + 26.0 * np.sin(2.0 * np.pi * 0.37 * time)
+        + 9.0 * np.sin(2.0 * np.pi * 0.11 * time)
+    )
+    phase = 2.0 * np.pi * np.cumsum(fundamental) / SAMPLE_RATE
+    voiced = sum(
+        np.sin(harmonic * phase + 0.17 * harmonic) / harmonic**0.8
+        for harmonic in range(1, 18)
+    )
+    envelope = np.zeros_like(time)
+    for index, center in enumerate(np.linspace(0.20, seconds - 0.25, 8)):
+        width = 0.07 + 0.035 * ((index + seed) % 4)
+        amplitude = 0.60 + 0.20 * ((index + seed) % 3)
+        envelope += amplitude * np.exp(-0.5 * np.square((time - center) / width))
+    envelope = np.minimum(envelope, 1.0)
+    waveform = voiced * envelope + 0.035 * rng.standard_normal(sample_count) * envelope
+    return 0.60 * waveform / np.max(np.abs(waveform))
+
+
+def _delayed_copy(waveform, *, delay_ms=73.0, gain=0.68):
+    delay = int(round(delay_ms * SAMPLE_RATE / 1000.0))
+    output = waveform.copy()
+    output[delay:] += gain * waveform[:-delay]
+    return output / max(1.0, np.max(np.abs(output)) / 0.90)
+
+
+def _dense_smear(waveform):
+    rng = np.random.default_rng(44)
+    impulse = np.zeros(int(0.20 * SAMPLE_RATE), dtype=np.float64)
+    impulse[0] = 1.0
+    indices = np.arange(int(0.015 * SAMPLE_RATE), impulse.size, 31)
+    impulse[indices] = (
+        rng.choice((-1.0, 1.0), size=indices.size)
+        * 0.16
+        * np.exp(-indices / (0.09 * SAMPLE_RATE))
+    )
+    output = np.convolve(waveform, impulse, mode="full")[: waveform.size]
+    return output / max(1.0, np.max(np.abs(output)) / 0.90)
+
+
+def _comb_filter(waveform):
+    impulse = np.zeros(int(0.15 * SAMPLE_RATE), dtype=np.float64)
+    impulse[0] = 1.0
+    for delay_seconds, gain in (
+        (0.025, 0.50),
+        (0.047, 0.38),
+        (0.071, 0.30),
+        (0.110, 0.20),
+    ):
+        impulse[int(round(delay_seconds * SAMPLE_RATE))] = gain
+    output = np.convolve(waveform, impulse, mode="full")[: waveform.size]
+    return output / max(1.0, np.max(np.abs(output)) / 0.90)
+
+
+@pytest.mark.parametrize("seed", range(5))
+def test_clean_nonstationary_speech_proxy_passes(seed):
+    diagnostics = evaluate_echo_smearing(_speech_proxy(seed=seed), SAMPLE_RATE)
+
+    assert diagnostics.passed
+    assert diagnostics.rejection_reasons == ()
+    assert diagnostics.delayed_copy_score < 0.33
+    assert diagnostics.smearing_score < 0.40
+    assert diagnostics.analysis_window_count >= 3
+
+
+def test_clean_broadband_noise_passes():
+    rng = np.random.default_rng(1234)
+    noise = 0.08 * rng.standard_normal(3 * SAMPLE_RATE)
+
+    diagnostics = evaluate_echo_smearing(noise, SAMPLE_RATE)
+
+    assert diagnostics.passed
+    assert diagnostics.rejection_reasons == ()
+
+
+@pytest.mark.parametrize("delay_ms", (48.0, 73.0, 121.0))
+def test_strong_delayed_copy_is_rejected_and_delay_is_localized(delay_ms):
+    diagnostics = evaluate_echo_smearing(
+        _delayed_copy(_speech_proxy(), delay_ms=delay_ms),
+        SAMPLE_RATE,
+    )
+
+    assert not diagnostics.passed
+    assert "delayed_copy" in diagnostics.rejection_reasons
+    assert diagnostics.delayed_copy_score >= 0.45
+    assert diagnostics.dominant_delay_ms == pytest.approx(delay_ms, abs=0.20)
+
+
+def test_moderate_current_smoke_like_comb_signature_is_rejected():
+    diagnostics = evaluate_echo_smearing(
+        _delayed_copy(_speech_proxy(), delay_ms=32.0, gain=0.10),
+        SAMPLE_RATE,
+    )
+
+    assert not diagnostics.passed
+    assert "delayed_copy" in diagnostics.rejection_reasons
+    assert diagnostics.cepstral_peak_ratio > 10.0
+
+
+def test_dense_reverberant_smear_is_rejected_by_density_proxy():
+    diagnostics = evaluate_echo_smearing(_dense_smear(_speech_proxy()), SAMPLE_RATE)
+
+    assert not diagnostics.passed
+    assert "smearing" in diagnostics.rejection_reasons
+    assert diagnostics.smearing_score >= 0.40
+
+
+def test_multi_tap_comb_filter_is_rejected():
+    diagnostics = evaluate_echo_smearing(_comb_filter(_speech_proxy()), SAMPLE_RATE)
+
+    assert not diagnostics.passed
+    assert "delayed_copy" in diagnostics.rejection_reasons
+
+
+def test_scores_are_deterministic_and_amplitude_invariant():
+    waveform = _delayed_copy(_speech_proxy())
+    first = evaluate_echo_smearing(waveform, SAMPLE_RATE)
+    second = evaluate_echo_smearing(waveform.copy(), SAMPLE_RATE)
+    quiet = evaluate_echo_smearing(waveform * 0.125, SAMPLE_RATE)
+
+    assert first == second
+    assert quiet.delayed_copy_score == pytest.approx(
+        first.delayed_copy_score, abs=1.0e-10
+    )
+    assert quiet.smearing_score == pytest.approx(first.smearing_score, abs=1.0e-10)
+
+
+@pytest.mark.parametrize(
+    ("audio", "sample_rate", "reason"),
+    (
+        ([], SAMPLE_RATE, "invalid_audio"),
+        (np.zeros((2, 8_000)), SAMPLE_RATE, "invalid_audio"),
+        (np.ones(SAMPLE_RATE, dtype=np.complex128), SAMPLE_RATE, "invalid_audio"),
+        (np.full(SAMPLE_RATE, np.nan), SAMPLE_RATE, "nonfinite_audio"),
+        (np.zeros(SAMPLE_RATE), SAMPLE_RATE, "silent_audio"),
+        (np.ones(1_000), SAMPLE_RATE, "insufficient_duration"),
+        (np.ones(SAMPLE_RATE), True, "invalid_sample_rate"),
+        (np.ones(SAMPLE_RATE), 7_999, "invalid_sample_rate"),
+    ),
+)
+def test_invalid_or_insufficient_inputs_fail_closed_with_finite_diagnostics(
+    audio,
+    sample_rate,
+    reason,
+):
+    diagnostics = evaluate_echo_smearing(audio, sample_rate)
+
+    assert not diagnostics.passed
+    assert diagnostics.rejection_reasons == (reason,)
+    for value in (
+        diagnostics.delayed_copy_score,
+        diagnostics.smearing_score,
+        diagnostics.dominant_delay_ms,
+        diagnostics.cepstral_peak_ratio,
+        diagnostics.cepstral_q99_ratio,
+        diagnostics.cepstral_dense_fraction,
+        diagnostics.duration_seconds,
+        diagnostics.input_rms,
+    ):
+        assert math.isfinite(value)
+
+
+def test_constant_dc_has_no_active_speech_windows_and_fails_closed():
+    diagnostics = evaluate_echo_smearing(np.full(2 * SAMPLE_RATE, 0.25), SAMPLE_RATE)
+
+    assert not diagnostics.passed
+    assert diagnostics.rejection_reasons == ("insufficient_active_windows",)
+
+
+def test_invalid_config_fails_closed_instead_of_raising():
+    diagnostics = evaluate_echo_smearing(
+        _speech_proxy(),
+        SAMPLE_RATE,
+        config=EchoSmearingGateConfig(delayed_copy_threshold=float("nan")),
+    )
+
+    assert not diagnostics.passed
+    assert diagnostics.rejection_reasons == ("invalid_config",)
+
+    malformed = evaluate_echo_smearing(
+        _speech_proxy(),
+        SAMPLE_RATE,
+        config=EchoSmearingGateConfig(min_duration_seconds="not-a-number"),
+    )
+    assert not malformed.passed
+    assert malformed.rejection_reasons == ("invalid_config",)

tests/test_audio_wsola.py

@@ -0,0 +1,128 @@
+import numpy as np
+import pytest
+
+from audio_wsola import wsola_time_stretch
+
+
+SAMPLE_RATE = 48_000
+
+
+def _voiced_fixture(seconds: float = 1.8) -> np.ndarray:
+    samples = int(round(seconds * SAMPLE_RATE))
+    time = np.arange(samples, dtype=np.float64) / SAMPLE_RATE
+    phase = 2.0 * np.pi * (190.0 * time + 18.0 * np.square(time))
+    envelope = 0.55 + 0.35 * np.sin(2.0 * np.pi * 2.3 * time)
+    waveform = envelope * (
+        0.30 * np.sin(phase)
+        + 0.13 * np.sin(2.0 * phase + 0.2)
+        + 0.07 * np.sin(3.0 * phase + 0.7)
+    )
+    return np.asarray(waveform, dtype=np.float32)
+
+
+def _dominant_f0(waveform: np.ndarray) -> float:
+    central = waveform[len(waveform) // 4 : 3 * len(waveform) // 4]
+    central = np.asarray(central, dtype=np.float64) * np.hanning(central.size)
+    spectrum = np.abs(np.fft.rfft(central))
+    frequencies = np.fft.rfftfreq(central.size, 1.0 / SAMPLE_RATE)
+    mask = (frequencies >= 150.0) & (frequencies <= 300.0)
+    return float(frequencies[mask][np.argmax(spectrum[mask])])
+
+
+@pytest.mark.parametrize("rate", (0.90, 0.95, 1.05))
+def test_wsola_is_deterministic_finite_and_has_exact_length(rate):
+    waveform = _voiced_fixture()
+
+    first = wsola_time_stretch(
+        waveform,
+        rate=rate,
+        sample_rate=SAMPLE_RATE,
+    )
+    second = wsola_time_stretch(
+        waveform,
+        rate=rate,
+        sample_rate=SAMPLE_RATE,
+    )
+
+    assert first.dtype == np.float32
+    assert first.ndim == 1
+    assert first.flags.c_contiguous
+    assert first.size == round(waveform.size / rate)
+    assert np.isfinite(first).all()
+    assert np.array_equal(first, second)
+
+
+@pytest.mark.parametrize("rate", (0.90, 0.95, 1.05))
+def test_wsola_preserves_voiced_pitch(rate):
+    waveform = _voiced_fixture()
+    stretched = wsola_time_stretch(
+        waveform,
+        rate=rate,
+        sample_rate=SAMPLE_RATE,
+    )
+
+    source_f0 = _dominant_f0(waveform)
+    stretched_f0 = _dominant_f0(stretched)
+    assert abs(stretched_f0 - source_f0) / source_f0 < 0.015
+
+
+def test_wsola_near_unity_is_bit_exact_copy():
+    waveform = _voiced_fixture(0.5)
+
+    stretched = wsola_time_stretch(
+        waveform,
+        rate=1.0005,
+        sample_rate=SAMPLE_RATE,
+    )
+
+    assert stretched is not waveform
+    assert np.array_equal(stretched, waveform)
+
+
+def test_wsola_preserves_transient_count_and_endpoint_transients():
+    rng = np.random.default_rng(31)
+    waveform = np.asarray(
+        0.002 * rng.standard_normal(2 * SAMPLE_RATE),
+        dtype=np.float32,
+    )
+    transient_positions = (200, 12_000, 34_000, 60_000, waveform.size - 201)
+    transient = np.asarray((0.08, 0.40, 0.80, 0.40, 0.08), dtype=np.float32)
+    for position in transient_positions:
+        waveform[position - 2 : position + 3] += transient
+
+    stretched = wsola_time_stretch(
+        waveform,
+        rate=0.90,
+        sample_rate=SAMPLE_RATE,
+    )
+    above_threshold = np.flatnonzero(np.abs(stretched) >= 0.30)
+    groups = np.split(
+        above_threshold,
+        np.flatnonzero(np.diff(above_threshold) > 500) + 1,
+    )
+
+    assert len(groups) == len(transient_positions)
+    assert int(groups[0][0]) < 500
+    assert int(groups[-1][-1]) > stretched.size - 500
+    assert all(float(np.max(np.abs(stretched[group]))) >= 0.50 for group in groups)
+
+
+@pytest.mark.parametrize(
+    ("audio", "rate", "sample_rate"),
+    (
+        (np.zeros(128, dtype=np.float32), 0.90, SAMPLE_RATE),
+        (np.zeros((1024, 2), dtype=np.float32), 0.90, SAMPLE_RATE),
+        (np.full(1024, np.nan, dtype=np.float32), 0.90, SAMPLE_RATE),
+        (np.zeros(1024, dtype=np.float32), 0.0, SAMPLE_RATE),
+        (np.zeros(1024, dtype=np.float32), 0.49, SAMPLE_RATE),
+        (np.zeros(1024, dtype=np.float32), 2.01, SAMPLE_RATE),
+        (np.zeros(1024, dtype=np.float32), 0.90, 0),
+    ),
+)
+def test_wsola_rejects_invalid_inputs(audio, rate, sample_rate):
+    with pytest.raises(ValueError):
+        wsola_time_stretch(
+            audio,
+            rate=rate,
+            sample_rate=sample_rate,
+        )

tests/test_inference_cleanup.py

@@ -42,6 +42,121 @@ def _isolated_app_function(name, namespace):
     return namespace[name]
 
 
+def test_app_speed_wrapper_uses_wsola_and_rejects_below_release_floor():
+    calls = []
+
+    def stretch(audio, *, rate, sample_rate):
+        calls.append((np.asarray(audio).copy(), rate, sample_rate))
+        return np.full(12, rate, dtype=np.float32)
+
+    apply_speed = _isolated_app_function(
+        "_apply_speed",
+        {
+            "np": np,
+            "wsola_time_stretch": stretch,
+            "MIN_PACE_SPEED": 0.90,
+            "SR": 48_000,
+        },
+    )
+    waveform = np.linspace(-0.5, 0.5, 16, dtype=np.float32)
+
+    output = apply_speed(waveform, 0.90, network_conditioned=True)
+
+    assert output.dtype == np.float32
+    assert np.array_equal(output, np.full(12, 0.90, dtype=np.float32))
+    assert len(calls) == 1
+    assert np.array_equal(calls[0][0], waveform)
+    assert calls[0][1:] == (0.90, 48_000)
+    with pytest.raises(ValueError, match="below the production WSOLA floor"):
+        apply_speed(waveform, 0.899)
+    with pytest.raises(ValueError, match="finite and positive"):
+        apply_speed(waveform, float("nan"))
+
+
+def test_echo_smearing_gate_projects_acoustic_failure_into_trajectory():
+    base = verify_trajectory(
+        (
+            CandidateObservation(
+                target_text="測試內容",
+                transcript_text="測試內容",
+                audio_duration_seconds=2.0,
+            ),
+        ),
+        speaker_gate_enabled=False,
+    )
+    assert base.passed
+    diagnostics = SimpleNamespace(
+        passed=False,
+        rejection_reasons=("delayed_copy",),
+        delayed_copy_score=0.6,
+        smearing_score=0.1,
+        dominant_delay_ms=42.0,
+        cepstral_peak_ratio=11.0,
+        analysis_window_count=5,
+    )
+    gate = _isolated_app_function(
+        "_apply_echo_smearing_gate",
+        {
+            "np": np,
+            "replace": replace,
+            "SR": 48_000,
+            "DEFAULT_ECHO_SMEARING_GATE_CONFIG": SimpleNamespace(
+                min_duration_seconds=1.0
+            ),
+            "evaluate_echo_smearing": lambda waveform, sample_rate: diagnostics,
+        },
+    )
+
+    rejected = gate(
+        base,
+        (np.ones(2 * 48_000, dtype=np.float32),),
+    )
+
+    assert not rejected.passed
+    assert np.isinf(rejected.score)
+    assert rejected.rejection_reasons == (
+        "chunk_0:audio_artifact_delayed_copy",
+    )
+    assert rejected.candidate_results[0].rejection_reasons == (
+        "audio_artifact_delayed_copy",
+    )
+
+
+def test_echo_smearing_gate_does_not_apply_estimator_below_one_second():
+    base = verify_trajectory(
+        (
+            CandidateObservation(
+                target_text="短句",
+                transcript_text="短句",
+                audio_duration_seconds=0.8,
+            ),
+        ),
+        speaker_gate_enabled=False,
+    )
+    calls = []
+    gate = _isolated_app_function(
+        "_apply_echo_smearing_gate",
+        {
+            "np": np,
+            "replace": replace,
+            "SR": 48_000,
+            "DEFAULT_ECHO_SMEARING_GATE_CONFIG": SimpleNamespace(
+                min_duration_seconds=1.0
+            ),
+            "evaluate_echo_smearing": lambda *args: calls.append(args),
+        },
+    )
+
+    unchanged = gate(
+        base,
+        (np.ones(int(0.8 * 48_000), dtype=np.float32),),
+    )
+
+    assert unchanged.passed
+    assert unchanged.rejection_reasons == ()
+    assert calls == []
+
+
 def test_closed_loop_pace_rerenders_once_from_untouched_model_waveform():
     apply_calls = []
     active_calls = []
@@ -70,7 +185,7 @@ def test_closed_loop_pace_rerenders_once_from_untouched_model_waveform():
         "endpoint_generation_plan": lambda *args, **kwargs: ("測試內容。", 10, 12),
         "effective_generation_cfg": lambda text, cfg, **kwargs: cfg,
         "set_generation_seed": lambda seed: None,
-        "target_pace_speed": lambda *args, **kwargs: 0.90,
+        "target_pace_speed": lambda *args, **kwargs: 0.95,
         "active_voiced_duration_seconds": active_duration,
         "active_pace_correction_speed": active_correction,
         "endpoint_tail_energy_ratio": lambda audio, sample_rate: 0.5,
@@ -87,7 +202,7 @@ def test_closed_loop_pace_rerenders_once_from_untouched_model_waveform():
         "TARGET_CPS": 4.0,
         "ACTIVE_PACE_TARGET_CPS": 4.0,
         "CLOSED_LOOP_ACTIVE_PACE_TARGET_CPS": 3.95,
-        "MIN_PACE_SPEED": 0.80,
+        "MIN_PACE_SPEED": 0.90,
         "STOP_THRESHOLD": 0.50,
         "STOP_CONSECUTIVE": 1,
     }
@@ -112,12 +227,12 @@ def test_closed_loop_pace_rerenders_once_from_untouched_model_waveform():
     assert len(apply_calls) == 2
     assert np.array_equal(apply_calls[0][0], np.ones(16, dtype=np.float32))
     assert np.array_equal(apply_calls[1][0], np.ones(16, dtype=np.float32))
-    assert apply_calls[0][1] == pytest.approx(0.90)
-    assert apply_calls[1][1] == pytest.approx(0.90 * 0.95)
+    assert apply_calls[0][1] == pytest.approx(0.95)
+    assert apply_calls[1][1] == pytest.approx(0.95 * 0.95)
     assert all(call[2] is True for call in apply_calls)
     assert np.array_equal(
         output.audio,
-        np.ones(16, dtype=np.float32) * np.float32(0.855),
+        np.ones(16, dtype=np.float32) * np.float32(0.9025),
     )
     assert output.stop_reason == "native_stop"
     assert output.endpoint_energy_ratio == 0.5
@@ -125,11 +240,11 @@ def test_closed_loop_pace_rerenders_once_from_untouched_model_waveform():
     assert output.hard_stop_steps == 12
     assert len(active_calls) == 2
     assert np.array_equal(active_calls[0][0], np.ones(16, dtype=np.float32))
-    assert np.array_equal(active_calls[1][0], np.ones(16, dtype=np.float32) * 0.90)
+    assert np.array_equal(active_calls[1][0], np.ones(16, dtype=np.float32) * 0.95)
     assert correction_calls[1][2] == {
         "target_cps": 3.95,
-        "prior_speed": 0.90,
-        "min_total_speed": 0.80,
+        "prior_speed": 0.95,
+        "min_total_speed": 0.90,
     }
 
 
@@ -171,7 +286,7 @@ def test_sparse_completion_policy_adds_only_bounded_one_two_unit_headroom():
             "TARGET_CPS": 4.0,
             "ACTIVE_PACE_TARGET_CPS": 4.0,
             "CLOSED_LOOP_ACTIVE_PACE_TARGET_CPS": 3.95,
-            "MIN_PACE_SPEED": 0.80,
+            "MIN_PACE_SPEED": 0.90,
             "STOP_THRESHOLD": 0.50,
             "STOP_CONSECUTIVE": 1,
         }

tests/test_release_pins.py

@@ -1035,14 +1035,15 @@ def test_chunk_generation_closed_loop_rerenders_final_audio_from_raw_once():
     assert "final_speed > EXTREME_SHORT_MAX_SPEED" in generate_source
     assert "final_speed = EXTREME_SHORT_MAX_SPEED" in generate_source
     assert "audio,\n            final_speed,\n            network_conditioned=False" in generate_source
-    assert "PACE_STRETCH_N_FFT = 1536" in source
-    assert "PACE_STRETCH_HOP_LENGTH = 384" in source
-    assert "NETWORK_PACE_STRETCH_N_FFT = 2048" in source
-    assert "NETWORK_PACE_STRETCH_HOP_LENGTH = 512" in source
+    assert "MIN_PACE_SPEED = 0.90" in source
+    assert "PACE_ONLY_FALLBACK_MIN_SPEED = MIN_PACE_SPEED" in source
+    assert "from audio_wsola import wsola_time_stretch" in source
     assert "network_conditioned=network_conditioned" in generate_source
-    assert "if network_conditioned" in apply_speed_source
-    assert "n_fft=n_fft" in apply_speed_source
-    assert "hop_length=hop_length" in apply_speed_source
+    assert "del network_conditioned" in apply_speed_source
+    assert "speed < MIN_PACE_SPEED" in apply_speed_source
+    assert "wsola_time_stretch(" in apply_speed_source
+    assert "sample_rate=SR" in apply_speed_source
+    assert "librosa.effects.time_stretch" not in apply_speed_source
 
 
 def test_public_tts_wrappers_serialize_the_same_pcm16_grid_used_for_verification():
@@ -1097,6 +1098,14 @@ def test_space_applies_pinned_squim_to_local_joined_and_final_audio():
     observation_index = verify_source.index("CandidateObservation(", score_index)
     gate_index = verify_source.index("squim_gate_enabled=not semantic_only")
     assert score_index < observation_index < gate_index
+    artifact_gate_index = verify_source.index(
+        "verification = _apply_echo_smearing_gate("
+    )
+    assert gate_index < artifact_gate_index
+    assert "if not semantic_only:" in verify_source[gate_index:artifact_gate_index]
+    assert "tuple(prepared_waveforms)" in verify_source[artifact_gate_index:]
+    assert "from audio_artifact_gate import (" in app_source
+    assert "evaluate_echo_smearing," in app_source
     assert "except ValueError:" in verify_source[score_index:observation_index]
     assert "except RuntimeError:" not in verify_source[score_index:observation_index]
     assert (
@@ -1509,7 +1518,8 @@ def test_space_locks_validated_nfe_and_bounds_total_generation_work():
     assert "EMAIL_MAIL_FALLBACK_CANDIDATE_ORDINALS = frozenset((2, 5, 6))" in source
     assert "NETWORK_REQUEST_ORDINARY_MAX_UNITS = 36" in source
     assert "ordinary_max_units=NETWORK_REQUEST_ORDINARY_MAX_UNITS" in source
-    assert "PACE_ONLY_FALLBACK_MIN_SPEED = 0.76" in source
+    assert "MIN_PACE_SPEED = 0.90" in source
+    assert "PACE_ONLY_FALLBACK_MIN_SPEED = MIN_PACE_SPEED" in source
     assert "PACE_ONLY_FALLBACK_MIN_UNITS = 30" in source
     assert "if observed_cps > QUALITY_MAX_PACE_CPS:" in source
     assert "final_audio = _apply_speed(" in source
@@ -1526,6 +1536,8 @@ def test_space_locks_validated_nfe_and_bounds_total_generation_work():
     assert "requested_steps != DEFAULT_STEPS" in source
     assert "interactive=False" in source
     assert "NFE steps（已驗證固定值）" in source
+    assert 'label="後處理語速（已驗證固定值）"' in source
+    assert "float(speed) != 1.0" in source
     assert "最多 3 條 culprit-diverse 完整路徑" in readme
     assert "不再為了取得某一段替代候選而重生整篇" in readme
     assert "boundary-only relaxation" in readme