@@ -9,7 +9,9 @@
 Three gates implemented:
 1. Sustained-vowel detection — reject turns with >2.8 s single sustained voiced segment.
 2. F0 guardrails — reject if median F0 outside gender-specific range.
-3. Click detection — flag DC-offset jumps between SSML blocks.
+3. Click detection — flag DC-offset baseline shifts (#80: targets sustained
+   step shifts, not per-sample amplitude jumps, so it does not fire on
+   Hebrew sibilants).
 """
 
 from __future__ import annotations
@@ -18,6 +20,7 @@
 from typing import Literal
 
 import numpy as np
+from scipy.signal import find_peaks
 
 # ---------------------------------------------------------------------------
 # Thresholds (from research-synthesis.md §Quality Gates)
@@ -32,18 +35,28 @@
 FEMALE_F0_MIN_HZ: float = 150.0
 FEMALE_F0_MAX_HZ: float = 290.0
 
-# Click detection: minimum absolute sample-to-sample jump (normalized to [-1,1])
-# that qualifies as a DC-offset click.  Set at 0.15 to avoid false positives on
-# legitimate plosive transients (/p/, /t/, /k/) which typically peak around 0.1.
-# True DC-offset jumps from SSML block boundaries are typically 0.2+.
-CLICK_THRESHOLD: float = 0.15
-
-# Minimum number of *isolated* click events to flag a turn.
-CLICK_COUNT_THRESHOLD: int = 3
-
-# Number of neighboring samples that must be below threshold for a spike to
-# qualify as an isolated click (vs. a plosive burst which spans many samples).
-CLICK_ISOLATION_RADIUS: int = 3
+# Click detection: a real DC-offset click manifests as a *sustained* baseline
+# shift across the click sample — the running mean before and after differs
+# by CLICK_STEP_THRESHOLD or more.  Using a baseline-shift criterion (rather
+# than a per-sample diff) is what distinguishes a true DC click from
+# zero-mean high-frequency content like Hebrew sibilants (/ʃ/ /s/), which
+# produce large per-sample diffs but no shift in the running mean.  See #80
+# for the diagnosis that motivated this change.
+CLICK_STEP_THRESHOLD: float = 0.08
+
+# Window width (each side, in milliseconds) over which the pre/post running
+# mean is computed for the step-shift comparison.  40 ms covers ≥3 F0 cycles
+# even at the male low end (80 Hz → 12.5 ms period), so the running mean
+# averages out the AC swing of a voiced segment and the step shift reflects
+# an actual DC change.
+CLICK_STEP_WINDOW_MS: int = 40
+
+# Minimum number of distinct step events (after non-maximum suppression) to
+# flag a turn.  A single sustained DC offset produces 2 events (rising +
+# falling edge), so this threshold is in *edges*, not in clicks: ≥3 events
+# corresponds to ≥2 sustained offsets (or ≥3 ramp-shaped artifacts), which
+# we treat as a systematic stitching problem.
+CLICK_STEP_EVENT_THRESHOLD: int = 3
 
 
 # ---------------------------------------------------------------------------
@@ -206,13 +219,25 @@ def check_f0_guardrails(
 
 
 def check_clicks(samples: np.ndarray, sr: int) -> GateResult:
-    """Detect DC-offset jump clicks in the audio.
-
-    Clicks manifest as sudden large sample-to-sample amplitude changes,
-    typically at SSML block boundaries.  To distinguish from legitimate
-    plosive transients (which span many consecutive high-diff samples),
-    only *isolated* spikes are counted — a diff event is a click only if
-    the surrounding ±CLICK_ISOLATION_RADIUS samples are all below threshold.
+    """Detect DC-offset clicks via running-mean step shifts.
+
+    A DC-offset click is a sustained baseline shift: the audio level steps
+    from one value to another and stays there for many samples.  This is
+    distinct from the per-sample amplitude swings produced by zero-mean
+    high-frequency content like fricatives, which also produce large
+    sample-to-sample diffs but leave the running mean unchanged.
+
+    For each candidate sample i, we compare the running mean of the
+    ``CLICK_STEP_WINDOW_MS`` ms window ending at i to the running mean of
+    the equally-sized window starting after i.  A baseline shift larger
+    than ``CLICK_STEP_THRESHOLD`` is a step event.  Adjacent positions are
+    collapsed into single events via non-maximum suppression at distance
+    ``win`` so each step transition is counted once.
+
+    The signal is virtually zero-padded by ``win`` samples on each side
+    so the detector covers every original sample, including the first
+    and last 40 ms — a DC offset present from sample 0 (or sustained
+    through the final sample) compares against silence and is flagged.
 
     Args:
         samples: Float32 audio samples, mono, normalized to [-1, 1].
@@ -221,35 +246,53 @@ def check_clicks(samples: np.ndarray, sr: int) -> GateResult:
     Returns:
         GateResult indicating pass/fail.
     """
-    if len(samples) < 2:
+    win = max(1, int(CLICK_STEP_WINDOW_MS * sr / 1000))
+    n = len(samples)
+    if n == 0:
         return GateResult(passed=True)
 
-    # Compute absolute sample-to-sample differences
-    diffs = np.abs(np.diff(samples))
-    candidates = np.where(diffs > CLICK_THRESHOLD)[0]
-
-    if len(candidates) < CLICK_COUNT_THRESHOLD:
-        return GateResult(passed=True)
-
-    # Filter to isolated spikes: surrounding samples must be below threshold
-    radius = CLICK_ISOLATION_RADIUS
-    click_count = 0
-    for idx in candidates:
-        lo = max(0, idx - radius)
-        hi = min(len(diffs), idx + radius + 1)
-        # Count how many neighbors (excluding self) are above threshold
-        neighborhood = diffs[lo:hi]
-        n_above = int(np.sum(neighborhood > CLICK_THRESHOLD))
-        # An isolated click has only 1-2 samples above threshold (the jump itself
-        # and possibly the immediate return)
-        if n_above <= 2:
-            click_count += 1
-
-    if click_count >= CLICK_COUNT_THRESHOLD:
+    # Zero-pad by win on each side so original sample i gets a valid pre and
+    # post window, even at the boundaries.  Cumulative sum then lets us
+    # compute window means in O(1) per index.  Promote to float64: at 24 kHz
+    # × 30 s = 720k samples, plain float32 cumsum can accumulate ~0.085 of
+    # drift, on the same order as the 0.08 step threshold; float64 keeps
+    # rounding error well below the threshold.
+    pad = np.zeros(win, dtype=np.float64)
+    padded = np.concatenate((pad, samples.astype(np.float64), pad))
+    cs = np.concatenate(([0.0], np.cumsum(padded)))
+    # idx indexes original samples [0, n).  In padded coordinates each
+    # original sample i lives at position i + win, with pre window
+    # padded[i:i+win] and post window padded[i+1+win:i+1+2*win].
+    idx = np.arange(n)
+    pre_mean = (cs[idx + win] - cs[idx]) / win
+    post_mean = (cs[idx + 1 + 2 * win] - cs[idx + 1 + win]) / win
+    step = np.abs(post_mean - pre_mean)
+
+    # Pad step with zero sentinels so step[0] and step[n-1] can be reported
+    # as peaks — find_peaks requires both neighbours, so without padding it
+    # silently drops boundary events.  The sentinels are below threshold,
+    # so they're never selected themselves; we shift indices back by 1.
+    peaks_padded, _ = find_peaks(
+        np.concatenate(([0.0], step, [0.0])),
+        height=CLICK_STEP_THRESHOLD,
+        distance=win,
+    )
+    peaks = peaks_padded - 1
+    click_count = int(len(peaks))
+
+    if click_count >= CLICK_STEP_EVENT_THRESHOLD:
+        # Surface the first three peak times in the detail so an operator
+        # can seek directly to the alleged click in the rendered turn.
+        # peaks are indices into step (= indices into the original signal).
+        first_times_s = [(int(p) + 0.5) / sr for p in peaks[:3]]
+        times_str = ", ".join(f"{t:.2f}" for t in first_times_s)
         return GateResult(
             passed=False,
             gate_name="click_detection",
-            detail=f"Detected {click_count} isolated click events (threshold: {CLICK_COUNT_THRESHOLD})",
+            detail=(
+                f"Detected {click_count} DC-offset step events "
+                f"(threshold: {CLICK_STEP_EVENT_THRESHOLD}); first at t=[{times_str}]s"
+            ),
         )
     return GateResult(passed=True)
 
 
@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import io
+from pathlib import Path
 
 import numpy as np
+import pytest
 import soundfile as sf
 
 from synthbanshee.tts.quality_gates import (
@@ -17,6 +19,8 @@
 
 SR = 16_000
 
+FIXTURES_DIR = Path(__file__).resolve().parents[1] / "fixtures" / "clicks"
+
 
 # ---------------------------------------------------------------------------
 # Helpers
@@ -128,35 +132,153 @@ def test_clean_sine_passes(self) -> None:
         result = check_clicks(samples, SR)
         assert result.passed
 
-    def test_isolated_dc_jumps_fail(self) -> None:
-        # Low-amplitude signal with isolated DC jumps (simulating SSML boundary clicks)
+    @pytest.mark.parametrize("sr", [16_000, 24_000])
+    def test_dc_offset_steps_fail(self, sr: int) -> None:
+        # Three sustained baseline shifts — the failure mode the gate targets.
+        # Each shift holds 50 ms (longer than the 40 ms detector window) so
+        # the rising and falling edge of every shift register as separate
+        # step events.  Six events expected (3 shifts × 2 edges); we accept
+        # 5–8 to allow for find_peaks dropping a single boundary edge.
+        samples = np.zeros(sr, dtype=np.float32)
+        shift_n = int(0.05 * sr)  # 50 ms
+        for start_s, amp in [(0.10, 0.20), (0.35, -0.18), (0.60, 0.25)]:
+            i = int(start_s * sr)
+            samples[i : i + shift_n] = amp
+        result = check_clicks(samples, sr)
+        assert not result.passed
+        assert result.gate_name == "click_detection"
+        # Tight bound on the count locks in detector behaviour, not just outcome.
+        # The detail string is "...step events (threshold: 3); first at t=[...]s".
+        assert result.detail is not None
+        n = int(result.detail.split()[1])
+        assert 5 <= n <= 8, f"expected 5-8 step events, got {n}: {result.detail}"
+
+    def test_isolated_single_sample_spikes_pass(self) -> None:
+        # Single-sample spikes are NOT DC clicks — they're impulse noise that
+        # leaves the running mean unchanged.  Pre-#80 the gate caught these
+        # alongside any high-frequency content (Hebrew sibilants).  This is
+        # an intentional capability change: the new detector targets only
+        # sustained baseline shifts, since Azure he-IL output does not
+        # produce isolated impulse noise in practice (see #80 diagnosis).
         samples = np.zeros(16000, dtype=np.float32)
-        # Insert isolated spikes well-separated (>CLICK_ISOLATION_RADIUS apart)
         for pos in [1000, 3000, 5000, 7000]:
-            samples[pos] = 0.8  # Isolated single-sample spike
+            samples[pos] = 0.8
         result = check_clicks(samples, SR)
-        assert not result.passed
-        assert result.gate_name == "click_detection"
+        assert result.passed
 
     def test_plosive_burst_passes(self) -> None:
-        # A plosive burst spans many consecutive high-diff samples — not isolated
+        # A 20-sample plosive burst at 0.5 leaves running mean ~0 either side
+        # of the burst; not a baseline shift.
         samples = np.zeros(16000, dtype=np.float32)
-        # Simulate a plosive: multiple consecutive high-amplitude samples
-        samples[5000:5020] = 0.5  # 20-sample burst — NOT an isolated click
+        samples[5000:5020] = 0.5
         result = check_clicks(samples, SR)
         assert result.passed
 
-    def test_few_clicks_passes(self) -> None:
-        # Only 1-2 isolated clicks — below count threshold of 3
+    @pytest.mark.parametrize("sr", [16_000, 24_000])
+    def test_sibilant_like_noise_passes(self, sr: int) -> None:
+        # Synthetic sibilant proxy: envelope-shaped white Gaussian noise.
+        # Real /ʃ/ /s/ have spectral peaks at 5–8 kHz; this fixture is
+        # weaker than that but exercises the zero-mean property the
+        # step detector relies on.  The real regression coverage lives
+        # in test_real_tts_turn_passes (Azure-rendered fixture).
+        rng = np.random.default_rng(42)
+        n = int(1.5 * sr)
+        envelope = np.zeros(n, dtype=np.float32)
+        for start_s in (0.3, 0.9):
+            i = int(start_s * sr)
+            burst_n = int(0.2 * sr)
+            ramp = np.hanning(burst_n).astype(np.float32)
+            envelope[i : i + burst_n] = ramp
+        noise = rng.standard_normal(n).astype(np.float32)
+        samples = (noise * envelope * 0.30).astype(np.float32)
+        result = check_clicks(samples, sr)
+        assert result.passed, f"sibilant-like noise wrongly flagged: {result.detail}"
+
+    @pytest.mark.parametrize(
+        "fixture_name",
+        [
+            # 16 kHz pair (post-mixer rate)
+            "sp_neu_a_0001_turn_03_female_2s_16k.wav",
+            "sp_neu_a_0001_turn_08_male_2s_16k.wav",
+            # 24 kHz pair (Azure provider native rate — what the gate sees in production)
+            "sp_neu_a_0001_turn_03_female_2s_24k.wav",
+            "sp_neu_a_0001_turn_08_male_2s_24k.wav",
+        ],
+    )
+    def test_real_tts_turn_passes(self, fixture_name: str) -> None:
+        # Regression guard for #80: 2 s segments captured from real Azure
+        # he-IL output for sp_neu_a_0001 (one VIC/F, one AGG/M) at the
+        # window with the highest pre-fix click density.  Both the 24 kHz
+        # native (gate-time) rate and the 16 kHz post-mixer rate are
+        # exercised because behaviour depends on win = win_ms * sr / 1000.
+        # Pre-#80 the per-sample-diff detector logged 100s of false events
+        # on these segments; the step-shift detector must report passed=True.
+        fixture_path = FIXTURES_DIR / fixture_name
+        samples, sr = sf.read(fixture_path, dtype="float32")
+        if samples.ndim > 1:
+            samples = samples[:, 0]
+        result = check_clicks(samples, sr)
+        assert result.passed, f"real Hebrew TTS turn wrongly flagged: {result.detail}"
+
+    def test_few_steps_pass(self) -> None:
+        # One sustained shift produces 2 edge events (rising + falling) —
+        # below the threshold of 3.
         samples = np.zeros(16000, dtype=np.float32)
-        samples[5000] = 0.8
+        samples[5000:5800] = 0.20
         result = check_clicks(samples, SR)
         assert result.passed
 
     def test_empty_passes(self) -> None:
         result = check_clicks(np.array([], dtype=np.float32), SR)
         assert result.passed
 
+    def test_short_audio_passes(self) -> None:
+        # All-zero short audio — virtual zero padding gives step ≈ 0 everywhere.
+        samples = np.zeros(100, dtype=np.float32)
+        result = check_clicks(samples, SR)
+        assert result.passed
+
+    def test_dc_offset_at_signal_start_caught(self) -> None:
+        # Three sustained offsets; the first starts at sample 0.  Without
+        # the boundary fix the t=0 rising edge is silently dropped and we
+        # see 5 events; with the fix we see 6.  Asserting count ≥ 6 and
+        # that the first detected peak is at t≈0 actually proves the
+        # boundary edge was counted.
+        samples = np.zeros(int(0.5 * SR), dtype=np.float32)
+        samples[: int(0.06 * SR)] = 0.20  # offset starts AT sample 0
+        samples[int(0.15 * SR) : int(0.20 * SR)] = -0.18
+        samples[int(0.30 * SR) : int(0.35 * SR)] = 0.22
+        result = check_clicks(samples, SR)
+        assert not result.passed
+        assert result.gate_name == "click_detection"
+        assert result.detail is not None
+        n = int(result.detail.split()[1])
+        assert n >= 6, f"sample-0 edge dropped: only {n} events; expected ≥6"
+        # Detail format: "...; first at t=[0.00, 0.06, 0.15]s" — the boundary
+        # edge must appear as the first detected peak (within one sample of t=0).
+        first_t_str = result.detail.split("[")[1].split(",")[0]
+        assert float(first_t_str) < 1.0 / SR, f"sample-0 edge not the first peak: {result.detail}"
+
+    def test_dc_offset_at_signal_end_caught(self) -> None:
+        # Symmetric: a DC offset that persists through the final sample.
+        # Without the boundary fix the trailing edge at sample n-1 is
+        # dropped (5 events); with the fix it's caught (6 events) and the
+        # last detected peak time lands within one sample of the final.
+        n_samples = int(0.5 * SR)
+        samples = np.zeros(n_samples, dtype=np.float32)
+        samples[int(0.10 * SR) : int(0.15 * SR)] = 0.20
+        samples[int(0.25 * SR) : int(0.30 * SR)] = -0.18
+        samples[int(0.44 * SR) :] = 0.22  # offset persists to last sample
+        result = check_clicks(samples, SR)
+        assert not result.passed
+        assert result.gate_name == "click_detection"
+        assert result.detail is not None
+        n = int(result.detail.split()[1])
+        assert n >= 6, f"sample-(n-1) edge dropped: only {n} events; expected ≥6"
+        # The detail surfaces the FIRST 3 peak timestamps, not the last —
+        # so we re-run with the same rationale and check the count alone
+        # proves the boundary edge was counted (5 events without fix, 6 with).
+
 
 # ---------------------------------------------------------------------------
 # Composite gate runner