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

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

gobby/mcp_proxy/tools/artifacts.py

@@ -25,6 +25,7 @@ if TYPE_CHECKING:
 def create_artifacts_registry(
     db: LocalDatabase | None = None,
     artifact_manager: LocalArtifactManager | None = None,
+    session_manager: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create an artifacts tool registry with all artifact-related tools.
@@ -32,10 +33,21 @@ def create_artifacts_registry(
     Args:
         db: LocalDatabase instance (used to create artifact_manager if not provided)
         artifact_manager: LocalArtifactManager instance
+        session_manager: Session manager for resolving session references
 
     Returns:
         InternalToolRegistry with artifact 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
+        ctx = get_project_context()
+        project_id = ctx.get("id") if ctx else None
+        return str(session_manager.resolve_session_reference(ref, project_id))
+
     # Create artifact manager if not provided
     if artifact_manager is None:
         if db is None:
@@ -55,7 +67,7 @@ def create_artifacts_registry(
 
     @registry.tool(
         name="search_artifacts",
-        description="Search artifacts by content using full-text search.",
+        description="Search artifacts by content using full-text search. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def search_artifacts(
         query: str,
@@ -68,7 +80,7 @@ def create_artifacts_registry(
 
         Args:
             query: Search query text
-            session_id: Optional session ID to filter by
+            session_id: Optional session reference (accepts #N, N, UUID, or prefix) to filter by
             artifact_type: Optional artifact type to filter by (code, diff, error, etc.)
             limit: Maximum number of results (default: 50)
 
@@ -78,10 +90,18 @@ def create_artifacts_registry(
         if not query or not query.strip():
             return {"success": True, "artifacts": [], "count": 0}
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        if session_id:
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e), "artifacts": []}
+
         try:
             artifacts = _artifact_manager.search_artifacts(
                 query_text=query,
-                session_id=session_id,
+                session_id=resolved_session_id,
                 artifact_type=artifact_type,
                 limit=limit,
             )
@@ -95,7 +115,7 @@ def create_artifacts_registry(
 
     @registry.tool(
         name="list_artifacts",
-        description="List artifacts with optional filters.",
+        description="List artifacts with optional filters. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def list_artifacts(
         session_id: str | None = None,
@@ -107,7 +127,7 @@ def create_artifacts_registry(
         List artifacts with optional filters.
 
         Args:
-            session_id: Optional session ID to filter by
+            session_id: Optional session reference (accepts #N, N, UUID, or prefix) to filter by
             artifact_type: Optional artifact type to filter by
             limit: Maximum number of results (default: 100)
             offset: Offset for pagination (default: 0)
@@ -115,9 +135,17 @@ def create_artifacts_registry(
         Returns:
             Dict with success status and list of artifacts
         """
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        if session_id:
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e), "artifacts": []}
+
         try:
             artifacts = _artifact_manager.list_artifacts(
-                session_id=session_id,
+                session_id=resolved_session_id,
                 artifact_type=artifact_type,
                 limit=limit,
                 offset=offset,
@@ -161,7 +189,7 @@ def create_artifacts_registry(
 
     @registry.tool(
         name="get_timeline",
-        description="Get artifacts for a session in chronological order.",
+        description="Get artifacts for a session in chronological order. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def get_timeline(
         session_id: str | None = None,
@@ -172,7 +200,7 @@ def create_artifacts_registry(
         Get artifacts for a session in chronological order (oldest first).
 
         Args:
-            session_id: Required session ID to get timeline for
+            session_id: Required session reference (accepts #N, N, UUID, or prefix) to get timeline for
             artifact_type: Optional artifact type to filter by
             limit: Maximum number of results (default: 100)
 
@@ -186,10 +214,16 @@ def create_artifacts_registry(
                 "artifacts": [],
             }
 
+        # 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), "artifacts": []}
+
         try:
             # Get artifacts (list_artifacts returns newest first by default)
             artifacts = _artifact_manager.list_artifacts(
-                session_id=session_id,
+                session_id=resolved_session_id,
                 artifact_type=artifact_type,
                 limit=limit,
                 offset=0,