gobby 0.2.7__tar.gz → 0.2.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gobby
-Version: 0.2.7
+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.7 → gobby-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gobby"
-version = "0.2.7"
+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.7 → 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.7 → 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.
@@ -104,6 +101,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         is_failure = hook_type == "post-tool-use-failure"
         metadata = {"is_failure": is_failure} if is_failure else {}
 
+        # Normalize event data for CLI-agnostic processing
+        # This allows downstream code to use consistent field names
+        normalized_data = self._normalize_event_data(input_data)
+
         return HookEvent(
             event_type=event_type,
             session_id=session_id,
@@ -111,10 +112,46 @@ class ClaudeCodeAdapter(BaseAdapter):
             timestamp=datetime.now(UTC),
             machine_id=input_data.get("machine_id"),
             cwd=input_data.get("cwd"),
-            data=input_data,
+            data=normalized_data,
             metadata=metadata,
         )
 
+    def _normalize_event_data(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """Normalize Claude Code event data for CLI-agnostic processing.
+
+        This method enriches the input_data with normalized fields so downstream
+        code doesn't need to handle Claude-specific formats.
+
+        Normalizations performed:
+        1. tool_input.server_name/tool_name → mcp_server/mcp_tool (for MCP calls)
+        2. tool_result → tool_output
+
+        Args:
+            input_data: Raw input data from Claude Code
+
+        Returns:
+            Enriched data dict with normalized fields added
+        """
+        # Start with a copy to avoid mutating original
+        data = dict(input_data)
+
+        # Get tool info
+        tool_name = data.get("tool_name", "")
+        tool_input = data.get("tool_input", {}) or {}
+
+        # 1. Extract MCP info from nested tool_input for call_tool calls
+        if tool_name in ("call_tool", "mcp__gobby__call_tool"):
+            if "mcp_server" not in data:
+                data["mcp_server"] = tool_input.get("server_name")
+            if "mcp_tool" not in data:
+                data["mcp_tool"] = tool_input.get("tool_name")
+
+        # 2. Normalize tool_result → tool_output
+        if "tool_result" in data and "tool_output" not in data:
+            data["tool_output"] = data["tool_result"]
+
+        return data
+
     # Map Claude Code hook types to hookEventName for hookSpecificOutput
     HOOK_EVENT_NAME_MAP: dict[str, str] = {
         "session-start": "SessionStart",
@@ -193,44 +230,65 @@ class ClaudeCodeAdapter(BaseAdapter):
         # Add session identifiers from metadata
         # Note: "session_id" in metadata is Gobby's internal platform session ID
         #       "external_id" in metadata is the CLI's session UUID
+        #       "session_ref" is the short #N format for easier reference
+        # Token optimization: Only inject full metadata on first hook per session
         if response.metadata:
             gobby_session_id = response.metadata.get("session_id")
+            session_ref = response.metadata.get("session_ref")
             external_id = response.metadata.get("external_id")
+            is_first_hook = response.metadata.get("_first_hook_for_session", False)
+
             if gobby_session_id:
-                # Build context with all available identifiers
-                # Use clear naming: Gobby Session ID for MCP calls, External ID for transcripts
-                context_lines = [f"Gobby Session ID: {gobby_session_id}"]
-                if external_id:
-                    context_lines.append(f"External ID: {external_id}")
-                if response.metadata.get("parent_session_id"):
-                    context_lines.append(
-                        f"parent_session_id: {response.metadata['parent_session_id']}"
-                    )
-                if response.metadata.get("machine_id"):
-                    context_lines.append(f"machine_id: {response.metadata['machine_id']}")
-                if response.metadata.get("project_id"):
-                    context_lines.append(f"project_id: {response.metadata['project_id']}")
-                # Add terminal context (non-null values only)
-                if response.metadata.get("terminal_term_program"):
-                    context_lines.append(f"terminal: {response.metadata['terminal_term_program']}")
-                if response.metadata.get("terminal_tty"):
-                    context_lines.append(f"tty: {response.metadata['terminal_tty']}")
-                if response.metadata.get("terminal_parent_pid"):
-                    context_lines.append(f"parent_pid: {response.metadata['terminal_parent_pid']}")
-                # Add terminal-specific session IDs (only one will be present)
-                for key in [
-                    "terminal_iterm_session_id",
-                    "terminal_term_session_id",
-                    "terminal_kitty_window_id",
-                    "terminal_tmux_pane",
-                    "terminal_vscode_terminal_id",
-                    "terminal_alacritty_socket",
-                ]:
-                    if response.metadata.get(key):
-                        # Use friendlier names in output
-                        friendly_name = key.replace("terminal_", "").replace("_", " ")
-                        context_lines.append(f"{friendly_name}: {response.metadata[key]}")
-                additional_context_parts.append("\n".join(context_lines))
+                if is_first_hook:
+                    # First hook: inject full metadata (~60-100 tokens)
+                    context_lines = []
+                    if session_ref:
+                        context_lines.append(
+                            f"Gobby Session ID: {session_ref} (or {gobby_session_id})"
+                        )
+                    else:
+                        context_lines.append(f"Gobby Session ID: {gobby_session_id}")
+                    if external_id:
+                        context_lines.append(
+                            f"CLI-Specific Session ID (external_id): {external_id}"
+                        )
+                    if response.metadata.get("parent_session_id"):
+                        context_lines.append(
+                            f"parent_session_id: {response.metadata['parent_session_id']}"
+                        )
+                    if response.metadata.get("machine_id"):
+                        context_lines.append(f"machine_id: {response.metadata['machine_id']}")
+                    if response.metadata.get("project_id"):
+                        context_lines.append(f"project_id: {response.metadata['project_id']}")
+                    # Add terminal context (non-null values only)
+                    if response.metadata.get("terminal_term_program"):
+                        context_lines.append(
+                            f"terminal: {response.metadata['terminal_term_program']}"
+                        )
+                    if response.metadata.get("terminal_tty"):
+                        context_lines.append(f"tty: {response.metadata['terminal_tty']}")
+                    if response.metadata.get("terminal_parent_pid"):
+                        context_lines.append(
+                            f"parent_pid: {response.metadata['terminal_parent_pid']}"
+                        )
+                    # Add terminal-specific session IDs (only one will be present)
+                    for key in [
+                        "terminal_iterm_session_id",
+                        "terminal_term_session_id",
+                        "terminal_kitty_window_id",
+                        "terminal_tmux_pane",
+                        "terminal_vscode_terminal_id",
+                        "terminal_alacritty_socket",
+                    ]:
+                        if response.metadata.get(key):
+                            # Use friendlier names in output
+                            friendly_name = key.replace("terminal_", "").replace("_", " ")
+                            context_lines.append(f"{friendly_name}: {response.metadata[key]}")
+                    additional_context_parts.append("\n".join(context_lines))
+                else:
+                    # Subsequent hooks: inject minimal session ref only (~8 tokens)
+                    if session_ref:
+                        additional_context_parts.append(f"Gobby Session ID: {session_ref}")
 
         # Build hookSpecificOutput if we have any context to inject
         # Only include hookSpecificOutput for hook types that Claude Code's schema accepts
@@ -249,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.
@@ -264,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.7 → gobby-0.2.9}/src/gobby/adapters/gemini.py

@@ -76,21 +76,39 @@ class GeminiAdapter(BaseAdapter):
 
     # Tool name mapping: Gemini tool names -> normalized names
     # Gemini uses different tool names than Claude Code
+    # This enables workflows to use Claude Code naming conventions
     TOOL_MAP: dict[str, str] = {
+        # Shell/Bash
         "run_shell_command": "Bash",
         "RunShellCommand": "Bash",
+        "ShellTool": "Bash",
+        # File read
         "read_file": "Read",
         "ReadFile": "Read",
         "ReadFileTool": "Read",
+        # File write
         "write_file": "Write",
         "WriteFile": "Write",
         "WriteFileTool": "Write",
+        # File edit
         "edit_file": "Edit",
         "EditFile": "Edit",
         "EditFileTool": "Edit",
+        # Search/Glob/Grep
         "GlobTool": "Glob",
         "GrepTool": "Grep",
-        "ShellTool": "Bash",
+        "search_file_content": "Grep",
+        "SearchText": "Grep",
+        # MCP tools (Gobby MCP server)
+        "call_tool": "mcp__gobby__call_tool",
+        "list_mcp_servers": "mcp__gobby__list_mcp_servers",
+        "list_tools": "mcp__gobby__list_tools",
+        "get_tool_schema": "mcp__gobby__get_tool_schema",
+        "search_tools": "mcp__gobby__search_tools",
+        "recommend_tools": "mcp__gobby__recommend_tools",
+        # Skill and agent tools
+        "activate_skill": "Skill",
+        "delegate_to_agent": "Task",
     }
 
     def __init__(self, hook_manager: "HookManager | None" = None):
@@ -135,6 +153,55 @@ class GeminiAdapter(BaseAdapter):
         """
         return self.TOOL_MAP.get(gemini_tool_name, gemini_tool_name)
 
+    def _normalize_event_data(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """Normalize Gemini event data for CLI-agnostic processing.
+
+        This method enriches the input_data with normalized fields so downstream
+        code doesn't need to handle Gemini-specific formats.
+
+        Normalizations performed:
+        1. mcp_context.server_name/tool_name → mcp_server/mcp_tool (top-level)
+        2. tool_response → tool_output
+        3. function_name → tool_name (if not already present)
+        4. parameters/args → tool_input (if not already present)
+
+        Args:
+            input_data: Raw input data from Gemini CLI
+
+        Returns:
+            Enriched data dict with normalized fields added
+        """
+        # Start with a copy to avoid mutating original
+        data = dict(input_data)
+
+        # 1. Flatten mcp_context to top-level mcp_server/mcp_tool
+        mcp_context = data.get("mcp_context")
+        if mcp_context and isinstance(mcp_context, dict):
+            if "mcp_server" not in data:
+                data["mcp_server"] = mcp_context.get("server_name")
+            if "mcp_tool" not in data:
+                data["mcp_tool"] = mcp_context.get("tool_name")
+
+        # 2. Normalize tool_response → tool_output
+        if "tool_response" in data and "tool_output" not in data:
+            data["tool_output"] = data["tool_response"]
+
+        # 3. Normalize function_name → tool_name
+        if "function_name" in data and "tool_name" not in data:
+            data["tool_name"] = self.normalize_tool_name(data["function_name"])
+        elif "tool_name" in data:
+            # Normalize existing tool_name
+            data["tool_name"] = self.normalize_tool_name(data["tool_name"])
+
+        # 4. Normalize parameters/args → tool_input
+        if "tool_input" not in data:
+            if "parameters" in data:
+                data["tool_input"] = data["parameters"]
+            elif "args" in data:
+                data["tool_input"] = data["args"]
+
+        return data
+
     def translate_to_hook_event(self, native_event: dict[str, Any]) -> HookEvent:
         """Convert Gemini CLI native event to unified HookEvent.
 
@@ -202,6 +269,10 @@ class GeminiAdapter(BaseAdapter):
         else:
             metadata = {}
 
+        # Normalize event data for CLI-agnostic processing
+        # This allows downstream code to use consistent field names
+        normalized_data = self._normalize_event_data(input_data)
+
         return HookEvent(
             event_type=event_type,
             session_id=session_id,
@@ -209,7 +280,7 @@ class GeminiAdapter(BaseAdapter):
             timestamp=timestamp,
             machine_id=machine_id,
             cwd=input_data.get("cwd"),
-            data=input_data,
+            data=normalized_data,
             metadata=metadata,
         )
 
@@ -254,46 +325,77 @@ class GeminiAdapter(BaseAdapter):
         if response.context:
             hook_specific["additionalContext"] = response.context
 
-        # Add session/terminal context for SessionStart only
-        if hook_type == "SessionStart" and response.metadata:
+        # Add session/terminal context for hooks that support additionalContext
+        # Parity with Claude Code: inject on SessionStart, BeforeAgent, BeforeTool, AfterTool
+        hooks_with_context = {"SessionStart", "BeforeAgent", "BeforeTool", "AfterTool"}
+        if hook_type in hooks_with_context and response.metadata:
             session_id = response.metadata.get("session_id")
+            session_ref = response.metadata.get("session_ref")
+            external_id = response.metadata.get("external_id")
+            is_first_hook = response.metadata.get("_first_hook_for_session", False)
+
             if session_id:
                 hook_event_name = self.HOOK_EVENT_NAME_MAP.get(hook_type, "Unknown")
-                context_lines = [f"session_id: {session_id}"]
-                if response.metadata.get("parent_session_id"):
-                    context_lines.append(
-                        f"parent_session_id: {response.metadata['parent_session_id']}"
+
+                if is_first_hook:
+                    # First hook: inject full metadata (~60-100 tokens)
+                    context_lines = []
+                    if session_ref:
+                        context_lines.append(f"Gobby Session ID: {session_ref} (or {session_id})")
+                    else:
+                        context_lines.append(f"Gobby Session ID: {session_id}")
+                    if external_id:
+                        context_lines.append(
+                            f"CLI-Specific Session ID (external_id): {external_id}"
+                        )
+                    if response.metadata.get("parent_session_id"):
+                        context_lines.append(
+                            f"parent_session_id: {response.metadata['parent_session_id']}"
+                        )
+                    if response.metadata.get("machine_id"):
+                        context_lines.append(f"machine_id: {response.metadata['machine_id']}")
+                    if response.metadata.get("project_id"):
+                        context_lines.append(f"project_id: {response.metadata['project_id']}")
+                    # Add terminal context (non-null values only)
+                    if response.metadata.get("terminal_term_program"):
+                        context_lines.append(
+                            f"terminal: {response.metadata['terminal_term_program']}"
+                        )
+                    if response.metadata.get("terminal_tty"):
+                        context_lines.append(f"tty: {response.metadata['terminal_tty']}")
+                    if response.metadata.get("terminal_parent_pid"):
+                        context_lines.append(
+                            f"parent_pid: {response.metadata['terminal_parent_pid']}"
+                        )
+                    # Add terminal-specific session IDs
+                    for key in [
+                        "terminal_iterm_session_id",
+                        "terminal_term_session_id",
+                        "terminal_kitty_window_id",
+                        "terminal_tmux_pane",
+                        "terminal_vscode_terminal_id",
+                        "terminal_alacritty_socket",
+                    ]:
+                        if response.metadata.get(key):
+                            friendly_name = key.replace("terminal_", "").replace("_", " ")
+                            context_lines.append(f"{friendly_name}: {response.metadata[key]}")
+
+                    hook_specific["hookEventName"] = hook_event_name
+                    # Append to existing additionalContext if present
+                    existing = hook_specific.get("additionalContext", "")
+                    new_context = "\n".join(context_lines)
+                    hook_specific["additionalContext"] = (
+                        f"{existing}\n{new_context}" if existing else new_context
                     )
-                if response.metadata.get("machine_id"):
-                    context_lines.append(f"machine_id: {response.metadata['machine_id']}")
-                if response.metadata.get("project_id"):
-                    context_lines.append(f"project_id: {response.metadata['project_id']}")
-                # Add terminal context (non-null values only)
-                if response.metadata.get("terminal_term_program"):
-                    context_lines.append(f"terminal: {response.metadata['terminal_term_program']}")
-                if response.metadata.get("terminal_tty"):
-                    context_lines.append(f"tty: {response.metadata['terminal_tty']}")
-                if response.metadata.get("terminal_parent_pid"):
-                    context_lines.append(f"parent_pid: {response.metadata['terminal_parent_pid']}")
-                # Add terminal-specific session IDs
-                for key in [
-                    "terminal_iterm_session_id",
-                    "terminal_term_session_id",
-                    "terminal_kitty_window_id",
-                    "terminal_tmux_pane",
-                    "terminal_vscode_terminal_id",
-                    "terminal_alacritty_socket",
-                ]:
-                    if response.metadata.get(key):
-                        friendly_name = key.replace("terminal_", "").replace("_", " ")
-                        context_lines.append(f"{friendly_name}: {response.metadata[key]}")
-                hook_specific["hookEventName"] = hook_event_name
-                # Append to existing additionalContext if present
-                existing = hook_specific.get("additionalContext", "")
-                new_context = "\n".join(context_lines)
-                hook_specific["additionalContext"] = (
-                    f"{existing}\n{new_context}" if existing else new_context
-                )
+                else:
+                    # Subsequent hooks: inject minimal session ref only (~8 tokens)
+                    if session_ref:
+                        hook_specific["hookEventName"] = hook_event_name
+                        existing = hook_specific.get("additionalContext", "")
+                        minimal_context = f"Gobby Session ID: {session_ref}"
+                        hook_specific["additionalContext"] = (
+                            f"{existing}\n{minimal_context}" if existing else minimal_context
+                        )
 
         # Handle BeforeModel-specific output (llm_request modification)
         if hook_type == "BeforeModel" and response.modify_args:

{gobby-0.2.7 → gobby-0.2.9}/src/gobby/agents/isolation.py

@@ -197,6 +197,13 @@ class WorktreeIsolationHandler(IsolationHandler):
             task_id=config.task_id,
         )
 
+        # Copy CLI hooks to worktree so hooks fire correctly
+        await self._copy_cli_hooks(
+            main_repo_path=self._git_manager.repo_path,
+            worktree_path=worktree_path,
+            provider=config.provider,
+        )
+
         return IsolationContext(
             cwd=worktree.worktree_path,
             branch_name=worktree.branch_name,
@@ -235,6 +242,64 @@ Commit your changes to the worktree branch when done.
         worktree_dir = tempfile.gettempdir()
         return f"{worktree_dir}/gobby-worktrees/{project_name}/{safe_branch}"
 
+    async def _copy_cli_hooks(
+        self,
+        main_repo_path: str,
+        worktree_path: str,
+        provider: str,
+    ) -> None:
+        """
+        Copy CLI-specific hooks to the worktree.
+
+        Without these hooks, the spawned agent won't trigger SessionStart
+        and other lifecycle hooks, breaking Gobby integration.
+
+        Args:
+            main_repo_path: Path to the main repository
+            worktree_path: Path to the newly created worktree
+            provider: CLI provider (gemini, claude, codex)
+        """
+        import asyncio
+        import logging
+        import shutil
+        from pathlib import Path
+
+        logger = logging.getLogger(__name__)
+
+        # Map provider to CLI hook directory
+        cli_dirs = {
+            "gemini": ".gemini",
+            "claude": ".claude",
+            "codex": ".codex",
+        }
+
+        cli_dir = cli_dirs.get(provider)
+        if not cli_dir:
+            logger.debug(f"No CLI hooks directory defined for provider: {provider}")
+            return
+
+        src_path = Path(main_repo_path) / cli_dir
+        dst_path = Path(worktree_path) / cli_dir
+
+        if not src_path.exists():
+            logger.debug(f"CLI hooks directory not found in main repo: {src_path}")
+            return
+
+        try:
+            # Copy entire CLI hooks directory (non-blocking)
+            await asyncio.to_thread(shutil.copytree, src_path, dst_path, dirs_exist_ok=True)
+            logger.info(f"Copied CLI hooks from {src_path} to {dst_path}")
+        except shutil.Error:
+            logger.warning(
+                f"Failed to copy CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+        except OSError:
+            logger.warning(
+                f"Filesystem error copying CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+
 
 class CloneIsolationHandler(IsolationHandler):
     """
@@ -310,6 +375,13 @@ class CloneIsolationHandler(IsolationHandler):
             task_id=config.task_id,
         )
 
+        # Copy CLI hooks to clone so hooks fire correctly
+        await self._copy_cli_hooks(
+            source_repo_path=config.project_path,
+            clone_path=clone_path,
+            provider=config.provider,
+        )
+
         return IsolationContext(
             cwd=clone.clone_path,
             branch_name=clone.branch_name,
@@ -348,6 +420,64 @@ Push your changes when ready to share with the original.
         clone_dir = tempfile.gettempdir()
         return f"{clone_dir}/gobby-clones/{project_name}/{safe_branch}"
 
+    async def _copy_cli_hooks(
+        self,
+        source_repo_path: str,
+        clone_path: str,
+        provider: str,
+    ) -> None:
+        """
+        Copy CLI-specific hooks to the clone.
+
+        Without these hooks, the spawned agent won't trigger SessionStart
+        and other lifecycle hooks, breaking Gobby integration.
+
+        Args:
+            source_repo_path: Path to the source repository
+            clone_path: Path to the newly created clone
+            provider: CLI provider (gemini, claude, codex)
+        """
+        import asyncio
+        import logging
+        import shutil
+        from pathlib import Path
+
+        logger = logging.getLogger(__name__)
+
+        # Map provider to CLI hook directory
+        cli_dirs = {
+            "gemini": ".gemini",
+            "claude": ".claude",
+            "codex": ".codex",
+        }
+
+        cli_dir = cli_dirs.get(provider)
+        if not cli_dir:
+            logger.debug(f"No CLI hooks directory defined for provider: {provider}")
+            return
+
+        src_path = Path(source_repo_path) / cli_dir
+        dst_path = Path(clone_path) / cli_dir
+
+        if not src_path.exists():
+            logger.debug(f"CLI hooks directory not found in source repo: {src_path}")
+            return
+
+        try:
+            # Copy entire CLI hooks directory (non-blocking)
+            await asyncio.to_thread(shutil.copytree, src_path, dst_path, dirs_exist_ok=True)
+            logger.info(f"Copied CLI hooks from {src_path} to {dst_path}")
+        except shutil.Error:
+            logger.warning(
+                f"Failed to copy CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+        except OSError:
+            logger.warning(
+                f"Filesystem error copying CLI hooks: provider={provider}, src={src_path}, dst={dst_path}",
+                exc_info=True,
+            )
+
 
 def get_isolation_handler(
     mode: Literal["current", "worktree", "clone"],

{gobby-0.2.7 → gobby-0.2.9}/src/gobby/agents/registry.py

@@ -137,6 +137,17 @@ class RunningAgentRegistry:
         with self._event_callbacks_lock:
             self._event_callbacks.append(callback)
 
+    def emit_event(self, event_type: str, run_id: str, data: dict[str, Any]) -> None:
+        """
+        Emit a custom event to all registered callbacks.
+
+        Args:
+            event_type: Type of event (e.g., terminal_output)
+            run_id: Agent run ID
+            data: Additional event data
+        """
+        self._emit_event(event_type, run_id, data)
+
     def _emit_event(self, event_type: str, run_id: str, data: dict[str, Any]) -> None:
         """
         Emit an event to all registered callbacks.

{gobby-0.2.7 → gobby-0.2.9}/src/gobby/agents/session.py

@@ -196,6 +196,7 @@ class ChildSessionManager:
             parent_session_id=config.parent_session_id,
             agent_depth=child_depth,
             spawned_by_agent_id=config.agent_id,
+            workflow_name=config.workflow_name,
         )
 
         child_id = child.id