voice-vibecoder 2.23.0__tar.gz → 2.24.1__tar.gz

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 <!-- version list -->
 
+## v2.24.1 (2026-07-13)
+
+### Bug Fixes
+
+- **ui**: Show untracked files in the file tree sidebar
+  ([`e7a5de7`](https://github.com/snokam/voice-vibecoder/commit/e7a5de72cc8597f1d67df01faf29f42d06edd2bc))
+
+
+## v2.24.0 (2026-07-13)
+
+### Bug Fixes
+
+- **providers**: Use whisper-1 transcription on Azure realtime
+  ([`4e487a9`](https://github.com/snokam/voice-vibecoder/commit/4e487a9d45ad5d7f870d51a7bd72e7f05d4ab2c0))
+
+- **session**: Stop the voice cancelling its own responses
+  ([`4acaa85`](https://github.com/snokam/voice-vibecoder/commit/4acaa85c6c3c38e353904b7e10203f10c9e02734))
+
+- **ui**: Update the running install and surface audio diagnostics
+  ([`d80ca29`](https://github.com/snokam/voice-vibecoder/commit/d80ca29337182d869cb5f3b2d7557879b64ea8e1))
+
+- **worktrees**: Prune stale registrations before reuse
+  ([`31bb71c`](https://github.com/snokam/voice-vibecoder/commit/31bb71c13d53b79594454ad8a4490c496e1d7336))
+
+### Features
+
+- **audio**: Full-duplex voice with macOS echo cancellation
+  ([`303b4b1`](https://github.com/snokam/voice-vibecoder/commit/303b4b161577c49ddc021882b4ada7027b04e4d8))
+
+- **voice**: GA voices (marin/cedar) and shorter spoken answers
+  ([`ffd36ed`](https://github.com/snokam/voice-vibecoder/commit/ffd36ed14ff21ae1ce28957258cfee3ca4e228b2))
+
+
 ## v2.23.0 (2026-06-30)
 
 ### Features

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.23.0
+Version: 2.24.1
 Summary: Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code
 Project-URL: Homepage, https://github.com/snokam/voice-vibecoder
 Project-URL: Repository, https://github.com/snokam/voice-vibecoder
@@ -24,6 +24,7 @@ Requires-Dist: claude-agent-sdk>=0.1.30
 Requires-Dist: cryptography>=42.0
 Requires-Dist: numpy>=1.24
 Requires-Dist: platformdirs>=4.0
+Requires-Dist: pyobjc-framework-avfoundation>=10.0; sys_platform == 'darwin'
 Requires-Dist: rich>=13.0
 Requires-Dist: sounddevice>=0.4
 Requires-Dist: textual>=0.50

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/app.py

@@ -3,7 +3,7 @@
 # requires-python = ">=3.10"
 # dependencies = ["voice-vibecoder"]
 # [tool.uv.sources]
-# voice-vibecoder = { path = "." }
+# voice-vibecoder = { path = ".", editable = true }
 # ///
 """Standalone entry point for Olaf The Vibecoder."""
 

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.23.0"
+version = "2.24.1"
 description = "Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,7 @@ dependencies = [
     "numpy>=1.24",
     "claude-agent-sdk>=0.1.30",
     "platformdirs>=4.0",
+    "pyobjc-framework-avfoundation>=10.0; sys_platform == 'darwin'",
 ]
 
 [project.urls]

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/src/voice_vibecoder/__init__.py

@@ -3,7 +3,7 @@
 A voice-controlled coding assistant using OpenAI Realtime API + Claude Code.
 """
 
-__version__ = "2.23.0"
+__version__ = "2.24.1"
 
 from voice_vibecoder.app_config import VoiceConfig
 from voice_vibecoder.ui.screen import VoiceCodingScreen

voice_vibecoder-2.24.1/src/voice_vibecoder/audio.py

@@ -0,0 +1,232 @@
+"""Terminal audio I/O using sounddevice for mic capture and speaker playback."""
+
+import base64
+import logging
+import queue
+import sys
+import threading
+import time
+from collections import deque
+from typing import Callable
+
+import numpy as np
+import sounddevice as sd
+
+from voice_vibecoder.config import (
+    AUDIO_SAMPLE_RATE,
+    AUDIO_CHANNELS,
+    AUDIO_DTYPE,
+    CHUNK_SIZE,
+)
+
+POST_PLAYBACK_HANGOVER_SEC = 0.4
+RESPONSE_GAP_BRIDGE_SEC = 2.0
+
+BARGE_RMS_FACTOR = 3.0
+BARGE_MIN_RMS = 400.0
+BARGE_ONSET_FRAMES = 2
+BARGE_CALIBRATION_FRAMES = 5
+_PREBUFFER_FRAMES = 3
+
+_CHUNK_BYTES = CHUNK_SIZE * 2
+
+logger = logging.getLogger(__name__)
+
+
+def create_audio_manager(on_audio_chunk: Callable[[str], None]):
+    """Best available audio backend: macOS voice-processing (system echo
+    cancellation, true full duplex) when available, sounddevice otherwise."""
+    if sys.platform == "darwin":
+        try:
+            from voice_vibecoder.audio_macos import VoiceProcessingAudioManager
+
+            return VoiceProcessingAudioManager(on_audio_chunk)
+        except Exception as e:
+            logger.info("VPIO unavailable, using sounddevice: %s", e)
+    return AudioManager(on_audio_chunk)
+
+
+class AudioManager:
+    """Manages mic input and speaker output for the Realtime API.
+
+    Audio format: PCM16, 24 kHz, mono — matches OpenAI Realtime requirements.
+    While assistant audio plays, mic input passes through an echo-aware
+    barge-in gate: speech clearly louder than the measured speaker-echo
+    floor is forwarded (so the user can interrupt), everything else is
+    dropped (so the assistant's own echo can't trip the server VAD).
+    """
+
+    def __init__(self, on_audio_chunk: Callable[[str], None]) -> None:
+        self._on_audio_chunk = on_audio_chunk
+        self._input_stream: sd.InputStream | None = None
+        self._output_stream: sd.OutputStream | None = None
+        self._playback_queue: queue.Queue[bytes] = queue.Queue()
+        self._muted = False
+        self._writing = False
+        self._abort_playback = False
+        self._response_active = False
+        self._last_play_end = 0.0
+        self._running = False
+        self._playback_thread: threading.Thread | None = None
+        self._echo_floor = 0.0
+        self._loud_streak = 0
+        self._gate_open = False
+        self._cal_frames = 0
+        self._prebuffer: deque[bytes] = deque(maxlen=_PREBUFFER_FRAMES)
+
+    @property
+    def muted(self) -> bool:
+        return self._muted
+
+    def start(self) -> None:
+        self._running = True
+        self._start_input()
+        self._start_output()
+
+    def _start_input(self) -> None:
+        self._input_stream = sd.InputStream(
+            samplerate=AUDIO_SAMPLE_RATE,
+            channels=AUDIO_CHANNELS,
+            dtype=AUDIO_DTYPE,
+            blocksize=CHUNK_SIZE,
+            callback=self._mic_callback,
+        )
+        self._input_stream.start()
+
+    def _start_output(self) -> None:
+        self._output_stream = sd.OutputStream(
+            samplerate=AUDIO_SAMPLE_RATE,
+            channels=AUDIO_CHANNELS,
+            dtype=AUDIO_DTYPE,
+            blocksize=CHUNK_SIZE,
+        )
+        self._output_stream.start()
+        self._playback_thread = threading.Thread(
+            target=self._playback_loop, daemon=True
+        )
+        self._playback_thread.start()
+
+    def stop(self) -> None:
+        self._running = False
+        if self._input_stream:
+            self._input_stream.stop()
+            self._input_stream.close()
+            self._input_stream = None
+        if self._output_stream:
+            self._output_stream.stop()
+            self._output_stream.close()
+            self._output_stream = None
+        self._playback_queue.put(b"")
+
+    def set_muted(self, muted: bool) -> None:
+        self._muted = muted
+
+    def set_response_active(self, active: bool) -> None:
+        """Called by the session when a model response starts/finishes."""
+        self._response_active = active
+
+    def play_audio(self, base64_pcm: str) -> None:
+        pcm_data = base64.b64decode(base64_pcm)
+        self._playback_queue.put(pcm_data)
+
+    def clear_playback(self) -> None:
+        """Stop playback and free the mic immediately — the user took the floor."""
+        self._abort_playback = True
+        while not self._playback_queue.empty():
+            try:
+                self._playback_queue.get_nowait()
+            except queue.Empty:
+                break
+        self._last_play_end = 0.0
+        self._reset_barge_state()
+
+    def _mic_suppressed(self) -> bool:
+        if self._writing or not self._playback_queue.empty():
+            return True
+        idle = time.monotonic() - self._last_play_end
+        limit = (
+            RESPONSE_GAP_BRIDGE_SEC
+            if self._response_active
+            else POST_PLAYBACK_HANGOVER_SEC
+        )
+        return idle < limit
+
+    def _barge_gate(self, rms: float) -> bool:
+        """Decide whether mic audio during playback is the user interrupting.
+
+        Tracks the speaker-echo level in _echo_floor; opens only for
+        sustained input well above it. Closed frames feed the floor
+        estimate, so the gate adapts to the current playback volume.
+        """
+        if self._cal_frames < BARGE_CALIBRATION_FRAMES:
+            self._cal_frames += 1
+            self._echo_floor = max(self._echo_floor, rms)
+            return False
+        threshold = max(BARGE_MIN_RMS, BARGE_RMS_FACTOR * self._echo_floor)
+        if self._gate_open:
+            if rms < threshold * 0.5:
+                self._gate_open = False
+                self._loud_streak = 0
+            return self._gate_open
+        if rms >= threshold:
+            self._loud_streak += 1
+            if self._loud_streak >= BARGE_ONSET_FRAMES:
+                self._gate_open = True
+                return True
+        else:
+            self._loud_streak = 0
+            self._echo_floor = (
+                0.8 * self._echo_floor + 0.2 * rms if self._echo_floor else rms
+            )
+        return False
+
+    def _reset_barge_state(self) -> None:
+        self._gate_open = False
+        self._loud_streak = 0
+        self._echo_floor = 0.0
+        self._cal_frames = 0
+        self._prebuffer.clear()
+
+    def _mic_callback(self, indata: np.ndarray, frames: int, time_info, status) -> None:
+        if self._muted or not self._running:
+            return
+        pcm_bytes = indata.tobytes()
+        if self._mic_suppressed():
+            rms = float(np.sqrt(np.mean(indata.astype(np.float64) ** 2)))
+            if not self._barge_gate(rms):
+                self._prebuffer.append(pcm_bytes)
+                return
+            while self._prebuffer:
+                buffered = self._prebuffer.popleft()
+                self._on_audio_chunk(base64.b64encode(buffered).decode("ascii"))
+        else:
+            self._reset_barge_state()
+        encoded = base64.b64encode(pcm_bytes).decode("ascii")
+        self._on_audio_chunk(encoded)
+
+    def _playback_loop(self) -> None:
+        while self._running:
+            try:
+                pcm_data = self._playback_queue.get(timeout=0.5)
+            except queue.Empty:
+                continue
+            if not pcm_data or not self._running:
+                break
+            self._abort_playback = False
+            self._writing = True
+            try:
+                for i in range(0, len(pcm_data), _CHUNK_BYTES):
+                    if self._abort_playback or not self._running:
+                        break
+                    chunk = np.frombuffer(
+                        pcm_data[i : i + _CHUNK_BYTES], dtype=np.int16
+                    ).reshape(-1, 1)
+                    if self._output_stream:
+                        self._output_stream.write(chunk)
+            except Exception:
+                pass
+            finally:
+                self._writing = False
+                if not self._abort_playback:
+                    self._last_play_end = time.monotonic()
+        self._writing = False

voice_vibecoder-2.24.1/src/voice_vibecoder/audio_macos.py

@@ -0,0 +1,93 @@
+"""macOS echo-cancelled capture via AVAudioEngine Voice Processing I/O.
+
+macOS's system echo canceller (the one FaceTime uses) removes the app's own
+speaker output from the mic signal at the device level — verified to work
+even when playback goes through sounddevice. With echo gone, the mic stays
+open the whole time: the user can interrupt the assistant mid-sentence and
+the server VAD handles it, with no half-duplex suppression or gating.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+from typing import Callable
+
+import numpy as np
+
+from voice_vibecoder.audio import AudioManager
+from voice_vibecoder.config import AUDIO_SAMPLE_RATE
+
+logger = logging.getLogger(__name__)
+
+
+class VoiceProcessingAudioManager(AudioManager):
+    """AudioManager with full-duplex, echo-cancelled mic capture.
+
+    Playback is inherited from AudioManager (sounddevice). Capture comes
+    from an AVAudioEngine input node with voice processing enabled;
+    start() raises if the engine can't start, letting the caller fall
+    back to the plain half-duplex AudioManager.
+    """
+
+    def __init__(self, on_audio_chunk: Callable[[str], None]) -> None:
+        super().__init__(on_audio_chunk)
+        self._engine = None
+        self._in_rate = AUDIO_SAMPLE_RATE
+
+    def _start_input(self) -> None:
+        from AVFoundation import AVAudioEngine
+
+        engine = AVAudioEngine.alloc().init()
+        input_node = engine.inputNode()
+        ok, err = input_node.setVoiceProcessingEnabled_error_(True, None)
+        if not ok:
+            raise RuntimeError(f"voice processing unavailable: {err}")
+
+        in_fmt = input_node.outputFormatForBus_(0)
+        self._in_rate = int(in_fmt.sampleRate()) or AUDIO_SAMPLE_RATE
+
+        def tap(buf, when) -> None:
+            self._handle_tap(buf)
+
+        input_node.installTapOnBus_bufferSize_format_block_(
+            0, max(256, self._in_rate // 10), None, tap
+        )
+        engine.prepare()
+        ok, err = engine.startAndReturnError_(None)
+        if not ok:
+            raise RuntimeError(f"AVAudioEngine start failed: {err}")
+        self._engine = engine
+        logger.info("VPIO capture started (%d Hz)", self._in_rate)
+
+    def _handle_tap(self, buf) -> None:
+        if not self._running or self._muted:
+            return
+        try:
+            frames = int(buf.frameLength())
+            if not frames:
+                return
+            channel = buf.floatChannelData()[0]
+            data = np.frombuffer(channel.as_buffer(frames), dtype=np.float32)
+            if self._in_rate != AUDIO_SAMPLE_RATE:
+                out_len = int(frames * AUDIO_SAMPLE_RATE / self._in_rate)
+                data = np.interp(
+                    np.linspace(0.0, frames - 1, out_len),
+                    np.arange(frames),
+                    data,
+                )
+            pcm16 = np.clip(data * 32768.0, -32768, 32767).astype(np.int16)
+            self._on_audio_chunk(base64.b64encode(pcm16.tobytes()).decode("ascii"))
+        except Exception as e:
+            logger.warning("VPIO tap error: %s", e)
+
+    def stop(self) -> None:
+        engine = self._engine
+        self._engine = None
+        if engine:
+            try:
+                engine.inputNode().removeTapOnBus_(0)
+                engine.stop()
+            except Exception:
+                pass
+        super().stop()

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/src/voice_vibecoder/config.py

@@ -31,7 +31,8 @@ def _agent_names(enabled: list[str] | None = None) -> str:
 _SYSTEM_INSTRUCTIONS: dict[Language, str] = {
     "no": """\
 Du er Olaf, en hjelpsom stemmeassistent for utviklere. Snakk alltid norsk. \
-Brukeren skal oppleve en helt vanlig samtale — du bare hjelper.
+Brukeren skal oppleve en helt vanlig samtale — du bare hjelper. \
+Dette er en talesamtale: svar kort, én til to setninger, med mindre brukeren ber om mer.
 
 Svar direkte på:
 - Hilsener, småprat, korte spørsmål
@@ -84,7 +85,8 @@ Spørsmål fra agenten:
 - Still spørsmålet til brukeren. Videresend svaret ordrett via answer_agent_question.""",
     "en": """\
 You are Olaf, a helpful voice assistant for developers. Always speak English. \
-The user should experience a normal conversation — you just help.
+The user should experience a normal conversation — you just help. \
+This is a spoken conversation: keep answers short, one or two sentences, unless the user asks for more.
 
 Answer directly:
 - Greetings, small talk, short questions
@@ -137,7 +139,8 @@ Questions from the agent:
 - Ask the user the question. Forward their answer verbatim via answer_agent_question.""",
     "sv": """\
 Du är Olaf, en hjälpsam röstassistent för utvecklare. Tala alltid svenska. \
-Användaren ska uppleva ett helt vanligt samtal — du bara hjälper.
+Användaren ska uppleva ett helt vanligt samtal — du bara hjälper. \
+Detta är ett röstsamtal: svara kort, en till två meningar, om inte användaren ber om mer.
 
 Svara direkt på:
 - Hälsningar, småprat, korta frågor
@@ -223,6 +226,7 @@ def get_system_instructions(
 Provider = Literal["openai", "azure", "gemini"]
 
 VOICES = ["ash", "ballad", "coral", "sage", "shimmer", "alloy", "echo", "verse"]
+GA_VOICES = ["marin", "cedar"]
 
 OPENAI_WS_URL = "wss://api.openai.com/v1/realtime"
 OPENAI_DEFAULT_MODEL = "gpt-4o-realtime-preview"
@@ -272,7 +276,7 @@ class AzureConfig:
     api_key: str = ""
     endpoint: str = AZURE_DEFAULT_ENDPOINT
     deployment: str = AZURE_DEFAULT_DEPLOYMENT
-    voice: str = "ash"
+    voice: str = "marin"
     vad_threshold: float = 0.8
     silence_duration_ms: int = 700
     prefix_padding_ms: int = 300

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/src/voice_vibecoder/session.py

@@ -134,6 +134,7 @@ class RealtimeSession:
         on_instance_status: Callable[[str, InstanceStatus], None] | None = None,
         on_interrupt: Callable[[], None] | None = None,
         on_ui_command: Callable[[str, str, Any], None] | None = None,
+        on_response_active: Callable[[bool], None] | None = None,
     ) -> None:
         self._provider = provider
         self._settings = settings
@@ -148,6 +149,7 @@ class RealtimeSession:
         self._on_instance_status = on_instance_status
         self._on_interrupt = on_interrupt
         self._on_ui_command = on_ui_command
+        self._on_response_active = on_response_active
         self._running = False
         self._assistant_transcript = ""
         self.text_only = False
@@ -155,6 +157,9 @@ class RealtimeSession:
         self._fallback_task: asyncio.Task | None = None
         self._loop: asyncio.AbstractEventLoop | None = None
         self._last_tool_narration: float = 0.0
+        self._response_active = False
+        self._user_speaking = False
+        self._pending_injections: list[str] = []
 
         # Create instance registry and wire callbacks
         self._registry = InstanceRegistry(user_email=user_email, user_jwt=user_jwt)
@@ -281,6 +286,11 @@ class RealtimeSession:
         # Store in registry for state persistence
         self._registry.add_transcript("user", text)
 
+        if self._response_active:
+            await self._provider.cancel_response()
+            if self._on_interrupt:
+                self._on_interrupt()
+
         # Send to voice provider to generate response
         await self._provider.inject_message(text)
 
@@ -325,28 +335,35 @@ class RealtimeSession:
                         self._on_transcript("user", t)
 
             case SpeechStarted():
-                await self._provider.cancel_response()
+                self._user_speaking = True
+                if self._response_active:
+                    await self._provider.cancel_response()
                 if self._on_interrupt:
                     self._on_interrupt()
                 if self._on_status:
                     self._on_status("listening")
 
             case SpeechStopped():
+                self._user_speaking = False
                 if self._on_status:
                     self._on_status("processing")
 
             case AudioCommitted():
+                self._user_speaking = False
                 self._response_pending = True
                 self._start_fallback()
 
             case ResponseCreated():
                 self._response_pending = False
                 self._cancel_fallback()
+                self._set_response_active(True)
 
             case FunctionCall(call_id=cid, name=n, arguments=a):
                 await self._handle_function_call(cid, n, a)
 
             case ResponseDone():
+                self._set_response_active(False)
+                await self._flush_pending_injections()
                 if self._on_status:
                     self._on_status("ready")
 
@@ -356,7 +373,40 @@ class RealtimeSession:
                     if self._on_status:
                         self._on_status(f"error: {m}")
 
+    def _set_response_active(self, active: bool) -> None:
+        self._response_active = active
+        if self._on_response_active:
+            try:
+                self._on_response_active(active)
+            except Exception:
+                pass
+
+    @property
+    def _conversation_busy(self) -> bool:
+        """True while the assistant is responding or the user is speaking."""
+        return self._response_active or self._user_speaking
+
+    async def _inject_or_queue(self, text: str) -> None:
+        """Deliver a background message once the floor is free (see
+        _flush_pending_injections); injecting mid-response or while the
+        user speaks made the assistant talk over the conversation."""
+        if self._conversation_busy:
+            self._pending_injections.append(text)
+            return
+        await self._provider.inject_message(text)
+
+    async def _flush_pending_injections(self) -> None:
+        if self._user_speaking or not self._pending_injections:
+            return
+        text = self._pending_injections.pop(0)
+        try:
+            await self._provider.inject_message(text)
+        except Exception as e:
+            logger.error("Failed to flush pending injection: %s", e)
+
     async def _attempt_reconnect(self) -> None:
+        self._set_response_active(False)
+        self._user_speaking = False
         for attempt in range(RECONNECT_MAX_ATTEMPTS):
             delay = RECONNECT_DELAYS[min(attempt, len(RECONNECT_DELAYS) - 1)]
             if self._on_status:
@@ -379,6 +429,8 @@ class RealtimeSession:
 
     async def disconnect(self) -> None:
         self._running = False
+        self._set_response_active(False)
+        self._user_speaking = False
         await self._provider.disconnect()
         if self._on_status:
             self._on_status("disconnected")
@@ -403,6 +455,8 @@ class RealtimeSession:
             return
         if not isinstance(line, str):
             return
+        if self._conversation_busy:
+            return
         hint = _friendly_tool_hint(line)
         if not hint:
             return
@@ -478,7 +532,7 @@ class RealtimeSession:
         agent_label = get_agent(agent_type).label
         system_text = f"{agent_label} finished on '{display_key}':\n\n{result}"
         try:
-            await self._provider.inject_message(system_text)
+            await self._inject_or_queue(system_text)
         except Exception as e:
             logger.error("Failed to inject agent result: %s", e)
         if self._on_status:
@@ -526,7 +580,7 @@ class RealtimeSession:
             system_text = f"{label} on '{display_key}' is asking:\n\n{formatted}"
 
         try:
-            await self._provider.inject_message(system_text)
+            await self._inject_or_queue(system_text)
         except Exception as e:
             logger.error("Failed to inject agent question: %s", e)
 

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/src/voice_vibecoder/tools/file_tree.py

@@ -163,6 +163,11 @@ def get_file_tree(worktree_path: str) -> dict:
                 if f:
                     all_paths[f] = changed.get(f, "unchanged")
 
+        # Untracked/new files aren't in ls-files but must show in the tree
+        for path, status in changed.items():
+            if path not in all_paths and status != "deleted":
+                all_paths[path] = status
+
         # Build tree structure
         tree = {
             "name": root,

{voice_vibecoder-2.23.0 → voice_vibecoder-2.24.1}/src/voice_vibecoder/ui/callbacks.py

@@ -15,8 +15,15 @@ from voice_vibecoder.ui.styles import _CATEGORY_STYLES, _format_output_line
 class CallbackMixin:
     """Mixin providing callback methods for VoiceCodingScreen."""
 
+    _mic_confirmed = False
+
     def _send_audio_chunk(self, base64_data: str) -> None:
         if self._loop and self._session and self._session.connected:
+            if not self._mic_confirmed:
+                self._mic_confirmed = True
+                self.app.call_from_thread(
+                    self._log, "[dim]mic live — audio streaming[/dim]"
+                )
             asyncio.run_coroutine_threadsafe(
                 self._session.send_audio(base64_data), self._loop
             )
@@ -39,6 +46,10 @@ class CallbackMixin:
         if self._audio:
             self._audio.clear_playback()
 
+    def _on_response_active(self, active: bool) -> None:
+        if self._audio:
+            self._audio.set_response_active(active)
+
     _prev_category: dict[str, str | None] = {}
 
     def _on_agent_output(self, instance_id: str, line: str) -> None:
@@ -133,6 +144,8 @@ class CallbackMixin:
             self._update_file_tree(instance_id, data)
 
     def _on_status(self, status: str) -> None:
+        if status.startswith("error:"):
+            self.app.call_from_thread(self._log, f"[red]{status}[/red]")
         self.app.call_from_thread(self._update_status_bar, status)
 
     def _on_tool_call(self, name: str, arguments: dict) -> None: