gobby 0.2.8__tar.gz → 0.2.9__tar.gz

{gobby-0.2.8 → gobby-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gobby
-Version: 0.2.8
+Version: 0.2.9
 Summary: A local-first daemon to unify your AI coding tools. Session tracking and handoffs across Claude Code, Gemini CLI, and Codex. An MCP proxy that discovers tools without flooding context. Task management with dependencies, validation, and TDD expansion. Agent spawning and worktree orchestration. Persistent memory, extensible workflows, and hooks.
 Author-email: Josh Wilhelmi <josh@gobby.ai>
 License-Expression: MIT

{gobby-0.2.8 → gobby-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gobby"
-version = "0.2.8"
+version = "0.2.9"
 description = "A local-first daemon to unify your AI coding tools. Session tracking and handoffs across Claude Code, Gemini CLI, and Codex. An MCP proxy that discovers tools without flooding context. Task management with dependencies, validation, and TDD expansion. Agent spawning and worktree orchestration. Persistent memory, extensible workflows, and hooks."
 readme = "README.md"
 license = "MIT"

{gobby-0.2.8 → gobby-0.2.9}/src/gobby/__init__.py

@@ -1,3 +1,3 @@
 """Gobby - Local-first daemon for multi-CLI session management."""
 
-__version__ = "0.2.7"
+__version__ = "0.2.9"

{gobby-0.2.8 → gobby-0.2.9}/src/gobby/adapters/claude_code.py

@@ -61,13 +61,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         """Initialize the Claude Code adapter.
 
         Args:
-            hook_manager: Reference to HookManager for strangler fig delegation.
+            hook_manager: Reference to HookManager for delegation.
                          If None, the adapter can only translate (not handle events).
         """
         self._hook_manager = hook_manager
-        # Phase 2C: Use new handle() path with unified HookEvent model
-        # Note: systemMessage handoff notification bug exists in both paths (see plan-multi-cli.md)
-        self._use_legacy = False
 
     def translate_to_hook_event(self, native_event: dict[str, Any]) -> HookEvent:
         """Convert Claude Code native event to unified HookEvent.
@@ -310,14 +307,6 @@ class ClaudeCodeAdapter(BaseAdapter):
     ) -> dict[str, Any]:
         """Main entry point for HTTP endpoint.
 
-        Strangler fig pattern:
-        - Phase 2A-2B: Delegates to existing execute() — validates translation only
-        - Phase 2C+: Calls new handle() with HookEvent
-
-        Note: This method is synchronous for Phase 2A-2B compatibility with
-        the existing execute() method. In Phase 2C+, it will become async
-        when handle() is implemented as async.
-
         Args:
             native_event: Raw payload from Claude Code's hook_dispatcher.py
             hook_manager: HookManager instance for processing.
@@ -325,22 +314,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         Returns:
             Response dict in Claude Code's expected format.
         """
-        # Always translate (validates our mapping is correct)
+        # Translate to HookEvent
         hook_event = self.translate_to_hook_event(native_event)
 
-        # Phase 2C+: Use new HookEvent-based handler
-        # Legacy execute() path removed as HookManager.execute is deprecated/removed.
+        # Use HookEvent-based handler
         hook_type = native_event.get("hook_type", "")
         hook_response = hook_manager.handle(hook_event)
         return self.translate_from_hook_response(hook_response, hook_type=hook_type)
-
-    def set_legacy_mode(self, use_legacy: bool) -> None:
-        """Toggle between legacy and new code paths.
-
-        This method is used during the strangler fig migration to switch
-        between delegating to execute() and calling handle() directly.
-
-        Args:
-            use_legacy: If True, use legacy execute() path. If False, use new handle() path.
-        """
-        self._use_legacy = use_legacy

gobby-0.2.9/src/gobby/app_context.py

@@ -0,0 +1,59 @@
+"""
+Service container for dependency injection in Gobby daemon.
+
+Holds references to singleton services to avoid prop-drilling in HTTPServer
+and other components.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from gobby.config.app import DaemonConfig
+from gobby.llm import LLMService
+from gobby.memory.manager import MemoryManager
+from gobby.storage.clones import LocalCloneManager
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.sessions import LocalSessionManager
+from gobby.storage.tasks import LocalTaskManager
+from gobby.storage.worktrees import LocalWorktreeManager
+from gobby.sync.memories import MemorySyncManager
+from gobby.sync.tasks import TaskSyncManager
+
+
+@dataclass
+class ServiceContainer:
+    """Container for daemon services."""
+
+    # Core Infrastructure
+    config: DaemonConfig
+    database: DatabaseProtocol
+
+    # Core Managers
+    session_manager: LocalSessionManager
+    task_manager: LocalTaskManager
+
+    # Sync Managers
+    task_sync_manager: TaskSyncManager | None = None
+    memory_sync_manager: MemorySyncManager | None = None
+
+    # Advanced Features
+    memory_manager: MemoryManager | None = None
+    llm_service: LLMService | None = None
+
+    # MCP & Agents
+    mcp_manager: Any | None = None  # MCPClientManager
+    mcp_db_manager: Any | None = None  # LocalMCPManager
+    metrics_manager: Any | None = None  # ToolMetricsManager
+    agent_runner: Any | None = None  # AgentRunner
+    message_processor: Any | None = None  # SessionMessageProcessor
+    message_manager: Any | None = None  # LocalSessionMessageManager
+
+    # Validation & Git
+    task_validator: Any | None = None  # TaskValidator
+    worktree_storage: LocalWorktreeManager | None = None
+    clone_storage: LocalCloneManager | None = None
+    git_manager: Any | None = None  # WorktreeGitManager
+
+    # Context
+    project_id: str | None = None
+    websocket_server: Any | None = None

{gobby-0.2.8 → gobby-0.2.9}/src/gobby/cli/utils.py

@@ -394,23 +394,10 @@ def get_install_dir() -> Path:
     Returns:
         Path to the install directory
     """
-    import gobby
+    # Import from centralized paths module to avoid duplication
+    from gobby.paths import get_install_dir as _get_install_dir
 
-    package_install_dir = Path(gobby.__file__).parent / "install"
-
-    # Try to find source directory (project root)
-    current = Path(gobby.__file__).resolve()
-    source_install_dir = None
-
-    for parent in current.parents:
-        potential_source = parent / "src" / "gobby" / "install"
-        if potential_source.exists():
-            source_install_dir = potential_source
-            break
-
-    if source_install_dir and source_install_dir.exists():
-        return source_install_dir
-    return package_install_dir
+    return _get_install_dir()
 
 
 def _is_process_alive(pid: int) -> bool:
@@ -472,7 +459,8 @@ def stop_daemon(quiet: bool = False) -> bool:
             click.echo(f"Sent shutdown signal to Gobby daemon (PID {pid})")
 
         # Wait for graceful shutdown
-        max_wait = 5
+        # Match daemon's uvicorn timeout_graceful_shutdown (15s) + buffer
+        max_wait = 20
         for _ in range(max_wait * 10):
             time.sleep(0.1)
             if not _is_process_alive(pid):

{gobby-0.2.8 → gobby-0.2.9}/src/gobby/config/features.py

@@ -23,7 +23,6 @@ __all__ = [
     "HookStageConfig",
     "HooksConfig",
     "TaskDescriptionConfig",
-    "DEFAULT_IMPORT_MCP_SERVER_PROMPT",
 ]
 
 
@@ -139,25 +138,6 @@ class RecommendToolsConfig(BaseModel):
     )
 
 
-DEFAULT_IMPORT_MCP_SERVER_PROMPT = """You are an MCP server configuration extractor. Given documentation for an MCP server, extract the configuration needed to connect to it.
-
-Return ONLY a valid JSON object (no markdown, no code blocks) with these fields:
-- name: Server name (lowercase, no spaces, use hyphens)
-- transport: "http", "stdio", or "websocket"
-- url: Server URL (required for http/websocket transports)
-- command: Command to run (required for stdio, e.g., "npx", "uv", "node")
-- args: Array of command arguments (for stdio)
-- env: Object of environment variables needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- headers: Object of HTTP headers needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- instructions: How to obtain any required API keys or setup steps
-
-Example stdio server:
-{"name": "filesystem", "transport": "stdio", "command": "npx", "args": ["-y", "@anthropic-ai/filesystem-mcp"], "env": {}, "instructions": "No setup required"}
-
-Example http server with API key:
-{"name": "exa", "transport": "http", "url": "https://mcp.exa.ai/mcp", "headers": {"EXA_API_KEY": "<YOUR_EXA_API_KEY>"}, "instructions": "Get your API key from https://exa.ai/dashboard"}"""
-
-
 class ImportMCPServerConfig(BaseModel):
     """MCP server import configuration."""
 

{gobby-0.2.8 → gobby-0.2.9}/src/gobby/config/tasks.py

@@ -669,6 +669,10 @@ class WorkflowConfig(BaseModel):
         default_factory=lambda: ["Edit", "Write", "Update", "NotebookEdit"],
         description="Tools that require an active task when require_task_before_edit is enabled",
     )
+    debug_echo_context: bool = Field(
+        default=False,
+        description="Debug: echo additionalContext to system_message for terminal visibility",
+    )
 
     @field_validator("timeout")
     @classmethod

gobby-0.2.9/src/gobby/hooks/event_handlers/__init__.py

@@ -0,0 +1,155 @@
+"""
+Event handlers module for hook event processing.
+
+This module is extracted from hook_manager.py using Strangler Fig pattern.
+It provides centralized event handler registration and dispatch.
+
+Classes:
+    EventHandlers: Manages event handler registration and dispatch.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from gobby.hooks.event_handlers._agent import AgentEventHandlerMixin
+from gobby.hooks.event_handlers._misc import MiscEventHandlerMixin
+from gobby.hooks.event_handlers._session import SessionEventHandlerMixin
+from gobby.hooks.event_handlers._tool import EDIT_TOOLS, ToolEventHandlerMixin
+from gobby.hooks.events import HookEvent, HookEventType, HookResponse
+
+if TYPE_CHECKING:
+    from gobby.config.skills import SkillsConfig
+    from gobby.config.tasks import WorkflowConfig
+    from gobby.hooks.artifact_capture import ArtifactCaptureHook
+    from gobby.hooks.session_coordinator import SessionCoordinator
+    from gobby.hooks.skill_manager import HookSkillManager
+    from gobby.sessions.manager import SessionManager
+    from gobby.sessions.summary import SummaryFileGenerator
+    from gobby.storage.session_messages import LocalSessionMessageManager
+    from gobby.storage.session_tasks import SessionTaskManager
+    from gobby.storage.sessions import LocalSessionManager
+    from gobby.storage.tasks import LocalTaskManager
+    from gobby.workflows.hooks import WorkflowHookHandler
+
+
+class EventHandlers(
+    SessionEventHandlerMixin,
+    AgentEventHandlerMixin,
+    ToolEventHandlerMixin,
+    MiscEventHandlerMixin,
+):
+    """
+    Manages event handler registration and dispatch.
+
+    Provides handler methods for all HookEventType values and a registration
+    mechanism for looking up handlers by event type.
+
+    Extracted from HookManager to separate event handling concerns.
+    """
+
+    def __init__(
+        self,
+        session_manager: SessionManager | None = None,
+        workflow_handler: WorkflowHookHandler | None = None,
+        session_storage: LocalSessionManager | None = None,
+        session_task_manager: SessionTaskManager | None = None,
+        message_processor: Any | None = None,
+        summary_file_generator: SummaryFileGenerator | None = None,
+        task_manager: LocalTaskManager | None = None,
+        session_coordinator: SessionCoordinator | None = None,
+        message_manager: LocalSessionMessageManager | None = None,
+        skill_manager: HookSkillManager | None = None,
+        skills_config: SkillsConfig | None = None,
+        artifact_capture_hook: ArtifactCaptureHook | None = None,
+        workflow_config: WorkflowConfig | None = None,
+        get_machine_id: Callable[[], str] | None = None,
+        resolve_project_id: Callable[[str | None, str | None], str] | None = None,
+        logger: logging.Logger | None = None,
+    ) -> None:
+        """
+        Initialize EventHandlers.
+
+        Args:
+            session_manager: SessionManager for session operations
+            workflow_handler: WorkflowHookHandler for lifecycle workflows
+            session_storage: LocalSessionManager for session storage
+            session_task_manager: SessionTaskManager for session-task links
+            message_processor: SessionMessageProcessor for message handling
+            summary_file_generator: SummaryFileGenerator for summaries
+            task_manager: LocalTaskManager for task operations
+            session_coordinator: SessionCoordinator for session tracking
+            message_manager: LocalSessionMessageManager for messages
+            skill_manager: HookSkillManager for skill discovery
+            skills_config: SkillsConfig for skill injection settings
+            artifact_capture_hook: ArtifactCaptureHook for capturing artifacts
+            workflow_config: WorkflowConfig for workflow settings (debug_echo_context)
+            get_machine_id: Function to get machine ID
+            resolve_project_id: Function to resolve project ID from cwd
+            logger: Optional logger instance
+        """
+        self._session_manager = session_manager
+        self._workflow_handler = workflow_handler
+        self._session_storage = session_storage
+        self._session_task_manager = session_task_manager
+        self._message_processor = message_processor
+        self._summary_file_generator = summary_file_generator
+        self._task_manager = task_manager
+        self._session_coordinator = session_coordinator
+        self._message_manager = message_manager
+        self._skill_manager = skill_manager
+        self._skills_config = skills_config
+        self._artifact_capture_hook = artifact_capture_hook
+        self._workflow_config = workflow_config
+        self._get_machine_id = get_machine_id or (lambda: "unknown-machine")
+        self._resolve_project_id = resolve_project_id or (lambda p, c: p or "")
+        self.logger = logger or logging.getLogger(__name__)
+
+        # Build handler map
+        self._handler_map: dict[HookEventType, Callable[[HookEvent], HookResponse]] = {
+            HookEventType.SESSION_START: self.handle_session_start,
+            HookEventType.SESSION_END: self.handle_session_end,
+            HookEventType.BEFORE_AGENT: self.handle_before_agent,
+            HookEventType.AFTER_AGENT: self.handle_after_agent,
+            HookEventType.BEFORE_TOOL: self.handle_before_tool,
+            HookEventType.AFTER_TOOL: self.handle_after_tool,
+            HookEventType.PRE_COMPACT: self.handle_pre_compact,
+            HookEventType.SUBAGENT_START: self.handle_subagent_start,
+            HookEventType.SUBAGENT_STOP: self.handle_subagent_stop,
+            HookEventType.NOTIFICATION: self.handle_notification,
+            HookEventType.BEFORE_TOOL_SELECTION: self.handle_before_tool_selection,
+            HookEventType.BEFORE_MODEL: self.handle_before_model,
+            HookEventType.AFTER_MODEL: self.handle_after_model,
+            HookEventType.PERMISSION_REQUEST: self.handle_permission_request,
+            HookEventType.STOP: self.handle_stop,
+        }
+
+    def get_handler(
+        self, event_type: HookEventType | str
+    ) -> Callable[[HookEvent], HookResponse] | None:
+        """
+        Get handler for an event type.
+
+        Args:
+            event_type: The event type to get handler for
+
+        Returns:
+            Handler callable or None if not found
+        """
+        if isinstance(event_type, str):
+            try:
+                event_type = HookEventType(event_type)
+            except ValueError:
+                return None
+        return self._handler_map.get(event_type)
+
+    def get_handler_map(self) -> dict[HookEventType, Callable[[HookEvent], HookResponse]]:
+        """
+        Get a copy of the handler map.
+
+        Returns:
+            Copy of handler map (modifications don't affect internal state)
+        """
+        return dict(self._handler_map)

gobby-0.2.9/src/gobby/hooks/event_handlers/_agent.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from gobby.hooks.event_handlers._base import EventHandlersBase
+from gobby.hooks.events import HookEvent, HookResponse, SessionSource
+
+
+class AgentEventHandlerMixin(EventHandlersBase):
+    """Mixin for handling agent-related events."""
+
+    def handle_before_agent(self, event: HookEvent) -> HookResponse:
+        """Handle BEFORE_AGENT event (user prompt submit)."""
+        input_data = event.data
+        prompt = input_data.get("prompt", "")
+        transcript_path = input_data.get("transcript_path")
+        session_id = event.metadata.get("_platform_session_id")
+
+        context_parts = []
+
+        if session_id:
+            self.logger.debug(f"BEFORE_AGENT: session {session_id}, prompt_len={len(prompt)}")
+
+            # Update status to active (unless /clear or /exit)
+            prompt_lower = prompt.strip().lower()
+            if prompt_lower not in ("/clear", "/exit") and self._session_manager:
+                try:
+                    self._session_manager.update_session_status(session_id, "active")
+                    if self._session_storage:
+                        self._session_storage.reset_transcript_processed(session_id)
+                except Exception as e:
+                    self.logger.warning(f"Failed to update session status: {e}")
+
+            # Handle /clear command - lifecycle workflows handle handoff
+            if prompt_lower in ("/clear", "/exit") and transcript_path:
+                self.logger.debug(f"Detected {prompt_lower} - lifecycle workflows handle handoff")
+
+        # Execute lifecycle workflow triggers
+        if self._workflow_handler:
+            try:
+                wf_response = self._workflow_handler.handle_all_lifecycles(event)
+                if wf_response.context:
+                    context_parts.append(wf_response.context)
+                if wf_response.decision != "allow":
+                    return wf_response
+            except Exception as e:
+                self.logger.error(f"Failed to execute lifecycle workflows: {e}", exc_info=True)
+
+        return HookResponse(
+            decision="allow",
+            context="\n\n".join(context_parts) if context_parts else None,
+        )
+
+    def handle_after_agent(self, event: HookEvent) -> HookResponse:
+        """Handle AFTER_AGENT event."""
+        session_id = event.metadata.get("_platform_session_id")
+        cli_source = event.source.value
+
+        context_parts = []
+
+        if session_id:
+            self.logger.debug(f"AFTER_AGENT: session {session_id}, cli={cli_source}")
+            if self._session_manager:
+                try:
+                    self._session_manager.update_session_status(session_id, "paused")
+                except Exception as e:
+                    self.logger.warning(f"Failed to update session status: {e}")
+        else:
+            self.logger.debug(f"AFTER_AGENT: cli={cli_source}")
+
+        # Execute lifecycle workflow triggers
+        if self._workflow_handler:
+            try:
+                wf_response = self._workflow_handler.handle_all_lifecycles(event)
+                if wf_response.context:
+                    context_parts.append(wf_response.context)
+                if wf_response.decision != "allow":
+                    return wf_response
+            except Exception as e:
+                self.logger.error(f"Failed to execute lifecycle workflows: {e}", exc_info=True)
+
+        return HookResponse(
+            decision="allow",
+            context="\n\n".join(context_parts) if context_parts else None,
+        )
+
+    def handle_stop(self, event: HookEvent) -> HookResponse:
+        """Handle STOP event (Claude Code only)."""
+        session_id = event.metadata.get("_platform_session_id")
+
+        context_parts = []
+
+        if session_id:
+            self.logger.debug(f"STOP: session {session_id}")
+            if self._session_manager:
+                try:
+                    self._session_manager.update_session_status(session_id, "paused")
+                except Exception as e:
+                    self.logger.warning(f"Failed to update session status: {e}")
+        else:
+            self.logger.debug("STOP")
+
+        # Execute lifecycle workflow triggers
+        if self._workflow_handler:
+            try:
+                wf_response = self._workflow_handler.handle_all_lifecycles(event)
+                if wf_response.context:
+                    context_parts.append(wf_response.context)
+                if wf_response.decision != "allow":
+                    return wf_response
+            except Exception as e:
+                self.logger.error(f"Failed to execute lifecycle workflows: {e}", exc_info=True)
+
+        return HookResponse(
+            decision="allow",
+            context="\n\n".join(context_parts) if context_parts else None,
+        )
+
+    def handle_pre_compact(self, event: HookEvent) -> HookResponse:
+        """Handle PRE_COMPACT event.
+
+        Note: Gemini fires PreCompress constantly during normal operation,
+        unlike Claude which fires it only when approaching context limits.
+        We skip handoff logic and workflow execution for Gemini to avoid
+        excessive state changes and workflow interruptions.
+        """
+        trigger = event.data.get("trigger", "auto")
+        session_id = event.metadata.get("_platform_session_id")
+
+        # Skip handoff logic for Gemini - it fires PreCompress too frequently
+        if event.source == SessionSource.GEMINI:
+            self.logger.debug(f"PRE_COMPACT ({trigger}): session {session_id} [Gemini - skipped]")
+            return HookResponse(decision="allow")
+
+        if session_id:
+            self.logger.debug(f"PRE_COMPACT ({trigger}): session {session_id}")
+            # Mark session as handoff_ready so it can be found as parent after compact
+            if self._session_manager:
+                self._session_manager.update_session_status(session_id, "handoff_ready")
+        else:
+            self.logger.debug(f"PRE_COMPACT ({trigger})")
+
+        # Execute lifecycle workflows
+        if self._workflow_handler:
+            try:
+                return self._workflow_handler.handle_all_lifecycles(event)
+            except Exception as e:
+                self.logger.error(f"Failed to execute lifecycle workflows: {e}", exc_info=True)
+
+        return HookResponse(decision="allow")
+
+    def handle_subagent_start(self, event: HookEvent) -> HookResponse:
+        """Handle SUBAGENT_START event."""
+        input_data = event.data
+        session_id = event.metadata.get("_platform_session_id")
+        agent_id = input_data.get("agent_id")
+        subagent_id = input_data.get("subagent_id")
+
+        log_msg = f"SUBAGENT_START: session {session_id}" if session_id else "SUBAGENT_START"
+        if agent_id:
+            log_msg += f", agent_id={agent_id}"
+        if subagent_id:
+            log_msg += f", subagent_id={subagent_id}"
+        self.logger.debug(log_msg)
+
+        return HookResponse(decision="allow")
+
+    def handle_subagent_stop(self, event: HookEvent) -> HookResponse:
+        """Handle SUBAGENT_STOP event."""
+        session_id = event.metadata.get("_platform_session_id")
+
+        if session_id:
+            self.logger.debug(f"SUBAGENT_STOP: session {session_id}")
+        else:
+            self.logger.debug("SUBAGENT_STOP")
+
+        return HookResponse(decision="allow")

gobby-0.2.9/src/gobby/hooks/event_handlers/_base.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from gobby.hooks.events import HookEvent, HookEventType, HookResponse
+
+if TYPE_CHECKING:
+    from gobby.config.skills import SkillsConfig
+    from gobby.config.tasks import WorkflowConfig
+    from gobby.hooks.artifact_capture import ArtifactCaptureHook
+    from gobby.hooks.session_coordinator import SessionCoordinator
+    from gobby.hooks.skill_manager import HookSkillManager
+    from gobby.sessions.manager import SessionManager
+    from gobby.sessions.summary import SummaryFileGenerator
+    from gobby.storage.session_messages import LocalSessionMessageManager
+    from gobby.storage.session_tasks import SessionTaskManager
+    from gobby.storage.sessions import LocalSessionManager
+    from gobby.storage.tasks import LocalTaskManager
+    from gobby.workflows.hooks import WorkflowHookHandler
+
+
+class EventHandlersBase:
+    """Base class for EventHandlers mixins with type hints for shared state."""
+
+    _session_manager: SessionManager | None
+    _workflow_handler: WorkflowHookHandler | None
+    _workflow_config: WorkflowConfig | None
+    _session_storage: LocalSessionManager | None
+    _session_task_manager: SessionTaskManager | None
+    _message_processor: Any | None
+    _summary_file_generator: SummaryFileGenerator | None
+    _task_manager: LocalTaskManager | None
+    _session_coordinator: SessionCoordinator | None
+    _message_manager: LocalSessionMessageManager | None
+    _skill_manager: HookSkillManager | None
+    _skills_config: SkillsConfig | None
+    _artifact_capture_hook: ArtifactCaptureHook | None
+    _get_machine_id: Callable[[], str]
+    _resolve_project_id: Callable[[str | None, str | None], str]
+    logger: logging.Logger
+    _handler_map: dict[HookEventType, Callable[[HookEvent], HookResponse]]
+
+    def _auto_activate_workflow(
+        self, workflow_name: str, session_id: str, project_path: str | None
+    ) -> None:
+        """Shared method for auto-activating workflows."""
+        if not self._workflow_handler:
+            return
+
+        try:
+            result = self._workflow_handler.activate_workflow(
+                workflow_name=workflow_name,
+                session_id=session_id,
+                project_path=project_path,
+            )
+            if result.get("success"):
+                self.logger.info(
+                    "Auto-activated workflow for session",
+                    extra={
+                        "workflow_name": workflow_name,
+                        "session_id": session_id,
+                        "project_path": project_path,
+                    },
+                )
+            else:
+                self.logger.warning(
+                    "Failed to auto-activate workflow",
+                    extra={
+                        "workflow_name": workflow_name,
+                        "session_id": session_id,
+                        "project_path": project_path,
+                        "error": result.get("error"),
+                    },
+                )
+        except Exception as e:
+            self.logger.warning(
+                "Failed to auto-activate workflow",
+                extra={
+                    "workflow_name": workflow_name,
+                    "session_id": session_id,
+                    "project_path": project_path,
+                    "error": str(e),
+                },
+                exc_info=True,
+            )