gobby 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -216,52 +216,111 @@ def main() -> int:
         # This captures the terminal/process info for session correlation
         if hook_type == "SessionStart":
             input_data["terminal_context"] = get_terminal_context()
+            # Note: gobby_context (parent_session_id, workflow, etc.) is no longer
+            # injected from env vars. For spawned agents, the session is pre-created
+            # with all linkage via preflight+resume pattern, so the daemon already
+            # has the context when SessionStart fires.
 
         # Log what Gemini CLI sends us (for debugging hook data issues)
-        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+        # Extract common context fields for structured logging
+        session_id = input_data.get("session_id")
+        task_id = input_data.get("task_id")
+        project_id = input_data.get("project_id")
+        base_context = {
+            "hook_type": hook_type,
+            "session_id": session_id,
+            "task_id": task_id,
+            "project_id": project_id,
+        }
+
+        logger.info(
+            "[%s] Received input keys: %s",
+            hook_type,
+            list(input_data.keys()),
+            extra=base_context,
+        )
 
         # Log hook-specific critical fields
         if hook_type == "SessionStart":
-            logger.info(f"[SessionStart] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[SessionStart] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "SessionEnd":
+            reason = input_data.get("reason")
             logger.info(
-                f"[SessionEnd] session_id={input_data.get('session_id')}, "
-                f"reason={input_data.get('reason')}"
+                "[SessionEnd] session_id=%s, reason=%s",
+                session_id,
+                reason,
+                extra={**base_context, "reason": reason},
             )
         elif hook_type == "BeforeAgent":
             prompt = input_data.get("prompt", "")
             prompt_preview = prompt[:100] + "..." if len(prompt) > 100 else prompt
             logger.info(
-                f"[BeforeAgent] session_id={input_data.get('session_id')}, prompt={prompt_preview}"
+                "[BeforeAgent] session_id=%s, prompt=%s",
+                session_id,
+                prompt_preview,
+                extra={**base_context, "prompt_preview": prompt_preview},
             )
         elif hook_type == "BeforeTool":
             tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
             logger.info(
-                f"[BeforeTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+                "[BeforeTool] tool_name=%s, session_id=%s",
+                tool_name,
+                session_id,
+                extra={**base_context, "tool_name": tool_name},
             )
         elif hook_type == "AfterTool":
             tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
+            error = input_data.get("error")
             logger.info(
-                f"[AfterTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+                "[AfterTool] tool_name=%s, session_id=%s",
+                tool_name,
+                session_id,
+                extra={**base_context, "tool_name": tool_name, "error": error},
             )
         elif hook_type == "BeforeToolSelection":
-            logger.info(f"[BeforeToolSelection] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[BeforeToolSelection] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "BeforeModel":
+            model = input_data.get("model", "unknown")
             logger.info(
-                f"[BeforeModel] session_id={input_data.get('session_id')}, "
-                f"model={input_data.get('model', 'unknown')}"
+                "[BeforeModel] session_id=%s, model=%s",
+                session_id,
+                model,
+                extra={**base_context, "model": model},
             )
         elif hook_type == "AfterModel":
-            logger.info(f"[AfterModel] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[AfterModel] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "PreCompress":
-            logger.info(f"[PreCompress] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[PreCompress] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "Notification":
+            message = input_data.get("message")
             logger.info(
-                f"[Notification] session_id={input_data.get('session_id')}, "
-                f"message={input_data.get('message')}"
+                "[Notification] session_id=%s, message=%s",
+                session_id,
+                message,
+                extra={**base_context, "notification_message": message},
             )
         elif hook_type == "AfterAgent":
-            logger.info(f"[AfterAgent] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[AfterAgent] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
 
         if debug_mode:
             logger.debug(f"Input data: {input_data}")

gobby/llm/resolver.py

@@ -18,7 +18,8 @@ from typing import TYPE_CHECKING, Literal
 from gobby.llm.executor import AgentExecutor
 
 if TYPE_CHECKING:
-    from gobby.config.app import DaemonConfig, LLMProvidersConfig
+    from gobby.config.app import DaemonConfig
+    from gobby.config.llm_providers import LLMProvidersConfig
     from gobby.workflows.definitions import WorkflowDefinition
 
 logger = logging.getLogger(__name__)
@@ -479,7 +480,7 @@ def _create_codex_executor(
 
 # Re-export for TYPE_CHECKING
 if TYPE_CHECKING:
-    from gobby.config.app import LLMProviderConfig
+    from gobby.config.llm_providers import LLMProviderConfig
 
 
 class ExecutorRegistry:

gobby/mcp_proxy/importer.py

@@ -5,6 +5,8 @@ import re
 from typing import TYPE_CHECKING, Any
 
 from gobby.config.app import DaemonConfig
+from gobby.config.features import DEFAULT_IMPORT_MCP_SERVER_PROMPT
+from gobby.prompts import PromptLoader
 from gobby.storage.database import DatabaseProtocol
 from gobby.storage.mcp import LocalMCPManager
 from gobby.storage.projects import LocalProjectManager
@@ -18,6 +20,21 @@ logger = logging.getLogger(__name__)
 # Pattern to detect placeholder secrets like <YOUR_API_KEY>
 SECRET_PLACEHOLDER_PATTERN = re.compile(r"<YOUR_[A-Z0-9_]+>")
 
+DEFAULT_GITHUB_FETCH_PROMPT = """Fetch the README from this GitHub repository and extract MCP server configuration:
+
+{github_url}
+
+If the URL doesn't point directly to a README, try to find and fetch the README.md file.
+
+After reading the documentation, extract the MCP server configuration as a JSON object."""
+
+DEFAULT_SEARCH_FETCH_PROMPT = """Search for MCP server: {search_query}
+
+Find the official documentation or GitHub repository for this MCP server.
+Then fetch and read the README or installation docs.
+
+After reading the documentation, extract the MCP server configuration as a JSON object."""
+
 
 class MCPServerImporter:
     """Handles importing MCP servers from various sources."""
@@ -46,6 +63,21 @@ class MCPServerImporter:
         self.mcp_client_manager = mcp_client_manager
         self.import_config = config.get_import_mcp_server_config()
 
+        # Initialize prompt loader
+        project_path = None
+        if current_project_id:
+            if project := self.project_manager.get(current_project_id):
+                project_path = project.repo_path
+
+        from pathlib import Path
+
+        self._loader = PromptLoader(project_dir=Path(project_path) if project_path else None)
+
+        # Register fallbacks
+        self._loader.register_fallback("import/github_fetch", lambda: DEFAULT_GITHUB_FETCH_PROMPT)
+        self._loader.register_fallback("import/search_fetch", lambda: DEFAULT_SEARCH_FETCH_PROMPT)
+        self._loader.register_fallback("import/system", lambda: DEFAULT_IMPORT_MCP_SERVER_PROMPT)
+
     async def import_from_project(
         self,
         source_project: str,
@@ -171,10 +203,23 @@ class MCPServerImporter:
             from claude_agent_sdk import AssistantMessage, ClaudeAgentOptions, TextBlock, query
 
             # Build prompt to fetch and extract config
-            prompt = self.import_config.github_fetch_prompt.format(github_url=github_url)
+            prompt_path = self.import_config.github_fetch_prompt_path or "import/github_fetch"
+            try:
+                prompt = self._loader.render(prompt_path, {"github_url": github_url})
+            except Exception as e:
+                logger.warning(f"Failed to load Github fetch prompt: {e}")
+                prompt = DEFAULT_GITHUB_FETCH_PROMPT.format(github_url=github_url)
+
+            # Get system prompt
+            sys_prompt_path = self.import_config.prompt_path or "import/system"
+            try:
+                system_prompt = self._loader.render(sys_prompt_path, {})
+            except Exception as e:
+                logger.warning(f"Failed to load import system prompt: {e}")
+                system_prompt = DEFAULT_IMPORT_MCP_SERVER_PROMPT
 
             options = ClaudeAgentOptions(
-                system_prompt=self.import_config.prompt,
+                system_prompt=system_prompt,
                 max_turns=3,
                 model=self.import_config.model,
                 allowed_tools=["WebFetch"],
@@ -222,10 +267,23 @@ class MCPServerImporter:
             from claude_agent_sdk import AssistantMessage, ClaudeAgentOptions, TextBlock, query
 
             # Build prompt to search and extract config
-            prompt = self.import_config.search_fetch_prompt.format(search_query=search_query)
+            prompt_path = self.import_config.search_fetch_prompt_path or "import/search_fetch"
+            try:
+                prompt = self._loader.render(prompt_path, {"search_query": search_query})
+            except Exception as e:
+                logger.warning(f"Failed to load search fetch prompt: {e}")
+                prompt = DEFAULT_SEARCH_FETCH_PROMPT.format(search_query=search_query)
+
+            # Get system prompt
+            sys_prompt_path = self.import_config.prompt_path or "import/system"
+            try:
+                system_prompt = self._loader.render(sys_prompt_path, {})
+            except Exception as e:
+                logger.warning(f"Failed to load import system prompt: {e}")
+                system_prompt = DEFAULT_IMPORT_MCP_SERVER_PROMPT
 
             options = ClaudeAgentOptions(
-                system_prompt=self.import_config.prompt,
+                system_prompt=system_prompt,
                 max_turns=5,  # More turns for search + fetch
                 model=self.import_config.model,
                 allowed_tools=["WebSearch", "WebFetch"],

gobby/mcp_proxy/instructions.py

@@ -26,9 +26,11 @@ def build_gobby_instructions() -> str:
 At the start of EVERY session:
 1. `list_mcp_servers()` — Discover available servers
 2. `list_skills()` — Discover available skills
-3. Session ID: Look for `session_id: <uuid>` in your context.
+3. Session ID: Look for `Gobby Session Ref:` or `Gobby Session ID:` in your context.
    If missing, call:
-   `call_tool("gobby-sessions", "get_current", {"external_id": "<your-session-id>", "source": "claude"})`
+   `call_tool("gobby-sessions", "get_current_session", {"external_id": "<your-session-id>", "source": "<cli-name>"})`
+
+Session and task references use `#N` format (e.g., `#1`, `#42`) which is project-scoped.
 </startup>
 
 <tool_discovery>

gobby/mcp_proxy/registries.py

@@ -114,7 +114,7 @@ def setup_internal_registries(
     # Initialize sessions registry (messages + session CRUD)
     # Register if either message_manager or local_session_manager is available
     if message_manager is not None or local_session_manager is not None:
-        from gobby.mcp_proxy.tools.session_messages import create_session_messages_registry
+        from gobby.mcp_proxy.tools.sessions import create_session_messages_registry
 
         session_messages_registry = create_session_messages_registry(
             message_manager=message_manager,
@@ -168,22 +168,38 @@ def setup_internal_registries(
 
     # Initialize agents registry if agent_runner is available
     if agent_runner is not None:
-        from gobby.agents.registry import get_running_agent_registry
+        from gobby.agents.definitions import AgentDefinitionLoader
         from gobby.mcp_proxy.tools.agents import create_agents_registry
 
+        # Create clone git manager if we have a git manager
+        clone_git_manager = None
+        if git_manager is not None:
+            try:
+                from gobby.clones.git import CloneGitManager
+
+                clone_git_manager = CloneGitManager(git_manager.repo_path)
+            except Exception as e:
+                logger.debug(f"CloneGitManager not available for spawn_agent: {e}")
+
         agents_registry = create_agents_registry(
             runner=agent_runner,
-            tool_proxy_getter=tool_proxy_getter,
+            agent_loader=AgentDefinitionLoader(),
+            session_manager=local_session_manager,
+            task_manager=task_manager,
+            worktree_storage=worktree_storage,
+            git_manager=git_manager,
+            clone_storage=clone_storage,
+            clone_manager=clone_git_manager,
         )
 
-        # Add inter-agent messaging tools if message manager is available
-        if inter_session_message_manager is not None:
+        # Add inter-agent messaging tools if message manager and session manager are available
+        if inter_session_message_manager is not None and local_session_manager is not None:
             from gobby.mcp_proxy.tools.agent_messaging import add_messaging_tools
 
             add_messaging_tools(
                 registry=agents_registry,
                 message_manager=inter_session_message_manager,
-                agent_registry=get_running_agent_registry(),
+                session_manager=local_session_manager,
             )
             logger.debug("Agent messaging tools added to agents registry")
 
@@ -198,7 +214,6 @@ def setup_internal_registries(
             worktree_storage=worktree_storage,
             git_manager=git_manager,
             project_id=project_id,
-            agent_runner=agent_runner,
         )
         manager.add_registry(worktrees_registry)
         logger.debug("Worktrees registry initialized")
@@ -222,7 +237,6 @@ def setup_internal_registries(
                 clone_storage=clone_storage,
                 git_manager=clone_git_manager,
                 project_id=project_id or "",
-                agent_runner=agent_runner,
             )
             manager.add_registry(clones_registry)
             logger.debug("Clones registry initialized")

gobby/mcp_proxy/services/recommendation.py

@@ -7,13 +7,30 @@ import logging
 from typing import TYPE_CHECKING, Any, Literal
 
 if TYPE_CHECKING:
-    from gobby.config.app import RecommendToolsConfig
+    from gobby.config.features import RecommendToolsConfig
+from gobby.prompts import PromptLoader
 
 logger = logging.getLogger("gobby.mcp.server")
 
 # Search mode type
 SearchMode = Literal["llm", "semantic", "hybrid"]
 
+DEFAULT_HYBRID_RERANK_PROMPT = """Re-rank the following tools for the task: "{task_description}"
+
+Candidates:
+{candidate_list}
+
+Select the best {top_k} tools. Return JSON:
+{{"recommendations": [{{"server": "...", "tool": "...", "reason": "..."}}]}}"""
+
+DEFAULT_LLM_PROMPT = """Recommend tools for the task: "{task_description}"
+
+Available Servers:
+{available_servers}
+
+Return JSON:
+{{"recommendations": [{{"server": "...", "tool": "...", "reason": "..."}}]}}"""
+
 
 class RecommendationService:
     """Service for recommending tools."""
@@ -31,12 +48,17 @@ class RecommendationService:
         self._semantic_search = semantic_search
         self._project_id = project_id
         self._config = config
+        self._loader = PromptLoader()
+        self._loader.register_fallback(
+            "features/recommend_hybrid", lambda: DEFAULT_HYBRID_RERANK_PROMPT
+        )
+        self._loader.register_fallback("features/recommend_llm", lambda: DEFAULT_LLM_PROMPT)
 
     def _get_config(self) -> RecommendToolsConfig:
         """Get config with fallback to defaults."""
         if self._config is not None:
             return self._config
-        from gobby.config.app import RecommendToolsConfig
+        from gobby.config.features import RecommendToolsConfig
 
         return RecommendToolsConfig()
 
@@ -153,11 +175,16 @@ class RecommendationService:
                 for c in candidates
             )
 
-            prompt = config.hybrid_rerank_prompt.format(
-                task_description=task_description,
-                candidate_list=candidate_list,
-                top_k=top_k,
-            )
+            prompt_path = config.hybrid_rerank_prompt_path or "features/recommend_hybrid"
+            context = {
+                "task_description": task_description,
+                "candidate_list": candidate_list,
+                "top_k": top_k,
+            }
+            try:
+                prompt = self._loader.render(prompt_path, context)
+            except Exception:
+                prompt = DEFAULT_HYBRID_RERANK_PROMPT.format(**context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)
@@ -191,10 +218,15 @@ class RecommendationService:
             config = self._get_config()
             available_servers = self._mcp_manager.get_available_servers()
 
-            prompt = config.llm_prompt.format(
-                task_description=task_description,
-                available_servers=", ".join(available_servers),
-            )
+            prompt_path = config.llm_prompt_path or "features/recommend_llm"
+            context = {
+                "task_description": task_description,
+                "available_servers": ", ".join(available_servers),
+            }
+            try:
+                prompt = self._loader.render(prompt_path, context)
+            except Exception:
+                prompt = DEFAULT_LLM_PROMPT.format(**context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)