voice-vibecoder 2.5.3__tar.gz → 2.7.0__tar.gz

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v2.7.0 (2026-02-20)
+
+
+## v2.6.0 (2026-02-20)
+
+### Features
+
+- **agent_task**: Support matching by display name in session lookup
+  ([`a97e0e6`](https://github.com/snokam/voice-vibecoder/commit/a97e0e67fdf7178ddee182acc275957a471e2691))
+
+### Refactoring
+
+- **instances**: Simplify branch key assignment logic
+  ([`58f5d34`](https://github.com/snokam/voice-vibecoder/commit/58f5d3475d1696dd3b92252e3843ee2e4a04826b))
+
+
 ## v2.5.3 (2026-02-20)
 
 ### Bug Fixes

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.5.3
+Version: 2.7.0
 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

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.5.3"
+version = "2.7.0"
 description = "Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/__init__.py

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

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/code_providers/claude.py

@@ -242,6 +242,7 @@ class ClaudeRunner:
     ) -> AgentResult:
         result_text = ""
         result_session_id: str | None = None
+        got_content = False
 
         async def _prompt():
             yield {
@@ -251,54 +252,61 @@ class ClaudeRunner:
                 "session_id": session_id,
             }
 
-        async for msg in query(prompt=_prompt(), options=options):
-            if isinstance(msg, AssistantMessage):
-                for block in msg.content:
-                    if isinstance(block, TextBlock):
-                        text = block.text.strip()
-                        if text and on_output:
-                            for line in text.splitlines():
-                                if line.strip():
-                                    on_output(AgentOutput(
-                                        category="text", content=line,
-                                    ))
-
-                    elif isinstance(block, ToolUseBlock):
-                        if not block.name:
-                            continue
-                        desc = describe_tool_call(block.name, block.input)
-                        if on_output:
-                            category = (
-                                "file_edit" if block.name in ("Edit", "Write")
-                                else "bash" if block.name == "Bash"
-                                else "tool_call"
-                            )
-                            on_output(AgentOutput(
-                                category=category, content=desc,
-                            ))
-                            if block.name in ("Edit", "Write"):
-                                _emit_edit_diff(on_output, block.name, block.input)
-
-                    elif isinstance(block, ToolResultBlock):
-                        content = block.content or ""
-                        if isinstance(content, str) and content.strip() and on_output:
-                            preview = content[:200] + ("..." if len(content) > 200 else "")
-                            on_output(AgentOutput(
-                                category="tool_result", content=preview,
-                            ))
-
-            elif isinstance(msg, UserMessage):
-                if isinstance(msg.content, list):
+        try:
+            async for msg in query(prompt=_prompt(), options=options):
+                if isinstance(msg, AssistantMessage):
                     for block in msg.content:
-                        if isinstance(block, ToolResultBlock):
+                        if isinstance(block, TextBlock):
+                            text = block.text.strip()
+                            if text and on_output:
+                                got_content = True
+                                for line in text.splitlines():
+                                    if line.strip():
+                                        on_output(AgentOutput(
+                                            category="text", content=line,
+                                        ))
+
+                        elif isinstance(block, ToolUseBlock):
+                            if not block.name:
+                                continue
+                            got_content = True
+                            desc = describe_tool_call(block.name, block.input)
+                            if on_output:
+                                category = (
+                                    "file_edit" if block.name in ("Edit", "Write")
+                                    else "bash" if block.name == "Bash"
+                                    else "tool_call"
+                                )
+                                on_output(AgentOutput(
+                                    category=category, content=desc,
+                                ))
+                                if block.name in ("Edit", "Write"):
+                                    _emit_edit_diff(on_output, block.name, block.input)
+
+                        elif isinstance(block, ToolResultBlock):
                             content = block.content or ""
-                            if isinstance(content, str) and content.strip():
-                                pass  # Already routed via AssistantMessage
-
-            elif isinstance(msg, ResultMessage):
-                result_text = msg.result or ""
-                if msg.session_id:
-                    result_session_id = msg.session_id
+                            if isinstance(content, str) and content.strip() and on_output:
+                                preview = content[:200] + ("..." if len(content) > 200 else "")
+                                on_output(AgentOutput(
+                                    category="tool_result", content=preview,
+                                ))
+
+                elif isinstance(msg, UserMessage):
+                    if isinstance(msg.content, list):
+                        for block in msg.content:
+                            if isinstance(block, ToolResultBlock):
+                                content = block.content or ""
+                                if isinstance(content, str) and content.strip():
+                                    pass  # Already routed via AssistantMessage
+
+                elif isinstance(msg, ResultMessage):
+                    result_text = msg.result or ""
+                    if msg.session_id:
+                        result_session_id = msg.session_id
+        except ProcessError:
+            if not got_content and not result_text:
+                raise
+            logger.warning("CLI process error after content was already streamed")
 
         return AgentResult(text=result_text, session_id=result_session_id)
 

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/instances.py

@@ -125,7 +125,7 @@ class InstanceRegistry:
             self.on_status_change(instance.instance_id, instance.status)
         if self.on_instance_change:
             self.on_instance_change()
-        # Start file tree updates for code instances (skip for sessions)
+        # Show file tree immediately when panel appears
         from voice_vibecoder.tools.file_tree import start_file_tree_updates
         start_file_tree_updates(instance.instance_id, worktree_path, self)
         return instance
@@ -136,16 +136,20 @@ class InstanceRegistry:
         if existing:
             return existing
         with self._lock:
+            # Re-check under lock to prevent race between concurrent creates
+            branch_key = f"_session_{name}"
+            if branch_key in self._branch_index:
+                return self._instances[self._branch_index[branch_key]]
             instance = AgentInstance(
                 instance_id=uuid.uuid4().hex[:8],
-                branch=f"_session_{name}",
+                branch=branch_key,
                 worktree_path="",
                 agent_type=agent_type,
                 instance_type=InstanceType.SESSION,
                 display_name=name,
             )
             self._instances[instance.instance_id] = instance
-            self._branch_index[instance.branch] = instance.instance_id
+            self._branch_index[branch_key] = instance.instance_id
         self._save_state()
         if self.on_status_change:
             self.on_status_change(instance.instance_id, instance.status)
@@ -415,7 +419,7 @@ class InstanceRegistry:
                 self._branch_index[branch] = instance.instance_id
                 loaded.append(instance)
 
-        # Start file tree updates for code instances only
+        # Start file tree updates for restored code instances
         from voice_vibecoder.tools.file_tree import start_file_tree_updates
         for inst in loaded:
             if inst.instance_type == InstanceType.SESSION:

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/session.py

@@ -128,8 +128,12 @@ class RealtimeSession:
             self._on_status("connected")
 
     async def configure_session(self) -> None:
+        from voice_vibecoder.tools.agent_task import warm_mcp_cache
         from voice_vibecoder.tools.handlers import get_active_instances_text, get_startup_context
 
+        # Pre-warm MCP server cache so first agent spawn doesn't pay the cost
+        warm_mcp_cache()
+
         s = self._settings
         overrides = self._voice_config.system_instructions if self._voice_config else None
         instructions = get_system_instructions(

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/tools/agent_task.py

@@ -23,10 +23,11 @@ _CLAUDE_JSON = Path.home() / ".claude.json"
 
 # Cached MCP servers — loaded once per session, files rarely change
 _mcp_cache: dict[str, dict] | None = None
+_mcp_lock = threading.Lock()
 
 
 def _load_mcp_servers() -> dict[str, dict]:
-    """Load MCP servers (cached after first call).
+    """Load MCP servers (cached after first call, thread-safe).
 
     Priority order:
     1. MCP_SERVERS_JSON environment variable (for Azure/production)
@@ -37,50 +38,60 @@ def _load_mcp_servers() -> dict[str, dict]:
     if _mcp_cache is not None:
         return _mcp_cache
 
-    import os
-    from voice_vibecoder.tools.dispatch import _repo_root
+    with _mcp_lock:
+        # Double-check after acquiring the lock
+        if _mcp_cache is not None:
+            return _mcp_cache
+
+        import os
+        from voice_vibecoder.tools.dispatch import _repo_root
+
+        servers: dict[str, dict] = {}
 
-    servers: dict[str, dict] = {}
+        # Load from .mcp.json in repo root
+        if _repo_root:
+            mcp_json = Path(_repo_root) / ".mcp.json"
+            if mcp_json.exists():
+                try:
+                    data = json.loads(mcp_json.read_text())
+                    servers.update(data.get("mcpServers", {}))
+                except Exception as e:
+                    logger.warning("Failed to read .mcp.json: %s", e)
 
-    # Load from .mcp.json in repo root
-    if _repo_root:
-        mcp_json = Path(_repo_root) / ".mcp.json"
-        if mcp_json.exists():
+        # Load from ~/.claude.json
+        if _repo_root and _CLAUDE_JSON.exists():
             try:
-                data = json.loads(mcp_json.read_text())
-                servers.update(data.get("mcpServers", {}))
+                data = json.loads(_CLAUDE_JSON.read_text())
+                project_key = str(Path(_repo_root))
+                project_data = data.get("projects", {}).get(project_key, {})
+                local_servers = project_data.get("mcpServers", {})
+                servers.update(local_servers)
             except Exception as e:
-                logger.warning("Failed to read .mcp.json: %s", e)
+                logger.warning("Failed to read ~/.claude.json: %s", e)
 
-    # Load from ~/.claude.json
-    if _repo_root and _CLAUDE_JSON.exists():
-        try:
-            data = json.loads(_CLAUDE_JSON.read_text())
-            project_key = str(Path(_repo_root))
-            project_data = data.get("projects", {}).get(project_key, {})
-            local_servers = project_data.get("mcpServers", {})
-            servers.update(local_servers)
-        except Exception as e:
-            logger.warning("Failed to read ~/.claude.json: %s", e)
-
-    # MCP_SERVERS_JSON takes precedence (for Azure Container Apps)
-    mcp_env = os.environ.get("MCP_SERVERS_JSON")
-    if mcp_env:
-        try:
-            env_servers = json.loads(mcp_env)
-            servers.update(env_servers.get("mcpServers", env_servers))
-            logger.info("Loaded MCP servers from MCP_SERVERS_JSON environment variable")
-        except Exception as e:
-            logger.warning("Failed to parse MCP_SERVERS_JSON: %s", e)
+        # MCP_SERVERS_JSON takes precedence (for Azure Container Apps)
+        mcp_env = os.environ.get("MCP_SERVERS_JSON")
+        if mcp_env:
+            try:
+                env_servers = json.loads(mcp_env)
+                servers.update(env_servers.get("mcpServers", env_servers))
+                logger.info("Loaded MCP servers from MCP_SERVERS_JSON environment variable")
+            except Exception as e:
+                logger.warning("Failed to parse MCP_SERVERS_JSON: %s", e)
+
+        # Ensure each MCP server inherits process env vars (the Claude CLI may
+        # not forward its own env to MCP server subprocesses).
+        for _name, cfg in servers.items():
+            if "env" not in cfg:
+                cfg["env"] = dict(os.environ)
+
+        _mcp_cache = servers
+        return servers
 
-    # Ensure each MCP server inherits process env vars (the Claude CLI may
-    # not forward its own env to MCP server subprocesses).
-    for _name, cfg in servers.items():
-        if "env" not in cfg:
-            cfg["env"] = dict(os.environ)
 
-    _mcp_cache = servers
-    return servers
+def warm_mcp_cache() -> None:
+    """Pre-load MCP server config so it's ready when agents spawn."""
+    _load_mcp_servers()
 
 
 def _create_runner(agent_type: str, permission_mode: str, mcp_servers: dict | None, env: dict | None = None) -> AgentRunner:
@@ -198,6 +209,10 @@ def _handle_send_to_session(message: str, session_name: str | None = None, agent
             session_name = "session"
 
     instance = _registry.get_session_by_name(session_name)
+    # Also try matching by display_name (LLM may use different session keys
+    # for the same logical session, e.g. "calendar-today" vs "today-s-calendar")
+    if not instance and display_name:
+        instance = _registry.get_session_by_name(display_name)
     is_new_session = instance is None
     if not instance:
         instance = _registry.create_session(session_name, agent_type=target_agent)

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/tools/file_tree.py

@@ -9,6 +9,7 @@ timer while an agent is running.
 import logging
 import subprocess
 import threading
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import PurePosixPath
 
 logger = logging.getLogger(__name__)
@@ -16,16 +17,15 @@ logger = logging.getLogger(__name__)
 MAX_DEPTH = 10  # Maximum tree depth to prevent excessive nesting
 
 
-def _merge_base(worktree_path: str) -> str:
-    """Get the merge-base commit between main and HEAD."""
-    result = subprocess.run(
-        ["git", "merge-base", "main", "HEAD"],
-        cwd=worktree_path,
+def _git(args: list[str], cwd: str) -> subprocess.CompletedProcess:
+    """Run a git command and return the CompletedProcess."""
+    return subprocess.run(
+        ["git", *args],
+        cwd=cwd,
         capture_output=True,
         text=True,
         timeout=10,
     )
-    return result.stdout.strip() if result.returncode == 0 else "main"
 
 
 def _build_tree_node(path: str, status: str | None, is_folder: bool) -> dict:
@@ -112,26 +112,25 @@ def get_file_tree(worktree_path: str) -> dict:
          "summary": {"modified": N, "new": N, "deleted": N, "unchanged": N}}
     """
     try:
-        # Get branch name
-        branch_result = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-        root = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
-
-        base = _merge_base(worktree_path)
+        # Run independent git commands in parallel, then diff after merge-base
+        with ThreadPoolExecutor(max_workers=4) as pool:
+            branch_fut = pool.submit(_git, ["rev-parse", "--abbrev-ref", "HEAD"], worktree_path)
+            base_fut = pool.submit(_git, ["merge-base", "main", "HEAD"], worktree_path)
+            untracked_fut = pool.submit(_git, ["ls-files", "--others", "--exclude-standard"], worktree_path)
+            all_files_fut = pool.submit(_git, ["ls-files"], worktree_path)
+
+            # Wait for merge-base, then submit diff (overlaps with ls-files)
+            base_result = base_fut.result()
+            base = base_result.stdout.strip() if base_result.returncode == 0 else "main"
+            diff_fut = pool.submit(_git, ["diff", "--name-status", base], worktree_path)
+
+            # Collect remaining results
+            branch_result = branch_fut.result()
+            diff_result = diff_fut.result()
+            untracked_result = untracked_fut.result()
+            all_files_result = all_files_fut.result()
 
-        # Get modified/deleted files vs merge-base
-        diff_result = subprocess.run(
-            ["git", "diff", "--name-status", base],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
+        root = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
 
         changed: dict[str, str] = {}  # path -> status
         if diff_result.returncode == 0:
@@ -151,29 +150,12 @@ def get_file_tree(worktree_path: str) -> dict:
                     elif status_code in ("R", "C"):
                         changed[path] = "modified"
 
-        # Get untracked files
-        untracked_result = subprocess.run(
-            ["git", "ls-files", "--others", "--exclude-standard"],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
         if untracked_result.returncode == 0:
             for path in untracked_result.stdout.strip().splitlines():
                 path = path.strip()
                 if path and path not in changed:
                     changed[path] = "new"
 
-        # Get all tracked files to show complete project structure
-        all_files_result = subprocess.run(
-            ["git", "ls-files"],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-
         all_paths: dict[str, str] = {}  # path -> status
         if all_files_result.returncode == 0:
             for f in all_files_result.stdout.strip().splitlines():
@@ -206,14 +188,18 @@ def get_file_tree(worktree_path: str) -> dict:
             if status in summary:
                 summary[status] += 1
 
-        return {"root": root, "tree": tree, "summary": summary}
+        # Flat entries list for the TUI sidebar
+        entries = [{"path": p, "status": s} for p, s in sorted(all_paths.items())]
+
+        return {"root": root, "tree": tree, "summary": summary, "entries": entries}
 
     except Exception as e:
         logger.warning("Failed to build file tree: %s", e)
         return {
             "root": "unknown",
             "tree": {"name": "unknown", "path": "", "type": "folder", "children": [], "expanded": True},
-            "summary": {"modified": 0, "new": 0, "deleted": 0, "unchanged": 0}
+            "summary": {"modified": 0, "new": 0, "deleted": 0, "unchanged": 0},
+            "entries": [],
         }
 
 

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/tools/handlers.py

@@ -395,7 +395,8 @@ def _handle_show_diff(branch: str | None = None, file: str | None = None) -> str
         return f"No changes on '{instance.branch}' vs main."
     if matched_file:
         return f"Showing diff for '{matched_file}' on '{instance.branch}'."
-    return f"Showing diff for '{instance.branch}': {file_count} file{'s' if file_count != 1 else ''} changed."
+    file_list = ", ".join(f.path for f in files[:15])
+    return f"Showing diff for '{instance.branch}': {file_count} changed file(s): {file_list}"
 
 
 def _handle_show_output(branch: str | None = None, session_name: str | None = None) -> str:

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/ui/panels.py

@@ -4,10 +4,13 @@ Handles creating, updating, toggling fullscreen, and removing agent
 instance panels in the grid layout.
 """
 
+import logging
 import math
 
+logger = logging.getLogger(__name__)
+
 from textual.containers import Grid, Horizontal, Vertical
-from textual.widgets import Static, RichLog
+from textual.widgets import Static, RichLog, Tree
 
 from voice_vibecoder.code_providers.registry import get_badge
 from voice_vibecoder.instances import AgentInstance, InstanceStatus
@@ -29,30 +32,68 @@ _FILE_STATUS_COLORS = {
 }
 
 
-def _format_file_tree(entries: list[dict]) -> str:
-    """Format file tree entries into Rich markup for the TUI sidebar."""
-    # Group by directory
-    tree: dict[str, list[tuple[str, str]]] = {}  # dir -> [(filename, status)]
-    for entry in entries:
-        path = entry.get("path", "")
-        status = entry.get("status", "unchanged")
-        if "/" in path:
-            folder, name = path.rsplit("/", 1)
+class FileTreeWidget(Tree):
+    """Interactive file tree sidebar with clickable expand/collapse folders."""
+
+    show_root = False
+
+    DEFAULT_CSS = """
+    FileTreeWidget {
+        scrollbar-size: 1 1;
+    }
+    """
+
+    def __init__(self, tree_data: dict, **kwargs):
+        super().__init__(tree_data.get("name", "files"), **kwargs)
+        self._user_toggled: dict[str, bool] = {}
+        self._rebuilding = False
+        self._build_from_data(tree_data)
+
+    def _build_from_data(self, tree_data: dict) -> None:
+        self._rebuilding = True
+        self.clear()
+        self.root.expand()
+        for child in tree_data.get("children", []):
+            self._insert_node(self.root, child)
+        self._rebuilding = False
+
+    def _insert_node(self, parent, node_data: dict) -> None:
+        path = node_data.get("path", "")
+        name = node_data.get("name", "")
+
+        if node_data["type"] == "folder":
+            if path in self._user_toggled:
+                should_expand = self._user_toggled[path]
+            else:
+                should_expand = node_data.get("expanded", False)
+
+            label = f"[bold dim]{name}/[/bold dim]"
+            folder_node = parent.add(label, data={"path": path, "type": "folder"}, expand=should_expand)
+
+            for child in node_data.get("children", []):
+                self._insert_node(folder_node, child)
         else:
-            folder, name = "", path
-        tree.setdefault(folder, []).append((name, status))
-
-    lines = []
-    for folder in sorted(tree.keys()):
-        if folder:
-            lines.append(f"[bold dim]{folder}/[/bold dim]")
-        for name, status in sorted(tree[folder], key=lambda x: x[0]):
-            icon = _FILE_STATUS_ICONS.get(status, "[dim]?[/dim]")
+            status = node_data.get("status", "unchanged")
+            icon = _FILE_STATUS_ICONS.get(status, "[dim]·[/dim]")
             color = _FILE_STATUS_COLORS.get(status, "dim")
-            indent = "  " if folder else ""
-            lines.append(f"{indent}{icon} [{color}]{name}[/{color}]")
+            label = f"{icon} [{color}]{name}[/{color}]"
+            parent.add_leaf(label, data={"path": path, "type": "file", "status": status})
+
+    def rebuild(self, tree_data: dict) -> None:
+        """Rebuild tree from new data, preserving user expand/collapse state."""
+        self._build_from_data(tree_data)
 
-    return "\n".join(lines)
+    def on_tree_node_expanded(self, event) -> None:
+        if self._rebuilding:
+            return
+        if event.node.data and event.node.data.get("type") == "folder":
+            self._user_toggled[event.node.data["path"]] = True
+
+    def on_tree_node_collapsed(self, event) -> None:
+        if self._rebuilding:
+            return
+        if event.node.data and event.node.data.get("type") == "folder":
+            self._user_toggled[event.node.data["path"]] = False
 
 
 def _format_header(inst: AgentInstance, status: InstanceStatus | None = None) -> str:
@@ -284,24 +325,23 @@ class PanelMixin:
             grid.styles.grid_size_rows = 1
 
     def _update_file_tree(self, instance_id: str, data: dict) -> None:
-        """Update (or create) the file tree sidebar in a panel."""
+        """Update (or create) the interactive file tree sidebar in a panel."""
         if not self._session:
             return
         inst = self._session.registry.get_by_id(instance_id)
         if not inst:
             return
 
-        entries = data.get("entries", [])
-        if not entries:
+        tree_data = data.get("tree")
+        if not tree_data or not tree_data.get("children"):
             return
 
-        formatted = _format_file_tree(entries)
         sidebar_id = f"file-tree-{instance_id}"
 
-        # Try to update existing sidebar
+        # Try to update existing tree widget
         try:
-            sidebar = self.query_one(f"#{sidebar_id}", Static)
-            sidebar.update(formatted)
+            tree_widget = self.query_one(f"#{sidebar_id}", FileTreeWidget)
+            tree_widget.rebuild(tree_data)
             return
         except Exception:
             pass
@@ -315,8 +355,8 @@ class PanelMixin:
         except Exception:
             return
 
-        sidebar = Static(
-            formatted,
+        tree_widget = FileTreeWidget(
+            tree_data,
             classes="file-tree-sidebar",
             id=sidebar_id,
         )
@@ -326,13 +366,14 @@ class PanelMixin:
         try:
             output.remove()
             container = Horizontal(
-                sidebar,
+                tree_widget,
                 output,
                 classes="file-tree-container",
                 id=f"file-tree-wrap-{instance_id}",
             )
             panel.mount(container)
         except Exception:
+            logger.exception("Failed to mount file tree for %s", instance_id)
             # If something fails, try to restore output directly
             try:
                 panel.mount(output)

{voice_vibecoder-2.5.3 → voice_vibecoder-2.7.0}/src/voice_vibecoder/ui/screen.py

@@ -361,6 +361,13 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
         asyncio.set_event_loop(self._loop)
         self._loop.run_until_complete(self._session_lifecycle())
 
+    def _call_ui(self, callback, *args) -> None:
+        """Safely call a UI callback from a background thread."""
+        try:
+            self.app.call_from_thread(callback, *args)
+        except Exception:
+            pass  # App not active (shutting down or not yet ready)
+
     async def _session_lifecycle(self) -> None:
         try:
             await self._session.connect()
@@ -371,12 +378,10 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
             self._audio = AudioManager(on_audio_chunk=self._send_audio_chunk)
             self._audio.start()
 
-            self.app.call_from_thread(self._log, "[green]Connected — start speaking[/green]")
+            self._call_ui(self._log, "[green]Connected — start speaking[/green]")
             if self._log_path:
-                self.app.call_from_thread(
-                    self._log, f"[dim]Log: {self._log_path}[/dim]"
-                )
-            self.app.call_from_thread(self._update_status_bar, "ready")
+                self._call_ui(self._log, f"[dim]Log: {self._log_path}[/dim]")
+            self._call_ui(self._update_status_bar, "ready")
 
             # Run custom startup callback if configured
             if self._config.on_startup:
@@ -384,10 +389,10 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
 
             await self._session.handle_messages()
         except Exception as e:
-            self.app.call_from_thread(
+            self._call_ui(
                 self._log, f"[bold red]Connection error: {e}[/bold red]"
             )
-            self.app.call_from_thread(
+            self._call_ui(
                 self._set_status,
                 f"[red]Error[/red]  |  [dim]s[/dim] settings  |  [dim]q[/dim] quit",
             )