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

gobby/mcp_proxy/tools/spawn_agent.py

@@ -12,7 +12,6 @@ One tool: spawn_agent(prompt, agent="generic", isolation="current"|"worktree"|"c
 from __future__ import annotations
 
 import logging
-import socket
 import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, cast
@@ -22,10 +21,12 @@ from gobby.agents.isolation import (
     SpawnConfig,
     get_isolation_handler,
 )
+from gobby.agents.registry import RunningAgent, get_running_agent_registry
 from gobby.agents.sandbox import SandboxConfig
 from gobby.agents.spawn_executor import SpawnRequest, execute_spawn
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 from gobby.mcp_proxy.tools.tasks import resolve_task_id_for_mcp
+from gobby.utils.machine_id import get_machine_id
 from gobby.utils.project_context import get_project_context
 
 if TYPE_CHECKING:
@@ -264,13 +265,30 @@ async def spawn_agent_impl(
         worktree_id=isolation_ctx.worktree_id,
         clone_id=isolation_ctx.clone_id,
         session_manager=runner._child_session_manager,
-        machine_id=socket.gethostname(),
+        machine_id=get_machine_id() or "unknown",
         sandbox_config=effective_sandbox_config,
     )
 
     spawn_result = await execute_spawn(spawn_request)
 
-    # 11. Return response with isolation metadata
+    # 11. Register with RunningAgentRegistry for send_to_parent/child messaging
+    # Only register if spawn succeeded and we have a valid child_session_id
+    if spawn_result.success and spawn_result.child_session_id is not None:
+        agent_registry = get_running_agent_registry()
+        agent_registry.add(
+            RunningAgent(
+                run_id=spawn_result.run_id,
+                session_id=spawn_result.child_session_id,
+                parent_session_id=parent_session_id,
+                mode=effective_mode,
+                pid=spawn_result.pid,
+                provider=effective_provider,
+                workflow_name=effective_workflow,
+                worktree_id=isolation_ctx.worktree_id,
+            )
+        )
+
+    # 12. Return response with isolation metadata
     return {
         "success": spawn_result.success,
         "run_id": spawn_result.run_id,
@@ -295,6 +313,7 @@ def create_spawn_agent_registry(
     git_manager: Any | None = None,
     clone_storage: Any | None = None,
     clone_manager: Any | None = None,
+    session_manager: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create a spawn_agent tool registry with the unified spawn_agent tool.
@@ -307,10 +326,20 @@ def create_spawn_agent_registry(
         git_manager: Git manager for worktree operations.
         clone_storage: Storage for clone records.
         clone_manager: Git manager for clone operations.
+        session_manager: Session manager for resolving session references.
 
     Returns:
         InternalToolRegistry with spawn_agent tool registered.
     """
+
+    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))
+
     registry = InternalToolRegistry(
         name="gobby-spawn-agent",
         description="Unified agent spawning with isolation support",
@@ -324,7 +353,8 @@ def create_spawn_agent_registry(
         description=(
             "Spawn a subagent to execute a task. Supports isolation modes: "
             "'current' (work in current directory), 'worktree' (create git worktree), "
-            "'clone' (create shallow clone). Can use named agent definitions or raw parameters."
+            "'clone' (create shallow clone). Can use named agent definitions or raw parameters. "
+            "Accepts #N, N, UUID, or prefix for parent_session_id."
         ),
     )
     async def spawn_agent(
@@ -374,12 +404,20 @@ def create_spawn_agent_registry(
             sandbox_mode: Sandbox mode (permissive/restrictive). Overrides agent_def.
             sandbox_allow_network: Allow network access. Overrides agent_def.
             sandbox_extra_paths: Extra paths for sandbox write access.
-            parent_session_id: Parent session ID
+            parent_session_id: Session reference (accepts #N, N, UUID, or prefix) for the parent session
             project_path: Project path override
 
         Returns:
             Dict with success status, run_id, child_session_id, isolation metadata
         """
+        # Resolve parent_session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_parent_session_id = parent_session_id
+        if parent_session_id:
+            try:
+                resolved_parent_session_id = _resolve_session_id(parent_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
         # Load agent definition (defaults to "generic")
         agent_def = loader.load(agent)
         if agent_def is None and agent != "generic":
@@ -410,7 +448,7 @@ def create_spawn_agent_registry(
             sandbox_mode=sandbox_mode,
             sandbox_allow_network=sandbox_allow_network,
             sandbox_extra_paths=sandbox_extra_paths,
-            parent_session_id=parent_session_id,
+            parent_session_id=resolved_parent_session_id,
             project_path=project_path,
         )
 

gobby/mcp_proxy/tools/task_readiness.py

@@ -14,6 +14,7 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+from gobby.storage.sessions import LocalSessionManager
 from gobby.storage.tasks import TaskNotFoundError
 from gobby.utils.project_context import get_project_context
 from gobby.workflows.state_manager import WorkflowStateManager
@@ -227,6 +228,7 @@ def create_readiness_registry(
 
     # Create workflow state manager for session_task scoping
     workflow_state_manager = WorkflowStateManager(task_manager.db)
+    session_manager = LocalSessionManager(task_manager.db)
 
     # --- list_ready_tasks ---
 
@@ -376,7 +378,16 @@ def create_readiness_registry(
 
         # Auto-scope to session_task if session_id is provided and parent_task_id is not set
         if session_id and not parent_task_id:
-            workflow_state = workflow_state_manager.get_state(session_id)
+            # Resolve session_id from #N format to UUID
+            try:
+                resolved_session_id = session_manager.resolve_session_reference(
+                    session_id, project_id
+                )
+            except Exception as e:
+                logger.warning(f"Could not resolve session_id '{session_id}': {e}")
+                resolved_session_id = session_id
+
+            workflow_state = workflow_state_manager.get_state(resolved_session_id)
             if workflow_state:
                 session_task = workflow_state.variables.get("session_task")
                 if session_task and session_task != "*":
@@ -395,6 +406,19 @@ def create_readiness_registry(
             ready_tasks = _get_ready_descendants(
                 task_manager, parent_task_id, task_type, project_id
             )
+            # If no ready descendants, check if the parent task itself is ready
+            # This handles the case where session_task is a leaf task with no children
+            if not ready_tasks:
+                parent_task = task_manager.get_task(parent_task_id)
+                if parent_task and parent_task.status == "open":
+                    # Check if it matches task_type filter
+                    if task_type is None or parent_task.task_type == task_type:
+                        # Check if task is ready by seeing if it appears in ready list
+                        ready_check = task_manager.list_ready_tasks(
+                            project_id=project_id, limit=200
+                        )
+                        if any(t.id == parent_task_id for t in ready_check):
+                            ready_tasks = [parent_task]
         else:
             ready_tasks = task_manager.list_ready_tasks(
                 task_type=task_type, limit=50, project_id=project_id
@@ -492,7 +516,7 @@ def create_readiness_registry(
             "score": best_score,
             "reason": f"Selected because: {', '.join(reasons) if reasons else 'best available option'}",
             "alternatives": [
-                {"ref": t.to_brief()["ref"], "title": t.title, "score": s}
+                {"ref": t.to_brief().get("ref", t.id), "title": t.title, "score": s}
                 for t, s, _, _ in scored[1:4]  # Show top 3 alternatives
             ],
             "recommended_skills": recommended_skills,
@@ -525,10 +549,9 @@ def create_readiness_registry(
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). Used to auto-scope suggestions based on workflow's session_task variable.",
+                    "description": "Your session ID (from system context). When provided, auto-scopes suggestions based on workflow's session_task variable.",
                 },
             },
-            "required": ["session_id"],
         },
         func=suggest_next_task,
     )

gobby/mcp_proxy/tools/tasks/_context.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING
 
 from gobby.storage.projects import LocalProjectManager
 from gobby.storage.session_tasks import SessionTaskManager
+from gobby.storage.sessions import LocalSessionManager
 from gobby.storage.task_dependencies import TaskDependencyManager
 from gobby.storage.tasks import LocalTaskManager
 from gobby.utils.project_context import get_project_context
@@ -42,6 +43,7 @@ class RegistryContext:
     # Derived managers (initialized in __post_init__)
     dep_manager: TaskDependencyManager = field(init=False)
     session_task_manager: SessionTaskManager = field(init=False)
+    session_manager: LocalSessionManager = field(init=False)
     workflow_state_manager: WorkflowStateManager = field(init=False)
     project_manager: LocalProjectManager = field(init=False)
 
@@ -56,6 +58,7 @@ class RegistryContext:
         db = self.task_manager.db
         self.dep_manager = TaskDependencyManager(db)
         self.session_task_manager = SessionTaskManager(db)
+        self.session_manager = LocalSessionManager(db)
         self.workflow_state_manager = WorkflowStateManager(db)
         self.project_manager = LocalProjectManager(db)
 
@@ -90,3 +93,18 @@ class RegistryContext:
         if not session_id:
             return None
         return self.workflow_state_manager.get_state(session_id)
+
+    def resolve_session_id(self, session_id: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID.
+
+        Args:
+            session_id: Session reference string
+
+        Returns:
+            Resolved UUID string
+
+        Raises:
+            ValueError: If session cannot be resolved
+        """
+        project_id = self.get_current_project_id()
+        return self.session_manager.resolve_session_reference(session_id, project_id)

gobby/mcp_proxy/tools/tasks/_crud.py

@@ -90,6 +90,13 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
         if effective_category is None:
             effective_category = _infer_category(title, description)
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError:
+            pass  # Fall back to raw value if resolution fails
+
         # Create task
         create_result = ctx.task_manager.create_task_with_decomposition(
             project_id=project_id,
@@ -101,14 +108,14 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
             labels=labels,
             category=effective_category,
             validation_criteria=validation_criteria,
-            created_in_session_id=session_id,
+            created_in_session_id=resolved_session_id,
         )
 
         task = ctx.task_manager.get_task(create_result["task"]["id"])
 
         # Link task to session (best-effort) - tracks which session created the task
         try:
-            ctx.session_task_manager.link_task(session_id, task.id, "created")
+            ctx.session_task_manager.link_task(resolved_session_id, task.id, "created")
         except Exception:
             pass  # nosec B110 - best-effort linking
 
@@ -116,7 +123,7 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
         if claim:
             updated_task = ctx.task_manager.update_task(
                 task.id,
-                assignee=session_id,
+                assignee=resolved_session_id,
                 status="in_progress",
             )
             if updated_task is None:
@@ -125,14 +132,14 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 task = updated_task
                 # Link task to session with "claimed" action (best-effort)
                 try:
-                    ctx.session_task_manager.link_task(session_id, task.id, "claimed")
+                    ctx.session_task_manager.link_task(resolved_session_id, task.id, "claimed")
                 except Exception:
                     pass  # nosec B110 - best-effort linking
 
             # Set workflow state for Claude Code (CC doesn't include tool results in PostToolUse)
             # This mirrors close_task behavior in _lifecycle.py:196-207
             try:
-                state = ctx.workflow_state_manager.get_state(session_id)
+                state = ctx.workflow_state_manager.get_state(resolved_session_id)
                 if state:
                     state.variables["task_claimed"] = True
                     state.variables["claimed_task_id"] = task.id  # Always use UUID
@@ -248,7 +255,7 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). Required to track which session created the task.",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). Required to track which session created the task.",
                 },
                 "claim": {
                     "type": "boolean",

gobby/mcp_proxy/tools/tasks/_lifecycle.py

@@ -93,13 +93,21 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Auto-skip validation for certain close reasons
         should_skip = skip_validation or reason.lower() in SKIP_REASONS
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        if session_id:
+            try:
+                resolved_session_id = ctx.resolve_session_id(session_id)
+            except ValueError:
+                pass  # Fall back to raw value if resolution fails
+
         # Enforce commits if session had edits
-        if session_id and not should_skip:
+        if resolved_session_id and not should_skip:
             try:
                 from gobby.storage.sessions import LocalSessionManager
 
                 session_manager = LocalSessionManager(ctx.task_manager.db)
-                session = session_manager.get(session_id)
+                session = session_manager.get(resolved_session_id)
 
                 # Check if task has commits (including the one being linked right now)
                 has_commits = bool(task.commits) or bool(commit_sha)
@@ -185,9 +193,9 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
             )
 
             # Auto-link session if provided
-            if session_id:
+            if resolved_session_id:
                 try:
-                    ctx.session_task_manager.link_task(session_id, resolved_id, "review")
+                    ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "review")
                 except Exception:
                     pass  # nosec B110 - best-effort linking
 
@@ -208,15 +216,15 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         ctx.task_manager.close_task(
             resolved_id,
             reason=reason,
-            closed_in_session_id=session_id,
+            closed_in_session_id=resolved_session_id,
             closed_commit_sha=current_commit_sha,
             validation_override_reason=override_justification if store_override else None,
         )
 
         # Auto-link session if provided
-        if session_id:
+        if resolved_session_id:
             try:
-                ctx.session_task_manager.link_task(session_id, resolved_id, "closed")
+                ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "closed")
             except Exception:
                 pass  # nosec B110 - best-effort linking, don't fail the close
 
@@ -224,9 +232,9 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Respects the clear_task_on_close variable (defaults to True if not set)
         # This is done here because Claude Code's post-tool-use hook doesn't include
         # the tool result, so the detection_helpers can't verify close succeeded
-        if session_id:
+        if resolved_session_id:
             try:
-                state = ctx.workflow_state_manager.get_state(session_id)
+                state = ctx.workflow_state_manager.get_state(resolved_session_id)
                 if state and state.variables.get("claimed_task_id") == resolved_id:
                     # Check if clear_task_on_close is enabled (default: True)
                     clear_on_close = state.variables.get("clear_task_on_close", True)
@@ -288,7 +296,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). Pass this to track which session closed the task.",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). Pass this to track which session closed the task.",
                     "default": None,
                 },
                 "override_justification": {
@@ -528,8 +536,15 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         if not task:
             return {"success": False, "error": f"Task {task_id} not found"}
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError:
+            pass  # Fall back to raw value if resolution fails
+
         # Check if already claimed by another session
-        if task.assignee and task.assignee != session_id and not force:
+        if task.assignee and task.assignee != resolved_session_id and not force:
             return {
                 "success": False,
                 "error": "Task already claimed by another session",
@@ -540,7 +555,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Update task with assignee and status in single atomic call
         updated = ctx.task_manager.update_task(
             resolved_id,
-            assignee=session_id,
+            assignee=resolved_session_id,
             status="in_progress",
         )
         if not updated:
@@ -548,7 +563,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
         # Link task to session (best-effort, don't fail the claim if this fails)
         try:
-            ctx.session_task_manager.link_task(session_id, resolved_id, "claimed")
+            ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "claimed")
         except Exception:
             pass  # nosec B110 - best-effort linking
 
@@ -566,7 +581,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). The session claiming the task.",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). The session claiming the task.",
                 },
                 "force": {
                     "type": "boolean",

gobby/mcp_proxy/tools/tasks/_session.py

@@ -40,15 +40,21 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
         except (TaskNotFoundError, ValueError) as e:
             return {"error": str(e)}
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
         try:
-            ctx.session_task_manager.link_task(session_id, resolved_id, action)
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError as e:
+            return {"error": f"Invalid session_id '{session_id}': {e}"}
+
+        try:
+            ctx.session_task_manager.link_task(resolved_session_id, resolved_id, action)
             return {}
         except ValueError as e:
             return {"error": str(e)}
 
     registry.register(
         name="link_task_to_session",
-        description="Link a task to a session.",
+        description="Link a task to a session. Accepts #N, N, UUID, or prefix for session_id.",
         input_schema={
             "type": "object",
             "properties": {
@@ -58,7 +64,7 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Session ID (optional, defaults to linking context if available)",
+                    "description": "Session reference (accepts #N, N, UUID, or prefix)",
                     "default": None,
                 },
                 "action": {
@@ -74,16 +80,25 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
     def get_session_tasks(session_id: str) -> dict[str, Any]:
         """Get all tasks associated with a session."""
-        tasks = ctx.session_task_manager.get_session_tasks(session_id)
-        return {"session_id": session_id, "tasks": tasks}
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError as e:
+            return {"error": f"Invalid session_id '{session_id}': {e}"}
+
+        tasks = ctx.session_task_manager.get_session_tasks(resolved_session_id)
+        return {"session_id": resolved_session_id, "tasks": tasks}
 
     registry.register(
         name="get_session_tasks",
-        description="Get all tasks associated with a session.",
+        description="Get all tasks associated with a session. Accepts #N, N, UUID, or prefix for session_id.",
         input_schema={
             "type": "object",
             "properties": {
-                "session_id": {"type": "string", "description": "Session ID"},
+                "session_id": {
+                    "type": "string",
+                    "description": "Session reference (accepts #N, N, UUID, or prefix)",
+                },
             },
             "required": ["session_id"],
         },