gobby 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

gobby/mcp_proxy/registries.py

@@ -143,6 +143,7 @@ def setup_internal_registries(
 
     workflows_registry = create_workflows_registry(
         session_manager=local_session_manager,
+        db=getattr(local_session_manager, "db", None) if local_session_manager else None,
     )
     manager.add_registry(workflows_registry)
     logger.debug("Workflows registry initialized")
@@ -168,21 +169,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,
+            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")
 
@@ -264,6 +282,19 @@ def setup_internal_registries(
     else:
         logger.debug("Skills registry not initialized: task_manager is None")
 
+    # Initialize artifacts registry using the existing database from task_manager
+    if task_manager is not None:
+        from gobby.mcp_proxy.tools.artifacts import create_artifacts_registry
+
+        artifacts_registry = create_artifacts_registry(
+            db=task_manager.db,
+            session_manager=local_session_manager,
+        )
+        manager.add_registry(artifacts_registry)
+        logger.debug("Artifacts registry initialized")
+    else:
+        logger.debug("Artifacts registry not initialized: task_manager is None")
+
     logger.info(f"Internal registries initialized: {len(manager)} registries")
     return manager
 

gobby/mcp_proxy/services/recommendation.py

@@ -15,22 +15,6 @@ 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."""
@@ -49,10 +33,6 @@ class RecommendationService:
         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."""
@@ -181,10 +161,7 @@ class RecommendationService:
                 "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)
+            prompt = self._loader.render(prompt_path, context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)
@@ -223,10 +200,7 @@ class RecommendationService:
                 "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)
+            prompt = self._loader.render(prompt_path, context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)

gobby/mcp_proxy/tools/agent_messaging.py

@@ -6,9 +6,10 @@ Provides messaging capabilities between parent and child sessions:
 - send_to_child: Parent sends message to a specific child
 - poll_messages: Check for incoming messages
 - mark_message_read: Mark a message as read
-- broadcast_to_children: Send message to all running children
+- broadcast_to_children: Send message to all children (active in database)
 
-These tools resolve session relationships from RunningAgentRegistry.
+These tools resolve session relationships from the database (LocalSessionManager),
+which is the authoritative source for parent_session_id relationships.
 """
 
 from __future__ import annotations
@@ -17,9 +18,9 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from gobby.agents.registry import RunningAgentRegistry
     from gobby.mcp_proxy.tools.internal import InternalToolRegistry
     from gobby.storage.inter_session_messages import InterSessionMessageManager
+    from gobby.storage.sessions import LocalSessionManager
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +28,7 @@ logger = logging.getLogger(__name__)
 def add_messaging_tools(
     registry: InternalToolRegistry,
     message_manager: InterSessionMessageManager,
-    agent_registry: RunningAgentRegistry,
+    session_manager: LocalSessionManager,
 ) -> None:
     """
     Add inter-agent messaging tools to an existing registry.
@@ -35,12 +36,20 @@ def add_messaging_tools(
     Args:
         registry: The InternalToolRegistry to add tools to (typically gobby-agents)
         message_manager: InterSessionMessageManager for persisting messages
-        agent_registry: RunningAgentRegistry for resolving parent/child relationships
+        session_manager: LocalSessionManager for resolving parent/child relationships
+            (database is the authoritative source for session relationships)
     """
+    from gobby.utils.project_context import get_project_context
+
+    def _resolve_session_id(ref: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+        return session_manager.resolve_session_reference(ref, project_id)
 
     @registry.tool(
         name="send_to_parent",
-        description="Send a message from a child session to its parent session.",
+        description="Send a message from a child session to its parent session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def send_to_parent(
         session_id: str,
@@ -54,7 +63,7 @@ def add_messaging_tools(
         or requests back to its parent session.
 
         Args:
-            session_id: The current (child) session ID
+            session_id: Session reference (accepts #N, N, UUID, or prefix) for the current (child) session
             content: Message content to send
             priority: Message priority ("normal" or "urgent")
 
@@ -62,30 +71,41 @@ def add_messaging_tools(
             Dict with success status and message details
         """
         try:
-            # Find the running agent to get parent relationship
-            agent = agent_registry.get_by_session(session_id)
-            if not agent:
+            # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
+            # Look up session in database (authoritative source for relationships)
+            session = session_manager.get(resolved_session_id)
+            if not session:
                 return {
                     "success": False,
-                    "error": f"Session {session_id} not found in running agent registry",
+                    "error": f"Session {resolved_session_id} not found",
                 }
 
-            parent_session_id = agent.parent_session_id
+            parent_session_id = session.parent_session_id
             if not parent_session_id:
                 return {
                     "success": False,
-                    "error": "No parent session found for this agent",
+                    "error": "No parent session for this session",
                 }
 
             # Create the message
             msg = message_manager.create_message(
-                from_session=session_id,
+                from_session=resolved_session_id,
                 to_session=parent_session_id,
                 content=content,
                 priority=priority,
             )
 
-            logger.info(f"Message sent from {session_id} to parent {parent_session_id}: {msg.id}")
+            logger.info(
+                "Message sent from %s to parent %s: %s",
+                resolved_session_id,
+                parent_session_id,
+                msg.id,
+            )
 
             return {
                 "success": True,
@@ -94,7 +114,7 @@ def add_messaging_tools(
             }
 
         except Exception as e:
-            logger.error(f"Failed to send message to parent: {e}")
+            logger.error("Failed to send message to parent: %s", e)
             return {
                 "success": False,
                 "error": str(e),
@@ -102,7 +122,7 @@ def add_messaging_tools(
 
     @registry.tool(
         name="send_to_child",
-        description="Send a message from a parent session to a specific child session.",
+        description="Send a message from a parent session to a specific child session. Accepts #N, N, UUID, or prefix for session IDs.",
     )
     async def send_to_child(
         parent_session_id: str,
@@ -117,8 +137,8 @@ def add_messaging_tools(
         updates, or coordination messages to a spawned child.
 
         Args:
-            parent_session_id: The parent session ID (sender)
-            child_session_id: The child session ID (recipient)
+            parent_session_id: Session reference (accepts #N, N, UUID, or prefix) for the parent (sender)
+            child_session_id: Session reference (accepts #N, N, UUID, or prefix) for the child (recipient)
             content: Message content to send
             priority: Message priority ("normal" or "urgent")
 
@@ -126,33 +146,43 @@ def add_messaging_tools(
             Dict with success status and message details
         """
         try:
-            # Verify the child exists and belongs to this parent
-            child_agent = agent_registry.get_by_session(child_session_id)
-            if not child_agent:
+            # Resolve session IDs to UUIDs (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_parent_id = _resolve_session_id(parent_session_id)
+                resolved_child_id = _resolve_session_id(child_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
+            # Verify the child exists in database and belongs to this parent
+            child_session = session_manager.get(resolved_child_id)
+            if not child_session:
                 return {
                     "success": False,
-                    "error": f"Child session {child_session_id} not found in running agent registry",
+                    "error": f"Child session {resolved_child_id} not found",
                 }
 
-            if child_agent.parent_session_id != parent_session_id:
+            if child_session.parent_session_id != resolved_parent_id:
                 return {
                     "success": False,
                     "error": (
-                        f"Session {child_session_id} is not a child of {parent_session_id}. "
-                        f"Actual parent: {child_agent.parent_session_id}"
+                        f"Session {resolved_child_id} is not a child of {resolved_parent_id}. "
+                        f"Actual parent: {child_session.parent_session_id}"
                     ),
                 }
 
             # Create the message
             msg = message_manager.create_message(
-                from_session=parent_session_id,
-                to_session=child_session_id,
+                from_session=resolved_parent_id,
+                to_session=resolved_child_id,
                 content=content,
                 priority=priority,
             )
 
             logger.info(
-                f"Message sent from {parent_session_id} to child {child_session_id}: {msg.id}"
+                "Message sent from %s to child %s: %s",
+                resolved_parent_id,
+                resolved_child_id,
+                msg.id,
             )
 
             return {
@@ -161,7 +191,7 @@ def add_messaging_tools(
             }
 
         except Exception as e:
-            logger.error(f"Failed to send message to child: {e}")
+            logger.error("Failed to send message to child: %s", e)
             return {
                 "success": False,
                 "error": str(e),
@@ -169,7 +199,7 @@ def add_messaging_tools(
 
     @registry.tool(
         name="poll_messages",
-        description="Poll for messages sent to this session.",
+        description="Poll for messages sent to this session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def poll_messages(
         session_id: str,
@@ -182,15 +212,21 @@ def add_messaging_tools(
         By default, returns only unread messages.
 
         Args:
-            session_id: The session ID to check messages for
+            session_id: Session reference (accepts #N, N, UUID, or prefix) to check messages for
             unread_only: If True, only return unread messages (default: True)
 
         Returns:
             Dict with success status and list of messages
         """
         try:
+            # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
             messages = message_manager.get_messages(
-                to_session=session_id,
+                to_session=resolved_session_id,
                 unread_only=unread_only,
             )
 
@@ -248,7 +284,7 @@ def add_messaging_tools(
 
     @registry.tool(
         name="broadcast_to_children",
-        description="Broadcast a message to all running child sessions.",
+        description="Broadcast a message to all active child sessions. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def broadcast_to_children(
         parent_session_id: str,
@@ -256,13 +292,14 @@ def add_messaging_tools(
         priority: str = "normal",
     ) -> dict[str, Any]:
         """
-        Broadcast a message to all running children.
+        Broadcast a message to all active children.
 
-        Send the same message to all child sessions spawned by this parent.
+        Send the same message to all child sessions spawned by this parent
+        that are currently active in the database.
         Useful for coordination or shutdown signals.
 
         Args:
-            parent_session_id: The parent session ID
+            parent_session_id: Session reference (accepts #N, N, UUID, or prefix) for the parent
             content: Message content to broadcast
             priority: Message priority ("normal" or "urgent")
 
@@ -270,13 +307,22 @@ def add_messaging_tools(
             Dict with success status and count of messages sent
         """
         try:
-            children = agent_registry.list_by_parent(parent_session_id)
+            # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_parent_id = _resolve_session_id(parent_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
+            # Get all children from database
+            all_children = session_manager.find_children(resolved_parent_id)
+            # Filter to active children only
+            children = [c for c in all_children if c.status == "active"]
 
             if not children:
                 return {
                     "success": True,
                     "sent_count": 0,
-                    "message": "No running children found",
+                    "message": "No active children found",
                 }
 
             sent_count = 0
@@ -285,14 +331,14 @@ def add_messaging_tools(
             for child in children:
                 try:
                     message_manager.create_message(
-                        from_session=parent_session_id,
-                        to_session=child.session_id,
+                        from_session=resolved_parent_id,
+                        to_session=child.id,
                         content=content,
                         priority=priority,
                     )
                     sent_count += 1
                 except Exception as e:
-                    errors.append(f"{child.session_id}: {e}")
+                    errors.append(f"{child.id}: {e}")
 
             result: dict[str, Any] = {
                 "success": True,
@@ -304,13 +350,16 @@ def add_messaging_tools(
                 result["errors"] = errors
 
             logger.info(
-                f"Broadcast from {parent_session_id} sent to {sent_count}/{len(children)} children"
+                "Broadcast from %s sent to %d/%d children",
+                resolved_parent_id,
+                sent_count,
+                len(children),
             )
 
             return result
 
         except Exception as e:
-            logger.error(f"Failed to broadcast to children: {e}")
+            logger.error("Failed to broadcast to children: %s", e)
             return {
                 "success": False,
                 "error": str(e),

gobby/mcp_proxy/tools/agents.py

@@ -32,6 +32,7 @@ def create_agents_registry(
     runner: AgentRunner,
     running_registry: RunningAgentRegistry | None = None,
     workflow_state_manager: Any | None = None,
+    session_manager: Any | None = None,
     # spawn_agent dependencies
     agent_loader: Any | None = None,
     task_manager: Any | None = None,
@@ -48,6 +49,7 @@ def create_agents_registry(
         running_registry: Optional in-memory registry for running agents.
         workflow_state_manager: Optional WorkflowStateManager for stopping workflows
             when agents are killed. If not provided, workflow stop will be skipped.
+        session_manager: Optional LocalSessionManager for resolving session references.
         agent_loader: Agent definition loader for spawn_agent.
         task_manager: Task manager for spawn_agent task resolution.
         worktree_storage: Worktree storage for spawn_agent isolation.
@@ -58,6 +60,16 @@ def create_agents_registry(
     Returns:
         InternalToolRegistry with all agent tools registered.
     """
+    from gobby.utils.project_context import get_project_context
+
+    def _resolve_session_id(ref: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+        if session_manager is None:
+            return ref  # No resolution available, return as-is
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+        return str(session_manager.resolve_session_reference(ref, project_id))
+
     registry = InternalToolRegistry(
         name="gobby-agents",
         description="Agent spawning - start, monitor, and manage subagents",
@@ -105,7 +117,7 @@ def create_agents_registry(
 
     @registry.tool(
         name="list_agents",
-        description="List agent runs for a session.",
+        description="List agent runs for a session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def list_agents(
         parent_session_id: str,
@@ -116,14 +128,20 @@ def create_agents_registry(
         List agent runs for a session.
 
         Args:
-            parent_session_id: The parent session ID.
+            parent_session_id: Session reference (accepts #N, N, UUID, or prefix) for the parent.
             status: Optional status filter (pending, running, success, error, timeout, cancelled).
             limit: Maximum results (default: 20).
 
         Returns:
             Dict with list of agent runs.
         """
-        runs = runner.list_runs(parent_session_id, status=status, limit=limit)
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_parent_id = _resolve_session_id(parent_session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
+        runs = runner.list_runs(resolved_parent_id, status=status, limit=limit)
 
         return {
             "success": True,
@@ -221,6 +239,12 @@ def create_agents_registry(
         agent = agent_registry.get(run_id)
         session_id = agent.session_id if agent else None
 
+        # Database fallback: if not in registry, look up from DB
+        if session_id is None:
+            db_run = runner.get_run(run_id)
+            if db_run and db_run.child_session_id:
+                session_id = db_run.child_session_id
+
         # Kill via registry (run in thread to avoid blocking event loop)
         import asyncio
 
@@ -245,7 +269,7 @@ def create_agents_registry(
 
     @registry.tool(
         name="can_spawn_agent",
-        description="Check if an agent can be spawned from the current session.",
+        description="Check if an agent can be spawned from the current session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def can_spawn_agent(parent_session_id: str) -> dict[str, Any]:
         """
@@ -254,12 +278,18 @@ def create_agents_registry(
         This checks the agent depth limit to prevent infinite nesting.
 
         Args:
-            parent_session_id: The session that would spawn the agent.
+            parent_session_id: Session reference (accepts #N, N, UUID, or prefix) for the session that would spawn the agent.
 
         Returns:
             Dict with can_spawn boolean and reason.
         """
-        can_spawn, reason, _parent_depth = runner.can_spawn(parent_session_id)
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_parent_id = _resolve_session_id(parent_session_id)
+        except ValueError as e:
+            return {"can_spawn": False, "reason": str(e)}
+
+        can_spawn, reason, _parent_depth = runner.can_spawn(resolved_parent_id)
         return {
             "can_spawn": can_spawn,
             "reason": reason,
@@ -267,7 +297,7 @@ def create_agents_registry(
 
     @registry.tool(
         name="list_running_agents",
-        description="List all currently running agents (in-memory process state).",
+        description="List all currently running agents (in-memory process state). Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def list_running_agents(
         parent_session_id: str | None = None,
@@ -280,14 +310,19 @@ def create_agents_registry(
         including PIDs and process handles not stored in the database.
 
         Args:
-            parent_session_id: Optional filter by parent session.
+            parent_session_id: Optional session reference (accepts #N, N, UUID, or prefix) to filter by parent.
             mode: Optional filter by execution mode (terminal, embedded, headless).
 
         Returns:
             Dict with list of running agents.
         """
         if parent_session_id:
-            agents = agent_registry.list_by_parent(parent_session_id)
+            # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_parent_id = _resolve_session_id(parent_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+            agents = agent_registry.list_by_parent(resolved_parent_id)
         elif mode:
             agents = agent_registry.list_by_mode(mode)
         else:
@@ -394,6 +429,7 @@ def create_agents_registry(
         git_manager=git_manager,
         clone_storage=clone_storage,
         clone_manager=clone_manager,
+        session_manager=session_manager,
     )
 
     # Merge spawn_agent tools into agents registry