gobby 0.2.7__py3-none-any.whl → 0.2.8__py3-none-any.whl

gobby/hooks/event_handlers.py

@@ -147,6 +147,56 @@ class EventHandlers:
         """
         return dict(self._handler_map)
 
+    def _auto_activate_workflow(
+        self, workflow_name: str, session_id: str, project_path: str | None
+    ) -> None:
+        """Auto-activate a workflow for a session.
+
+        Args:
+            workflow_name: Name of the workflow to activate
+            session_id: Session ID to activate workflow for
+            project_path: Project path for workflow context
+        """
+        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,
+            )
+
     # ==================== SESSION HANDLERS ====================
 
     def handle_session_start(self, event: HookEvent) -> HookResponse:
@@ -207,6 +257,12 @@ class EventHandlers:
                         except Exception as e:
                             self.logger.warning(f"Failed to start agent run: {e}")
 
+                    # Auto-activate workflow if specified for this session
+                    if existing_session.workflow_name and session_id:
+                        self._auto_activate_workflow(
+                            existing_session.workflow_name, session_id, cwd
+                        )
+
                     # Update event metadata
                     event.metadata["_platform_session_id"] = session_id
 
@@ -235,9 +291,9 @@ class EventHandlers:
                     session_ref = (
                         f"#{existing_session.seq_num}" if existing_session.seq_num else session_id
                     )
-                    system_message = f"\nGobby Session Ref: {session_ref}"
-                    system_message += f"\nGobby Session ID: {session_id}"
-                    system_message += f"\nExternal ID: {external_id}"
+                    system_message = f"\nGobby Session ID: {session_ref}"
+                    system_message += " <- Use this for MCP tool calls (session_id parameter)"
+                    system_message += f"\nExternal ID: {external_id} (CLI-native, rarely needed)"
                     if parent_session_id:
                         context_parts.append(f"Parent session: {parent_session_id}")
 
@@ -261,6 +317,7 @@ class EventHandlers:
                         system_message=system_message,
                         metadata={
                             "session_id": session_id,
+                            "session_ref": session_ref,
                             "parent_session_id": parent_session_id,
                             "machine_id": machine_id,
                             "project_id": existing_session.project_id,
@@ -272,9 +329,13 @@ class EventHandlers:
             except Exception as e:
                 self.logger.debug(f"No pre-created session found: {e}")
 
-        # Step 1: Find parent session if this is a handoff (source='clear' only)
-        parent_session_id = None
-        if session_source == "clear" and self._session_storage:
+        # Step 1: Find parent session
+        # Check env vars first (spawned agent case), then handoff (source='clear')
+        parent_session_id = input_data.get("parent_session_id")
+        workflow_name = input_data.get("workflow_name")
+        agent_depth = input_data.get("agent_depth")
+
+        if not parent_session_id and session_source == "clear" and self._session_storage:
             try:
                 parent = self._session_storage.find_parent(
                     machine_id=machine_id,
@@ -291,6 +352,14 @@ class EventHandlers:
         # Step 2: Register new session with parent if found
         # Extract terminal context (injected by hook_dispatcher for terminal correlation)
         terminal_context = input_data.get("terminal_context")
+        # Parse agent_depth as int if provided
+        agent_depth_val = 0
+        if agent_depth:
+            try:
+                agent_depth_val = int(agent_depth)
+            except (ValueError, TypeError):
+                pass
+
         session_id = None
         if self._session_manager:
             session_id = self._session_manager.register_session(
@@ -302,6 +371,8 @@ class EventHandlers:
                 source=cli_source,
                 project_path=cwd,
                 terminal_context=terminal_context,
+                workflow_name=workflow_name,
+                agent_depth=agent_depth_val,
             )
 
         # Step 2b: Mark parent session as expired after successful handoff
@@ -312,6 +383,10 @@ class EventHandlers:
             except Exception as e:
                 self.logger.warning(f"Failed to mark parent session as expired: {e}")
 
+        # Step 2c: Auto-activate workflow if specified (for spawned agents)
+        if workflow_name and session_id:
+            self._auto_activate_workflow(workflow_name, session_id, cwd)
+
         # Step 3: Track registered session
         if transcript_path and self._session_coordinator:
             try:
@@ -354,9 +429,13 @@ class EventHandlers:
             session_obj = self._session_storage.get(session_id)
             if session_obj and session_obj.seq_num:
                 session_ref = f"#{session_obj.seq_num}"
-        system_message = f"\nGobby Session Ref: {session_ref}"
-        system_message += f"\nGobby Session ID: {session_id}"
-        system_message += f"\nExternal ID: {external_id}"
+        # Format: "Gobby Session ID: #N" with usage hint
+        if session_ref and session_ref != session_id:
+            system_message = f"\nGobby Session ID: {session_ref}"
+        else:
+            system_message = f"\nGobby Session ID: {session_id}"
+        system_message += " <- Use this for MCP tool calls (session_id parameter)"
+        system_message += f"\nExternal ID: {external_id} (CLI-native, rarely needed)"
 
         # Add active lifecycle workflows
         if wf_response.metadata and "discovered_workflows" in wf_response.metadata:
@@ -384,6 +463,7 @@ class EventHandlers:
         # Build metadata with terminal context (filter out nulls)
         metadata: dict[str, Any] = {
             "session_id": session_id,
+            "session_ref": session_ref,
             "parent_session_id": parent_session_id,
             "machine_id": machine_id,
             "project_id": project_id,
@@ -716,10 +796,16 @@ class EventHandlers:
 
             # Track edits for session high-water mark
             # Only if tool succeeded, matches edit tools, and session has claimed a task
+            # Skip .gobby/ internal files (tasks.jsonl, memories.jsonl, etc.)
+            tool_input = input_data.get("tool_input", {})
+            file_path = tool_input.get("file_path", "")
+            is_gobby_internal = "/.gobby/" in file_path or file_path.startswith(".gobby/")
+
             if (
                 not is_failure
                 and tool_name
                 and tool_name.lower() in EDIT_TOOLS
+                and not is_gobby_internal
                 and self._session_storage
                 and self._task_manager
             ):
@@ -780,10 +866,23 @@ class EventHandlers:
     # ==================== COMPACT HANDLER ====================
 
     def handle_pre_compact(self, event: HookEvent) -> HookResponse:
-        """Handle PRE_COMPACT event."""
+        """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.
+        """
+        from gobby.hooks.events import SessionSource
+
         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

gobby/hooks/hook_manager.py

@@ -369,6 +369,10 @@ class HookManager:
         # Skill manager for core skill injection
         self._skill_manager = HookSkillManager()
 
+        # Track sessions that have received full metadata injection
+        # Key: "{platform_session_id}:{source}" - cleared on daemon restart
+        self._injected_sessions: set[str] = set()
+
         # Event handlers (delegated to EventHandlers module)
         self._event_handlers = EventHandlers(
             session_manager=self._session_manager,
@@ -644,7 +648,21 @@ class HookManager:
             # 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"]
+                platform_session_id = event.metadata["_platform_session_id"]
+                response.metadata["session_id"] = platform_session_id
+                # Look up seq_num for session_ref (#N format)
+                if self._session_storage:
+                    session_obj = self._session_storage.get(platform_session_id)
+                    if session_obj and session_obj.seq_num:
+                        response.metadata["session_ref"] = f"#{session_obj.seq_num}"
+
+                # Track first hook per session for token optimization
+                # Adapters use this flag to inject full metadata only on first hook
+                session_key = f"{platform_session_id}:{event.source.value}"
+                is_first = session_key not in self._injected_sessions
+                if is_first:
+                    self._injected_sessions.add(session_key)
+                response.metadata["_first_hook_for_session"] = is_first
             if event.session_id:  # external_id (e.g., Claude Code's session UUID)
                 response.metadata["external_id"] = event.session_id
             if event.machine_id:

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -216,52 +216,111 @@ def main() -> int:
         # This captures the terminal/process info for session correlation
         if hook_type == "SessionStart":
             input_data["terminal_context"] = get_terminal_context()
+            # Note: gobby_context (parent_session_id, workflow, etc.) is no longer
+            # injected from env vars. For spawned agents, the session is pre-created
+            # with all linkage via preflight+resume pattern, so the daemon already
+            # has the context when SessionStart fires.
 
         # Log what Gemini CLI sends us (for debugging hook data issues)
-        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+        # Extract common context fields for structured logging
+        session_id = input_data.get("session_id")
+        task_id = input_data.get("task_id")
+        project_id = input_data.get("project_id")
+        base_context = {
+            "hook_type": hook_type,
+            "session_id": session_id,
+            "task_id": task_id,
+            "project_id": project_id,
+        }
+
+        logger.info(
+            "[%s] Received input keys: %s",
+            hook_type,
+            list(input_data.keys()),
+            extra=base_context,
+        )
 
         # Log hook-specific critical fields
         if hook_type == "SessionStart":
-            logger.info(f"[SessionStart] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[SessionStart] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "SessionEnd":
+            reason = input_data.get("reason")
             logger.info(
-                f"[SessionEnd] session_id={input_data.get('session_id')}, "
-                f"reason={input_data.get('reason')}"
+                "[SessionEnd] session_id=%s, reason=%s",
+                session_id,
+                reason,
+                extra={**base_context, "reason": reason},
             )
         elif hook_type == "BeforeAgent":
             prompt = input_data.get("prompt", "")
             prompt_preview = prompt[:100] + "..." if len(prompt) > 100 else prompt
             logger.info(
-                f"[BeforeAgent] session_id={input_data.get('session_id')}, prompt={prompt_preview}"
+                "[BeforeAgent] session_id=%s, prompt=%s",
+                session_id,
+                prompt_preview,
+                extra={**base_context, "prompt_preview": prompt_preview},
             )
         elif hook_type == "BeforeTool":
             tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
             logger.info(
-                f"[BeforeTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+                "[BeforeTool] tool_name=%s, session_id=%s",
+                tool_name,
+                session_id,
+                extra={**base_context, "tool_name": tool_name},
             )
         elif hook_type == "AfterTool":
             tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
+            error = input_data.get("error")
             logger.info(
-                f"[AfterTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+                "[AfterTool] tool_name=%s, session_id=%s",
+                tool_name,
+                session_id,
+                extra={**base_context, "tool_name": tool_name, "error": error},
             )
         elif hook_type == "BeforeToolSelection":
-            logger.info(f"[BeforeToolSelection] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[BeforeToolSelection] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "BeforeModel":
+            model = input_data.get("model", "unknown")
             logger.info(
-                f"[BeforeModel] session_id={input_data.get('session_id')}, "
-                f"model={input_data.get('model', 'unknown')}"
+                "[BeforeModel] session_id=%s, model=%s",
+                session_id,
+                model,
+                extra={**base_context, "model": model},
             )
         elif hook_type == "AfterModel":
-            logger.info(f"[AfterModel] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[AfterModel] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "PreCompress":
-            logger.info(f"[PreCompress] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[PreCompress] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
         elif hook_type == "Notification":
+            message = input_data.get("message")
             logger.info(
-                f"[Notification] session_id={input_data.get('session_id')}, "
-                f"message={input_data.get('message')}"
+                "[Notification] session_id=%s, message=%s",
+                session_id,
+                message,
+                extra={**base_context, "notification_message": message},
             )
         elif hook_type == "AfterAgent":
-            logger.info(f"[AfterAgent] session_id={input_data.get('session_id')}")
+            logger.info(
+                "[AfterAgent] session_id=%s",
+                session_id,
+                extra=base_context,
+            )
 
         if debug_mode:
             logger.debug(f"Input data: {input_data}")

gobby/mcp_proxy/instructions.py

@@ -26,9 +26,9 @@ def build_gobby_instructions() -> str:
 At the start of EVERY session:
 1. `list_mcp_servers()` — Discover available servers
 2. `list_skills()` — Discover available skills
-3. Session ID: Look for `session_id: <uuid>` in your context.
+3. Session ID: Look for `Gobby Session Ref:` or `Gobby Session ID:` in your context.
    If missing, call:
-   `call_tool("gobby-sessions", "get_current", {"external_id": "<your-session-id>", "source": "claude"})`
+   `call_tool("gobby-sessions", "get_current_session", {"external_id": "<your-session-id>", "source": "<cli-name>"})`
 
 Session and task references use `#N` format (e.g., `#1`, `#42`) which is project-scoped.
 </startup>

gobby/mcp_proxy/registries.py

@@ -168,21 +168,38 @@ def setup_internal_registries(
 
     # Initialize agents registry if agent_runner is available
     if agent_runner is not None:
-        from gobby.agents.registry import get_running_agent_registry
+        from gobby.agents.definitions import AgentDefinitionLoader
         from gobby.mcp_proxy.tools.agents import create_agents_registry
 
+        # Create clone git manager if we have a git manager
+        clone_git_manager = None
+        if git_manager is not None:
+            try:
+                from gobby.clones.git import CloneGitManager
+
+                clone_git_manager = CloneGitManager(git_manager.repo_path)
+            except Exception as e:
+                logger.debug(f"CloneGitManager not available for spawn_agent: {e}")
+
         agents_registry = create_agents_registry(
             runner=agent_runner,
+            agent_loader=AgentDefinitionLoader(),
+            session_manager=local_session_manager,
+            task_manager=task_manager,
+            worktree_storage=worktree_storage,
+            git_manager=git_manager,
+            clone_storage=clone_storage,
+            clone_manager=clone_git_manager,
         )
 
-        # Add inter-agent messaging tools if message manager is available
-        if inter_session_message_manager is not None:
+        # Add inter-agent messaging tools if message manager and session manager are available
+        if inter_session_message_manager is not None and local_session_manager is not None:
             from gobby.mcp_proxy.tools.agent_messaging import add_messaging_tools
 
             add_messaging_tools(
                 registry=agents_registry,
                 message_manager=inter_session_message_manager,
-                agent_registry=get_running_agent_registry(),
+                session_manager=local_session_manager,
             )
             logger.debug("Agent messaging tools added to agents registry")