fix(rr): Wave-A brutal-review fixes — barge-in poisoning (CRITICAL) + Anthropic 400s

5-lens adversarial review of Wave A (wf_6afb89db) confirmed + empirically
reproduced 3 real defects; fixed:

CRITICAL (d3-masking-races / regression-surface, both lenses + reproduced): the
D3 filler called arm_barge_in_suppression(350) which flips the SESSION-GLOBAL
allow_interruption=false, but the real answer is spoken via speak_if_epoch(
allow_interruption=true) which never RESTORES it — so the flag stayed false, the
egress wrapper kept extending non_interruptible_until_ms per answer chunk, and
can_interrupt() returned false for the WHOLE answer (and leaked across turns).
The STT callback drops barge-in when !can_interrupt(), so a user could not barge
in on the real answer — silently re-introducing the exact §4.4 failure on the
slow turns D3 targets. Fix: REMOVE arm_barge_in_suppression from the masking
timer — the filler is interruptible by design (a real barge-in during it must be
honored); echo cancellation, not a session-wide flag flip, handles the bot's own
tail. New regression test latency_filler_does_not_poison_interruptibility asserts
is_interruption_blocked()==false after a masked turn. (arm_barge_in_suppression
stays as a VoiceManager API + the §4.4 test's window simulator.)

HIGH (d1-vendor-correctness, verified against the claude-api skill): the Anthropic
adapter emitted thinking:{type:"enabled",budget_tokens} for (a) adaptive-only
models (Opus 4.7/4.8, Fable 5) which REJECT that form with a 400, and (b) budgets
clamped below the 1024 minimum (the voice cap 256 makes [1024, max_tokens)
unsatisfiable) — also a guaranteed 400. Fix: adaptive-only models emit NO thinking
block (they think adaptively by default); others emit `enabled` ONLY when a valid
budget (>=1024 and <max_tokens) fits, else nothing — never a guaranteed 400.
is_anthropic_adaptive_only helper + ANTHROPIC_MIN_THINKING_BUDGET; test rewritten
for the 400-safe matrix (voice-cap→none, room→enabled, adaptive-only→none, off→none).

lib floor 6173/0, conversation_loop 20/0 (incl the new regression), clippy clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jithinAB

gateway/src/core/conversation/mod.rs

@@ -542,10 +542,15 @@ impl ConversationOrchestrator {
                     if latch.swap(true, std::sync::atomic::Ordering::AcqRel) {
                         return; // one masking utterance per turn
                     }
-                    // Suppress the filler's own VAD tail (≤400ms) while keeping the
-                    // clip interruptible, then speak it (epoch-gated so a barge-in
-                    // that already cleared drops it).
-                    vm.arm_barge_in_suppression(350);
+                    // Speak the filler as ORDINARY interruptible audio (epoch-gated
+                    // so a barge-in that already cleared drops it). We must NOT flip
+                    // the session-global interruption flag here: the filler is
+                    // interruptible by design, and a real barge-in during it (or
+                    // during the real answer that follows) must be honored — the
+                    // brutal review proved that poisoning allow_interruption here
+                    // silently disabled barge-in for the WHOLE answer (critique:
+                    // re-introduced the §4.4 failure). Echo cancellation, not a
+                    // session-wide suppression window, handles the bot's own tail.
                     match vm.speak_if_epoch(&phrase, true, true, epoch).await {
                         Ok(true) => debug!(session = %session, %phrase, "D3 masking filler spoken"),
                         Ok(false) => {

gateway/src/core/llm/adapter.rs

@@ -138,6 +138,24 @@ impl ReasoningEffort {
     }
 }
 
+/// Anthropic minimum `budget_tokens` for the `type:"enabled"` thinking form.
+/// Below this, the API 400s — so we don't emit the enabled form (see render).
+const ANTHROPIC_MIN_THINKING_BUDGET: u32 = 1024;
+
+/// Whether an Anthropic model is adaptive-thinking-ONLY (Opus 4.7/4.8, Fable 5):
+/// these REJECT `thinking:{type:"enabled",budget_tokens}` with a 400 and only
+/// honor their built-in adaptive thinking — so we emit no thinking block at all
+/// (the model thinks adaptively by default; budget can't control it).
+fn is_anthropic_adaptive_only(model: &str) -> bool {
+    let m = model.to_ascii_lowercase();
+    m.contains("opus-4-7")
+        || m.contains("opus-4.7")
+        || m.contains("opus-4-8")
+        || m.contains("opus-4.8")
+        || m.contains("fable-5")
+        || m.contains("claude-fable")
+}
+
 /// Anthropic extended-thinking budget per effort. The caller MUST further clamp
 /// to `< max_tokens` (Anthropic 400s otherwise).
 fn anthropic_budget_tokens(e: ReasoningEffort) -> u32 {
@@ -636,18 +654,27 @@ impl LlmAdapter for AnthropicAdapter {
         if let Some(p) = cfg.top_p {
             obj.insert("top_p".into(), json!(p));
         }
-        // D1: Anthropic extended thinking. `Off`/`None` → emit nothing (default
-        // is no thinking). EXACTLY ONE param (`thinking`). INVARIANT: Anthropic
-        // 400s unless `budget_tokens < max_tokens`, so clamp the budget below the
-        // body's `max_tokens` (the voice path caps at 256).
+        // D1: Anthropic extended thinking (brutal-review hardened). `Off`/`None`
+        // → nothing. EXACTLY ONE param. The `enabled` form requires
+        // `1024 <= budget_tokens < max_tokens`; the voice cap (256) makes that
+        // jointly unsatisfiable, and adaptive-only models (Opus 4.7/4.8, Fable 5)
+        // reject the `enabled` form entirely. So: adaptive-only → emit nothing
+        // (model thinks adaptively by default); otherwise emit `enabled` ONLY when
+        // a valid budget (>= 1024 and < max_tokens) fits — else emit nothing
+        // rather than a guaranteed 400.
         if let Some(effort) = cfg.reasoning_effort {
-            if effort != ReasoningEffort::Off {
+            if effort != ReasoningEffort::Off && !is_anthropic_adaptive_only(&cfg.model) {
                 let max_tok = cfg.max_tokens.unwrap_or(ANTHROPIC_DEFAULT_MAX_TOKENS);
                 let budget = anthropic_budget_tokens(effort).min(max_tok.saturating_sub(1));
-                obj.insert(
-                    "thinking".into(),
-                    json!({ "type": "enabled", "budget_tokens": budget }),
-                );
+                if budget >= ANTHROPIC_MIN_THINKING_BUDGET {
+                    obj.insert(
+                        "thinking".into(),
+                        json!({ "type": "enabled", "budget_tokens": budget }),
+                    );
+                }
+                // else: budget can't satisfy [1024, max_tokens) — skip thinking
+                // (no 400). A reasoning Anthropic model on voice needs a higher
+                // explicit max_tokens to actually think.
             }
         }
         if let Some(stop) = &cfg.stop {
@@ -1317,21 +1344,40 @@ mod tests {
     }
 
     #[test]
-    fn anthropic_maps_reasoning_effort_to_thinking_budget_below_max_tokens() {
+    fn anthropic_maps_reasoning_effort_thinking_400_safe() {
+        // Voice cap (256): a valid budget needs 1024 <= budget < max_tokens, which
+        // is unsatisfiable at 256 → emit NO thinking block (never a guaranteed 400).
         let mut c = cfg(Some(AdapterKind::Anthropic));
-        c.max_tokens = Some(256); // the voice path's cap
-        c.reasoning_effort = Some(ReasoningEffort::High); // raw budget 8192 > 256
+        c.max_tokens = Some(256);
+        c.reasoning_effort = Some(ReasoningEffort::High);
+        let r = AnthropicAdapter.render_request(&convo(), &c, false, None);
+        assert!(
+            r.body.get("thinking").is_none(),
+            "budget can't satisfy [1024, 256) → no thinking block, not a 400"
+        );
+
+        // Room for a valid budget → enabled with 1024 <= budget < max_tokens.
+        c.max_tokens = Some(4000);
         let r = AnthropicAdapter.render_request(&convo(), &c, false, None);
         assert_eq!(r.body["thinking"]["type"], "enabled");
         let budget = r.body["thinking"]["budget_tokens"].as_u64().unwrap();
-        assert!(budget < 256, "budget {budget} must be < max_tokens 256 (anti-400)");
+        assert!((1024..4000).contains(&(budget as u32)), "budget {budget} in [1024,4000)");
         assert!(r.body.get("reasoning_effort").is_none(), "exactly one param");
 
-        // Off → no thinking key at all (Anthropic default is no extended thinking).
+        // Adaptive-only model (Opus 4.8) rejects the enabled form → emit nothing.
+        c.model = "claude-opus-4-8".to_string();
+        c.reasoning_effort = Some(ReasoningEffort::High);
+        let r = AnthropicAdapter.render_request(&convo(), &c, false, None);
+        assert!(
+            r.body.get("thinking").is_none(),
+            "adaptive-only model: never the enabled+budget form (it 400s)"
+        );
+
+        // Off / None → no thinking key (default no extended thinking).
+        c.model = "claude-sonnet-4-5".to_string();
         c.reasoning_effort = Some(ReasoningEffort::Off);
         let r = AnthropicAdapter.render_request(&convo(), &c, false, None);
         assert!(r.body.get("thinking").is_none());
-
         c.reasoning_effort = None;
         let r = AnthropicAdapter.render_request(&convo(), &c, false, None);
         assert!(r.body.get("thinking").is_none());

gateway/tests/conversation_loop.rs

@@ -550,6 +550,48 @@ async fn latency_filler_off_speaks_nothing() {
     );
 }
 
+#[tokio::test]
+#[serial_test::serial]
+async fn latency_filler_does_not_poison_interruptibility() {
+    // REGRESSION (brutal review CRITICAL): the masking filler must NOT leave the
+    // session non-interruptible — a barge-in on the real answer (and on every
+    // later turn) must keep working. The old code armed a session-global
+    // suppression window that was never restored, silently disabling barge-in.
+    unsafe {
+        std::env::set_var("WAAV_ALLOW_LOOPBACK_ENDPOINTS", "1");
+    }
+    register_mock_tts();
+    reset_tts_stats();
+
+    let llm_state = LlmMockState::default();
+    *llm_state.reply.lock() = "Your balance is forty two dollars.".to_string();
+    llm_state.delay_ms.store(400, Ordering::SeqCst);
+    let base_url = start_llm_mock(llm_state.clone()).await;
+
+    let vm = build_voice_manager();
+    vm.start().await.expect("vm start");
+    let _ = wire_audio_egress(&vm).await;
+
+    let cfg = ConversationConfig {
+        latency_filler: LatencyFiller::Auto,
+        latency_filler_after_ms: Some(100),
+        ..conv_config(base_url, false)
+    };
+    let orchestrator =
+        Arc::new(ConversationOrchestrator::new("session-poison", cfg, vm.clone()).expect("orch"));
+    orchestrator.run_turn("what is my balance").await.ok();
+    tokio::time::sleep(Duration::from_millis(50)).await;
+
+    // A filler fired (slow turn past the 100ms threshold).
+    let spoken = TTS_STATS.spoken.lock().clone();
+    assert!(spoken.iter().any(|s| is_filler(s)), "filler should have fired: {spoken:?}");
+    // The session must NOT be stuck non-interruptible after the masked turn.
+    assert!(
+        !vm.is_interruption_blocked().await,
+        "barge-in must remain available after a masking filler (no allow_interruption poisoning)"
+    );
+}
+
 // ──────────────────────────────────────────────────────────────────────────────
 // TEST 3: multi-turn history is preserved (turn 2 includes turn 1).
 // ──────────────────────────────────────────────────────────────────────────────