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

gobby/llm/service.py

@@ -6,7 +6,9 @@ Gemini, LiteLLM) based on the multi-provider config structure with feature-speci
 provider routing.
 """
 
+import asyncio
 import logging
+from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -14,6 +16,7 @@ if TYPE_CHECKING:
         DaemonConfig,
     )
     from gobby.llm.base import LLMProvider
+    from gobby.llm.claude import ChatEvent
 
 logger = logging.getLogger(__name__)
 
@@ -234,3 +237,149 @@ class LLMService:
         enabled = self.enabled_providers
         initialized = self.initialized_providers
         return f"LLMService(enabled={enabled}, initialized={initialized})"
+
+    async def stream_chat(
+        self,
+        messages: list[dict[str, str]],
+        provider_name: str | None = None,
+        model: str | None = None,
+    ) -> AsyncIterator[str]:
+        """
+        Stream a chat response from the LLM.
+
+        Takes messages in OpenAI-style format and yields response chunks.
+        Currently simulates streaming by chunking the full response.
+        Real streaming support can be added per-provider later.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content' keys
+            provider_name: Optional provider to use (defaults to default provider)
+            model: Optional model override
+
+        Yields:
+            String chunks of the response
+
+        Example:
+            messages = [
+                {"role": "system", "content": "You are helpful."},
+                {"role": "user", "content": "Hello!"}
+            ]
+            async for chunk in service.stream_chat(messages):
+                print(chunk, end="", flush=True)
+        """
+        # Get provider
+        if provider_name:
+            provider = self.get_provider(provider_name)
+        else:
+            provider = self.get_default_provider()
+
+        # Build prompt from messages
+        system_prompt = None
+        user_messages = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt = content
+            else:
+                prefix = "User: " if role == "user" else "Assistant: "
+                user_messages.append(f"{prefix}{content}")
+
+        prompt = "\n\n".join(user_messages)
+        if user_messages:
+            prompt += "\n\nAssistant:"
+
+        # Generate full response
+        response = await provider.generate_text(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            model=model,
+        )
+
+        # Simulate streaming by yielding words with small delays
+        # This provides a better UX while we add real streaming later
+        words = response.split(" ")
+        for i, word in enumerate(words):
+            if i > 0:
+                yield " "
+            yield word
+            # Small delay to simulate streaming (5-15ms per word)
+            await asyncio.sleep(0.008)
+
+    async def stream_chat_with_tools(
+        self,
+        messages: list[dict[str, str]],
+        allowed_tools: list[str],
+        model: str | None = None,
+        max_turns: int = 10,
+    ) -> AsyncIterator["ChatEvent"]:
+        """
+        Stream a chat response with MCP tool support.
+
+        Takes messages in OpenAI-style format and streams response events
+        including text chunks and tool call/result events.
+
+        This method uses the Claude provider's stream_with_mcp_tools(),
+        which requires subscription mode (Claude Agent SDK).
+
+        Args:
+            messages: List of message dicts with 'role' and 'content' keys
+            allowed_tools: List of allowed MCP tool patterns.
+                Tools should be in format "mcp__{server}__{tool}" or patterns
+                like "mcp__gobby-tasks__*" for all tools from a server.
+            model: Optional model override
+            max_turns: Maximum number of agentic turns (default: 10)
+
+        Yields:
+            ChatEvent: One of TextChunk, ToolCallEvent, ToolResultEvent, or DoneEvent.
+
+        Example:
+            >>> allowed_tools = ["mcp__gobby-tasks__*", "mcp__gobby-memory__*"]
+            >>> async for event in service.stream_chat_with_tools(messages, allowed_tools):
+            ...     if isinstance(event, TextChunk):
+            ...         print(event.content, end="")
+        """
+        from gobby.llm.claude import ClaudeLLMProvider, DoneEvent, TextChunk
+
+        # Get Claude provider (required for MCP tools)
+        try:
+            provider = self.get_provider("claude")
+        except ValueError:
+            yield TextChunk(content="Claude provider not configured. MCP tools require Claude.")
+            yield DoneEvent(tool_calls_count=0)
+            return
+
+        if not isinstance(provider, ClaudeLLMProvider):
+            yield TextChunk(content="MCP tools require Claude provider.")
+            yield DoneEvent(tool_calls_count=0)
+            return
+
+        # Build system prompt and user prompt from messages
+        system_prompt = None
+        user_messages = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt = content
+            else:
+                prefix = "User: " if role == "user" else "Assistant: "
+                user_messages.append(f"{prefix}{content}")
+
+        prompt = "\n\n".join(user_messages)
+        if user_messages:
+            prompt += "\n\nAssistant:"
+
+        # Stream with MCP tools
+        async for event in provider.stream_with_mcp_tools(
+            prompt=prompt,
+            allowed_tools=allowed_tools,
+            system_prompt=system_prompt,
+            model=model,
+            max_turns=max_turns,
+        ):
+            yield event

gobby/mcp_proxy/instructions.py

@@ -6,33 +6,16 @@ These instructions are injected into the MCP server via FastMCP's `instructions`
 
 
 def build_gobby_instructions() -> str:
-    """Build XML-structured instructions for Gobby MCP server.
+    """Build compact instructions for Gobby MCP server.
 
-    These instructions teach agents how to use Gobby correctly.
-    Every agent connecting to Gobby receives these automatically.
-
-    The instructions cover:
-    - Session startup sequence
-    - Progressive tool disclosure pattern
-    - Progressive skill disclosure pattern
-    - Critical rules for task management
+    Provides minimal guidance for progressive tool disclosure, caching, and task rules.
+    Startup sequence and skill discovery are now handled via workflow injection.
 
     Returns:
-        XML-structured instructions string
+        XML-structured instructions string (~120 tokens)
     """
     return """<gobby_system>
 
-<startup>
-At the start of EVERY session:
-1. `list_mcp_servers()` — Discover available servers
-2. `list_skills()` — Discover available skills
-3. Session ID: Look for `Gobby Session Ref:` or `Gobby Session ID:` in your context.
-   If missing, call:
-   `call_tool("gobby-sessions", "get_current_session", {"external_id": "<your-session-id>", "source": "<cli-name>"})`
-
-Session and task references use `#N` format (e.g., `#1`, `#42`) which is project-scoped.
-</startup>
-
 <tool_discovery>
 NEVER assume tool schemas. Use progressive disclosure:
 1. `list_tools(server="...")` — Lightweight metadata (~100 tokens/tool)
@@ -40,12 +23,11 @@ NEVER assume tool schemas. Use progressive disclosure:
 3. `call_tool(server, tool, args)` — Execute
 </tool_discovery>
 
-<skill_discovery>
-Skills provide detailed guidance. Use progressive disclosure:
-1. `list_skills()` — Already done at startup
-2. `get_skill(name="...")` — Full content when needed
-3. `search_skills(query="...")` — Find by task description
-</skill_discovery>
+<caching>
+Schema fetches are cached per session. Once you call `get_tool_schema(server, tool)`,
+you can `call_tool` that same server:tool repeatedly WITHOUT re-fetching the schema.
+Do NOT call list_tools or get_tool_schema before every call_tool — only on first use.
+</caching>
 
 <rules>
 - Create/claim a task before using Edit, Write, or NotebookEdit tools

gobby/mcp_proxy/models.py

@@ -41,6 +41,7 @@ class ToolProxyErrorCode(str, Enum):
     SERVER_NOT_FOUND = "SERVER_NOT_FOUND"
     SERVER_NOT_CONFIGURED = "SERVER_NOT_CONFIGURED"
     TOOL_NOT_FOUND = "TOOL_NOT_FOUND"
+    TOOL_BLOCKED = "TOOL_BLOCKED"
     INVALID_ARGUMENTS = "INVALID_ARGUMENTS"
     EXECUTION_ERROR = "EXECUTION_ERROR"
     CONNECTION_ERROR = "CONNECTION_ERROR"

gobby/mcp_proxy/registries.py

@@ -17,14 +17,18 @@ if TYPE_CHECKING:
     from gobby.memory.manager import MemoryManager
     from gobby.sessions.manager import SessionManager
     from gobby.storage.clones import LocalCloneManager
+    from gobby.storage.database import DatabaseProtocol
     from gobby.storage.inter_session_messages import InterSessionMessageManager
     from gobby.storage.merge_resolutions import MergeResolutionManager
+    from gobby.storage.pipelines import LocalPipelineExecutionManager
     from gobby.storage.session_messages import LocalSessionMessageManager
     from gobby.storage.sessions import LocalSessionManager
     from gobby.storage.tasks import LocalTaskManager
     from gobby.storage.worktrees import LocalWorktreeManager
     from gobby.sync.tasks import TaskSyncManager
     from gobby.tasks.validation import TaskValidator
+    from gobby.workflows.loader import WorkflowLoader
+    from gobby.workflows.pipeline_executor import PipelineExecutor
     from gobby.worktrees.git import WorktreeGitManager
     from gobby.worktrees.merge import MergeResolver
 
@@ -36,6 +40,7 @@ def setup_internal_registries(
     _session_manager: SessionManager | None = None,
     memory_manager: MemoryManager | None = None,
     task_manager: LocalTaskManager | None = None,
+    db: DatabaseProtocol | None = None,
     sync_manager: TaskSyncManager | None = None,
     task_validator: TaskValidator | None = None,
     message_manager: LocalSessionMessageManager | None = None,
@@ -51,6 +56,9 @@ def setup_internal_registries(
     project_id: str | None = None,
     tool_proxy_getter: Callable[[], ToolProxyService | None] | None = None,
     inter_session_message_manager: InterSessionMessageManager | None = None,
+    pipeline_executor: PipelineExecutor | None = None,
+    workflow_loader: WorkflowLoader | None = None,
+    pipeline_execution_manager: LocalPipelineExecutionManager | None = None,
 ) -> InternalRegistryManager:
     """
     Setup internal MCP registries (tasks, messages, memory, metrics, agents, worktrees).
@@ -60,6 +68,7 @@ def setup_internal_registries(
         _session_manager: Session manager (reserved for future use)
         memory_manager: Memory manager for memory operations
         task_manager: Task storage manager
+        db: Database connection for registries that only need storage (skills, artifacts)
         sync_manager: Task sync manager for git sync
         task_validator: Task validator for validation
         message_manager: Message storage manager
@@ -75,6 +84,9 @@ def setup_internal_registries(
         tool_proxy_getter: Callable that returns ToolProxyService for routing
             tool calls in in-process agents. Called lazily during agent execution.
         inter_session_message_manager: Inter-session message manager for agent messaging
+        pipeline_executor: Pipeline executor for running pipelines
+        workflow_loader: Workflow loader for loading pipeline definitions
+        pipeline_execution_manager: Pipeline execution manager for tracking executions
 
     Returns:
         InternalRegistryManager containing all registries
@@ -191,6 +203,9 @@ def setup_internal_registries(
             git_manager=git_manager,
             clone_storage=clone_storage,
             clone_manager=clone_git_manager,
+            # For mode=self (workflow activation on caller session)
+            workflow_loader=workflow_loader,
+            db=db,
         )
 
         # Add inter-agent messaging tools if message manager and session manager are available
@@ -268,32 +283,64 @@ def setup_internal_registries(
         manager.add_registry(hub_registry)
         logger.debug("Hub registry initialized")
 
-    # Initialize skills registry using the existing database from task_manager
-    # to avoid creating a duplicate connection that would leak
-    if task_manager is not None:
+    # Initialize skills registry if database is available
+    if db is not None:
+        from gobby.config.skills import SkillsConfig
         from gobby.mcp_proxy.tools.skills import create_skills_registry
+        from gobby.skills.hubs import (
+            ClaudePluginsProvider,
+            ClawdHubProvider,
+            GitHubCollectionProvider,
+            HubManager,
+            SkillHubProvider,
+        )
+
+        # Get skills config (or use defaults)
+        skills_config = _config.skills if _config and hasattr(_config, "skills") else SkillsConfig()
+
+        # Create hub manager with configured hubs
+        hub_manager = HubManager(configs=skills_config.hubs)
+
+        # Register provider factories
+        hub_manager.register_provider_factory("clawdhub", ClawdHubProvider)
+        hub_manager.register_provider_factory("skillhub", SkillHubProvider)
+        hub_manager.register_provider_factory("github-collection", GitHubCollectionProvider)
+        hub_manager.register_provider_factory("claude-plugins", ClaudePluginsProvider)
 
         skills_registry = create_skills_registry(
-            db=task_manager.db,
+            db=db,
             project_id=project_id,
+            hub_manager=hub_manager,
         )
         manager.add_registry(skills_registry)
         logger.debug("Skills registry initialized")
     else:
-        logger.debug("Skills registry not initialized: task_manager is None")
+        logger.debug("Skills registry not initialized: db is None")
 
-    # Initialize artifacts registry using the existing database from task_manager
-    if task_manager is not None:
+    # Initialize artifacts registry if database is available
+    if db is not None:
         from gobby.mcp_proxy.tools.artifacts import create_artifacts_registry
 
         artifacts_registry = create_artifacts_registry(
-            db=task_manager.db,
+            db=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.debug("Artifacts registry not initialized: db is None")
+
+    # Initialize pipelines registry if pipeline_executor is available
+    if pipeline_executor is not None:
+        from gobby.mcp_proxy.tools.pipelines import create_pipelines_registry
+
+        pipelines_registry = create_pipelines_registry(
+            loader=workflow_loader,
+            executor=pipeline_executor,
+            execution_manager=pipeline_execution_manager,
+        )
+        manager.add_registry(pipelines_registry)
+        logger.debug("Pipelines registry initialized")
 
     logger.info(f"Internal registries initialized: {len(manager)} registries")
     return manager

gobby/mcp_proxy/server.py

@@ -98,6 +98,7 @@ class GobbyDaemonTools:
         server_name: str,
         tool_name: str,
         arguments: dict[str, Any] | None = None,
+        session_id: str | None = None,
     ) -> Any:
         """Call a tool.
 
@@ -105,8 +106,11 @@ class GobbyDaemonTools:
         underlying service indicates an error. This ensures the MCP protocol
         properly signals errors to LLM clients instead of returning error dicts
         as successful responses.
+
+        When session_id is provided and a workflow is active, checks that the
+        tool is not blocked by the current workflow step's blocked_tools setting.
         """
-        result = await self.tool_proxy.call_tool(server_name, tool_name, arguments)
+        result = await self.tool_proxy.call_tool(server_name, tool_name, arguments, session_id)
 
         # Check if result indicates an error (ToolProxyService returns dict with success: False)
         if isinstance(result, dict) and result.get("success") is False:
@@ -382,7 +386,7 @@ class GobbyDaemonTools:
 
         Args:
             event_type: Hook event type (e.g., "session_start", "before_tool")
-            source: Source CLI to simulate (claude, gemini, codex)
+            source: Source CLI to simulate (claude, gemini, codex, cursor, windsurf, copilot)
             data: Optional additional data for the event
 
         Returns:

gobby/mcp_proxy/services/tool_filter.py

@@ -4,6 +4,8 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from gobby.workflows.definitions import WorkflowDefinition
+
 if TYPE_CHECKING:
     from gobby.storage.database import LocalDatabase
     from gobby.workflows.loader import WorkflowLoader
@@ -89,6 +91,11 @@ class ToolFilterService:
             logger.warning(f"Workflow '{state.workflow_name}' not found")
             return None
 
+        # Tool filtering only applies to step-based workflows
+        if not isinstance(definition, WorkflowDefinition):
+            logger.debug(f"Workflow '{state.workflow_name}' is not a step-based workflow")
+            return None
+
         step = definition.get_step(state.step)
         if not step:
             logger.warning(f"Step '{state.step}' not found in workflow '{state.workflow_name}'")

gobby/mcp_proxy/services/tool_proxy.py

@@ -208,6 +208,7 @@ class ToolProxyService:
         server_name: str,
         tool_name: str,
         arguments: dict[str, Any] | None = None,
+        session_id: str | None = None,
     ) -> Any:
         """Execute a tool with optional pre-validation.
 
@@ -218,9 +219,24 @@ class ToolProxyService:
         On execution error, includes fallback_suggestions if a fallback resolver
         is configured.
 
+        When session_id is provided and a workflow is active, checks that the
+        tool is not blocked by the current workflow step's blocked_tools setting.
+
         """
         args = arguments or {}
 
+        # Check workflow tool restrictions if session_id provided
+        if session_id and self._tool_filter:
+            is_allowed, reason = self._tool_filter.is_tool_allowed(tool_name, session_id)
+            if not is_allowed:
+                return {
+                    "success": False,
+                    "error": reason,
+                    "error_code": ToolProxyErrorCode.TOOL_BLOCKED.value,
+                    "server_name": server_name,
+                    "tool_name": tool_name,
+                }
+
         # Pre-validate arguments if enabled
         if self._validate_arguments and args:
             schema_result = await self.get_tool_schema(server_name, tool_name)
@@ -361,6 +377,7 @@ class ToolProxyService:
         self,
         tool_name: str,
         arguments: dict[str, Any] | None = None,
+        session_id: str | None = None,
     ) -> Any:
         """
         Call a tool by name, automatically resolving the server.
@@ -371,6 +388,7 @@ class ToolProxyService:
         Args:
             tool_name: Name of the tool to call
             arguments: Tool arguments
+            session_id: Optional session ID for workflow tool restriction checks
 
         Returns:
             Tool execution result, or error dict if tool not found
@@ -386,4 +404,4 @@ class ToolProxyService:
             }
 
         logger.debug(f"Routing tool '{tool_name}' to server '{server_name}'")
-        return await self.call_tool(server_name, tool_name, arguments)
+        return await self.call_tool(server_name, tool_name, arguments, session_id)

gobby/mcp_proxy/stdio.py

@@ -116,6 +116,16 @@ class DaemonProxy:
             "validate_task",
         ):
             timeout = 300.0
+        # Wait tools: use the requested timeout plus a buffer
+        elif tool_name in (
+            "wait_for_task",
+            "wait_for_any_task",
+            "wait_for_all_tasks",
+        ):
+            # Extract timeout from arguments, default to 300s if not specified
+            arg_timeout = float((arguments or {}).get("timeout", 300.0))
+            # Add 30s buffer for HTTP overhead
+            timeout = arg_timeout + 30.0
 
         return await self._request(
             "POST",
@@ -242,13 +252,15 @@ class DaemonProxy:
             },
         )
 
-    async def init_project(
-        self, name: str | None = None, github_url: str | None = None
-    ) -> dict[str, Any]:
-        """Initialize a project - use 'gobby init' CLI command instead."""
+    async def init_project(self, name: str, project_path: str | None = None) -> dict[str, Any]:
+        """Initialize a new Gobby project.
+
+        Note: Project initialization requires CLI access and cannot be done
+        via the MCP proxy. Use 'gobby init' command instead.
+        """
         return {
             "success": False,
-            "error": "init_project requires CLI access. Run 'gobby init' from your terminal.",
+            "error": "Project initialization requires CLI access. Use 'gobby init' command instead.",
         }
 
 
@@ -410,22 +422,6 @@ def register_proxy_tools(mcp: FastMCP, proxy: DaemonProxy) -> None:
             cwd=cwd,
         )
 
-    @mcp.tool()
-    async def init_project(
-        name: str | None = None, github_url: str | None = None
-    ) -> dict[str, Any]:
-        """
-        Initialize a new Gobby project in the current directory.
-
-        Args:
-            name: Optional project name (auto-detected from directory name if not provided)
-            github_url: Optional GitHub URL (auto-detected from git remote if not provided)
-
-        Returns:
-            Dict with success status and project details
-        """
-        return await proxy.init_project(name, github_url)
-
     @mcp.tool()
     async def add_mcp_server(
         name: str,
@@ -503,6 +499,26 @@ def register_proxy_tools(mcp: FastMCP, proxy: DaemonProxy) -> None:
             query=query,
         )
 
+    @mcp.tool()
+    async def init_project(
+        name: str,
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Initialize a new Gobby project.
+
+        Note: Project initialization requires CLI access and cannot be done
+        via the MCP proxy. Use 'gobby init' command instead.
+
+        Args:
+            name: Project name
+            project_path: Path to project directory (optional)
+
+        Returns:
+            Result dict with error (CLI access required)
+        """
+        return await proxy.init_project(name, project_path)
+
 
 async def ensure_daemon_running() -> None:
     """Ensure the Gobby daemon is running and healthy."""

gobby/mcp_proxy/tools/agents.py

@@ -40,6 +40,9 @@ def create_agents_registry(
     git_manager: Any | None = None,
     clone_storage: Any | None = None,
     clone_manager: Any | None = None,
+    # For mode=self (workflow activation on caller session)
+    workflow_loader: Any | None = None,
+    db: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create an agent tool registry with all agent-related tools.
@@ -430,6 +433,10 @@ def create_agents_registry(
         clone_storage=clone_storage,
         clone_manager=clone_manager,
         session_manager=session_manager,
+        workflow_loader=workflow_loader,
+        # For mode=self (workflow activation on caller session)
+        state_manager=workflow_state_manager,
+        db=db,
     )
 
     # Merge spawn_agent tools into agents registry

gobby/mcp_proxy/tools/hub.py

@@ -45,7 +45,7 @@ def create_hub_registry(
     """
     registry = HubToolRegistry(
         name="gobby-hub",
-        description="Hub (cross-project) queries - list_all_projects, list_cross_project_tasks, list_cross_project_sessions, hub_stats",
+        description="Hub (cross-project) queries and system info - get_machine_id, list_all_projects, list_cross_project_tasks, list_cross_project_sessions, hub_stats",
     )
 
     def _get_hub_db() -> LocalDatabase | None:
@@ -54,6 +54,35 @@ def create_hub_registry(
             return None
         return LocalDatabase(hub_db_path)
 
+    @registry.tool(
+        name="get_machine_id",
+        description="Get the daemon's machine identifier. Use this from sandboxed agents that cannot read ~/.gobby/machine_id directly.",
+    )
+    async def get_machine_id() -> dict[str, Any]:
+        """
+        Get the machine identifier used by this Gobby daemon.
+
+        The machine_id is stored in ~/.gobby/machine_id and is generated
+        once on first daemon run. This tool provides read-only access to
+        the daemon's authoritative machine_id.
+
+        Returns:
+            Dict with machine_id or error if not found.
+        """
+        from gobby.utils.machine_id import get_machine_id as _get_machine_id
+
+        machine_id = _get_machine_id()
+        if machine_id:
+            return {
+                "success": True,
+                "machine_id": machine_id,
+            }
+
+        return {
+            "success": False,
+            "error": "machine_id not found - daemon may not have initialized properly",
+        }
+
     @registry.tool(
         name="list_all_projects",
         description="List all unique projects in the hub database.",

gobby/mcp_proxy/tools/orchestration/cleanup.py

@@ -38,7 +38,7 @@ def register_cleanup(
         """
         Approve a reviewed task and clean up its worktree.
 
-        This tool transitions a task from "review" to "closed" status
+        This tool transitions a task from "needs_review" to "closed" status
         and optionally deletes the associated worktree.
 
         Args:
@@ -71,11 +71,11 @@ def register_cleanup(
                 "error": f"Task not found: {task_id}",
             }
 
-        # Verify task is in review status
-        if task.status != "review":
+        # Verify task is in needs_review status
+        if task.status != "needs_review":
             return {
                 "success": False,
-                "error": f"Task must be in 'review' status to approve. Current status: {task.status}",
+                "error": f"Task must be in 'needs_review' status to approve. Current status: {task.status}",
             }
 
         # Get associated worktree (if any)
@@ -148,7 +148,7 @@ def register_cleanup(
         name="approve_and_cleanup",
         description=(
             "Approve a reviewed task and clean up its worktree. "
-            "Transitions task from 'review' to 'closed' status and deletes worktree."
+            "Transitions task from 'needs_review' to 'closed' status and deletes worktree."
         ),
         input_schema={
             "type": "object",

gobby/mcp_proxy/tools/orchestration/monitor.py

@@ -101,7 +101,7 @@ def register_monitor(
                 closed_tasks.append(task_info)
             elif task.status == "in_progress":
                 in_progress_tasks.append(task_info)
-            elif task.status == "review":
+            elif task.status == "needs_review":
                 review_tasks.append(task_info)
             else:
                 open_tasks.append(task_info)