@@ -70,6 +70,7 @@ SFX onset/offset times come **only** from the Stage 3b augmentation log. Speech-
 - **Cache key: SHA-256 of the full rendered SSML string** — not `(voice_id, text)`
 - **M3a — per-turn RMS gain:** `StyleEntry.rms_target_dbfs` → module-level `_apply_rms_gain()` in `synthbanshee/tts/mixer.py`; 4-tuple segment API `(wav_bytes, pause_s, speaker_id, rms_target_dbfs)`
 - **Temp WAV from mixer must be `subtype="FLOAT"`** — never `PCM_16` before `preprocess()` to avoid hard-clipping M3 gain
+- **#87 effective-prosody cap:** `synthbanshee/tts/renderer._apply_effective_prosody_cap` clamps post-state, post-randomization prosody to `pitch ∈ [−3.0, +2.0] st`, `rate ∈ [0.85, 1.20]`. Volume is left to `_volume_to_string`'s ±50% Azure clamp (Whisper internally normalizes loudness; #82 lever probe). Cap activations are recorded per-turn in `DialogueTurn.effective_prosody_caps` and rolled up into `ClipMetadata.generation_metadata.effective_prosody_caps`. Caps are anchored to the pre-#51 effective envelope (the 04-15 reference baseline that Whisper handles with WER 0.04–0.08); changing them requires a paired listening test + Whisper sanity check (see "ASR sanity check policy" below).
 
 ## Splits
 
@@ -85,6 +86,23 @@ SFX onset/offset times come **only** from the Stage 3b augmentation log. Speech-
   3. JSON parses as `ClipMetadata` with `is_synthetic=True`
   4. Filename stem is ASCII-only lowercase
 
+## ASR sanity check policy (#87)
+
+The Whisper-large-v3 sanity check (`synthbanshee qa-report --asr`) detects audio that synthesizes fine to a listener but trips Whisper's silence-detection / segmentation heuristic — the failure mode that surfaced in #87 and went undetected on `sp_it_a_0001` for weeks. The canonical fingerprint is **length-ratio collapse** (`hyp_words / ref_words < 0.85`).
+
+**Cost:** ~5–20 s per clip on M-series MPS, ~3 GB Whisper-large-v3 download on first use. Real Azure render to populate the cache is an additional ~$0.05–$0.20 per scene.
+
+**Policy — for the foreseeable future, this check is _local-only_, not in CI:**
+
+1. **Unit tests** for the cap logic (in `tests/unit/test_effective_prosody_cap.py`) run on every PR. They cover ~90 % of regressions with no Azure / Whisper cost.
+2. **`qa-report --asr` (Tier-3)** is run **locally**, **once**, **after all PR reviews and fixes are done**, **and only for PRs that might affect audio rendering** (anything touching `synthbanshee/tts/`, `synthbanshee/script/`, `synthbanshee/augment/`, or the speaker / scene / acoustic / project YAML configs). PRs that only touch labels, packaging, docs, or tests skip it.
+3. **Cost discipline:** use this command **very sparingly** — each invocation incurs Azure spend (~$1–$2 per real-render run). Prefer running against a directory of already-cached clips when possible; only re-render when a code change invalidates the SSML cache.
+4. **Result documentation:** when run, paste the `qa-report --asr` output (table of any clips with `length_ratio < 0.85`, plus the green-tick "no asr warnings" line if all clean) into the PR body's "Test plan" section under a "Tier-3 ASR sanity (local)" sub-heading.
+
+**Future CI consideration:** see GH issue tracking the addition of a scheduled / labeled Whisper-based CI workflow, including repo-secret management for `AZURE_TTS_KEY` and Azure spend caps. Re-evaluate when scene volume increases enough that local manual runs become impractical.
+
+**Install:** `uv pip install --python .venv/bin/python -e ".[eval-asr]"` (heavyweight optional extra).
+
 ## Environment variables
 
 ```
@@ -153,3 +171,5 @@ When addressing PR review comments (Copilot, human, or bot):
 - Don't generate clips shorter than 3.0 s
 - Don't add a new typology to `taxonomy.yaml` without adding it to `_TYPOLOGY_INTENSITY_MAP`
 - Don't pin `pr-agent-context` workflow references to a specific patch version — keep `@v4` floating
+- Don't relax the #87 effective-prosody cap (`_EFFECTIVE_PITCH_*`, `_EFFECTIVE_RATE_*` in `synthbanshee/tts/renderer.py`) without a paired listening test + `qa-report --asr` Tier-3 run; the cap defends both naturalness (May-3 listening test) and Whisper transcription
+- Don't merge a PR that touches audio rendering (`synthbanshee/tts/`, `synthbanshee/script/`, `synthbanshee/augment/`, or speaker / scene / acoustic / project YAMLs) without running `qa-report --asr` locally first and pasting the result into the PR's test plan (see "ASR sanity check policy")
@@ -58,6 +58,17 @@ google-tts = [
     "google-cloud-texttospeech>=2.16",
 ]
 
+# Whisper-based ASR sanity for `qa-report --asr` (#87 length-ratio detector).
+# Heavyweight: pulls torch + transformers + ~3 GB of Whisper-large-v3 weights
+# on first use.  Not required for normal generation/QA — only install when
+# running the ASR sanity check locally (see CLAUDE.md "ASR sanity check policy").
+eval-asr = [
+    "torch>=2.0",
+    "transformers>=4.40",
+    "accelerate>=0.30",
+    "jiwer>=3.0",
+]
+
 dev = [
     "pytest>=8.0",
     "pytest-cov>=5.0",
 
@@ -628,7 +628,7 @@ def vlog(msg: str) -> None:
     from collections import Counter
 
     from synthbanshee import __version__
-    from synthbanshee.labels.schema import GenerationMetadata
+    from synthbanshee.labels.schema import EffectiveProsodyCapEvent, GenerationMetadata
 
     # Per-speaker TTS backend and voice family.
     _backends_map: dict[str, str] = {sid: spk.tts_provider for sid, spk in speakers.items()}
@@ -655,6 +655,19 @@ def vlog(msg: str) -> None:
         if turn.speaker_id not in _speaker_states and turn.speaker_state_snapshot:
             _speaker_states[turn.speaker_id] = turn.speaker_state_snapshot
 
+    # #87: roll up per-turn effective-prosody cap activations into clip metadata.
+    _cap_events: list[EffectiveProsodyCapEvent] = [
+        EffectiveProsodyCapEvent(
+            turn_index=i,
+            intensity=turn.intensity,
+            dim=ev["dim"],
+            pre_cap=ev["pre_cap"],
+            post_cap=ev["post_cap"],
+        )
+        for i, turn in enumerate(turns)
+        for ev in turn.effective_prosody_caps
+    ]
+
     gen_meta = GenerationMetadata(
         pipeline_version=__version__,
         tts_backend=_backends_map,
@@ -668,6 +681,7 @@ def vlog(msg: str) -> None:
         loudness_target_peak_dbfs=preproc_config.target_peak_dbfs,
         breathiness_applied=_breathiness_was_applied,
         speaker_state_serialized=_speaker_states,
+        effective_prosody_caps=_cap_events,
     )
 
     metadata = label_gen.generate_clip_metadata(
@@ -1444,8 +1458,29 @@ def validate(clip: Path) -> None:
     default=False,
     help="Compute and display M10b run-level aggregation metrics.",
 )
+@click.option(
+    "--asr",
+    is_flag=True,
+    default=False,
+    help="Run Whisper-large-v3 on every clip and flag length-ratio collapse "
+    "(the #87 'silence-detector trip' fingerprint). Heavyweight: ~5-20s per "
+    "clip on M-series MPS, ~3GB model download. Requires the 'eval-asr' extra.",
+)
+@click.option(
+    "--asr-min-length-ratio",
+    type=float,
+    default=0.85,
+    show_default=True,
+    help="Length-ratio (hyp_words / ref_words) threshold below which a clip is "
+    "flagged by --asr. The #87 fingerprint sat at ~0.70; baseline is 1.00.",
+)
 def qa_report(
-    data_dir: Path, output: Path | None, max_failure_rate: float, run_summary: bool
+    data_dir: Path,
+    output: Path | None,
+    max_failure_rate: float,
+    run_summary: bool,
+    asr: bool,
+    asr_min_length_ratio: float,
 ) -> None:
     """Run the automated QA suite on a dataset directory.
 
@@ -1455,13 +1490,23 @@ def qa_report(
     from synthbanshee.package.qa import (
         _HIGH_EMOTION_DOWNGRADE_RATE,
         _MIN_VOICE_DIVERSITY,
+        run_asr_check,
         run_qa,
     )
 
     console.print(f"[cyan]Running QA on:[/cyan] {data_dir}")
     report = run_qa(data_dir, max_failure_rate=max_failure_rate, run_summary=run_summary)
     stats = report.stats
 
+    # #87: opt-in Whisper sanity check.  Runs after run_qa so we already
+    # know the clips that validated; ASR results attach to the same report.
+    if asr:
+        console.print(
+            f"[cyan]Running ASR sanity (Whisper-large-v3, "
+            f"length_ratio < {asr_min_length_ratio}):[/cyan] {data_dir}"
+        )
+        report.asr_warnings = run_asr_check(data_dir, min_length_ratio=asr_min_length_ratio)
+
     table = Table(title="Dataset Statistics")
     table.add_column("Metric")
     table.add_column("Value", justify="right")
@@ -1476,6 +1521,12 @@ def qa_report(
     )
     table.add_row("Unique speakers", str(stats.speaker_count))
     table.add_row("Quality-flagged", str(stats.quality_flagged_clips))
+    if stats.clips_with_prosody_cap_activations > 0:
+        table.add_row(
+            "Clips with prosody-cap activations (#87)",
+            f"[yellow]{stats.clips_with_prosody_cap_activations}[/yellow]"
+            f" ({stats.prosody_cap_activations_total} total events)",
+        )
     missing_jsonl_label = (
         f"[yellow]{stats.clips_missing_strong_labels}[/yellow]"
         if stats.clips_missing_strong_labels > 0
@@ -1517,6 +1568,44 @@ def qa_report(
         if len(report.failed_clip_ids) > 20:
             console.print(f"  ... and {len(report.failed_clip_ids) - 20} more")
 
+    # #87: prosody-cap activations are surfaced as a top-level table because
+    # they catch a class of regression that the M10a/M10b checks cannot —
+    # specifically, prosody pushed past the listening-test-validated envelope.
+    if report.prosody_cap_activations:
+        t_caps = Table(title="Effective-Prosody Cap Activations (#87)")
+        t_caps.add_column("Clip ID")
+        t_caps.add_column("Cap events", justify="right")
+        for clip_id, count in sorted(
+            report.prosody_cap_activations.items(),
+            key=lambda kv: kv[1],
+            reverse=True,
+        )[:20]:
+            t_caps.add_row(clip_id, str(count))
+        console.print(t_caps)
+        if len(report.prosody_cap_activations) > 20:
+            console.print(f"  ... and {len(report.prosody_cap_activations) - 20} more")
+
+    # #87: ASR sanity surfaces clips whose length-ratio collapsed below the
+    # configured threshold — the Whisper "silence-detector trip" fingerprint.
+    if report.asr_warnings:
+        t_asr = Table(title=f"ASR Sanity Failures (#87, length_ratio < {asr_min_length_ratio})")
+        t_asr.add_column("Clip ID")
+        t_asr.add_column("WER", justify="right")
+        t_asr.add_column("len_ratio", justify="right")
+        t_asr.add_column("hyp / ref", justify="right")
+        for clip_id, m in sorted(report.asr_warnings.items(), key=lambda kv: kv[1]["length_ratio"])[
+            :20
+        ]:
+            t_asr.add_row(
+                clip_id,
+                f"{m['wer']:.3f}",
+                f"[red]{m['length_ratio']:.3f}[/red]",
+                f"{m['hyp_words']} / {m['ref_words']}",
+            )
+        console.print(t_asr)
+        if len(report.asr_warnings) > 20:
+            console.print(f"  ... and {len(report.asr_warnings) - 20} more")
+
     # --- M10b: run-level summary table ---
     if report.run_summary is not None:
         rs = report.run_summary
@@ -1595,28 +1684,34 @@ def qa_report(
 
     if output is not None:
         output.parent.mkdir(parents=True, exist_ok=True)
-        report_dict = {
+        stats_dict: dict[str, object] = {
+            "total_clips": stats.total_clips,
+            "failed_clips": stats.failed_clips,
+            "total_duration_seconds": stats.total_duration_seconds,
+            "speaker_count": stats.speaker_count,
+            "quality_flagged_clips": stats.quality_flagged_clips,
+            "clips_missing_strong_labels": stats.clips_missing_strong_labels,
+            "clips_by_typology": stats.clips_by_typology,
+            "clips_by_split": stats.clips_by_split,
+            "clips_by_tier": stats.clips_by_tier,
+            "intensity_distribution": {str(k): v for k, v in stats.intensity_distribution.items()},
+            # #87: surface the prosody-cap counts in the JSON report so CI /
+            # post-batch scripts can detect drift without parsing every clip.
+            "clips_with_prosody_cap_activations": stats.clips_with_prosody_cap_activations,
+            "prosody_cap_activations_total": stats.prosody_cap_activations_total,
+        }
+        report_dict: dict[str, object] = {
             "data_dir": report.data_dir,
             "passed": report.passed,
             "failure_rate": report.failure_rate,
-            "stats": {
-                "total_clips": stats.total_clips,
-                "failed_clips": stats.failed_clips,
-                "total_duration_seconds": stats.total_duration_seconds,
-                "speaker_count": stats.speaker_count,
-                "quality_flagged_clips": stats.quality_flagged_clips,
-                "clips_missing_strong_labels": stats.clips_missing_strong_labels,
-                "clips_by_typology": stats.clips_by_typology,
-                "clips_by_split": stats.clips_by_split,
-                "clips_by_tier": stats.clips_by_tier,
-                "intensity_distribution": {
-                    str(k): v for k, v in stats.intensity_distribution.items()
-                },
-            },
+            "stats": stats_dict,
             "failed_clip_ids": report.failed_clip_ids,
             "quality_flagged": report.quality_flagged,
             "acoustic_warnings": report.acoustic_warnings,
             "structural_warnings": report.structural_warnings,
+            # #87: prosody-cap activations + ASR sanity (empty unless --asr).
+            "prosody_cap_activations": report.prosody_cap_activations,
+            "asr_warnings": report.asr_warnings,
         }
         if report.run_summary is not None:
             rs = report.run_summary
 
@@ -126,6 +126,23 @@ class PreprocessingApplied(BaseModel):
     silence_padded: bool = False
 
 
+class EffectiveProsodyCapEvent(BaseModel):
+    """One activation of the #87 runtime effective-prosody cap.
+
+    Recorded per turn and per dimension when the post-state, post-randomization
+    prosody value would have exceeded the envelope that Whisper-large-v3 can
+    transcribe and the listener finds natural at high intensities.  See
+    ``synthbanshee.tts.renderer._apply_effective_prosody_cap`` for thresholds
+    and rationale.
+    """
+
+    turn_index: int = Field(ge=0)
+    intensity: int = Field(ge=1, le=5)
+    dim: Literal["rate", "pitch", "volume"]
+    pre_cap: float
+    post_cap: float
+
+
 class GenerationMetadata(BaseModel):
     """Pipeline provenance metadata for ablation studies (spec §4.11).
 
@@ -161,6 +178,17 @@ class GenerationMetadata(BaseModel):
     breathiness_applied: bool = False
     speaker_state_serialized: dict[str, dict[str, float]] = Field(default_factory=dict)
 
+    effective_prosody_caps: list[EffectiveProsodyCapEvent] = Field(default_factory=list)
+    """Per-turn activations of the #87 effective-prosody cap.
+
+    One entry per ``(turn_index, dim)`` clamp.  An empty list means every turn's
+    effective prosody fell within the envelope (post-state, post-randomization).
+    A non-empty list is a static signal that the renderer pulled the turn's
+    pitch or rate back from the helium / Whisper-trip range — typically a small
+    number of high-intensity turns near the end of an arc with significant M7
+    SpeakerState drift.  Use ``synthbanshee qa-report`` to flag clips with
+    ``len(effective_prosody_caps) > N``."""
+
 
 # ---------------------------------------------------------------------------
 # Per-clip metadata (one .json per clip)