voice-mcp-server 0.1.24 → 0.2.0

package/src/daemon/audio_server.py

@@ -4,7 +4,6 @@ import os
 import time
 import threading
 import queue
-import logging
 from contextlib import asynccontextmanager
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import StreamingResponse
@@ -20,6 +19,7 @@ os.environ["TORCH_HOME"] = os.path.join(app_support_dir, "torch")
 # Add src to python path for imports
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
+from logger import logger
 from simulation.models import Config
 from simulation.engine import CoreEngine, State
 from adapters_real.queue_llm import QueueLLMBridge
@@ -75,7 +75,7 @@ def pre_download_models():
         daemon_status_message = "Finalizing AI setup..."
         daemon_progress = 90
     except Exception as e:
-        print(f"Model download error: {e}", file=sys.stderr)
+        logger.error(f"Model download error: {e}")
         daemon_status_message = f"Error downloading models: {e}"
 
 def run_audio_daemon():
@@ -92,7 +92,7 @@ def run_audio_daemon():
     
     with initialize(version_base=None, config_path="../../config"):
         cfg = compose(config_name="config")
-        print("Loaded Hydra configuration successfully.")
+        logger.info("Loaded Hydra configuration successfully.")
 
     mic = instantiate(cfg.microphone)
     speaker = instantiate(cfg.speaker)
@@ -114,7 +114,7 @@ def run_audio_daemon():
     daemon_status = "READY"
     daemon_status_message = "Audio Engine is online."
     daemon_progress = 100
-    print("Audio Daemon Started. Waiting for commands.", file=sys.stderr)
+    logger.info("Audio Daemon Started. Waiting for commands.")
     
     try:
         while True:
@@ -125,7 +125,9 @@ def run_audio_daemon():
                     
                     # We got a command, wake up the hardware!
                     mic.start_stream()
-                    engine.start_conversation(cmd.get("text", ""))
+                    if hasattr(vad, "set_active"):
+                        vad.set_active(True)
+                    engine.start_conversation(cmd.get("text", ""), standby_mode=cmd.get("standby_mode", False))
                     engine.expect_reply = cmd.get("expect_reply", True)
                     
                 except queue.Empty:
@@ -135,10 +137,12 @@ def run_audio_daemon():
                 # Once we drop back to EXECUTING, we finished the conversation loop
                 if engine.state == State.EXECUTING:
                     mic.stop_stream()
+                    if hasattr(vad, "set_active"):
+                        vad.set_active(False)
                     last_active_timestamp = time.time()
                     
     except Exception as e:
-        print(f"Daemon exception: {e}", file=sys.stderr)
+        logger.error(f"Daemon exception: {e}")
     finally:
         if mic:
             mic.close()
@@ -150,17 +154,19 @@ async def watchdog():
         await asyncio.sleep(60)
         idle_time = time.time() - last_active_timestamp
         if idle_time > IDLE_TIMEOUT_SECONDS:
-            print(f"Idle timeout reached ({idle_time:.0f}s). Self-destructing to free RAM.", file=sys.stderr)
+            logger.info(f"Idle timeout reached ({idle_time:.0f}s). Self-destructing to free RAM.")
             if mic:
                 mic.close()
             os._exit(0)
 
 def parent_pid_polling():
     """Polls the parent PID. If the parent dies, the daemon instantly self-destructs."""
+    original_ppid = os.getppid()
     while True:
         time.sleep(3.0)
-        if os.getppid() == 1:
-            print("Parent process died. Stopping daemon to prevent Zombie microphone lock.", file=sys.stderr)
+        current_ppid = os.getppid()
+        if current_ppid == 1 or current_ppid != original_ppid:
+            logger.warning("Parent process died. Stopping daemon to prevent Zombie microphone lock.")
             os._exit(0)
 
 @asynccontextmanager
@@ -172,10 +178,6 @@ async def lifespan(app: FastAPI):
     # Start the watchdog
     asyncio.create_task(watchdog())
     
-    # Start the Parent PID Poller
-    polling_thread = threading.Thread(target=parent_pid_polling, daemon=True)
-    polling_thread.start()
-    
     yield
     # Shutdown logic
     if mic:
@@ -289,6 +291,36 @@ async def reload_config():
             daemon_status_message = f"Failed to reload: {str(e)}"
             return {"status": "error", "message": daemon_status_message}
 
+@app.post("/abort")
+async def abort_conversation():
+    global engine, mic, speaker, vad, active_session_id
+    logger.info("Received /abort command from client. Stopping audio.")
+    with mutex_lock:
+        if speaker:
+            speaker.flush()
+        if engine:
+            engine.state = State.EXECUTING
+            engine.buffer = []
+            if hasattr(engine.vad, "set_active"):
+                engine.vad.set_active(False)
+        if mic:
+            mic.stop_stream()
+            
+        while not mcp_command_queue.empty():
+            try: mcp_command_queue.get_nowait()
+            except queue.Empty: break
+            
+        mcp_result_queue.put({
+            "status": "ok", 
+            "user_transcript": "", 
+            "was_interrupted": True,
+            "message": "User manually aborted the voice loop using the panic button. You MUST NOT try to speak to the user right now. Wait for them to initiate the next interaction."
+        })
+        
+        active_session_id = None
+        
+    return {"status": "ok"}
+
 @app.post("/converse")
 async def converse(request: Request):
     global active_session_id, last_active_timestamp
@@ -304,6 +336,7 @@ async def converse(request: Request):
     session_id = body.get("session_id")
     text_to_speak = body.get("text_to_speak", "")
     expect_reply = body.get("expect_reply", True)
+    standby_mode = body.get("standby_mode", False)
     
     with mutex_lock:
         if active_session_id is not None and active_session_id != session_id:
@@ -317,17 +350,19 @@ async def converse(request: Request):
 
     try:
         # Feed command to daemon
-        mcp_command_queue.put({"text": text_to_speak, "expect_reply": expect_reply})
+        mcp_command_queue.put({"text": text_to_speak, "expect_reply": expect_reply, "standby_mode": standby_mode})
         
         # Wait for human to interact or natural termination, checking for client disconnects
         while True:
             if await request.is_disconnected():
-                print(f"[{session_id}] Client disconnected! Aborting audio loop.", file=sys.stderr)
+                logger.warning(f"[{session_id}] Client disconnected! Aborting audio loop.")
                 # Client hung up (e.g. reload or ctrl+c). We must reset the engine immediately.
                 if speaker:
                     speaker.flush()
                 if engine:
                     engine.state = State.EXECUTING # This will trigger mic.stop_stream() in the loop
+                    if hasattr(vad, "set_active"):
+                        vad.set_active(False)
                 raise HTTPException(status_code=499, detail="Client Disconnected")
             
             try:
@@ -336,6 +371,8 @@ async def converse(request: Request):
                 last_active_timestamp = time.time()
                 return result
             except queue.Empty:
+                if standby_mode:
+                    last_active_timestamp = time.time()
                 await asyncio.sleep(0.01)
 
     finally:

package/src/logger.py

@@ -0,0 +1,29 @@
+import logging
+import sys
+import os
+
+def setup_logger(name="VoiceMCP", level=logging.INFO):
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        logger.setLevel(level)
+        # Use a professional telemetry format
+        formatter = logging.Formatter(
+            fmt='%(asctime)s.%(msecs)03d | %(levelname)-7s | %(module)-15s | %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        
+        # Output to stderr to avoid breaking stdio (MCP communication)
+        handler = logging.StreamHandler(sys.stderr)
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        
+        # File logger for persistent telemetry
+        log_dir = os.path.expanduser("~/Library/Application Support/VoiceMCP/logs")
+        os.makedirs(log_dir, exist_ok=True)
+        file_handler = logging.FileHandler(os.path.join(log_dir, "telemetry.log"))
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+        
+    return logger
+
+logger = setup_logger()

package/src/mcp_server.py

@@ -17,20 +17,64 @@ import json
 import socket
 import http.client
 import time
-import logging
 import asyncio
 import random
 
 from mcp.server.fastmcp import FastMCP, Context
+from logger import logger
 
-logging.basicConfig(level=logging.INFO, stream=sys.stderr)
-
-# Inject the busy-signal instructions into the server instructions
+# Inject the advanced conversational instructions into the server
 instructions = """
 <voice_loop_instructions>
-If the voice_converse tool returns "status": "system_busy", it means the physical microphone is currently locked by another AI agent in a different window. 
-DO NOT retry the tool. Output a standard text message explaining the audio channel is busy, and continue the conversation via text.
-CRITICAL RULE: If you use the voice_converse tool and it returns "status": "silence_timeout", you MUST NOT abandon the voice loop by simply typing a text response. You MUST formally close the hardware loop by calling voice_converse ONE LAST TIME with "expect_reply": false and "text_to_speak": "I didn't hear anything, so I am turning off the microphone now."
+# VOICE-NATIVE PAIR PROGRAMMING PROTOCOL
+You are a senior pair-programming partner collaborating with the user via a bidirectional, real-time voice interface. You are NOT a traditional text-based chatbot; you are an autonomous peer sitting next to the user.
+
+## Core Hardware Constraints & Your Senses
+1. **Push-To-Talk (PTT):** The user communicates with you by pressing and holding the `Right Option (⌥)` key. 
+2. **Deaf by Default:** You execute tools strictly sequentially. When you run non-voice tools (reading files, searching, editing), your microphone is physically OFF. The user cannot interrupt you during these times.
+3. **Hardware Watchdog:** To save the user's Unified Memory, your backend audio daemon will self-destruct and sleep if you are completely silent for 15 minutes.
+4. **The Panic Button (Double-Tap):** Due to a known bug in the Gemini CLI, clicking "Stop" in the UI will NOT tell the audio daemon to stop talking or listening. To forcefully stop your voice or close the microphone, the user must DOUBLE-TAP the `Right Option` key.
+
+To prevent the user from feeling abandoned, confused, or locked out, you must orchestrate the conversation using the following rules:
+
+## 1. First Contact (Onboarding)
+Since voice interfaces lack visual menus, the user might not know the physical controls. On your VERY FIRST conversational turn in a new session, you MUST seamlessly weave a brief explanation of the controls into your greeting.
+*Example:* "Hey, I'm ready to dive in. Just a quick heads up—whenever you want to talk, just press and hold the Right Option key. To force me to stop talking or listening, just double-tap it quickly. If you ever need time to think, just ask me to pause. What are we working on today?"
+CRITICAL: Do not repeat this instruction after the first interaction.
+
+## 2. Floor Management (`expect_reply` Heuristics)
+Think of the microphone as a shared conversational token.
+
+**Keep the Token (`expect_reply: false`):**
+Use this for micro-updates, acknowledgments, and transitions. You speak, the mic stays OFF, and you immediately execute your next tool.
+- *Acknowledgment:* "Got it, looking into the routing file."
+- *The "Head Down" Warning (CRITICAL):* If you are about to do a heavy search or multi-file edit, warn the user they cannot interrupt you. "I'm going to run a deep codebase search. I'll be deaf for a minute, so the Right Option key won't work until I'm done."
+
+**Yield the Token (`expect_reply: true`):**
+Use this ONLY when you genuinely need the user to speak. This MUST be the final tool call in your current execution sequence.
+- *Clarification:* "I hit a compilation error on the auth module. Do you want me to rewrite the types or mock it out?"
+
+## 3. Handling Hardware Interruptions (`was_interrupted: true`)
+If `voice_converse` returns `was_interrupted: true`, it means the user held the Right Option key and cut you off mid-sentence. Instantly drop your previous train of thought. Do not try to finish your sentence. Acknowledge the interruption naturally and pivot immediately to their new input. (e.g., "Ah, good catch, switching to the backend folder now.")
+
+## 4. Handling User Think Time & The 15-Minute Watchdog
+If the user says "give me a minute", "let me think", or similar:
+1. Acknowledge them quickly using `voice_converse(..., expect_reply=False)`.
+2. Gently warn them about the 15-minute hardware watchdog.
+3. Remind them to hold the `Right Option` key when they are ready to return.
+4. IMMEDIATELY call the `wait_for_user()` tool.
+*Example:* "Take your time. Just hold the Right Option key to wake me up when you're ready. As a heads up, my audio engine spins down after 15 minutes to save your Mac's memory, but I'll be right here."
+
+## 5. Handling Silences / Timeouts
+If you ask a question (`expect_reply: true`) but the user doesn't press the Right Option key, the tool will return `{"status": "silence_timeout"}`. 
+CRITICAL: Do not treat this as an error. Act like a human colleague voluntarily giving them space. Gracefully close the microphone by calling `voice_converse` one last time with `expect_reply: false`.
+- *Example:* "Looks like you're focused. I'll pause my mic and stand by. Just hold the Right Option key when you want to pick it up."
+
+## 6. General Rules of Engagement
+- **Be Conversational & Terse:** Never use AI-isms ("As an AI..."). Speak like a human engineer.
+- **Never Dump Code:** Never read raw code blocks out loud. Summarize conceptually.
+- **Interleave Work:** Do not chain multiple silent tools together without muttering an update (`expect_reply: false`).
+- **Handling System Busy:** If you get `"status": "system_busy"`, output a standard text message explaining the audio channel is locked, and continue via text.
 </voice_loop_instructions>
 """
 
@@ -81,10 +125,10 @@ def ensure_daemon_running():
     if check_daemon_health():
         return
 
-    logging.info("Daemon is down, attempting to boot detached process...")
+    logger.info("Daemon is down, attempting to boot detached process...")
     # Boot the daemon detached
     project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-    python_exec = os.path.join(app_support_dir, "venv", "bin", "python3")
+    python_exec = sys.executable
     daemon_script = os.path.join(project_root, "src", "daemon", "audio_server.py")
     
     subprocess.Popen(
@@ -159,20 +203,35 @@ async def render_visualizer(ctx: Context):
     except asyncio.CancelledError:
         pass
 
+import threading
+
+def fire_abort():
+    logger.info("Firing synchronous abort request to daemon...")
+    try:
+        make_uds_request("POST", "/abort", None, 5.0)
+        logger.info("Abort request sent successfully.")
+    except Exception as e:
+        logger.error(f"Failed to send abort request: {e}")
+
+async def make_cancellable_converse_request(payload: dict, timeout: float) -> tuple[int, dict]:
+    try:
+        return await asyncio.to_thread(make_uds_request, "POST", "/converse", payload, timeout)
+    except asyncio.CancelledError:
+        # If the MCP client cancels this tool call, immediately tell the daemon to abort audio
+        logger.warning("Tool call was cancelled by MCP client! Triggering abort.")
+        threading.Thread(target=fire_abort, daemon=True).start()
+        raise
+
 @mcp.tool()
 async def voice_converse(text_to_speak: str, expect_reply: bool = True, ctx: Context = None) -> dict:
     """
-    Speak a prompt to the user and listen for a response.
-    If expect_reply is False, the tool returns immediately after queuing the speech.
+    Speak a prompt to the user and listen for a response. If expect_reply is False, the tool queues the speech and returns immediately. If expect_reply is True, it yields the floor to the user. If the returned JSON contains `was_interrupted: true`, the user used the Right Option key to cut you off mid-speech; you MUST completely abandon your previous thought and address their new input.
     """
     try:
         ensure_daemon_running()
 
         async def _do_converse():
-            return await asyncio.to_thread(
-                make_uds_request,
-                "POST", 
-                "/converse", 
+            return await make_cancellable_converse_request(
                 {"session_id": SESSION_ID, "text_to_speak": text_to_speak, "expect_reply": expect_reply},
                 300.0
             )
@@ -204,6 +263,7 @@ async def voice_converse(text_to_speak: str, expect_reply: bool = True, ctx: Con
                             await ctx.report_progress(d_progress, 100, message=d_msg)
                         
                         if d_status == "READY":
+                            logger.info("Model initialized to RAM")
                             if ctx:
                                 await ctx.info("Voice MCP: Setup Complete!")
                                 
@@ -244,6 +304,74 @@ async def voice_converse(text_to_speak: str, expect_reply: bool = True, ctx: Con
             "message": f"CRITICAL Error starting audio daemon: {str(e)}"
         }
 
+@mcp.tool()
+async def wait_for_user(ctx: Context = None) -> dict:
+    """
+    Call this tool IMMEDIATELY after using voice_converse(expect_reply=False) to acknowledge a user's explicit request for time to think. It suspends the AI indefinitely until the user presses the Right Option key to wake you back up. Note: The underlying audio daemon will self-destruct after 15 minutes of idle time to free Unified Memory, so you must warn the user of this limit before calling.
+    """
+    try:
+        ensure_daemon_running()
+        if ctx:
+            await ctx.info("🎙️ Waiting for user to speak... 🎙️")
+            
+        status, response_data = await make_cancellable_converse_request(
+            {"session_id": SESSION_ID, "text_to_speak": "", "expect_reply": True, "standby_mode": True},
+            3600.0
+        )
+        return response_data
+        
+    except Exception as e:
+        # The daemon likely died from the 15-minute watchdog to save RAM.
+        # Implement the "Ghost Wake-Up": silently listen for Right Option, then boot the daemon.
+        if ctx:
+            await ctx.info("💤 Audio Engine sleeping to save RAM. Press Right Option to wake... 💤")
+        
+        import pynput
+        loop = asyncio.get_running_loop()
+        wake_event = asyncio.Event()
+
+        def on_press(key):
+            if key in (pynput.keyboard.Key.alt_r, pynput.keyboard.Key.ctrl_r):
+                loop.call_soon_threadsafe(wake_event.set)
+                
+        listener = pynput.keyboard.Listener(on_press=on_press)
+        listener.start()
+        
+        await wake_event.wait()
+        listener.stop()
+        
+        if ctx:
+            await ctx.info("🚀 Waking up Audio Engine... This might take a few seconds... 🚀")
+            
+        try:
+            ensure_daemon_running()
+            status, response_data = await make_cancellable_converse_request(
+                {"session_id": SESSION_ID, "text_to_speak": "", "expect_reply": True, "standby_mode": True},
+                3600.0
+            )
+            return response_data
+        except Exception as retry_e:
+            return {
+                "status": "error", 
+                "user_transcript": "", 
+                "message": f"CRITICAL Error waking up audio daemon: {str(retry_e)}"
+            }
+
+import signal
+
+def cleanup_on_exit(signum, frame):
+    logger.warning(f"Received termination signal {signum}. Firing abort request to daemon...")
+    try:
+        # Use a short timeout to prevent hanging the shutdown process
+        make_uds_request("POST", "/abort", None, 1.0)
+        logger.info("Abort request sent successfully during shutdown.")
+    except Exception as e:
+        logger.error(f"Failed to send abort request during shutdown: {e}")
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, cleanup_on_exit)
+signal.signal(signal.SIGTERM, cleanup_on_exit)
+
 if __name__ == "__main__":
     # 4. Restore the OS-level stdout just before handing control to the MCP SDK
     os.dup2(original_stdout_fd, 1)

package/src/simulation/engine.py

@@ -2,6 +2,7 @@ from enum import Enum
 from typing import List
 from .models import Config, VirtualAudioFrame
 from .ports import IMicrophone, ISpeaker, IVAD, ISTT, ILLMBridge
+from logger import logger
 
 class State(Enum):
     IDLE = 1
@@ -9,6 +10,7 @@ class State(Enum):
     LISTENING = 3
     PROCESSING = 4
     EXECUTING = 5
+    STANDBY = 6
 
 class CoreEngine:
     def __init__(self, config: Config, mic: IMicrophone, speaker: ISpeaker, vad: IVAD, stt: ISTT, llm: ILLMBridge):
@@ -30,17 +32,28 @@ class CoreEngine:
         self.latest_transcription = ""
         self.last_tool_call_result = None
         self.expect_reply = True
+        self.standby_mode = False
         
         self.total_recording_ms = 0
         self.total_listening_ms = 0
         self.has_started_speaking = False
         self.processing_wait_ms = 0
 
-    def start_conversation(self, initial_text: str):
+    def start_conversation(self, initial_text: str, standby_mode: bool = False):
         self.expect_reply = True
+        self.standby_mode = standby_mode
         if initial_text:
             self.state = State.AI_SPEAKING
             self.speaker.speak(initial_text)
+        elif self.standby_mode:
+            # We are entering standby mode to wait for the user indefinitely.
+            # If the VAD is PTT, we can safely close the mic stream to turn off the orange dot.
+            if hasattr(self.vad, "is_pressed"):
+                if hasattr(self.mic, "stop_stream"):
+                    logger.debug("Microphone stream stopped")
+                    self.mic.stop_stream()
+            self.state = State.STANDBY
+            self._reset_listening_state()
         else:
             self.state = State.LISTENING
             self._reset_listening_state()
@@ -111,23 +124,32 @@ class CoreEngine:
                     else:
                         spoken_text = self.speaker.flush()
                         self.was_interrupted = True
+                        logger.info("Barge-in detected! User interrupted the AI.")
                         self.state = State.LISTENING
                         self.current_silence_duration_ms = 0
                         self.total_recording_ms = self.current_speech_duration_ms
                         self.has_started_speaking = True
                         self.total_listening_ms = 0
                 elif not self.speaker.is_speaking():
-                    self.state = State.LISTENING if self.expect_reply else State.EXECUTING
-                    if self.state == State.LISTENING:
-                        self.was_interrupted = False
-                        self.current_silence_duration_ms = 0
-                        self.total_recording_ms = self.current_speech_duration_ms
-                        self.has_started_speaking = True
-                        self.total_listening_ms = 0
-                    elif self.state == State.EXECUTING:
-                        if hasattr(self.mic, 'stop_stream'):
+                    if self.standby_mode:
+                        self.state = State.STANDBY
+                        if hasattr(self.vad, "is_pressed") and hasattr(self.mic, "stop_stream"):
+                            logger.debug("Microphone stream stopped")
                             self.mic.stop_stream()
-                        self.llm.start_request({"status": "notification_delivered"})
+                        self._reset_listening_state()
+                    else:
+                        self.state = State.LISTENING if self.expect_reply else State.EXECUTING
+                        if self.state == State.LISTENING:
+                            self.was_interrupted = False
+                            self.current_silence_duration_ms = 0
+                            self.total_recording_ms = self.current_speech_duration_ms
+                            self.has_started_speaking = True
+                            self.total_listening_ms = 0
+                        elif self.state == State.EXECUTING:
+                            if hasattr(self.mic, 'stop_stream'):
+                                logger.debug("Microphone stream stopped")
+                                self.mic.stop_stream()
+                            self.llm.start_request({"status": "notification_delivered"})
             else:
                 self.current_grace_ms += self.tick_ms
                 if self.current_grace_ms > self.config.vad_silence_grace_ms:
@@ -138,14 +160,22 @@ class CoreEngine:
                     self.current_grace_ms = 0
                     
                 if not self.speaker.is_speaking():
-                    self.state = State.LISTENING if self.expect_reply else State.EXECUTING
-                    if self.state == State.LISTENING:
-                        self._reset_listening_state()
-                        self.was_interrupted = False
-                    elif self.state == State.EXECUTING:
-                        if hasattr(self.mic, 'stop_stream'):
+                    if self.standby_mode:
+                        self.state = State.STANDBY
+                        if hasattr(self.vad, "is_pressed") and hasattr(self.mic, "stop_stream"):
+                            logger.debug("Microphone stream stopped")
                             self.mic.stop_stream()
-                        self.llm.start_request({"status": "notification_delivered"})
+                        self._reset_listening_state()
+                    else:
+                        self.state = State.LISTENING if self.expect_reply else State.EXECUTING
+                        if self.state == State.LISTENING:
+                            self._reset_listening_state()
+                            self.was_interrupted = False
+                        elif self.state == State.EXECUTING:
+                            if hasattr(self.mic, 'stop_stream'):
+                                logger.debug("Microphone stream stopped")
+                                self.mic.stop_stream()
+                            self.llm.start_request({"status": "notification_delivered"})
 
         elif self.state == State.LISTENING:
             self.buffer.append(frame)
@@ -178,6 +208,7 @@ class CoreEngine:
                 return
 
             if not self.has_started_speaking and self.total_listening_ms >= self.config.listening_timeout_ms:
+                logger.info("Silence timeout reached. Prompting LLM.")
                 self.llm.start_request({"status": "silence_timeout", "user_transcript": ""})
                 self.state = State.PROCESSING
                 self.processing_wait_ms = 0
@@ -189,15 +220,31 @@ class CoreEngine:
                 else:
                     self._reset_listening_state()
 
+        elif self.state == State.STANDBY:
+            if is_speech:
+                self.standby_mode = False
+                self.state = State.LISTENING
+                if hasattr(self.vad, "is_pressed") and hasattr(self.mic, "start_stream"):
+                    # We closed it earlier for PTT, so we need to reopen it.
+                    logger.debug("Microphone stream started")
+                    self.mic.start_stream()
+                self._reset_listening_state()
+                self.buffer.append(frame)
+                self.total_listening_ms += self.tick_ms
+                self.current_speech_duration_ms += self.tick_ms
+                self.has_started_speaking = True
+                self.total_recording_ms += self.tick_ms
+
         elif self.state == State.PROCESSING:
             self.buffer.append(frame)
             self.processing_wait_ms += self.tick_ms
             
             if self.processing_wait_ms >= self.config.llm_timeout_ms:
                 import sys
-                print("LLM Timeout reached. Assuming agent abandoned the voice loop. Tearing down hardware.", file=sys.stderr)
+                logger.error("LLM Timeout reached. Assuming agent abandoned the voice loop. Tearing down hardware.")
                 self.state = State.EXECUTING
                 if hasattr(self.mic, 'stop_stream'):
+                    logger.debug("Microphone stream stopped")
                     self.mic.stop_stream()
                 self.processing_wait_ms = 0
                 self.buffer = []
@@ -209,6 +256,7 @@ class CoreEngine:
                 
                 orphan_speech = any(f.has_speech for f in self.buffer)
                 if orphan_speech:
+                    logger.warning("Orphan speech detected. Interrupted previous context.")
                     self.was_interrupted = True
                     self.state = State.LISTENING
                     self.has_started_speaking = True