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

gobby/mcp_proxy/tools/sessions/_commits.py

@@ -27,9 +27,18 @@ def register_commits_tools(
         session_manager: LocalSessionManager instance for session operations
     """
 
+    def _resolve_session_id(ref: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+        from gobby.utils.project_context import get_project_context
+
+        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="get_session_commits",
-        description="Get git commits made during a session timeframe.",
+        description="Get git commits made during a session timeframe. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def get_session_commits(
         session_id: str,
@@ -42,7 +51,7 @@ def register_commits_tools(
         git log within that timeframe.
 
         Args:
-            session_id: Session ID
+            session_id: Session reference - supports #N, N (seq_num), UUID, or prefix
             max_commits: Maximum commits to return (default 20)
 
         Returns:
@@ -55,21 +64,15 @@ def register_commits_tools(
         if session_manager is None:
             return {"error": "Session manager not available"}
 
-        # Get session
-        session = session_manager.get(session_id)
+        # Resolve session reference (#N, N, UUID, or prefix)
+        try:
+            resolved_id = _resolve_session_id(session_id)
+            session = session_manager.get(resolved_id)
+        except ValueError as e:
+            return {"error": str(e)}
+
         if not session:
-            # Try prefix match
-            sessions = session_manager.list(limit=100)
-            matches = [s for s in sessions if s.id.startswith(session_id)]
-            if len(matches) == 1:
-                session = matches[0]
-            elif len(matches) > 1:
-                return {
-                    "error": f"Ambiguous session ID prefix '{session_id}'",
-                    "matches": [s.id for s in matches[:5]],
-                }
-            else:
-                return {"error": f"Session {session_id} not found"}
+            return {"error": f"Session {session_id} not found"}
 
         # Get working directory from transcript path or project
         cwd = None
@@ -163,12 +166,12 @@ def register_commits_tools(
 
     @registry.tool(
         name="mark_loop_complete",
-        description="""Mark the autonomous loop as complete, preventing session chaining.
+        description="""Mark the autonomous loop as complete, preventing session chaining. Accepts #N, N, UUID, or prefix for session_id.
 
 Args:
-    session_id: (REQUIRED) Your session ID. Get it from:
-        1. Your injected context (look for 'session_id: xxx')
-        2. Or call get_current(external_id, source) first""",
+    session_id: (REQUIRED) Your session ID. Accepts #N, N, UUID, or prefix. Get it from:
+        1. Your injected context (look for 'Session Ref: #N' or 'session_id: xxx')
+        2. Or call get_current_session(external_id, source) first""",
     )
     def mark_loop_complete(session_id: str) -> dict[str, Any]:
         """
@@ -184,16 +187,20 @@ Args:
         - The user has explicitly asked to stop
 
         Args:
-            session_id: Session ID (REQUIRED)
+            session_id: Session reference - supports #N, N (seq_num), UUID, or prefix (REQUIRED)
 
         Returns:
             Success status and session details
         """
         if not session_manager:
-            raise RuntimeError("Session manager not available")
+            return {"error": "Session manager not available"}
 
-        # Find session - session_id is now required
-        session = session_manager.get(session_id)
+        # Resolve session reference (#N, N, UUID, or prefix)
+        try:
+            resolved_id = _resolve_session_id(session_id)
+            session = session_manager.get(resolved_id)
+        except ValueError as e:
+            return {"error": str(e), "session_id": session_id}
 
         if not session:
             return {"error": f"Session {session_id} not found", "session_id": session_id}

gobby/mcp_proxy/tools/sessions/_crud.py

@@ -2,7 +2,7 @@
 
 This module contains MCP tools for:
 - Getting session details (get_session)
-- Getting current session (get_current)
+- Getting current session (get_current_session)
 - Listing sessions (list_sessions)
 - Session statistics (session_stats)
 """
@@ -71,7 +71,7 @@ def register_crud_tools(
         }
 
     @registry.tool(
-        name="get_current",
+        name="get_current_session",
         description="""Get YOUR current session ID - the CORRECT way to look up your session.
 
 Use this when session_id wasn't in your injected context. Pass your external_id
@@ -79,7 +79,7 @@ Use this when session_id wasn't in your injected context. Pass your external_id
 
 DO NOT use list_sessions to find your session - it won't work with multiple active sessions.""",
     )
-    def get_current(
+    def get_current_session(
         external_id: str,
         source: str,
     ) -> dict[str, Any]:
@@ -148,7 +148,7 @@ DO NOT use list_sessions to find your session - it won't work with multiple acti
 WARNING: Do NOT use this to find your own session_id!
 - `list_sessions(status="active", limit=1)` will NOT reliably return YOUR session
 - Multiple sessions can be active simultaneously (parallel agents, multiple terminals)
-- Use `get_current(external_id, source)` instead - it uses your unique session key
+- Use `get_current_session(external_id, source)` instead - it uses your unique session key
 
 This tool is for browsing/listing sessions, not for self-identification.""",
     )
@@ -192,7 +192,7 @@ This tool is for browsing/listing sessions, not for self-identification.""",
                 "warning": (
                     "list_sessions(status='active', limit=1) will NOT reliably get YOUR session_id! "
                     "Multiple sessions can be active simultaneously. "
-                    "Use get_current(external_id='<your-external-id>', source='claude') instead."
+                    "Use get_current_session(external_id='<your-external-id>', source='claude') instead."
                 ),
                 "hint": "Your external_id is in your transcript path: /path/to/<external_id>.jsonl",
                 "sessions": [s.to_dict() for s in sessions],

gobby/mcp_proxy/tools/sessions/_handoff.py

@@ -123,23 +123,29 @@ def register_handoff_tools(
         registry: The InternalToolRegistry to register tools with
         session_manager: LocalSessionManager instance for session operations
     """
+    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="get_handoff_context",
-        description="Get the handoff context (compact_markdown) for a session. Accepts #N, UUID, or prefix.",
+        description="Get the handoff context (compact_markdown) for a session. Accepts #N, N, UUID, or prefix.",
     )
     def get_handoff_context(session_id: str) -> dict[str, Any]:
         """
         Retrieve stored handoff context.
 
         Args:
-            session_id: Session reference - supports #N (project-scoped), UUID, or prefix
+            session_id: Session reference - supports #N, N (seq_num), UUID, or prefix
 
         Returns:
             Session ID, compact_markdown, and whether context exists
         """
-        from gobby.utils.project_context import get_project_context
-
         if not session_manager:
             raise RuntimeError("Session manager not available")
 
@@ -165,12 +171,12 @@ def register_handoff_tools(
 
     @registry.tool(
         name="create_handoff",
-        description="""Create handoff context by extracting structured data from the session transcript.
+        description="""Create handoff context by extracting structured data from the session transcript. Accepts #N, N, UUID, or prefix for session_id.
 
 Args:
-    session_id: (REQUIRED) Your session ID. Get it from:
-        1. Your injected context (look for 'session_id: xxx')
-        2. Or call get_current(external_id, source) first""",
+    session_id: (REQUIRED) Your session ID. Accepts #N, N, UUID, or prefix. Get it from:
+        1. Your injected context (look for 'Session Ref: #N' or 'session_id: xxx')
+        2. Or call get_current_session(external_id, source) first""",
     )
     async def create_handoff(
         session_id: str,
@@ -187,7 +193,7 @@ Args:
         Always saves to database. Optionally writes to file.
 
         Args:
-            session_id: Session ID (REQUIRED)
+            session_id: Session reference - supports #N, N (seq_num), UUID, or prefix (REQUIRED)
             notes: Additional notes to include in handoff
             compact: Generate compact summary only (default: False, neither = both)
             full: Generate full LLM summary only (default: False, neither = both)
@@ -207,19 +213,12 @@ Args:
         if session_manager is None:
             return {"success": False, "error": "Session manager not available"}
 
-        # Find session - session_id is now required
-        session = session_manager.get(session_id)
-        if not session:
-            # Try prefix match
-            sessions = session_manager.list(limit=100)
-            matches = [s for s in sessions if s.id.startswith(session_id)]
-            if len(matches) == 1:
-                session = matches[0]
-            elif len(matches) > 1:
-                return {
-                    "error": f"Ambiguous session ID prefix '{session_id}'",
-                    "matches": [s.id for s in matches[:5]],
-                }
+        # Resolve session reference (#N, N, UUID, or prefix)
+        try:
+            resolved_id = _resolve_session_id(session_id)
+            session = session_manager.get(resolved_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e), "session_id": session_id}
 
         if not session:
             return {"success": False, "error": "No session found", "session_id": session_id}
@@ -397,7 +396,7 @@ Args:
 
     @registry.tool(
         name="pickup",
-        description="Restore context from a previous session's handoff. For CLIs/IDEs without hooks.",
+        description="Restore context from a previous session's handoff. For CLIs/IDEs without hooks. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def pickup(
         session_id: str | None = None,
@@ -413,10 +412,10 @@ Args:
         for injection into a new session.
 
         Args:
-            session_id: Specific session ID to pickup from (optional)
+            session_id: Session reference - supports #N, N (seq_num), UUID, or prefix (optional)
             project_id: Project ID to find parent session in (optional)
             source: Filter by CLI source - claude_code, gemini, codex (optional)
-            link_child_session_id: If provided, links this session as a child
+            link_child_session_id: Session to link as child - supports #N, N, UUID, or prefix (optional)
 
         Returns:
             Handoff context markdown and session metadata
@@ -428,20 +427,13 @@ Args:
 
         parent_session = None
 
-        # Option 1: Direct session_id lookup
+        # Option 1: Direct session_id lookup with resolution
         if session_id:
-            parent_session = session_manager.get(session_id)
-            if not parent_session:
-                # Try prefix match
-                sessions = session_manager.list(limit=100)
-                matches = [s for s in sessions if s.id.startswith(session_id)]
-                if len(matches) == 1:
-                    parent_session = matches[0]
-                elif len(matches) > 1:
-                    return {
-                        "error": f"Ambiguous session ID prefix '{session_id}'",
-                        "matches": [s.id for s in matches[:5]],
-                    }
+            try:
+                resolved_id = _resolve_session_id(session_id)
+                parent_session = session_manager.get(resolved_id)
+            except ValueError as e:
+                return {"error": str(e)}
 
         # Option 2: Find parent by project_id and source
         if not parent_session and project_id:
@@ -481,9 +473,21 @@ Args:
                 "message": "Session found but has no handoff context",
             }
 
-        # Optionally link child session
+        # Optionally link child session (resolve if using #N format)
+        resolved_child_id = None
         if link_child_session_id:
-            session_manager.update_parent_session_id(link_child_session_id, parent_session.id)
+            try:
+                resolved_child_id = _resolve_session_id(link_child_session_id)
+                session_manager.update_parent_session_id(resolved_child_id, parent_session.id)
+            except ValueError as e:
+                # Do not fallback to raw reference - propagate the error
+                return {
+                    "found": True,
+                    "session_id": parent_session.id,
+                    "has_context": True,
+                    "error": f"Failed to resolve child session '{link_child_session_id}': {e}",
+                    "context": context,
+                }
 
         return {
             "found": True,
@@ -495,5 +499,5 @@ Args:
             ),
             "parent_title": parent_session.title,
             "parent_status": parent_session.status,
-            "linked_child": link_child_session_id,
+            "linked_child": resolved_child_id or link_child_session_id,
         }

gobby/mcp_proxy/tools/sessions/_messages.py

@@ -12,11 +12,13 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from gobby.mcp_proxy.tools.internal import InternalToolRegistry
     from gobby.storage.session_messages import LocalSessionMessageManager
+    from gobby.storage.sessions import LocalSessionManager
 
 
 def register_message_tools(
     registry: InternalToolRegistry,
     message_manager: LocalSessionMessageManager,
+    session_manager: LocalSessionManager | None = None,
 ) -> None:
     """
     Register message retrieval and search tools with a registry.
@@ -24,11 +26,31 @@ def register_message_tools(
     Args:
         registry: The InternalToolRegistry to register tools with
         message_manager: LocalSessionMessageManager instance for message operations
+        session_manager: LocalSessionManager for resolving session references
     """
 
+    def _resolve_session_id(session_id: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID.
+
+        Returns:
+            str: Resolved UUID on success
+
+        Raises:
+            ValueError: If session reference cannot be resolved (when session_manager exists)
+        """
+        if not session_manager:
+            return session_id  # Fall back to raw value if no manager (backward compat)
+
+        from gobby.utils.project_context import get_project_context
+
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+
+        return session_manager.resolve_session_reference(session_id, project_id)
+
     @registry.tool(
         name="get_session_messages",
-        description="Get messages for a session.",
+        description="Get messages for a session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def get_session_messages(
         session_id: str,
@@ -40,7 +62,7 @@ def register_message_tools(
         Get messages for a session.
 
         Args:
-            session_id: The session ID
+            session_id: Session reference - supports #N, N (seq_num), UUID, or prefix
             limit: Max messages to return
             offset: Offset for pagination
             full_content: If True, returns full content. If False (default), truncates large content.
@@ -48,8 +70,10 @@ def register_message_tools(
         try:
             if not message_manager:
                 raise RuntimeError("Message manager not available")
+
+            resolved_id = _resolve_session_id(session_id)
             messages = await message_manager.get_messages(
-                session_id=session_id,
+                session_id=resolved_id,
                 limit=limit,
                 offset=offset,
             )
@@ -79,7 +103,7 @@ def register_message_tools(
                         ):
                             tr["content"] = tr["content"][:200] + "... (truncated)"
 
-            session_total = await message_manager.count_messages(session_id)
+            session_total = await message_manager.count_messages(resolved_id)
 
             return {
                 "success": True,
@@ -95,7 +119,7 @@ def register_message_tools(
 
     @registry.tool(
         name="search_messages",
-        description="Search messages using Full Text Search (FTS).",
+        description="Search messages using Full Text Search (FTS). Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def search_messages(
         query: str,
@@ -108,16 +132,20 @@ def register_message_tools(
 
         Args:
             query: Search query
-            session_id: Optional session filter
+            session_id: Optional session filter - supports #N, N (seq_num), UUID, or prefix
             limit: Max results
             full_content: If True, returns full content. If False (default), truncates large content.
         """
         try:
             if not message_manager:
                 raise RuntimeError("Message manager not available")
+
+            resolved_session_id = None
+            if session_id:
+                resolved_session_id = _resolve_session_id(session_id)
             results = await message_manager.search_messages(
                 query_text=query,
-                session_id=session_id,
+                session_id=resolved_session_id,
                 limit=limit,
             )
 

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/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",