gobby 0.2.5__py3-none-any.whl

gobby/workflows/detection_helpers.py

@@ -0,0 +1,208 @@
+"""
+Detection helper functions for workflow engine.
+
+Extracted from engine.py to reduce complexity.
+These functions detect specific events (task claims, plan mode, MCP calls)
+and update workflow state variables accordingly.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from gobby.hooks.events import HookEvent
+    from gobby.tasks.session_tasks import SessionTaskManager
+
+    from .definitions import WorkflowState
+
+logger = logging.getLogger(__name__)
+
+
+def detect_task_claim(
+    event: "HookEvent",
+    state: "WorkflowState",
+    session_task_manager: "SessionTaskManager | None" = None,
+) -> None:
+    """Detect gobby-tasks calls that claim or release a task for this session.
+
+    Sets `task_claimed: true` in workflow state variables when the agent
+    successfully creates a task or updates a task to in_progress status.
+
+    Clears `task_claimed: false` when the agent closes a task, requiring
+    them to claim another task before making further file modifications.
+
+    This enables session-scoped task enforcement where each session must
+    explicitly claim a task rather than free-riding on project-wide checks.
+
+    Args:
+        event: The AFTER_TOOL hook event
+        state: Current workflow state (modified in place)
+        session_task_manager: Optional manager for auto-linking tasks to sessions
+    """
+    if not event.data:
+        return
+
+    tool_name = event.data.get("tool_name", "")
+    tool_input = event.data.get("tool_input", {}) or {}
+    tool_output = event.data.get("tool_output", {}) or {}
+
+    # Check if this is a gobby-tasks call via MCP proxy
+    # Tool name could be "call_tool" (from legacy) or "mcp__gobby__call_tool" (direct)
+    if tool_name not in ("call_tool", "mcp__gobby__call_tool"):
+        return
+
+    # Check server is gobby-tasks
+    server_name = tool_input.get("server_name", "")
+    if server_name != "gobby-tasks":
+        return
+
+    # Check inner tool name
+    inner_tool_name = tool_input.get("tool_name", "")
+    if inner_tool_name not in ("create_task", "update_task", "close_task"):
+        return
+
+    # For update_task, only count if status is being set to in_progress
+    if inner_tool_name == "update_task":
+        arguments = tool_input.get("arguments", {}) or {}
+        if arguments.get("status") != "in_progress":
+            return
+
+    # For close_task, we'll clear task_claimed after success check
+    is_close_task = inner_tool_name == "close_task"
+
+    # Check if the call succeeded (not an error)
+    # tool_output structure varies, but errors typically have "error" key
+    # or the MCP response has "status": "error"
+    if isinstance(tool_output, dict):
+        if tool_output.get("error") or tool_output.get("status") == "error":
+            return
+        # Also check nested result for MCP proxy responses
+        result = tool_output.get("result", {})
+        if isinstance(result, dict) and result.get("error"):
+            return
+
+    # Handle close_task - clear the claim only if closing the claimed task
+    if is_close_task:
+        arguments = tool_input.get("arguments", {}) or {}
+        closed_task_id = arguments.get("task_id")
+        claimed_task_id = state.variables.get("claimed_task_id")
+
+        # Only clear task_claimed if we're closing the task that was claimed
+        if closed_task_id and claimed_task_id and closed_task_id == claimed_task_id:
+            state.variables["task_claimed"] = False
+            state.variables["claimed_task_id"] = None
+            logger.info(
+                f"Session {state.session_id}: task_claimed=False "
+                f"(claimed task {closed_task_id} closed via close_task)"
+            )
+        else:
+            logger.debug(
+                f"Session {state.session_id}: close_task for {closed_task_id} "
+                f"(claimed: {claimed_task_id}) - not clearing task_claimed"
+            )
+        return
+
+    # Extract task_id based on tool type
+    arguments = tool_input.get("arguments", {}) or {}
+    if inner_tool_name == "update_task":
+        task_id = arguments.get("task_id")
+    elif inner_tool_name == "create_task":
+        # For create_task, the id is in the result
+        result = tool_output.get("result", {}) if isinstance(tool_output, dict) else {}
+        task_id = result.get("id") if isinstance(result, dict) else None
+    else:
+        task_id = None
+
+    # All conditions met - set task_claimed and claimed_task_id
+    state.variables["task_claimed"] = True
+    state.variables["claimed_task_id"] = task_id
+    logger.info(
+        f"Session {state.session_id}: task_claimed=True, claimed_task_id={task_id} "
+        f"(via {inner_tool_name})"
+    )
+
+    # Auto-link task to session when status is set to in_progress
+    if inner_tool_name == "update_task":
+        arguments = tool_input.get("arguments", {}) or {}
+        task_id = arguments.get("task_id")
+        if task_id and session_task_manager:
+            try:
+                session_task_manager.link_task(state.session_id, task_id, "worked_on")
+                logger.info(f"Auto-linked task {task_id} to session {state.session_id}")
+            except Exception as e:
+                logger.warning(f"Failed to auto-link task {task_id}: {e}")
+
+
+def detect_plan_mode(event: "HookEvent", state: "WorkflowState") -> None:
+    """Detect Claude Code plan mode entry/exit and set workflow variable.
+
+    Sets `plan_mode: true` when EnterPlanMode tool is called, allowing
+    file modifications without an active task (planning writes to plan files).
+
+    Clears `plan_mode: false` when ExitPlanMode tool is called, re-enabling
+    task enforcement for actual implementation work.
+
+    Args:
+        event: The AFTER_TOOL hook event
+        state: Current workflow state (modified in place)
+    """
+    if not event.data:
+        return
+
+    tool_name = event.data.get("tool_name", "")
+
+    if tool_name == "EnterPlanMode":
+        state.variables["plan_mode"] = True
+        logger.info(f"Session {state.session_id}: plan_mode=True (entered plan mode)")
+    elif tool_name == "ExitPlanMode":
+        state.variables["plan_mode"] = False
+        logger.info(f"Session {state.session_id}: plan_mode=False (exited plan mode)")
+
+
+def detect_mcp_call(event: "HookEvent", state: "WorkflowState") -> None:
+    """Track MCP tool calls by server/tool for workflow conditions.
+
+    Sets state.variables["mcp_calls"] = {
+        "gobby-memory": ["recall", "remember"],
+        "context7": ["get-library-docs"],
+        ...
+    }
+
+    This enables workflow conditions like:
+        when: "mcp_called('gobby-memory', 'recall')"
+
+    Args:
+        event: The AFTER_TOOL hook event
+        state: Current workflow state (modified in place)
+    """
+    if not event.data:
+        return
+
+    tool_name = event.data.get("tool_name", "")
+    tool_input = event.data.get("tool_input", {}) or {}
+    tool_output = event.data.get("tool_output", {}) or {}
+
+    # Check for MCP proxy call
+    if tool_name not in ("call_tool", "mcp__gobby__call_tool"):
+        return
+
+    server_name = tool_input.get("server_name", "")
+    inner_tool = tool_input.get("tool_name", "")
+
+    if not server_name or not inner_tool:
+        return
+
+    # Check if call succeeded (skip tracking failed calls)
+    if isinstance(tool_output, dict):
+        if tool_output.get("error") or tool_output.get("status") == "error":
+            return
+        result = tool_output.get("result", {})
+        if isinstance(result, dict) and result.get("error"):
+            return
+
+    # Track the call
+    mcp_calls = state.variables.setdefault("mcp_calls", {})
+    server_calls = mcp_calls.setdefault(server_name, [])
+    if inner_tool not in server_calls:
+        server_calls.append(inner_tool)
+        logger.debug(f"Session {state.session_id}: MCP call tracked {server_name}/{inner_tool}")

gobby/workflows/engine.py

@@ -0,0 +1,485 @@
+import logging
+from datetime import UTC, datetime
+from pathlib import Path
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Any
+
+from gobby.hooks.events import HookEvent, HookEventType, HookResponse
+from gobby.storage.workflow_audit import WorkflowAuditManager
+
+from .approval_flow import handle_approval_response
+from .audit_helpers import (
+    log_approval,
+    log_rule_eval,
+    log_tool_call,
+    log_transition,
+)
+from .definitions import WorkflowDefinition, WorkflowState
+from .detection_helpers import detect_mcp_call, detect_plan_mode, detect_task_claim
+from .evaluator import ConditionEvaluator
+from .lifecycle_evaluator import (
+    evaluate_all_lifecycle_workflows as _evaluate_all_lifecycle_workflows,
+)
+from .lifecycle_evaluator import (
+    evaluate_lifecycle_triggers as _evaluate_lifecycle_triggers,
+)
+from .lifecycle_evaluator import (
+    evaluate_workflow_triggers as _evaluate_workflow_triggers,
+)
+from .lifecycle_evaluator import (
+    process_action_result,
+)
+from .loader import WorkflowLoader
+from .premature_stop import check_premature_stop
+from .state_manager import WorkflowStateManager
+
+if TYPE_CHECKING:
+    from .actions import ActionExecutor
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowEngine:
+    """
+    Core engine for executing step-based workflows.
+    """
+
+    def __init__(
+        self,
+        loader: WorkflowLoader,
+        state_manager: WorkflowStateManager,
+        action_executor: "ActionExecutor",
+        evaluator: ConditionEvaluator | None = None,
+        audit_manager: WorkflowAuditManager | None = None,
+    ):
+        self.loader = loader
+        self.state_manager = state_manager
+        self.action_executor = action_executor
+        self.evaluator = evaluator or ConditionEvaluator()
+        self.audit_manager = audit_manager
+
+    # Maps canonical trigger names to their legacy aliases for backward compatibility.
+    TRIGGER_ALIASES: dict[str, list[str]] = {
+        "on_before_agent": ["on_prompt_submit"],
+        "on_before_tool": ["on_tool_call"],
+        "on_after_tool": ["on_tool_result"],
+    }
+
+    # Variables to inherit from parent session
+    VARS_TO_INHERIT = ["plan_mode"]
+
+    async def handle_event(self, event: HookEvent) -> HookResponse:
+        """
+        Main entry point for hook events.
+        """
+        session_id = event.metadata.get("_platform_session_id")
+        if not session_id:
+            return HookResponse(decision="allow")  # No session, no workflow
+
+        # 1. Load state
+        state = self.state_manager.get_state(session_id)
+
+        # 2. If no state, check triggers to start one (e.g. on_session_start)
+        # Note: This logic might need to move to a specialized trigger handler
+        # For now, simplistic check
+
+        if not state:
+            # TODO: Logic to load workflow?
+            # For now, return allow
+            return HookResponse(decision="allow")
+
+        # Check if workflow is temporarily disabled (escape hatch)
+        if state.disabled:
+            logger.debug(
+                f"Workflow '{state.workflow_name}' is disabled for session {session_id}. "
+                f"Reason: {state.disabled_reason or 'No reason specified'}"
+            )
+            return HookResponse(decision="allow")
+
+        # Stuck prevention: Check if step duration exceeding limit
+        # This is a basic implementation of "Stuck Detection"
+        if state.step_entered_at:
+            logger.debug(f"step_entered_at type: {type(state.step_entered_at)}")
+            logger.debug(f"step_entered_at value: {state.step_entered_at}")
+            diff = datetime.now(UTC) - state.step_entered_at
+            logger.debug(f"diff type: {type(diff)}, value: {diff}")
+            duration = diff.total_seconds()
+            logger.debug(f"duration type: {type(duration)}, value: {duration}")
+            # Hardcoded limit for MVP: 30 minutes
+            if duration > 1800:
+                # Force transition to reflect if not already there
+                if state.step != "reflect":
+                    project_path = Path(event.cwd) if event.cwd else None
+                    workflow = self.loader.load_workflow(state.workflow_name, project_path)
+                    if workflow and workflow.get_step("reflect"):
+                        await self.transition_to(state, "reflect", workflow)
+                        return HookResponse(
+                            decision="modify",
+                            context="[System Alert] Step duration limit exceeded. Transitioning to 'reflect' step.",
+                        )
+
+        # 3. Load definition
+        # Skip if this is a lifecycle-only state (used for task_claimed tracking)
+        if state.workflow_name == "__lifecycle__":
+            logger.debug(
+                f"Skipping step workflow handling for lifecycle state in session {session_id}"
+            )
+            return HookResponse(decision="allow")
+
+        project_path = Path(event.cwd) if event.cwd else None
+        workflow = self.loader.load_workflow(state.workflow_name, project_path)
+        if not workflow:
+            logger.error(f"Workflow '{state.workflow_name}' not found for session {session_id}")
+            return HookResponse(decision="allow")
+
+        # Skip step handling for lifecycle workflows - they only use triggers
+        if workflow.type == "lifecycle":
+            logger.debug(
+                f"Skipping step workflow handling for lifecycle workflow '{workflow.name}' "
+                f"in session {session_id}"
+            )
+            return HookResponse(decision="allow")
+
+        # 4. Process event
+        # Logic matches WORKFLOWS.md "Evaluation Flow"
+
+        # Determine context for evaluation
+        # Use SimpleNamespace for variables so dot notation works (variables.session_task)
+        # Look up session info for condition evaluation
+        session_info = {}
+        if (
+            self.action_executor
+            and self.action_executor.session_manager
+            and event.machine_id
+            and event.project_id
+        ):
+            session = self.action_executor.session_manager.find_by_external_id(
+                external_id=event.session_id,
+                machine_id=event.machine_id,
+                project_id=event.project_id,
+                source=event.source.value,
+            )
+            if session:
+                session_info = {
+                    "id": session.id,
+                    "external_id": session.external_id,
+                    "project_id": session.project_id,
+                    "status": session.status,
+                    "git_branch": session.git_branch,
+                    "source": session.source,
+                }
+        eval_context = {
+            "event": event,
+            "workflow_state": state,
+            "variables": SimpleNamespace(**state.variables),
+            "session": SimpleNamespace(**session_info),
+            "tool_name": event.data.get("tool_name"),
+            "tool_args": event.data.get("tool_args", {}),
+            # State attributes for transition conditions
+            "step_action_count": state.step_action_count,
+            "total_action_count": state.total_action_count,
+            "step": state.step,
+        }
+
+        current_step = workflow.get_step(state.step)
+        if not current_step:
+            logger.error(f"Step '{state.step}' not found in workflow '{workflow.name}'")
+            return HookResponse(decision="allow")
+
+        # Handle approval flow on user prompt submit
+        if event.event_type == HookEventType.BEFORE_AGENT:
+            approval_response = self._handle_approval_response(event, state, current_step)
+            if approval_response:
+                return approval_response
+
+            # Reset premature stop counter on user prompt
+            # This allows the failsafe to distinguish agent-stuck-in-loop from user-initiated-stops
+            if state.variables.get("_premature_stop_count", 0) > 0:
+                state.variables["_premature_stop_count"] = 0
+                self.state_manager.save_state(state)
+                logger.debug(f"Reset premature_stop_count for session {session_id}")
+
+        # Check blocked tools
+        if event.event_type == HookEventType.BEFORE_TOOL:
+            # Block tool calls while waiting for approval
+            if state.approval_pending:
+                reason = "Waiting for user approval. Please respond with 'yes' or 'no'."
+                self._log_tool_call(session_id, state.step, "unknown", "block", reason)
+                return HookResponse(decision="block", reason=reason)
+
+            # Reset premature stop counter on tool calls
+            # This ensures the failsafe only triggers for repeated stops without work in between
+            if state.variables.get("_premature_stop_count", 0) > 0:
+                state.variables["_premature_stop_count"] = 0
+                self.state_manager.save_state(state)
+                logger.debug(f"Reset premature_stop_count on tool call for session {session_id}")
+
+            raw_tool_name = eval_context.get("tool_name")
+            tool_name = str(raw_tool_name) if raw_tool_name is not None else ""
+
+            # Check blocked list
+            if tool_name in current_step.blocked_tools:
+                reason = f"Tool '{tool_name}' is blocked in step '{state.step}'."
+                self._log_tool_call(session_id, state.step, tool_name, "block", reason)
+                return HookResponse(decision="block", reason=reason)
+
+            # Check allowed list (if not "all")
+            if current_step.allowed_tools != "all":
+                if tool_name not in current_step.allowed_tools:
+                    reason = f"Tool '{tool_name}' is not in allowed list for step '{state.step}'."
+                    self._log_tool_call(session_id, state.step, tool_name, "block", reason)
+                    return HookResponse(decision="block", reason=reason)
+
+            # Check rules
+            for rule in current_step.rules:
+                if self.evaluator.evaluate(rule.when, eval_context):
+                    if rule.action == "block":
+                        reason = rule.message or "Blocked by workflow rule."
+                        self._log_rule_eval(
+                            session_id,
+                            state.step,
+                            rule.name or "unnamed",
+                            rule.when,
+                            "block",
+                            reason,
+                        )
+                        return HookResponse(decision="block", reason=reason)
+                    # Handle other actions like warn, require_approval
+
+            # Log successful tool allow
+            self._log_tool_call(session_id, state.step, tool_name, "allow")
+
+        # Check transitions
+        logger.debug("Checking transitions")
+        for transition in current_step.transitions:
+            if self.evaluator.evaluate(transition.when, eval_context):
+                # Transition!
+                await self.transition_to(state, transition.to, workflow)
+                return HookResponse(
+                    decision="modify", context=f"Transitioning to step: {transition.to}"
+                )
+
+        # Check exit conditions
+        logger.debug("Checking exit conditions")
+        if self.evaluator.check_exit_conditions(current_step.exit_conditions, state):
+            # TODO: Determine next step or completion logic
+            # For now, simplistic 'next step' if linear, or rely on transitions
+            pass
+
+        # Update stats (generic)
+        if event.event_type == HookEventType.AFTER_TOOL:
+            state.step_action_count += 1
+            state.total_action_count += 1
+
+            # Detect gobby-tasks calls for session-scoped task claiming
+            self._detect_task_claim(event, state)
+
+            # Detect Claude Code plan mode entry/exit
+            self._detect_plan_mode(event, state)
+
+            # Track all MCP proxy calls for workflow conditions
+            self._detect_mcp_call(event, state)
+
+            self.state_manager.save_state(state)  # Persist updates
+
+        return HookResponse(decision="allow")
+
+    async def transition_to(
+        self, state: WorkflowState, new_step_name: str, workflow: WorkflowDefinition
+    ) -> None:
+        """
+        Execute transition logic.
+        """
+        old_step = workflow.get_step(state.step)
+        new_step = workflow.get_step(new_step_name)
+
+        if not new_step:
+            logger.error(f"Cannot transition to unknown step '{new_step_name}'")
+            return
+
+        logger.info(
+            f"Transitioning session {state.session_id} from '{state.step}' to '{new_step_name}'"
+        )
+
+        # Log the transition
+        self._log_transition(state.session_id, state.step, new_step_name)
+
+        # Execute on_exit of old step
+        if old_step:
+            await self._execute_actions(old_step.on_exit, state)
+
+        # Update state
+        state.step = new_step_name
+        state.step_entered_at = datetime.now(UTC)
+        state.step_action_count = 0
+        state.context_injected = False  # Reset for new step context
+
+        self.state_manager.save_state(state)
+
+        # Execute on_enter of new step
+        await self._execute_actions(new_step.on_enter, state)
+
+    async def _execute_actions(self, actions: list[dict[str, Any]], state: WorkflowState) -> None:
+        """
+        Execute a list of actions.
+        """
+        from .actions import ActionContext
+
+        context = ActionContext(
+            session_id=state.session_id,
+            state=state,
+            db=self.action_executor.db,
+            session_manager=self.action_executor.session_manager,
+            template_engine=self.action_executor.template_engine,
+            llm_service=self.action_executor.llm_service,
+            transcript_processor=self.action_executor.transcript_processor,
+            config=self.action_executor.config,
+            mcp_manager=self.action_executor.mcp_manager,
+            memory_manager=self.action_executor.memory_manager,
+            memory_sync_manager=self.action_executor.memory_sync_manager,
+            task_sync_manager=self.action_executor.task_sync_manager,
+            session_task_manager=self.action_executor.session_task_manager,
+        )
+
+        for action_def in actions:
+            action_type = action_def.get("action")
+            if not action_type:
+                continue
+
+            result = await self.action_executor.execute(action_type, context, **action_def)
+
+            if result and "inject_context" in result:
+                # Log context injection for now
+                logger.info(f"Context injected: {result['inject_context'][:50]}...")
+
+    def _handle_approval_response(
+        self,
+        event: HookEvent,
+        state: WorkflowState,
+        current_step: Any,
+    ) -> HookResponse | None:
+        """Handle user response to approval request."""
+        return handle_approval_response(
+            event, state, current_step, self.evaluator, self.state_manager
+        )
+
+    async def evaluate_all_lifecycle_workflows(
+        self, event: HookEvent, context_data: dict[str, Any] | None = None
+    ) -> HookResponse:
+        """Discover and evaluate all lifecycle workflows for the given event."""
+        return await _evaluate_all_lifecycle_workflows(
+            event=event,
+            loader=self.loader,
+            state_manager=self.state_manager,
+            action_executor=self.action_executor,
+            evaluator=self.evaluator,
+            detect_task_claim_fn=self._detect_task_claim,
+            detect_plan_mode_fn=self._detect_plan_mode,
+            check_premature_stop_fn=self._check_premature_stop,
+            context_data=context_data,
+        )
+
+    def _process_action_result(
+        self,
+        result: dict[str, Any],
+        context_data: dict[str, Any],
+        state: "WorkflowState",
+        injected_context: list[str],
+    ) -> str | None:
+        """Process action execution result."""
+        return process_action_result(result, context_data, state, injected_context)
+
+    async def _evaluate_workflow_triggers(
+        self,
+        workflow: "WorkflowDefinition",
+        event: HookEvent,
+        context_data: dict[str, Any],
+    ) -> HookResponse:
+        """Evaluate triggers for a single workflow definition."""
+        return await _evaluate_workflow_triggers(
+            workflow, event, context_data, self.state_manager, self.action_executor, self.evaluator
+        )
+
+    async def evaluate_lifecycle_triggers(
+        self, workflow_name: str, event: HookEvent, context_data: dict[str, Any] | None = None
+    ) -> HookResponse:
+        """Evaluate triggers for a specific lifecycle workflow (e.g. session-handoff)."""
+        return await _evaluate_lifecycle_triggers(
+            workflow_name, event, self.loader, self.action_executor, self.evaluator, context_data
+        )
+
+    # --- Premature Stop Handling ---
+
+    async def _check_premature_stop(
+        self, event: HookEvent, context_data: dict[str, Any]
+    ) -> HookResponse | None:
+        """Check if an active step workflow should handle a premature stop."""
+        template_engine = self.action_executor.template_engine if self.action_executor else None
+        return await check_premature_stop(
+            event, context_data, self.state_manager, self.loader, self.evaluator, template_engine
+        )
+
+    # --- Audit Logging Helpers ---
+
+    def _log_tool_call(
+        self,
+        session_id: str,
+        step: str,
+        tool_name: str,
+        result: str,
+        reason: str | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> None:
+        """Log a tool call permission check to the audit log."""
+        log_tool_call(self.audit_manager, session_id, step, tool_name, result, reason, context)
+
+    def _log_rule_eval(
+        self,
+        session_id: str,
+        step: str,
+        rule_id: str,
+        condition: str,
+        result: str,
+        reason: str | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> None:
+        """Log a rule evaluation to the audit log."""
+        log_rule_eval(
+            self.audit_manager, session_id, step, rule_id, condition, result, reason, context
+        )
+
+    def _log_transition(
+        self,
+        session_id: str,
+        from_step: str,
+        to_step: str,
+        reason: str | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> None:
+        """Log a step transition to the audit log."""
+        log_transition(self.audit_manager, session_id, from_step, to_step, reason, context)
+
+    def _log_approval(
+        self,
+        session_id: str,
+        step: str,
+        result: str,
+        condition_id: str | None = None,
+        prompt: str | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> None:
+        """Log an approval gate event to the audit log."""
+        log_approval(self.audit_manager, session_id, step, result, condition_id, prompt, context)
+
+    def _detect_task_claim(self, event: HookEvent, state: WorkflowState) -> None:
+        """Detect gobby-tasks calls that claim or release a task for this session."""
+        session_task_manager = getattr(self.action_executor, "session_task_manager", None)
+        detect_task_claim(event, state, session_task_manager)
+
+    def _detect_plan_mode(self, event: HookEvent, state: WorkflowState) -> None:
+        """Detect Claude Code plan mode entry/exit and set workflow variable."""
+        detect_plan_mode(event, state)
+
+    def _detect_mcp_call(self, event: HookEvent, state: WorkflowState) -> None:
+        """Track MCP tool calls by server/tool for workflow conditions."""
+        detect_mcp_call(event, state)