voice-vibecoder 2.5.2__tar.gz → 2.6.0__tar.gz

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.0}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 <!-- version list -->
 
+## 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
+
+- Prevent duplicate sessions by embedding active instances in instructions
+  ([`7f493dc`](https://github.com/snokam/voice-vibecoder/commit/7f493dc275d7913edc760afc8ac3b2c066062954))
+
+
 ## v2.5.2 (2026-02-20)
 
 ### Bug Fixes

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.5.2
+Version: 2.6.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.2 → voice_vibecoder-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.5.2"
+version = "2.6.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.2 → voice_vibecoder-2.6.0}/src/voice_vibecoder/__init__.py

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

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.0}/src/voice_vibecoder/config.py

@@ -47,9 +47,12 @@ Branch-navn fuzzy-matches — f.eks. "branding" matcher "feat/branding-refresh".
 send_to_session med beskrivende navn. Gjenbruk eksisterende sesjoner for samme tema.
 
 Sesjoner:
+- SJEKK ALLTID listen over aktive sesjoner nedenfor før du oppretter en ny.
+- Hvis en sesjon dekker samme tema, GJENBRUK den ved å bruke det eksakte navnet.
+- Opprett kun en ny sesjon for et genuint annet tema.
 - Bruk beskrivende navn: "jira-research", "ci-status", "arkitektur-gjennomgang".
-- Gjenbruk en sesjon hvis temaet er det samme. Opprett ny for nytt tema.
 - remove_session for å fjerne en sesjon.
+{active_instances}
 
 Agenter:
 - Tilgjengelige agenter: {agent_names}.
@@ -100,9 +103,12 @@ Branch names are fuzzy-matched — e.g. "branding" matches "feat/branding-refres
 send_to_session with a descriptive name. Reuse existing sessions for the same topic.
 
 Sessions:
+- ALWAYS check the active sessions list below before creating a new one.
+- If a session covers the same topic, REUSE it by using its exact name.
+- Only create a new session for a genuinely different topic.
 - Use descriptive names: "jira-research", "ci-status", "architecture-review".
-- Reuse a session if the topic is the same. Create new for a different topic.
 - remove_session to remove a session.
+{active_instances}
 
 Agents:
 - Available agents: {agent_names}.
@@ -153,9 +159,12 @@ Branch-namn fuzzy-matchas — t.ex. "branding" matchar "feat/branding-refresh".
 send_to_session med beskrivande namn. Återanvänd befintliga sessioner för samma ämne.
 
 Sessioner:
+- KONTROLLERA ALLTID listan över aktiva sessioner nedan innan du skapar en ny.
+- Om en session täcker samma ämne, ÅTERANVÄND den genom att använda det exakta namnet.
+- Skapa bara en ny session för ett genuint annorlunda ämne.
 - Använd beskrivande namn: "jira-research", "ci-status", "arkitektur-granskning".
-- Återanvänd en session om ämnet är detsamma. Skapa ny för nytt ämne.
 - remove_session för att ta bort en session.
+{active_instances}
 
 Agenter:
 - Tillgängliga agenter: {agent_names}.
@@ -195,12 +204,25 @@ def get_system_instructions(
     context: str = "",
     overrides: dict[str, str] | None = None,
     enabled_agents: list[str] | None = None,
+    active_instances: str = "",
 ) -> str:
     if overrides and language in overrides:
         base = overrides[language]
     else:
         base = _SYSTEM_INSTRUCTIONS.get(language, _SYSTEM_INSTRUCTIONS["en"])
-    base = base.format(agent_names=_agent_names(enabled_agents))
+    instances_text = active_instances or "(No active sessions or agents.)"
+    has_instances_placeholder = "{active_instances}" in base
+    try:
+        base = base.format(
+            agent_names=_agent_names(enabled_agents),
+            active_instances=instances_text,
+        )
+    except KeyError:
+        # Override instructions may not have all placeholders
+        base = base.format(agent_names=_agent_names(enabled_agents))
+    # If the template didn't have {active_instances}, append inline
+    if not has_instances_placeholder and active_instances:
+        base += f"\n\n{instances_text}"
     if context:
         return f"{base}\n\n{context}"
     return base

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.0}/src/voice_vibecoder/instances.py

@@ -125,9 +125,6 @@ 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)
-        from voice_vibecoder.tools.file_tree import start_file_tree_updates
-        start_file_tree_updates(instance.instance_id, worktree_path, self)
         return instance
 
     def create_session(self, name: str, agent_type: str = "claude") -> AgentInstance:
@@ -136,16 +133,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,11 +416,4 @@ class InstanceRegistry:
                 self._branch_index[branch] = instance.instance_id
                 loaded.append(instance)
 
-        # Start file tree updates for code instances only
-        from voice_vibecoder.tools.file_tree import start_file_tree_updates
-        for inst in loaded:
-            if inst.instance_type == InstanceType.SESSION:
-                continue
-            start_file_tree_updates(inst.instance_id, inst.worktree_path, self)
-
         return loaded

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.0}/src/voice_vibecoder/session.py

@@ -128,13 +128,18 @@ class RealtimeSession:
             self._on_status("connected")
 
     async def configure_session(self) -> None:
-        from voice_vibecoder.tools.handlers import get_startup_context
+        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(
             s.language, context=get_startup_context(),
             overrides=overrides, enabled_agents=s.enabled_agents,
+            active_instances=get_active_instances_text(),
         )
 
         vad: VADSettings | None = None
@@ -304,12 +309,13 @@ class RealtimeSession:
             asyncio.run_coroutine_threadsafe(self._refresh_instructions(), self._loop)
 
     async def _refresh_instructions(self) -> None:
-        from voice_vibecoder.tools.handlers import get_startup_context
+        from voice_vibecoder.tools.handlers import get_active_instances_text, get_startup_context
 
         overrides = self._voice_config.system_instructions if self._voice_config else None
         instructions = get_system_instructions(
             self._settings.language, context=get_startup_context(),
             overrides=overrides, enabled_agents=self._settings.enabled_agents,
+            active_instances=get_active_instances_text(),
         )
         try:
             await self._provider.update_session(instructions=instructions)

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.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,11 @@ 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)
     # Update display_name if a better one was provided by the LLM
@@ -239,7 +255,13 @@ def _handle_send_to_session(message: str, session_name: str | None = None, agent
             daemon=True,
         )
         thread.start()
-        return f"Sent to session '{instance.display_name}'."
+        result = f"Sent to session '{instance.display_name}'."
+        if is_new_session:
+            all_sessions = registry.get_all_sessions()
+            if len(all_sessions) > 1:
+                names = [s.display_name for s in all_sessions]
+                result += f" (Active sessions: {', '.join(names)})"
+        return result
 
     thread = threading.Thread(
         target=_run_agent_background,
@@ -248,7 +270,13 @@ def _handle_send_to_session(message: str, session_name: str | None = None, agent
     )
     thread.start()
 
-    return f"Sent to session '{instance.display_name}'."
+    result = f"Sent to session '{instance.display_name}'."
+    if is_new_session:
+        all_sessions = registry.get_all_sessions()
+        if len(all_sessions) > 1:
+            names = [s.display_name for s in all_sessions]
+            result += f" (Active sessions: {', '.join(names)})"
+    return result
 
 
 def _run_agent_background(instance: AgentInstance, message: str, registry: "InstanceRegistry") -> None:

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.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"
+        # 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()
 
-        base = _merge_base(worktree_path)
-
-        # 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():

{voice_vibecoder-2.5.2 → voice_vibecoder-2.6.0}/src/voice_vibecoder/tools/handlers.py

@@ -15,19 +15,12 @@ from voice_vibecoder.tools.dispatch import (
 from voice_vibecoder.worktrees import remove_worktree, resolve_worktree_path
 
 
-def get_startup_context() -> str:
-    """Build a context string with current instances, agents, and worktrees for the system prompt."""
+def get_active_instances_text() -> str:
+    """Return a text summary of active sessions and code instances for inline insertion."""
     from voice_vibecoder.code_providers.registry import get_agent
 
     parts = []
 
-    enabled = _dispatch._enabled_agents
-    if len(enabled) > 1:
-        labels = [get_agent(a).label for a in enabled]
-        parts.append(f"Enabled agents: {', '.join(labels)}")
-        parts.append(f"Default agent: {get_agent(enabled[0]).label}")
-        parts.append("Use the 'agent' parameter in send_to_agent/send_to_session to pick a specific agent.")
-
     if _dispatch._registry:
         code_instances = _dispatch._registry.get_all_code_instances()
         sessions = _dispatch._registry.get_all_sessions()
@@ -44,6 +37,24 @@ def get_startup_context() -> str:
                 agent_label = get_agent(inst.agent_type).label
                 parts.append(f"  - {inst.display_name} ({inst.status.value}) [{agent_label}]")
 
+    if not parts:
+        return ""
+    return "\n".join(parts)
+
+
+def get_startup_context() -> str:
+    """Build a context string with agent config and worktrees for the system prompt."""
+    from voice_vibecoder.code_providers.registry import get_agent
+
+    parts = []
+
+    enabled = _dispatch._enabled_agents
+    if len(enabled) > 1:
+        labels = [get_agent(a).label for a in enabled]
+        parts.append(f"Enabled agents: {', '.join(labels)}")
+        parts.append(f"Default agent: {get_agent(enabled[0]).label}")
+        parts.append("Use the 'agent' parameter in send_to_agent/send_to_session to pick a specific agent.")
+
     if _dispatch._repo_root:
         from voice_vibecoder.worktrees import list_worktrees