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

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/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

@@ -12,6 +12,7 @@ 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
@@ -19,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).
@@ -99,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,
@@ -275,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,
+    )

gobby/workflows/engine.py

@@ -553,10 +553,13 @@ class WorkflowEngine:
             }
         step = definition.steps[0].name
 
-        # Merge workflow default variables with passed-in variables
-        merged_variables = dict(definition.variables)
+        # Merge variables: preserve existing lifecycle variables, then apply workflow declarations
+        # Priority: existing state < workflow defaults < passed-in variables
+        # This preserves lifecycle variables (like unlocked_tools) that the step workflow doesn't declare
+        merged_variables = dict(existing.variables) if existing else {}
+        merged_variables.update(definition.variables)  # Override with workflow-declared defaults
         if variables:
-            merged_variables.update(variables)
+            merged_variables.update(variables)  # Override with passed-in values
 
         # Create state
         state = WorkflowState(

gobby/workflows/lifecycle_evaluator.py

@@ -636,6 +636,7 @@ async def evaluate_all_lifecycle_workflows(
                     "path": str(w.path),
                 }
                 for w in workflows
-            ]
+            ],
+            "workflow_variables": context_data,
         },
     )

{gobby-0.2.8.dist-info → gobby-0.2.9.dist-info}/METADATA

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