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

gobby/tools/summarizer.py

@@ -23,25 +23,6 @@ MAX_DESCRIPTION_LENGTH = 200
 _config: ToolSummarizerConfig | None = None
 _loader: PromptLoader | None = None
 
-DEFAULT_SUMMARY_PROMPT = """Summarize this MCP tool description in 180 characters or less.
-Keep it to three sentences or less. Be concise and preserve the key functionality.
-Do not add quotes, extra formatting, or code examples.
-
-Description: {description}
-
-Summary:"""
-
-DEFAULT_SUMMARY_SYSTEM_PROMPT = "You are a technical summarizer. Create concise tool descriptions."
-
-DEFAULT_SERVER_DESC_PROMPT = """Write a single concise sentence describing what the '{server_name}' MCP server does based on its tools.
-
-Tools:
-{tools_list}
-
-Description (1 sentence, try to keep under 100 characters):"""
-
-DEFAULT_SERVER_DESC_SYSTEM_PROMPT = "You write concise technical descriptions."
-
 
 def init_summarizer_config(config: ToolSummarizerConfig, project_dir: str | None = None) -> None:
     """Initialize the summarizer with configuration."""
@@ -50,13 +31,6 @@ def init_summarizer_config(config: ToolSummarizerConfig, project_dir: str | None
     global _config, _loader
     _config = config
     _loader = PromptLoader(project_dir=Path(project_dir) if project_dir else None)
-    # Register fallbacks
-    _loader.register_fallback("features/tool_summary", lambda: DEFAULT_SUMMARY_PROMPT)
-    _loader.register_fallback("features/tool_summary_system", lambda: DEFAULT_SUMMARY_SYSTEM_PROMPT)
-    _loader.register_fallback("features/server_description", lambda: DEFAULT_SERVER_DESC_PROMPT)
-    _loader.register_fallback(
-        "features/server_description_system", lambda: DEFAULT_SERVER_DESC_SYSTEM_PROMPT
-    )
 
 
 def _get_config() -> ToolSummarizerConfig:
@@ -96,9 +70,9 @@ async def _summarize_description_with_claude(description: str) -> str:
             if _loader is None:
                 raise RuntimeError("Summarizer not initialized")
             prompt = _loader.render(prompt_path, {"description": description})
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load prompt from {prompt_path}: {e}, using default")
-            prompt = DEFAULT_SUMMARY_PROMPT.format(description=description)
+        except (OSError, KeyError, ValueError, RuntimeError) as e:
+            logger.debug(f"Failed to load prompt from {prompt_path}: {e}")
+            raise
 
         # Get system prompt
         sys_prompt_path = config.system_prompt_path or "features/tool_summary_system"
@@ -106,9 +80,9 @@ async def _summarize_description_with_claude(description: str) -> str:
             if _loader is None:
                 raise RuntimeError("Summarizer not initialized")
             system_prompt = _loader.render(sys_prompt_path, {})
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load system prompt from {sys_prompt_path}: {e}, using default")
-            system_prompt = DEFAULT_SUMMARY_SYSTEM_PROMPT
+        except (OSError, KeyError, ValueError, RuntimeError) as e:
+            logger.debug(f"Failed to load system prompt from {sys_prompt_path}: {e}")
+            system_prompt = "You are a technical summarizer."
 
         # Configure for single-turn completion
         options = ClaudeAgentOptions(
@@ -198,30 +172,23 @@ async def generate_server_description(
             "server_name": server_name,
             "tools_list": tools_list,
         }
-        try:
-            if _loader is None:
-                _get_config()  # force init
-            if _loader is None:
-                # Still None after _get_config, use default
-                prompt = DEFAULT_SERVER_DESC_PROMPT.format(**context)
-            else:
-                prompt = _loader.render(prompt_path, context)
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load prompt from {prompt_path}: {e}, using default")
-            prompt = DEFAULT_SERVER_DESC_PROMPT.format(**context)
+        if _loader is None:
+            _get_config()  # force init
+        if _loader is None:
+            # Still None after _get_config, use default
+            raise RuntimeError("Summarizer not initialized")
+        else:
+            prompt = _loader.render(prompt_path, context)
 
         # Get system prompt
         sys_prompt_path = (
             config.server_description_system_prompt_path or "features/server_description_system"
         )
-        try:
-            if _loader is None:
-                system_prompt = DEFAULT_SERVER_DESC_SYSTEM_PROMPT
-            else:
-                system_prompt = _loader.render(sys_prompt_path, {})
-        except (FileNotFoundError, OSError, KeyError, ValueError, RuntimeError) as e:
-            logger.debug(f"Failed to load system prompt from {sys_prompt_path}: {e}, using default")
-            system_prompt = DEFAULT_SERVER_DESC_SYSTEM_PROMPT
+
+        if _loader is None:
+            system_prompt = "You write concise technical descriptions."
+        else:
+            system_prompt = _loader.render(sys_prompt_path, {})
 
         # Configure for single-turn completion
         options = ClaudeAgentOptions(

gobby/utils/status.py

@@ -84,6 +84,11 @@ def fetch_rich_status(http_port: int, timeout: float = 2.0) -> dict[str, Any]:
         if skills_data:
             status_kwargs["skills_total"] = skills_data.get("total", 0)
 
+        # Artifacts
+        artifacts_data = data.get("artifacts", {})
+        if artifacts_data and artifacts_data.get("count", 0) > 0:
+            status_kwargs["artifacts_count"] = artifacts_data.get("count", 0)
+
     except (httpx.ConnectError, httpx.TimeoutException):
         # Daemon not responding - return empty
         pass
@@ -124,6 +129,8 @@ def format_status_message(
     memories_avg_importance: float | None = None,
     # Skills
     skills_total: int | None = None,
+    # Artifacts
+    artifacts_count: int | None = None,
     **kwargs: Any,
 ) -> str:
     """
@@ -254,6 +261,12 @@ def format_status_message(
         lines.append(f"  {mem_str}")
         lines.append("")
 
+    # Artifacts section (only show if we have data)
+    if artifacts_count is not None:
+        lines.append("Artifacts:")
+        lines.append(f"  Captured: {artifacts_count}")
+        lines.append("")
+
     # Paths section (only when running)
     if running and (pid_file or log_files):
         lines.append("Paths:")

gobby/workflows/actions.py

@@ -32,6 +32,7 @@ from gobby.workflows.enforcement import (
     handle_require_commit_before_stop,
     handle_require_task_complete,
     handle_require_task_review_or_close_before_stop,
+    handle_track_schema_lookup,
     handle_validate_session_task_scope,
 )
 from gobby.workflows.llm_actions import handle_call_llm
@@ -283,6 +284,9 @@ class ActionExecutor:
         async def capture_baseline(context: ActionContext, **kw: Any) -> dict[str, Any] | None:
             return await handle_capture_baseline_dirty_files(context, task_manager=tm, **kw)
 
+        async def track_schema(context: ActionContext, **kw: Any) -> dict[str, Any] | None:
+            return await handle_track_schema_lookup(context, task_manager=tm, **kw)
+
         self.register("block_tools", block_tools)
         self.register("require_active_task", require_active)
         self.register("require_task_complete", require_complete)
@@ -290,6 +294,7 @@ class ActionExecutor:
         self.register("require_task_review_or_close_before_stop", require_review)
         self.register("validate_session_task_scope", validate_scope)
         self.register("capture_baseline_dirty_files", capture_baseline)
+        self.register("track_schema_lookup", track_schema)
 
     def _register_webhook_action(self) -> None:
         """Register webhook action with config closure."""

gobby/workflows/context_actions.py

@@ -308,16 +308,8 @@ def extract_handoff_context(
         except Exception as wt_err:
             logger.debug(f"Failed to get worktree context: {wt_err}")
 
-        # Add active skills from HookSkillManager
-        try:
-            from gobby.hooks.skill_manager import HookSkillManager
-
-            skill_manager = HookSkillManager()
-            core_skills = skill_manager.discover_core_skills()
-            always_apply_skills = [s.name for s in core_skills if s.is_always_apply()]
-            handoff_ctx.active_skills = always_apply_skills
-        except Exception as skill_err:
-            logger.debug(f"Failed to get active skills: {skill_err}")
+        # Note: active_skills population removed - redundant with _build_skill_injection_context()
+        # which already handles skill restoration on session start
 
         # Format as markdown (like /clear stores formatted summary)
         markdown = format_handoff_as_markdown(handoff_ctx)
@@ -414,16 +406,24 @@ def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) ->
     if ctx.git_status:
         sections.append(f"### Uncommitted Changes\n```\n{ctx.git_status}\n```")
 
-    # Files modified section
-    if ctx.files_modified:
-        lines = ["### Files Being Modified"]
-        for f in ctx.files_modified:
-            lines.append(f"- {f}")
-        sections.append("\n".join(lines))
-
-    # Initial goal section
+    # Files modified section - only show files still dirty (not yet committed)
+    if ctx.files_modified and ctx.git_status:
+        # Filter to files that appear in git status (still uncommitted)
+        dirty_files = [f for f in ctx.files_modified if f in ctx.git_status]
+        if dirty_files:
+            lines = ["### Files Being Modified"]
+            for f in dirty_files:
+                lines.append(f"- {f}")
+            sections.append("\n".join(lines))
+
+    # Initial goal section - only if task is still active (not closed/completed)
     if ctx.initial_goal:
-        sections.append(f"### Original Goal\n{ctx.initial_goal}")
+        task_status = None
+        if ctx.active_gobby_task:
+            task_status = ctx.active_gobby_task.get("status")
+        # Only include if no task or task is still open/in_progress
+        if task_status in (None, "open", "in_progress"):
+            sections.append(f"### Original Goal\n{ctx.initial_goal}")
 
     # Recent activity section
     if ctx.recent_activity:
@@ -432,11 +432,8 @@ def format_handoff_as_markdown(ctx: Any, prompt_template: str | None = None) ->
             lines.append(f"- {activity}")
         sections.append("\n".join(lines))
 
-    # Active skills section
-    if hasattr(ctx, "active_skills") and ctx.active_skills:
-        lines = ["### Active Skills"]
-        lines.append(f"Skills available: {', '.join(ctx.active_skills)}")
-        sections.append("\n".join(lines))
+    # Note: Active Skills section removed - redundant with _build_skill_injection_context()
+    # which already handles skill restoration on session start
 
     return "\n\n".join(sections)
 

gobby/workflows/detection_helpers.py

@@ -7,7 +7,7 @@ and update workflow state variables accordingly.
 """
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from gobby.hooks.events import HookEvent
@@ -44,30 +44,24 @@ def detect_task_claim(
     if not event.data:
         return
 
-    tool_name = event.data.get("tool_name", "")
     tool_input = event.data.get("tool_input", {}) or {}
-    # Claude Code sends "tool_result", but we also check "tool_output" for compatibility
-    tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
-
-    # Check if this is a gobby-tasks call via MCP proxy
-    # Tool name could be "call_tool" (from legacy) or "mcp__gobby__call_tool" (direct)
-    if tool_name not in ("call_tool", "mcp__gobby__call_tool"):
-        return
+    # Use normalized tool_output (adapters normalize tool_result/tool_response)
+    tool_output = event.data.get("tool_output") or {}
 
-    # Check server is gobby-tasks
-    server_name = tool_input.get("server_name", "")
+    # Use normalized MCP fields from adapter layer
+    # Adapters extract these from CLI-specific formats
+    server_name = event.data.get("mcp_server", "")
     if server_name != "gobby-tasks":
         return
 
-    # Check inner tool name
-    inner_tool_name = tool_input.get("tool_name", "")
+    inner_tool_name = event.data.get("mcp_tool", "")
 
     # Handle close_task - clears task_claimed when task is closed
     # Note: Claude Code doesn't include tool_result in post-tool-use hooks, so for CC
     # the workflow state is updated directly in the MCP proxy's close_task function.
     # This detection provides a fallback for CLIs that do report tool results (Gemini/Codex).
     if inner_tool_name == "close_task":
-        tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
+        # tool_output already normalized at top of function
 
         # If no tool output, skip - can't verify success
         # The MCP proxy's close_task handles state clearing for successful closes
@@ -254,6 +248,11 @@ def detect_mcp_call(event: "HookEvent", state: "WorkflowState") -> None:
     This enables workflow conditions like:
         when: "mcp_called('gobby-memory', 'recall')"
 
+    Uses normalized fields from adapters:
+    - mcp_server: The MCP server name (normalized from both Claude and Gemini formats)
+    - mcp_tool: The tool name on the server (normalized from both formats)
+    - tool_output: The tool result (normalized from tool_result/tool_response)
+
     Args:
         event: The AFTER_TOOL hook event
         state: Current workflow state (modified in place)
@@ -261,21 +260,36 @@ def detect_mcp_call(event: "HookEvent", state: "WorkflowState") -> None:
     if not event.data:
         return
 
-    tool_name = event.data.get("tool_name", "")
-    tool_input = event.data.get("tool_input", {}) or {}
-    # Claude Code sends "tool_result", but we also check "tool_output" for compatibility
-    tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
+    # Use normalized fields from adapter layer
+    # Adapters extract these from CLI-specific formats:
+    # - Claude: tool_input.server_name/tool_name → mcp_server/mcp_tool
+    # - Gemini: mcp_context.server_name/tool_name → mcp_server/mcp_tool
+    server_name = event.data.get("mcp_server", "")
+    inner_tool = event.data.get("mcp_tool", "")
 
-    # Check for MCP proxy call
-    if tool_name not in ("call_tool", "mcp__gobby__call_tool"):
+    if not server_name or not inner_tool:
         return
 
-    server_name = tool_input.get("server_name", "")
-    inner_tool = tool_input.get("tool_name", "")
+    # Use normalized tool_output (adapters normalize tool_result/tool_response)
+    tool_output = event.data.get("tool_output") or {}
 
-    if not server_name or not inner_tool:
-        return
+    _track_mcp_call(state, server_name, inner_tool, tool_output)
+
+
+def _track_mcp_call(
+    state: "WorkflowState",
+    server_name: str,
+    inner_tool: str,
+    tool_output: dict[str, Any] | Any,
+) -> None:
+    """Track a successful MCP call in workflow state.
 
+    Args:
+        state: Current workflow state (modified in place)
+        server_name: MCP server name (e.g., "gobby-sessions")
+        inner_tool: Tool name on the server (e.g., "get_current_session")
+        tool_output: Tool output to check for errors
+    """
     # Check if call succeeded (skip tracking failed calls)
     if isinstance(tool_output, dict):
         if tool_output.get("error") or tool_output.get("status") == "error":

gobby/workflows/enforcement/__init__.py

@@ -4,7 +4,12 @@ This package provides actions that enforce task tracking before allowing
 certain tools, and enforce task completion before allowing agent to stop.
 """
 
-from gobby.workflows.enforcement.blocking import block_tools
+from gobby.workflows.enforcement.blocking import (
+    block_tools,
+    is_discovery_tool,
+    is_tool_unlocked,
+    track_schema_lookup,
+)
 from gobby.workflows.enforcement.commit_policy import (
     capture_baseline_dirty_files,
     require_commit_before_stop,
@@ -17,6 +22,7 @@ from gobby.workflows.enforcement.handlers import (
     handle_require_commit_before_stop,
     handle_require_task_complete,
     handle_require_task_review_or_close_before_stop,
+    handle_track_schema_lookup,
     handle_validate_session_task_scope,
 )
 from gobby.workflows.enforcement.task_policy import (
@@ -28,6 +34,9 @@ from gobby.workflows.enforcement.task_policy import (
 __all__ = [
     # Blocking
     "block_tools",
+    "is_discovery_tool",
+    "is_tool_unlocked",
+    "track_schema_lookup",
     # Commit policy
     "capture_baseline_dirty_files",
     "require_commit_before_stop",
@@ -43,5 +52,6 @@ __all__ = [
     "handle_require_commit_before_stop",
     "handle_require_task_complete",
     "handle_require_task_review_or_close_before_stop",
+    "handle_track_schema_lookup",
     "handle_validate_session_task_scope",
 ]

gobby/workflows/enforcement/blocking.py

@@ -5,12 +5,14 @@ Provides configurable tool blocking based on workflow state and conditions.
 
 from __future__ import annotations
 
+import json
 import logging
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from gobby.workflows.git_utils import get_dirty_files
 from gobby.workflows.safe_evaluator import LazyBool, SafeExpressionEvaluator
+from gobby.workflows.templates import TemplateEngine
 
 if TYPE_CHECKING:
     from gobby.storage.tasks import LocalTaskManager
@@ -18,6 +20,89 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# MCP discovery tools that don't require prior schema lookup
+DISCOVERY_TOOLS = {
+    "list_mcp_servers",
+    "list_tools",
+    "get_tool_schema",
+    "search_tools",
+    "recommend_tools",
+    "list_skills",
+    "get_skill",
+    "search_skills",
+}
+
+
+def is_discovery_tool(tool_name: str | None) -> bool:
+    """Check if the tool is a discovery/introspection tool.
+
+    These tools are allowed without prior schema lookup since they ARE
+    the discovery mechanism.
+
+    Args:
+        tool_name: The MCP tool name (from tool_input.tool_name)
+
+    Returns:
+        True if this is a discovery tool that doesn't need schema unlock
+    """
+    return tool_name in DISCOVERY_TOOLS if tool_name else False
+
+
+def is_tool_unlocked(
+    tool_input: dict[str, Any],
+    variables: dict[str, Any],
+) -> bool:
+    """Check if a tool has been unlocked via prior get_tool_schema call.
+
+    Args:
+        tool_input: The tool input containing server_name and tool_name
+        variables: Workflow state variables containing unlocked_tools list
+
+    Returns:
+        True if the server:tool combo was previously unlocked via get_tool_schema
+    """
+    server = tool_input.get("server_name", "")
+    tool = tool_input.get("tool_name", "")
+    if not server or not tool:
+        return False
+    key = f"{server}:{tool}"
+    unlocked = variables.get("unlocked_tools", [])
+    return key in unlocked
+
+
+def track_schema_lookup(
+    tool_input: dict[str, Any],
+    workflow_state: WorkflowState | None,
+) -> dict[str, Any] | None:
+    """Track a successful get_tool_schema call by adding to unlocked_tools.
+
+    Called from on_after_tool when tool_name is get_tool_schema and succeeded.
+
+    Args:
+        tool_input: The tool input containing server_name and tool_name
+        workflow_state: Workflow state to update
+
+    Returns:
+        Dict with tracking result or None
+    """
+    if not workflow_state:
+        return None
+
+    server = tool_input.get("server_name", "")
+    tool = tool_input.get("tool_name", "")
+    if not server or not tool:
+        return None
+
+    key = f"{server}:{tool}"
+    unlocked = workflow_state.variables.setdefault("unlocked_tools", [])
+
+    if key not in unlocked:
+        unlocked.append(key)
+        logger.debug(f"Unlocked tool schema: {key}")
+        return {"unlocked": key, "total_unlocked": len(unlocked)}
+
+    return {"already_unlocked": key}
+
 
 def _is_plan_file(file_path: str, source: str | None = None) -> bool:
     """Check if file path is a Claude Code plan file (platform-agnostic).
@@ -98,6 +183,8 @@ def _evaluate_block_condition(
     # Allowed functions for safe evaluation
     allowed_funcs: dict[str, Callable[..., Any]] = {
         "is_plan_file": _is_plan_file,
+        "is_discovery_tool": is_discovery_tool,
+        "is_tool_unlocked": lambda ti: is_tool_unlocked(ti, variables),
         "bool": bool,
         "str": str,
         "int": int,
@@ -241,7 +328,18 @@ async def block_tools(
                 if mcp_key in mcp_tools:
                     rule_matches = True
                     # For MCP tools, the actual arguments are in tool_input.arguments
-                    mcp_tool_args = tool_input.get("arguments", {}) or {}
+                    # Arguments may be a JSON string (Claude Code serialization) or dict
+                    raw_args = tool_input.get("arguments")
+                    if isinstance(raw_args, str):
+                        try:
+                            parsed = json.loads(raw_args)
+                            mcp_tool_args = parsed if isinstance(parsed, dict) else {}
+                        except (json.JSONDecodeError, TypeError):
+                            mcp_tool_args = {}
+                    elif isinstance(raw_args, dict):
+                        mcp_tool_args = raw_args
+                    else:
+                        mcp_tool_args = {}
 
         if not rule_matches:
             continue
@@ -263,6 +361,16 @@ async def block_tools(
                 continue
 
         reason = rule.get("reason", f"Tool '{tool_name}' is blocked.")
+
+        # Render Jinja2 template variables in reason message
+        if "{{" in reason:
+            try:
+                engine = TemplateEngine()
+                reason = engine.render(reason, {"tool_input": tool_input})
+            except Exception as e:
+                logger.warning(f"Failed to render reason template: {e}")
+                # Keep original reason on failure
+
         logger.info(f"block_tools: Blocking '{tool_name}' - {reason[:100]}")
         return {"decision": "block", "reason": reason}
 

gobby/workflows/enforcement/handlers.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any
 
-from gobby.workflows.enforcement.blocking import block_tools
+from gobby.workflows.enforcement.blocking import block_tools, track_schema_lookup
 from gobby.workflows.enforcement.commit_policy import (
     capture_baseline_dirty_files,
     require_commit_before_stop,
@@ -33,6 +33,7 @@ __all__ = [
     "handle_require_commit_before_stop",
     "handle_require_task_complete",
     "handle_require_task_review_or_close_before_stop",
+    "handle_track_schema_lookup",
     "handle_validate_session_task_scope",
 ]
 
@@ -267,3 +268,36 @@ async def handle_require_task_complete(
         project_id=project_id,
         workflow_state=context.state,
     )
+
+
+async def handle_track_schema_lookup(
+    context: Any,
+    task_manager: LocalTaskManager | None = None,
+    **kwargs: Any,
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for track_schema_lookup.
+
+    Tracks successful get_tool_schema calls to unlock tools for call_tool.
+    Should be triggered on on_after_tool when the tool is get_tool_schema.
+    """
+    if not context.event_data:
+        return None
+
+    tool_name = context.event_data.get("tool_name", "")
+    is_failure = context.event_data.get("is_failure", False)
+
+    # Only track successful get_tool_schema calls
+    # Handle both native MCP format and Gobby proxy format
+    if tool_name not in ("get_tool_schema", "mcp__gobby__get_tool_schema"):
+        return None
+
+    if is_failure:
+        return None
+
+    # Extract tool_input - for MCP proxy, it's in tool_input directly
+    tool_input = context.event_data.get("tool_input", {}) or {}
+
+    return track_schema_lookup(
+        tool_input=tool_input,
+        workflow_state=context.state,
+    )