Stream guarded stable audio prefixes

README.md

@@ -28,11 +28,11 @@ RoleForge is a private feasibility lab for directing a fictional voice NPC. This
 
 ## Current gate
 
-This phase tests a quality-first free-Space approximation to live conversation:
+This phase tests a guarded low-latency free-Space approximation to live conversation:
 
 1. Wear headphones and press **Start 120-second live session**; approve microphone access when prompted.
 2. Wait for **Listening**, then speak naturally without pressing Stop.
-3. A short pause ends the visitor turn; the model generates a reply and then plays reference-decoded speech.
+3. A short pause ends the visitor turn; playback begins once the opening guard and first stable audio prefix are ready.
 4. Speaking clearly during playback interrupts it and begins a new visitor turn.
 
 The app retains LFM's multimodal conversation state for up to six turns inside one bounded 120-second listening
@@ -43,9 +43,11 @@ This is interruptible turn-taking rather than mathematically simultaneous model
 speech can cancel an active reply before the new utterance is processed. A browser AudioWorklet captures continuous
 raw PCM and a same-origin WebSocket carries input and output packets. Gradio still owns controls, diagnostics, and
 the bounded ZeroGPU call, but it no longer owns the microphone or audio playback. This avoids both the native
-Record/Waiting state machine and HLS buffering. The server buffers each short answer through LFM's known-clean
-whole-response decoder, divides the result into 160 ms packets, and the browser schedules them sample-exactly through
-WebAudio with an adaptive 180 ms lead, a bounded server buffer,
+Record/Waiting state machine and HLS buffering. During generation, the server decodes growing audio-code prefixes,
+holds back one unstable 80 ms frame, and emits only samples proven stable by the preceding physical A/B test. At EOS it
+decodes the clean whole response once and emits only the not-yet-played reference tail. A prefix-decode exception falls
+back automatically to the clean whole-response path. PCM is divided into packets of at most 160 ms and the browser
+schedules them sample-exactly through WebAudio with an adaptive 180 ms lead, a bounded server buffer,
 and immediate playback flush on barge-in. Playback epochs reset at reply boundaries so gaps between separate turns
 are not counted as underruns. Normal session completion stops microphone capture but lets already scheduled reply
 audio drain before closing WebAudio; manual stop and barge-in remain immediate. Microphone worklet packets are 4096 samples to reduce queue
@@ -54,20 +56,27 @@ cancellations.
 
 The system turn is exactly LiquidAI's required interleaved-mode instruction: `Respond with interleaved text and
 audio.` A short, public user-turn instruction pins the assistant's name to Lyra without assigning or inferring any
-visitor identity. Protected facts, trust scores, and private director instructions remain outside model context.
+fixed visitor identity. It states that personal names heard in visitor audio belong to the speaker, forbids Lyra from
+adopting them, and asks for direct replies without opening fillers such as Ah, Um, or Hmm. Protected facts, trust scores,
+and private director instructions remain outside model context.
 Generated text is labeled `Model response text` until a physical test proves it matches the
 spoken assistant response. Audio-code handling follows LiquidAI's reference implementation: retain the complete code
 sequence and remove only a confirmed terminal all-2048 end-of-audio frame. The obsolete incremental Mimi decoder and
 its GPU warm-up are removed. A 600 ms pause closes the visitor turn. Model output runs until its audio EOS or the
-bounded 768-token generation cap so decoded text cannot outrun audible speech on longer replies, while the
-whole-response reference decoder preserves voice quality. Diagnostics report token/EOS handling, microphone signal quality/drops, playback
-underruns, startup/generation/retry/decode timing, and an inaudible stable-prefix equivalence comparison after the
-first eligible reply.
+bounded 768-token generation cap so decoded text cannot outrun audible speech on longer replies. Diagnostics report
+token/EOS handling, microphone signal quality/drops, playback underruns, startup/generation/retry/decode timing,
+prefix-stream first-audio time, checkpoints, fallback/late-guard status, emitted duration, overhead, and live prefix/reference
+waveform equivalence.
 
-On every turn, live generation rejects false assistant identities before playback. After the first turn it also rejects
+On every turn, live generation rejects false assistant identities—including attempts to “go by” a visitor's name—and
+narrated openings before playback. The first attempt also rejects filler openings. After the first turn it rejects
 generic assistant openings and openings that closely match any earlier session response. Two bounded regeneration
 attempts use progressively broader text sampling; a remaining false-identity output fails closed rather than becoming
-audible. Diagnostics distinguish identity, generic-opening, history-repeat, and narration regenerations without
+audible. Prefix playback waits for a complete opening sentence or a 96-character guard window. A protected marker,
+false identity, or narrated role error discovered after streaming begins immediately aborts and flushes that reply.
+The completed clean decode is compared with the emitted prefix; a waveform mismatch disables prefix streaming for
+the remainder of that session and returns subsequent turns to whole-response playback.
+Diagnostics distinguish identity, filler, generic-opening, history-repeat, and narration regenerations without
 changing the official system prompt or audio-code path.
 
 ## Privacy and safety

live_app.py

@@ -47,14 +47,17 @@ SPEECH_RMS = 0.012
 BARGE_IN_RMS = 0.035
 BARGE_IN_CONFIRM_SECONDS = 0.22
 BARGE_IN_GRACE_SECONDS = 0.3
-STREAM_DIAGNOSTIC_CHUNK_FRAMES = 24
-STREAM_DIAGNOSTIC_STABLE_LAG_FRAMES = 1
-STREAM_DIAGNOSTIC_MAX_CHECKPOINTS = 4
-STREAM_DIAGNOSTIC_LATEST_START_SECONDS = 165.0
+PREFIX_STREAM_CHUNK_FRAMES = 24
+PREFIX_STREAM_STABLE_LAG_FRAMES = 1
+PREFIX_STREAM_GUARD_MIN_CHARS = 48
 TRANSPORT_VERSION = "webaudio-websocket-pcm-v1"
 INTERLEAVED_SYSTEM_PROMPT = "Respond with interleaved text and audio."
 ASSISTANT_NAME = "Lyra"
-ASSISTANT_IDENTITY_CONTEXT = "Your name is Lyra. Always identify yourself only as Lyra."
+ASSISTANT_IDENTITY_CONTEXT = (
+    "Your name is Lyra and you must identify yourself only as Lyra. The audio is spoken by the visitor. "
+    "Any personal name stated in that audio belongs to the visitor unless they are directly addressing Lyra; "
+    "never adopt that name as your own. Reply directly without opening fillers such as Ah, Um, or Hmm."
+)
 AUDIO_EOS_TOKEN = 2048
 
 DIRECTOR_CUES = {
@@ -203,12 +206,20 @@ def generic_assistant_opening(value):
 
 
 def false_assistant_identity(value):
-    opening = " ".join(normalized_words(value).split()[:24])
+    opening = " ".join(normalized_words(value).split()[:48])
     if not opening:
         return False
-    if "my name is" in opening and "my name is lyra" not in opening:
+    stated_name = re.search(r"\bmy name is\s+([a-z][a-z0-9'-]*)", opening)
+    if stated_name and stated_name.group(1) != "lyra":
         return True
-    if "you can call me" in opening and "you can call me lyra" not in opening:
+    called_name = re.search(r"\byou can call me\s+([a-z][a-z0-9'-]*)", opening)
+    if called_name and called_name.group(1) != "lyra":
+        return True
+    adopted_name = re.search(
+        r"\b(?:go by|call me|refer to me as)\s+([a-z][a-z0-9'-]*)",
+        opening,
+    )
+    if adopted_name and adopted_name.group(1) != "lyra":
         return True
     wrong_identity_markers = (
         "im qwen",
@@ -226,6 +237,18 @@ def false_assistant_identity(value):
     return "lyra" not in opening and any(marker in opening for marker in wrong_identity_markers)
 
 
+def filler_opening(value):
+    opening = normalized_words(value)
+    return bool(re.match(r"^(?:ah+|um+|uh+|hmm+)\b", opening))
+
+
+def prefix_stream_guard_ready(value):
+    compact = " ".join(value.split())
+    if len(compact) < PREFIX_STREAM_GUARD_MIN_CHARS:
+        return False
+    return bool(re.search(r"[.!?](?:[\"'’”)]*)\s*$", compact)) or len(compact) >= 96
+
+
 @dataclass
 class TurnDetector:
     speaking: bool = False
@@ -287,11 +310,11 @@ def prefix_stream_diagnostic(processor, audio_codes, reference_pcm):
     decode_seconds = 0.0
 
     for checkpoint in range(
-        STREAM_DIAGNOSTIC_CHUNK_FRAMES,
+        PREFIX_STREAM_CHUNK_FRAMES,
         total_frames,
-        STREAM_DIAGNOSTIC_CHUNK_FRAMES,
+        PREFIX_STREAM_CHUNK_FRAMES,
     ):
-        if len(checkpoints) >= STREAM_DIAGNOSTIC_MAX_CHECKPOINTS:
+        if len(checkpoints) >= 4:
             break
         started = time.perf_counter()
         prefix_pcm = (
@@ -305,7 +328,7 @@ def prefix_stream_diagnostic(processor, audio_codes, reference_pcm):
         decode_seconds += time.perf_counter() - started
         stable_samples = min(
             prefix_pcm.size,
-            max(0, checkpoint - STREAM_DIAGNOSTIC_STABLE_LAG_FRAMES) * AUDIO_FRAME_SAMPLES,
+            max(0, checkpoint - PREFIX_STREAM_STABLE_LAG_FRAMES) * AUDIO_FRAME_SAMPLES,
             reference.size,
         )
         if stable_samples > emitted_samples:
@@ -355,6 +378,38 @@ def prefix_stream_diagnostic(processor, audio_codes, reference_pcm):
     }
 
 
+def compare_prefix_waveform(candidate_pcm, reference_pcm):
+    candidate = np.asarray(candidate_pcm, dtype=np.float32).reshape(-1)
+    reference = np.asarray(reference_pcm, dtype=np.float32).reshape(-1)
+    compared_samples = min(candidate.size, reference.size)
+    if not compared_samples:
+        return {
+            "compared_seconds": 0.0,
+            "correlation": None,
+            "rms_ratio": None,
+            "snr_db": None,
+            "max_abs_error": None,
+        }
+    candidate = candidate[:compared_samples].astype(np.float64)
+    reference = reference[:compared_samples].astype(np.float64)
+    error = candidate - reference
+    reference_rms = float(np.sqrt(np.mean(reference * reference)))
+    candidate_rms = float(np.sqrt(np.mean(candidate * candidate)))
+    error_rms = float(np.sqrt(np.mean(error * error)))
+    correlation = (
+        float(np.corrcoef(candidate, reference)[0, 1])
+        if np.std(candidate) > 1e-12 and np.std(reference) > 1e-12
+        else (1.0 if np.allclose(candidate, reference) else 0.0)
+    )
+    return {
+        "compared_seconds": compared_samples / OUTPUT_SAMPLE_RATE,
+        "correlation": correlation,
+        "rms_ratio": candidate_rms / max(reference_rms, 1e-12),
+        "snr_db": 20.0 * np.log10(reference_rms / max(error_rms, 1e-12)),
+        "max_abs_error": float(np.max(np.abs(error))),
+    }
+
+
 _model_cache = {}
 _manager = multiprocessing.Manager()
 _live_sessions = _manager.dict()
@@ -466,6 +521,7 @@ def session_metrics(phase, started, turns, counters, first_reply, interruptions,
             "duplicate_regenerations": playback.get("history_repeat_regenerations", 0),
             "generic_opening_regenerations": playback.get("generic_opening_regenerations", 0),
             "identity_regenerations": playback.get("identity_regenerations", 0),
+            "filler_opening_regenerations": playback.get("filler_regenerations", 0),
             "total_regenerations": playback.get("regenerations", 0),
             "narration_regenerations": playback.get("style_regenerations", 0),
             "unsafe_outputs_suppressed": playback.get("unsafe_suppressed", 0),
@@ -549,9 +605,23 @@ def session_metrics(phase, started, turns, counters, first_reply, interruptions,
             "stream_diagnostic_max_abs_error": None
             if playback.get("stream_diagnostic_max_abs_error") is None
             else round(playback["stream_diagnostic_max_abs_error"], 6),
-            "stream_diagnostic_audible": False,
-            "stream_diagnostic_chunk_frames": STREAM_DIAGNOSTIC_CHUNK_FRAMES,
-            "stream_diagnostic_stable_lag_frames": STREAM_DIAGNOSTIC_STABLE_LAG_FRAMES,
+            "stream_diagnostic_audible": playback.get("stream_diagnostic_status")
+            == "completed_audible_prefix",
+            "stream_diagnostic_chunk_frames": PREFIX_STREAM_CHUNK_FRAMES,
+            "stream_diagnostic_stable_lag_frames": PREFIX_STREAM_STABLE_LAG_FRAMES,
+            "prefix_stream_status": playback.get("prefix_stream_status"),
+            "prefix_stream_fallbacks": playback.get("prefix_stream_fallbacks", 0),
+            "prefix_stream_late_guard_aborts": playback.get("prefix_stream_late_guard_aborts", 0),
+            "prefix_stream_first_audio_seconds": None
+            if playback.get("prefix_stream_first_audio_seconds") is None
+            else round(playback["prefix_stream_first_audio_seconds"], 3),
+            "prefix_stream_emitted_seconds": round(
+                playback.get("prefix_stream_emitted_seconds", 0.0), 3
+            ),
+            "prefix_stream_overhead_seconds_last_turn": round(
+                playback.get("prefix_stream_overhead_seconds_last_turn", 0.0), 3
+            ),
+            "prefix_stream_session_enabled": playback.get("prefix_stream_session_enabled", True),
             "reply_packets_emitted": playback["packets"],
             "reply_audio_emitted_seconds": round(playback["samples"] / OUTPUT_SAMPLE_RATE, 3),
             "reply_packet_target_seconds": round(OUTPUT_PACKET_SAMPLES / OUTPUT_SAMPLE_RATE, 3),
@@ -562,9 +632,9 @@ def session_metrics(phase, started, turns, counters, first_reply, interruptions,
             "transport": TRANSPORT_VERSION,
             "model_contract": "official exact interleaved system prompt",
             "assistant_identity": ASSISTANT_NAME,
-            "identity_grounding": "public text attached to each visitor turn",
-            "audio_delivery": "buffered whole-response reference decode",
-            "mode": "interruptible quality-first LFM2.5-Audio",
+            "identity_grounding": "Lyra-only public role boundary attached to each visitor turn",
+            "audio_delivery": "guarded held-tail stable-prefix stream with clean reference tail",
+            "mode": "interruptible low-latency LFM2.5-Audio",
         },
         indent=2,
     )
@@ -611,6 +681,7 @@ def run_live_session(scene, transport_id):
         "history_repeat_regenerations": 0,
         "generic_opening_regenerations": 0,
         "identity_regenerations": 0,
+        "filler_regenerations": 0,
         "style_regenerations": 0,
         "style_suppressed": 0,
         "identity_suppressed": 0,
@@ -639,7 +710,7 @@ def run_live_session(scene, transport_id):
         "last_false_identity": None,
         "last_history_repeat_score": None,
         "legacy_filter_would_drop": None,
-        "stream_diagnostic_status": "pending",
+        "stream_diagnostic_status": "pending_audible_prefix",
         "stream_diagnostic_checkpoints": 0,
         "stream_diagnostic_compared_seconds": None,
         "stream_diagnostic_decode_seconds": None,
@@ -647,9 +718,15 @@ def run_live_session(scene, transport_id):
         "stream_diagnostic_rms_ratio": None,
         "stream_diagnostic_snr_db": None,
         "stream_diagnostic_max_abs_error": None,
+        "prefix_stream_status": "not_started",
+        "prefix_stream_fallbacks": 0,
+        "prefix_stream_late_guard_aborts": 0,
+        "prefix_stream_first_audio_seconds": None,
+        "prefix_stream_emitted_seconds": 0.0,
+        "prefix_stream_overhead_seconds_last_turn": 0.0,
+        "prefix_stream_session_enabled": True,
     }
-    stream_diagnostic_codes = None
-    stream_diagnostic_reference = None
+    prefix_stream_enabled = True
 
     def emit_audio_packet(packet, response_started):
         nonlocal first_reply
@@ -663,6 +740,42 @@ def run_live_session(scene, transport_id):
             first_reply = time.perf_counter() - response_started
         return True
 
+    def collect_stream_interrupt(playback_started):
+        nonlocal utterance_rate
+        for pending_rate, pending_audio in drain_queue(input_queue):
+            pending_audio = np.asarray(pending_audio, dtype=np.float32).reshape(-1)
+            pending_duration = pending_audio.size / max(float(pending_rate), 1.0)
+            pending_rms = (
+                float(np.sqrt(np.mean(pending_audio * pending_audio))) if pending_audio.size else 0.0
+            )
+            pending_events = detector.push(
+                pending_rms,
+                pending_duration,
+                assistant_speaking=True,
+                assistant_elapsed=time.perf_counter() - playback_started,
+            )
+            if "speech_started" in pending_events:
+                utterance.extend(pre_roll)
+                pre_roll.clear()
+                utterance_rate = pending_rate
+            if detector.speaking or "turn_ready" in pending_events:
+                if utterance_rate == pending_rate:
+                    utterance.append(pending_audio)
+            else:
+                pre_roll.append(pending_audio)
+            if "interrupt" in pending_events:
+                return True
+        return False
+
+    def emit_pcm(pcm, response_started, playback_started):
+        pcm16 = (np.clip(np.asarray(pcm, dtype=np.float32), -1.0, 1.0) * 32767.0).astype(np.int16)
+        for offset in range(0, pcm16.size, OUTPUT_PACKET_SAMPLES):
+            if collect_stream_interrupt(playback_started):
+                return False
+            if not emit_audio_packet(pcm16[offset : offset + OUTPUT_PACKET_SAMPLES], response_started):
+                return False
+        return True
+
     ready_event.set()
     queue_control(output_queue, {"type": "phase", "phase": "listening"})
     live_started = time.perf_counter()
@@ -723,6 +836,18 @@ def run_live_session(scene, transport_id):
         yield "**Lyra is thinking.** You can speak again to cancel this reply.", gr.skip(), gr.skip()
 
         response_started = time.perf_counter()
+        playback["prefix_stream_status"] = "not_started"
+        playback["prefix_stream_first_audio_seconds"] = None
+        playback["prefix_stream_emitted_seconds"] = 0.0
+        playback["prefix_stream_overhead_seconds_last_turn"] = 0.0
+        playback["stream_diagnostic_status"] = "pending_audible_prefix"
+        playback["stream_diagnostic_checkpoints"] = 0
+        playback["stream_diagnostic_compared_seconds"] = None
+        playback["stream_diagnostic_decode_seconds"] = None
+        playback["stream_diagnostic_correlation"] = None
+        playback["stream_diagnostic_rms_ratio"] = None
+        playback["stream_diagnostic_snr_db"] = None
+        playback["stream_diagnostic_max_abs_error"] = None
         interrupted = False
         history_texts = [
             entry["response"]
@@ -735,6 +860,8 @@ def run_live_session(scene, transport_id):
         legacy_filter_would_drop = 0
         attempts_used = 0
         retry_generation_seconds = 0.0
+        stream_overhead_turn = 0.0
+        stream_guard_abort = False
         for attempt in range(MAX_GENERATION_ATTEMPTS):
             attempts_used = attempt + 1
             text_tokens = []
@@ -746,6 +873,17 @@ def run_live_session(scene, transport_id):
             attempt_started = time.perf_counter()
             attempt_first_token_seconds = None
             attempt_first_audio_token_seconds = None
+            attempt_stream_overhead = 0.0
+            current_text = ""
+            stream_emitted_samples = 0
+            stream_candidate_parts = []
+            stream_checkpoints = 0
+            stream_last_checkpoint_frames = 0
+            stream_decode_seconds = 0.0
+            stream_started = False
+            stream_playback_started = None
+            stream_decode_failed = False
+            stream_guard_abort = False
 
             with torch.inference_mode():
                 generation = model.generate_interleaved(
@@ -793,11 +931,28 @@ def run_live_session(scene, transport_id):
                         text_tokens.append(token)
                         modalities.append(LFMModality.TEXT)
                         current_text = processor.text.decode(torch.cat(text_tokens)).removesuffix("<|text_end|>").strip()
-                        if attempt < MAX_GENERATION_ATTEMPTS - 1:
-                            if false_assistant_identity(current_text):
+                        identity_error = false_assistant_identity(current_text)
+                        style_error = dialogue_style_violation(current_text)
+                        leak_error = bool(leak_markers(current_text))
+                        if stream_started and (identity_error or style_error or leak_error):
+                            stream_guard_abort = True
+                            playback["prefix_stream_late_guard_aborts"] += 1
+                            generation.close()
+                            flush_output(output_queue)
+                            break
+                        if not stream_started and attempt < MAX_GENERATION_ATTEMPTS - 1:
+                            if identity_error:
                                 opening_guard_reason = "identity"
                                 generation.close()
                                 break
+                            if attempt == 0 and filler_opening(current_text):
+                                opening_guard_reason = "filler"
+                                generation.close()
+                                break
+                            if style_error:
+                                opening_guard_reason = "style"
+                                generation.close()
+                                break
                             if guard_active and generic_assistant_opening(current_text):
                                 opening_guard_reason = "generic"
                                 generation.close()
@@ -817,8 +972,83 @@ def run_live_session(scene, transport_id):
                         modalities.append(LFMModality.AUDIO_OUT)
                         if torch.any(token == AUDIO_EOS_TOKEN).item():
                             legacy_filter_would_drop += 1
+                        should_decode_prefix = (
+                            prefix_stream_enabled
+                            and not is_audio_eos(token)
+                            and not stream_decode_failed
+                            and len(audio_tokens) >= PREFIX_STREAM_CHUNK_FRAMES
+                            and (
+                                not stream_started
+                                or len(audio_tokens) - stream_last_checkpoint_frames
+                                >= PREFIX_STREAM_CHUNK_FRAMES
+                            )
+                            and prefix_stream_guard_ready(current_text)
+                            and not false_assistant_identity(current_text)
+                            and not dialogue_style_violation(current_text)
+                            and not leak_markers(current_text)
+                            and (attempt > 0 or not filler_opening(current_text))
+                        )
+                        if should_decode_prefix:
+                            prefix_started = time.perf_counter()
+                            stable_delta = None
+                            stable_samples = stream_emitted_samples
+                            try:
+                                prefix_codes = torch.stack(audio_tokens, dim=1).unsqueeze(0)
+                                prefix_pcm = np.clip(
+                                    processor.decode(prefix_codes)[0]
+                                    .detach()
+                                    .float()
+                                    .cpu()
+                                    .numpy(),
+                                    -1.0,
+                                    1.0,
+                                ).reshape(-1)
+                                stable_samples = min(
+                                    prefix_pcm.size,
+                                    max(0, len(audio_tokens) - PREFIX_STREAM_STABLE_LAG_FRAMES)
+                                    * AUDIO_FRAME_SAMPLES,
+                                )
+                                if stable_samples > stream_emitted_samples:
+                                    stable_delta = prefix_pcm[stream_emitted_samples:stable_samples].copy()
+                            except Exception as exc:
+                                stream_decode_failed = True
+                                playback["prefix_stream_fallbacks"] += 1
+                                print(f"RoleForge prefix decode fell back: {type(exc).__name__}")
+                            finally:
+                                decode_elapsed = time.perf_counter() - prefix_started
+                                stream_decode_seconds += decode_elapsed
+                                attempt_stream_overhead += decode_elapsed
+                            if stable_delta is not None:
+                                if not stream_started:
+                                    stream_started = True
+                                    stream_playback_started = time.perf_counter()
+                                    playback["prefix_stream_first_audio_seconds"] = (
+                                        stream_playback_started - response_started
+                                    )
+                                    queue_control(output_queue, {"type": "phase", "phase": "speaking"})
+                                emission_started = time.perf_counter()
+                                emitted = emit_pcm(
+                                    stable_delta,
+                                    response_started,
+                                    stream_playback_started,
+                                )
+                                attempt_stream_overhead += time.perf_counter() - emission_started
+                                if not emitted:
+                                    interrupted = True
+                                    interruptions += 1
+                                    generation.close()
+                                    flush_output(output_queue)
+                                    break
+                                stream_candidate_parts.append(stable_delta)
+                                stream_emitted_samples = stable_samples
+                                stream_checkpoints += 1
+                                stream_last_checkpoint_frames = len(audio_tokens)
+                    if interrupted or stream_guard_abort:
+                        break
 
-            attempt_seconds = time.perf_counter() - attempt_started
+            attempt_wall_seconds = time.perf_counter() - attempt_started
+            stream_overhead_turn += attempt_stream_overhead
+            attempt_seconds = max(0.0, attempt_wall_seconds - attempt_stream_overhead)
             playback["generation_seconds_last_attempt"] = attempt_seconds
             playback["first_token_seconds_last_attempt"] = attempt_first_token_seconds
             playback["first_audio_token_seconds_last_attempt"] = attempt_first_audio_token_seconds
@@ -832,8 +1062,12 @@ def run_live_session(scene, transport_id):
                 playback["regenerations"] += 1
                 if opening_guard_reason == "identity":
                     playback["identity_regenerations"] += 1
+                elif opening_guard_reason == "filler":
+                    playback["filler_regenerations"] += 1
                 elif opening_guard_reason == "generic":
                     playback["generic_opening_regenerations"] += 1
+                elif opening_guard_reason == "style":
+                    playback["style_regenerations"] += 1
                 else:
                     playback["history_repeat_regenerations"] += 1
                 print(f"RoleForge rejected opening reason={opening_guard_reason}; regenerating.")
@@ -843,7 +1077,11 @@ def run_live_session(scene, transport_id):
                 if text_tokens
                 else ""
             )
-            if dialogue_style_violation(candidate_text) and attempt < MAX_GENERATION_ATTEMPTS - 1:
+            if (
+                dialogue_style_violation(candidate_text)
+                and attempt < MAX_GENERATION_ATTEMPTS - 1
+                and not stream_started
+            ):
                 retry_generation_seconds += attempt_seconds
                 playback["regenerations"] += 1
                 playback["style_regenerations"] += 1
@@ -851,7 +1089,10 @@ def run_live_session(scene, transport_id):
                 continue
             break
 
-        turn_generation_seconds = time.perf_counter() - response_started
+        turn_generation_seconds = max(
+            0.0,
+            time.perf_counter() - response_started - stream_overhead_turn,
+        )
         playback["generation_seconds_last_turn"] = turn_generation_seconds
         playback["retry_generation_seconds_last_turn"] = retry_generation_seconds
         model_seconds += turn_generation_seconds
@@ -879,6 +1120,10 @@ def run_live_session(scene, transport_id):
         identity_violation = false_assistant_identity(response_text)
         style_violation = dialogue_style_violation(response_text)
         reference_pcm = np.empty(0, dtype=np.float32)
+        playback["prefix_stream_overhead_seconds_last_turn"] = stream_overhead_turn
+        playback["stream_diagnostic_checkpoints"] = stream_checkpoints
+        playback["stream_diagnostic_decode_seconds"] = stream_decode_seconds
+        playback["prefix_stream_emitted_seconds"] = stream_emitted_samples / OUTPUT_SAMPLE_RATE
         if (
             not interrupted
             and playable_audio_tokens
@@ -894,9 +1139,30 @@ def run_live_session(scene, transport_id):
             turn_decode_seconds = time.perf_counter() - decode_started
             playback["reference_decode_seconds"] += turn_decode_seconds
             playback["reference_decode_seconds_last_turn"] = turn_decode_seconds
-            if stream_diagnostic_codes is None and len(playable_audio_tokens) > STREAM_DIAGNOSTIC_CHUNK_FRAMES:
-                stream_diagnostic_codes = audio_codes.detach().cpu()
-                stream_diagnostic_reference = reference_pcm.copy()
+            if stream_candidate_parts:
+                streamed_candidate = np.concatenate(stream_candidate_parts)
+                comparison = compare_prefix_waveform(streamed_candidate, reference_pcm)
+                playback["stream_diagnostic_status"] = "completed_audible_prefix"
+                playback["stream_diagnostic_compared_seconds"] = comparison["compared_seconds"]
+                playback["stream_diagnostic_correlation"] = comparison["correlation"]
+                playback["stream_diagnostic_rms_ratio"] = comparison["rms_ratio"]
+                playback["stream_diagnostic_snr_db"] = comparison["snr_db"]
+                playback["stream_diagnostic_max_abs_error"] = comparison["max_abs_error"]
+                waveform_safe = (
+                    comparison["correlation"] is not None
+                    and comparison["correlation"] >= 0.9999
+                    and comparison["rms_ratio"] is not None
+                    and 0.999 <= comparison["rms_ratio"] <= 1.001
+                    and comparison["snr_db"] is not None
+                    and comparison["snr_db"] >= 60.0
+                    and comparison["max_abs_error"] is not None
+                    and comparison["max_abs_error"] <= 0.001
+                )
+                if not waveform_safe:
+                    prefix_stream_enabled = False
+                    playback["prefix_stream_session_enabled"] = False
+                    playback["prefix_stream_fallbacks"] += 1
+                    playback["stream_diagnostic_status"] = "disabled_after_waveform_mismatch"
 
         if leaks:
             playback["unsafe_suppressed"] += 1
@@ -912,42 +1178,43 @@ def run_live_session(scene, transport_id):
             response_text = "[narrated model output suppressed]"
 
         if reference_pcm.size and not interrupted:
-            queue_control(output_queue, {"type": "phase", "phase": "speaking"})
-            yield "**Model is speaking.** Speak clearly to interrupt.", gr.skip(), gr.skip()
-            playback_started = time.perf_counter()
-            reference_int16 = (reference_pcm * 32767.0).astype(np.int16)
-            for offset in range(0, reference_int16.size, OUTPUT_PACKET_SAMPLES):
-                for pending_rate, pending_audio in drain_queue(input_queue):
-                    pending_audio = np.asarray(pending_audio, dtype=np.float32).reshape(-1)
-                    pending_duration = pending_audio.size / max(float(pending_rate), 1.0)
-                    pending_rms = (
-                        float(np.sqrt(np.mean(pending_audio * pending_audio))) if pending_audio.size else 0.0
+            if stream_started:
+                playback["prefix_stream_status"] = (
+                    "disabled_after_waveform_mismatch"
+                    if not prefix_stream_enabled
+                    else (
+                        "completed_with_reference_tail_after_decode_fallback"
+                        if stream_decode_failed
+                        else "completed"
                     )
-                    pending_events = detector.push(
-                        pending_rms,
-                        pending_duration,
-                        assistant_speaking=True,
-                        assistant_elapsed=time.perf_counter() - playback_started,
+                )
+                tail_pcm = reference_pcm[stream_emitted_samples:]
+                playback_started = stream_playback_started
+            else:
+                playback["prefix_stream_status"] = (
+                    "fallback_whole_response_stream_disabled"
+                    if not prefix_stream_enabled
+                    else (
+                        "fallback_whole_response_decode_error"
+                        if stream_decode_failed
+                        else "fallback_whole_response_guard_or_short_reply"
                     )
-                    if "speech_started" in pending_events:
-                        utterance.extend(pre_roll)
-                        pre_roll.clear()
-                        utterance_rate = pending_rate
-                    if detector.speaking or "turn_ready" in pending_events:
-                        if utterance_rate == pending_rate:
-                            utterance.append(pending_audio)
-                    else:
-                        pre_roll.append(pending_audio)
-                    if "interrupt" in pending_events:
-                        interrupted = True
-                if interrupted:
-                    interruptions += 1
-                    flush_output(output_queue)
-                    break
-                packet = reference_int16[offset : offset + OUTPUT_PACKET_SAMPLES]
-                if not emit_audio_packet(packet, response_started):
-                    interrupted = True
-                    break
+                )
+                playback["stream_diagnostic_status"] = playback["prefix_stream_status"]
+                tail_pcm = reference_pcm
+                playback_started = time.perf_counter()
+                queue_control(output_queue, {"type": "phase", "phase": "speaking"})
+                yield "**Model is speaking.** Speak clearly to interrupt.", gr.skip(), gr.skip()
+            if tail_pcm.size and not emit_pcm(
+                tail_pcm,
+                response_started,
+                playback_started,
+            ):
+                interrupted = True
+                interruptions += 1
+                flush_output(output_queue)
+        elif stream_guard_abort:
+            playback["prefix_stream_status"] = "aborted_late_guard"
 
         repeat_score = history_repetition_score(response_text, history_texts)
         repeated = repeat_score >= 0.86
@@ -977,48 +1244,6 @@ def run_live_session(scene, transport_id):
                 "repeated": repeated,
             }
         )
-        if stream_diagnostic_codes is not None and playback["stream_diagnostic_status"] == "pending":
-            if time.perf_counter() - started > STREAM_DIAGNOSTIC_LATEST_START_SECONDS:
-                playback["stream_diagnostic_status"] = "skipped_deadline_guard"
-            else:
-                queue_control(output_queue, {"type": "phase", "phase": "calibrating"})
-                yield (
-                    "**Lyra audio calibration.** Comparing inaudible stable-prefix audio with the clean reply…",
-                    render_transcript(entries),
-                    session_metrics(
-                        "diagnostics",
-                        started,
-                        turns,
-                        counters,
-                        first_reply,
-                        interruptions,
-                        model_seconds,
-                        playback,
-                        repeats,
-                    ),
-                )
-                try:
-                    with torch.inference_mode():
-                        diagnostic = prefix_stream_diagnostic(
-                            processor,
-                            stream_diagnostic_codes.to(DEVICE),
-                            stream_diagnostic_reference,
-                        )
-                    playback["stream_diagnostic_status"] = (
-                        "completed" if diagnostic["attempted"] else "skipped_insufficient_checkpoints"
-                    )
-                    playback["stream_diagnostic_checkpoints"] = len(diagnostic["checkpoints"])
-                    playback["stream_diagnostic_compared_seconds"] = diagnostic["compared_seconds"]
-                    playback["stream_diagnostic_decode_seconds"] = diagnostic["decode_seconds"]
-                    playback["stream_diagnostic_correlation"] = diagnostic["correlation"]
-                    playback["stream_diagnostic_rms_ratio"] = diagnostic["rms_ratio"]
-                    playback["stream_diagnostic_snr_db"] = diagnostic["snr_db"]
-                    playback["stream_diagnostic_max_abs_error"] = diagnostic["max_abs_error"]
-                except Exception as exc:
-                    playback["stream_diagnostic_status"] = f"failed_{type(exc).__name__}"
-                    print(f"RoleForge stable-prefix diagnostic failed: {type(exc).__name__}")
-            stream_diagnostic_codes = None
-            stream_diagnostic_reference = None
         if turns >= MAX_TURNS:
             break
         queue_control(output_queue, {"type": "phase", "phase": "listening"})
@@ -1031,8 +1256,8 @@ def run_live_session(scene, transport_id):
     ready_event.clear()
     queue_control(output_queue, {"type": "complete"})
     stop_event.set()
-    if playback["stream_diagnostic_status"] == "pending":
-        playback["stream_diagnostic_status"] = "skipped_no_eligible_response"
+    if playback["stream_diagnostic_status"] == "pending_audible_prefix":
+        playback["stream_diagnostic_status"] = "no_eligible_response"
     final_status = "Session complete. Start a new live session to continue." if turns else "Session ended before a turn completed."
     yield (
         final_status,
@@ -1242,15 +1467,16 @@ with gr.Blocks(title="RoleForge Live Voice NPC", theme=gr.themes.Soft(), css=CSS
     gr.HTML(
         """
         <div class="hero">
-          <div class="phase">QUALITY-FIRST LIVE LFM2.5-AUDIO</div>
+          <div class="phase">LOW-LATENCY LIVE LFM2.5-AUDIO</div>
           <h1>🎭 RoleForge: Live Voice NPC Director</h1>
-          <div>Continuous WebAudio microphone, reference-quality PCM playback, bounded memory, and barge-in.</div>
+          <div>Continuous WebAudio microphone, stable-prefix PCM streaming, bounded memory, and barge-in.</div>
         </div>
         """
     )
     gr.Markdown(
-        "This quality-first build buffers each short reply through LFM's whole-response decoder before playback. "
-        "The microphone remains open and playback can still be interrupted. **Wear headphones** to prevent echo-triggered interruption."
+        "This build begins playback from guarded, proven-stable LFM prefix decodes and finishes with the clean reference tail. "
+        "It automatically falls back to whole-response playback if prefix decoding fails. The microphone remains open and playback "
+        "can be interrupted. **Wear headphones** to prevent echo-triggered interruption."
     )
 
     with gr.Row():