gobby 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

gobby/hooks/event_handlers.py

@@ -17,7 +17,9 @@ 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.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
@@ -48,6 +50,8 @@ class EventHandlers:
         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,
         get_machine_id: Callable[[], str] | None = None,
         resolve_project_id: Callable[[str | None, str | None], str] | None = None,
         logger: logging.Logger | None = None,
@@ -65,6 +69,8 @@ class EventHandlers:
             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
             get_machine_id: Function to get machine ID
             resolve_project_id: Function to resolve project ID from cwd
             logger: Optional logger instance
@@ -78,6 +84,8 @@ class EventHandlers:
         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._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__)
@@ -213,9 +221,22 @@ class EventHandlers:
                             self.logger.warning(f"Workflow error: {e}")
 
                     # Build system message (terminal display only)
-                    system_message = "\nSession enhanced by gobby."
+                    system_message = f"\nGobby Session ID: {session_id}"
+                    system_message += f"\nExternal ID: {external_id}"
                     if parent_session_id:
                         context_parts.append(f"Parent session: {parent_session_id}")
+
+                    # Add active lifecycle workflows
+                    if wf_response.metadata and "discovered_workflows" in wf_response.metadata:
+                        wf_list = wf_response.metadata["discovered_workflows"]
+                        if wf_list:
+                            system_message += "\nActive workflows:"
+                            for w in wf_list:
+                                source = "project" if w["is_project"] else "global"
+                                system_message += (
+                                    f"\n  - {w['name']} ({source}, priority={w['priority']})"
+                                )
+
                     if wf_response.system_message:
                         system_message += f"\n\n{wf_response.system_message}"
 
@@ -312,7 +333,18 @@ class EventHandlers:
             context_parts.append(f"Parent session: {parent_session_id}")
 
         # Build system message (terminal display only)
-        system_message = "\nSession enhanced by gobby."
+        system_message = f"\nGobby Session ID: {session_id}"
+        system_message += f"\nExternal ID: {external_id}"
+
+        # Add active lifecycle workflows
+        if wf_response.metadata and "discovered_workflows" in wf_response.metadata:
+            wf_list = wf_response.metadata["discovered_workflows"]
+            if wf_list:
+                system_message += "\nActive workflows:"
+                for w in wf_list:
+                    source = "project" if w["is_project"] else "global"
+                    system_message += f"\n  - {w['name']} ({source}, priority={w['priority']})"
+
         if wf_response.system_message:
             system_message += f"\n\n{wf_response.system_message}"
 
@@ -322,6 +354,11 @@ class EventHandlers:
             context_parts.append("\n## Active Task Context\n")
             context_parts.append(f"You are working on task: {task_title} ({event.task_id})")
 
+        # Inject core skills if enabled (restoring from parent session if available)
+        skill_context = self._build_skill_injection_context(parent_session_id)
+        if skill_context:
+            context_parts.append(skill_context)
+
         # Build metadata with terminal context (filter out nulls)
         metadata: dict[str, Any] = {
             "session_id": session_id,
@@ -434,6 +471,112 @@ class EventHandlers:
 
         return HookResponse(decision="allow")
 
+    def _build_skill_injection_context(self, parent_session_id: str | None = None) -> str | None:
+        """Build skill injection context for session-start.
+
+        Combines alwaysApply skills with skills restored from parent session.
+
+        Args:
+            parent_session_id: Optional parent session ID to restore skills from
+
+        Returns context string with available skills if injection is enabled,
+        or None if disabled.
+        """
+        # Skip if no skill manager or config
+        if not self._skill_manager or not self._skills_config:
+            return None
+
+        # Check if injection is enabled
+        if not self._skills_config.inject_core_skills:
+            return None
+
+        # Check injection format
+        if self._skills_config.injection_format == "none":
+            return None
+
+        # Get alwaysApply skills
+        try:
+            core_skills = self._skill_manager.discover_core_skills()
+            always_apply_skills = [s for s in core_skills if s.is_always_apply()]
+
+            # Get restored skills from parent session
+            restored_skills = self._restore_skills_from_parent(parent_session_id)
+
+            # Combine: alwaysApply skills + any additional restored skills
+            skill_names = [s.name for s in always_apply_skills]
+            for skill_name in restored_skills:
+                if skill_name not in skill_names:
+                    skill_names.append(skill_name)
+
+            if not skill_names:
+                return None
+
+            # Build context based on format
+            if self._skills_config.injection_format == "summary":
+                return (
+                    "\n## Available Skills\n"
+                    f"The following skills are always available: {', '.join(skill_names)}\n"
+                    "Use the /skill-name syntax to invoke them."
+                )
+            elif self._skills_config.injection_format == "full":
+                parts = ["\n## Available Skills\n"]
+                # Build a map of always_apply skills for quick lookup
+                always_apply_map = {s.name: s for s in always_apply_skills}
+                # Iterate over combined skill_names list (always_apply + restored)
+                for skill_name in skill_names:
+                    parts.append(f"### {skill_name}")
+                    # Get description from always_apply skill if available
+                    if skill_name in always_apply_map:
+                        skill = always_apply_map[skill_name]
+                        if skill.description:
+                            parts.append(skill.description)
+                    parts.append("")
+                return "\n".join(parts)
+            else:
+                return None
+
+        except Exception as e:
+            self.logger.warning(f"Failed to build skill injection context: {e}")
+            return None
+
+    def _restore_skills_from_parent(self, parent_session_id: str | None) -> list[str]:
+        """Restore active skills from parent session's handoff context.
+
+        Args:
+            parent_session_id: Parent session ID to restore from
+
+        Returns:
+            List of skill names from the parent session
+        """
+        if not parent_session_id or not self._session_storage:
+            return []
+
+        try:
+            parent = self._session_storage.get(parent_session_id)
+            if not parent:
+                return []
+
+            compact_md = getattr(parent, "compact_markdown", None)
+            if not compact_md:
+                return []
+
+            # Parse active skills from markdown
+            # Format: "### Active Skills\nSkills available: skill1, skill2, skill3"
+            import re
+
+            match = re.search(r"### Active Skills\s*\nSkills available:\s*([^\n]+)", compact_md)
+            if match:
+                skills_str = match.group(1).strip()
+                skills = [s.strip() for s in skills_str.split(",") if s.strip()]
+                self.logger.debug(f"Restored {len(skills)} skills from parent session")
+                return skills
+
+            return []
+
+        except Exception as e:
+            self.logger.warning(f"Failed to restore skills from parent: {e}")
+            return []
+
     # ==================== AGENT HANDLERS ====================
 
     def handle_before_agent(self, event: HookEvent) -> HookResponse:

gobby/hooks/hook_manager.py

@@ -17,7 +17,7 @@ Example:
 
     manager = HookManager(
         daemon_host="localhost",
-        daemon_port=8765
+        daemon_port=60887
     )
 
     result = manager.execute(
@@ -42,6 +42,7 @@ from gobby.hooks.events import HookEvent, HookEventType, HookResponse
 from gobby.hooks.health_monitor import HealthMonitor
 from gobby.hooks.plugins import PluginLoader, run_plugin_handlers
 from gobby.hooks.session_coordinator import SessionCoordinator
+from gobby.hooks.skill_manager import HookSkillManager
 from gobby.hooks.webhooks import WebhookDispatcher
 from gobby.memory.manager import MemoryManager
 from gobby.sessions.manager import SessionManager
@@ -79,6 +80,21 @@ class HookManager:
     - TranscriptProcessor: JSONL parsing and analysis
     - WorkflowEngine: Handles session handoff and LLM-powered summaries
 
+    Session ID Mapping:
+        There are two types of session IDs used throughout the system:
+
+        | Name                     | Description                                    | Example                                |
+        |--------------------------|------------------------------------------------|----------------------------------------|
+        | external_id / session_id | CLI's internal session UUID (Claude Code, etc) | 683bc13e-091e-4911-9e59-e7546e385cd6   |
+        | _platform_session_id     | Gobby's internal session.id (database PK)      | 0ebb2c00-0f58-4c39-9370-eba1833dec33   |
+
+        The _platform_session_id is derived from session_manager.get_session_id(external_id, source)
+        which looks up Gobby's session by the CLI's external_id.
+
+        When injecting into agent context:
+        - "session_id" in response.metadata = Gobby's _platform_session_id (for MCP tool calls)
+        - "external_id" in response.metadata = CLI's session UUID (for transcript lookups)
+
     Attributes:
         daemon_host: Host for daemon communication
         daemon_port: Port for daemon communication
@@ -89,7 +105,7 @@ class HookManager:
     def __init__(
         self,
         daemon_host: str = "localhost",
-        daemon_port: int = 8765,
+        daemon_port: int = 60887,
         llm_service: "LLMService | None" = None,
         config: Any | None = None,
         log_file: str | None = None,
@@ -350,6 +366,9 @@ class HookManager:
             logger=self.logger,
         )
 
+        # Skill manager for core skill injection
+        self._skill_manager = HookSkillManager()
+
         # Event handlers (delegated to EventHandlers module)
         self._event_handlers = EventHandlers(
             session_manager=self._session_manager,
@@ -361,6 +380,8 @@ class HookManager:
             task_manager=self._task_manager,
             session_coordinator=self._session_coordinator,
             message_manager=self._message_manager,
+            skill_manager=self._skill_manager,
+            skills_config=self._config.skills if self._config else None,
             get_machine_id=self.get_machine_id,
             resolve_project_id=self._resolve_project_id,
             logger=self.logger,
@@ -620,6 +641,31 @@ class HookManager:
         try:
             response = handler(event)
 
+            # Copy session metadata from event to response for adapter injection
+            # The adapter reads response.metadata to inject session info into agent context
+            if event.metadata.get("_platform_session_id"):
+                response.metadata["session_id"] = event.metadata["_platform_session_id"]
+            if event.session_id:  # external_id (e.g., Claude Code's session UUID)
+                response.metadata["external_id"] = event.session_id
+            if event.machine_id:
+                response.metadata["machine_id"] = event.machine_id
+            if event.project_id:
+                response.metadata["project_id"] = event.project_id
+            # Copy terminal context if present
+            for key in [
+                "terminal_term_program",
+                "terminal_tty",
+                "terminal_parent_pid",
+                "terminal_iterm_session_id",
+                "terminal_term_session_id",
+                "terminal_kitty_window_id",
+                "terminal_tmux_pane",
+                "terminal_vscode_terminal_id",
+                "terminal_alacritty_socket",
+            ]:
+                if event.metadata.get(key):
+                    response.metadata[key] = event.metadata[key]
+
             # Merge workflow context if present
             if workflow_context:
                 if response.context:

gobby/hooks/skill_manager.py

@@ -0,0 +1,130 @@
+"""HookSkillManager - Skill management for the hook system.
+
+This module provides skill discovery and management for the hook system,
+allowing hooks to access and use skills (Agent Skills specification).
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from gobby.skills.loader import SkillLoader
+from gobby.skills.parser import ParsedSkill
+
+logger = logging.getLogger(__name__)
+
+
+class HookSkillManager:
+    """Manage skills for the hook system.
+
+    Provides discovery and access to core skills bundled with Gobby,
+    as well as project-specific skills.
+
+    Example usage:
+        ```python
+        from gobby.hooks.skill_manager import HookSkillManager
+
+        manager = HookSkillManager()
+        skills = manager.discover_core_skills()
+
+        # Get a specific skill
+        tasks_skill = manager.get_skill_by_name("gobby-tasks")
+        ```
+    """
+
+    def __init__(self) -> None:
+        """Initialize the skill manager."""
+        # Path to built-in skills: src/gobby/hooks/ -> src/gobby/install/shared/skills/
+        self._base_dir = Path(__file__).parent.parent
+        self._core_skills_path = self._base_dir / "install" / "shared" / "skills"
+
+        # Loader for parsing skills (use "filesystem" for bundled core skills)
+        self._loader = SkillLoader(default_source_type="filesystem")
+
+        # Cache of discovered skills
+        self._core_skills: list[ParsedSkill] | None = None
+
+    def discover_core_skills(self) -> list[ParsedSkill]:
+        """Discover built-in skills from install/shared/skills/.
+
+        Returns:
+            List of ParsedSkill objects for all valid core skills.
+            Invalid skills are logged as warnings and skipped.
+        """
+        if self._core_skills is not None:
+            return self._core_skills
+
+        if not self._core_skills_path.exists():
+            logger.warning(f"Core skills path not found: {self._core_skills_path}")
+            self._core_skills = []
+            return self._core_skills
+
+        # Load all skills from the core directory
+        self._core_skills = self._loader.load_directory(
+            self._core_skills_path,
+            validate=True,
+        )
+
+        logger.debug(f"Discovered {len(self._core_skills)} core skills")
+        return self._core_skills
+
+    def get_skill_by_name(self, name: str) -> ParsedSkill | None:
+        """Get a skill by name.
+
+        Args:
+            name: The skill name to look up.
+
+        Returns:
+            ParsedSkill if found, None otherwise.
+        """
+        # Ensure skills are discovered
+        skills = self.discover_core_skills()
+
+        for skill in skills:
+            if skill.name == name:
+                return skill
+
+        return None
+
+    def refresh(self) -> None:
+        """Clear the cache and rediscover skills."""
+        self._core_skills = None
+
+    def recommend_skills(self, category: str | None = None) -> list[str]:
+        """Recommend relevant skills based on task category.
+
+        Maps task categories to relevant core skills that would be helpful
+        for that type of work.
+
+        Args:
+            category: Task category (e.g., 'code', 'docs', 'test', 'config')
+
+        Returns:
+            List of skill names that are relevant for the category
+        """
+        # Category to skill mappings
+        category_skills: dict[str, list[str]] = {
+            "code": ["gobby-tasks", "gobby-expand", "gobby-worktrees"],
+            "test": ["gobby-tasks", "gobby-expand"],
+            "docs": ["gobby-tasks", "gobby-plan"],
+            "config": ["gobby-tasks", "gobby-mcp"],
+            "refactor": ["gobby-tasks", "gobby-expand", "gobby-worktrees"],
+            "planning": ["gobby-tasks", "gobby-plan", "gobby-expand"],
+            "research": ["gobby-tasks", "gobby-memory"],
+        }
+
+        # Get skills for the category (or empty list if no match)
+        recommended = category_skills.get(category or "", [])
+
+        # Always include alwaysApply skills
+        skills = self.discover_core_skills()
+        always_apply = [s.name for s in skills if s.is_always_apply()]
+
+        # Combine and dedupe while preserving order
+        result = list(always_apply)
+        for skill_name in recommended:
+            if skill_name not in result:
+                result.append(skill_name)
+
+        return result

gobby/install/claude/hooks/hook_dispatcher.py

@@ -23,7 +23,7 @@ from pathlib import Path
 # No longer need to import HookManager - we call it via HTTP daemon instead
 
 # Default daemon configuration
-DEFAULT_DAEMON_PORT = 8765
+DEFAULT_DAEMON_PORT = 60887
 DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
 
 
@@ -31,10 +31,10 @@ def get_daemon_url() -> str:
     """Get the daemon HTTP URL from config file.
 
     Reads daemon_port from ~/.gobby/config.yaml if it exists,
-    otherwise uses the default port 8765.
+    otherwise uses the default port 60887.
 
     Returns:
-        Full daemon URL like http://localhost:8765
+        Full daemon URL like http://localhost:60887
     """
     config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
 
@@ -308,7 +308,7 @@ def main() -> int:
                 "input_data": input_data,
                 "source": "claude",  # Required: identifies CLI source
             },
-            timeout=30.0,  # Generous timeout for hook processing
+            timeout=90.0,  # LLM-powered hooks (pre-compact summary) need more time
         )
 
         if response.status_code == 200:

gobby/install/codex/hooks/hook_dispatcher.py

@@ -19,7 +19,7 @@ from typing import Any
 
 import httpx
 
-DEFAULT_DAEMON_PORT = 8765
+DEFAULT_DAEMON_PORT = 60887
 DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
 DEBUG_ENV_VAR = "GOBBY_CODEX_NOTIFY_DEBUG"
 

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -26,11 +26,12 @@ Exit Codes:
 
 import argparse
 import json
+import os
 import sys
 from pathlib import Path
 
 # Default daemon configuration
-DEFAULT_DAEMON_PORT = 8765
+DEFAULT_DAEMON_PORT = 60887
 DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
 
 
@@ -38,10 +39,10 @@ def get_daemon_url() -> str:
     """Get the daemon HTTP URL from config file.
 
     Reads daemon_port from ~/.gobby/config.yaml if it exists,
-    otherwise uses the default port 8765.
+    otherwise uses the default port 60887.
 
     Returns:
-        Full daemon URL like http://localhost:8765
+        Full daemon URL like http://localhost:60887
     """
     config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
 
@@ -61,6 +62,55 @@ def get_daemon_url() -> str:
     return f"http://localhost:{port}"
 
 
+def get_terminal_context() -> dict[str, str | int | bool | None]:
+    """Capture terminal/process context for session correlation.
+
+    Returns:
+        Dict with terminal identifiers (values may be None if unavailable)
+    """
+    context: dict[str, str | int | bool | None] = {}
+
+    # Parent process ID (shell or Gemini process)
+    try:
+        context["parent_pid"] = os.getppid()
+    except Exception:
+        context["parent_pid"] = None
+
+    # TTY device name
+    try:
+        context["tty"] = os.ttyname(0)
+    except Exception:
+        context["tty"] = None
+
+    # macOS Terminal.app session ID
+    context["term_session_id"] = os.environ.get("TERM_SESSION_ID")
+
+    # iTerm2 session ID
+    context["iterm_session_id"] = os.environ.get("ITERM_SESSION_ID")
+
+    # VS Code integrated terminal detection
+    # VSCODE_IPC_HOOK_CLI is set when running in VS Code's integrated terminal
+    # TERM_PROGRAM == "vscode" is also a reliable indicator
+    vscode_ipc_hook = os.environ.get("VSCODE_IPC_HOOK_CLI")
+    term_program = os.environ.get("TERM_PROGRAM")
+    context["vscode_ipc_hook_cli"] = vscode_ipc_hook
+    context["vscode_terminal_detected"] = bool(vscode_ipc_hook) or term_program == "vscode"
+
+    # Tmux pane (if running in tmux)
+    context["tmux_pane"] = os.environ.get("TMUX_PANE")
+
+    # Kitty terminal window ID
+    context["kitty_window_id"] = os.environ.get("KITTY_WINDOW_ID")
+
+    # Alacritty IPC socket path (unique per instance)
+    context["alacritty_socket"] = os.environ.get("ALACRITTY_SOCKET")
+
+    # Generic terminal program identifier (set by many terminals)
+    context["term_program"] = os.environ.get("TERM_PROGRAM")
+
+    return context
+
+
 def parse_arguments() -> argparse.Namespace:
     """Parse command line arguments.
 
@@ -128,11 +178,26 @@ def main() -> int:
 
     # Check if gobby daemon is running before processing hooks
     if not check_daemon_running():
-        # Daemon is not running - return gracefully without processing
-        print(
-            json.dumps({"status": "daemon_not_running", "message": "gobby daemon is not running"})
-        )
-        return 0  # Exit 0 (allow) - this is expected behavior, not an error
+        # Critical hooks that manage session state MUST have daemon running
+        # Per Gemini CLI docs: SessionEnd, Notification, PreCompress are async/non-blocking
+        # Only SessionStart is critical for session initialization
+        critical_hooks = {"SessionStart"}
+        if hook_type in critical_hooks:
+            # Block the hook - forces user to start daemon before critical lifecycle events
+            print(
+                f"Gobby daemon is not running. Start with 'gobby start' before continuing. "
+                f"({hook_type} requires daemon for session state management)",
+                file=sys.stderr,
+            )
+            return 2  # Exit 2 = block operation
+        else:
+            # Non-critical hooks can proceed without daemon
+            print(
+                json.dumps(
+                    {"status": "daemon_not_running", "message": "gobby daemon is not running"}
+                )
+            )
+            return 0  # Exit 0 (allow) - allow operation to continue
 
     # Setup logger for dispatcher (not HookManager)
     import logging
@@ -147,6 +212,11 @@ def main() -> int:
         # Read JSON input from stdin
         input_data = json.load(sys.stdin)
 
+        # Inject terminal context for SessionStart hooks
+        # This captures the terminal/process info for session correlation
+        if hook_type == "SessionStart":
+            input_data["terminal_context"] = get_terminal_context()
+
         # Log what Gemini CLI sends us (for debugging hook data issues)
         logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
 
@@ -228,13 +298,18 @@ def main() -> int:
             # Determine exit code based on decision
             decision = result.get("decision", "allow")
 
-            # Print JSON output for Gemini CLI
+            # Check for block/deny decision - return exit code 2 to signal blocking
+            # For blocking, output goes to STDERR (Gemini reads stderr on exit 2)
+            if result.get("continue") is False or decision in ("deny", "block"):
+                # Output just the reason, not the full JSON
+                reason = result.get("stopReason") or result.get("reason") or "Blocked by hook"
+                print(reason, file=sys.stderr)
+                return 2
+
+            # Only print output if there's something meaningful to show
             if result and result != {}:
                 print(json.dumps(result))
 
-            # Exit code: 0 = allow, 2 = deny
-            if decision == "deny":
-                return 2
             return 0
         else:
             # HTTP error from daemon