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

gobby/mcp_proxy/tools/tasks/_lifecycle.py

@@ -41,7 +41,6 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         skip_validation: bool = False,
         session_id: str | None = None,
         override_justification: str | None = None,
-        no_commit_needed: bool = False,
         commit_sha: str | None = None,
     ) -> dict[str, Any]:
         """Close a task with validation.
@@ -51,14 +50,12 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
         Args:
             task_id: Task reference (#N, path, or UUID)
-            reason: Reason for closing
+            reason: Reason for closing. Use "duplicate", "already_implemented", "wont_fix",
+                or "obsolete" to auto-skip commit check (these imply no work was done).
             changes_summary: Summary of changes (enables LLM validation for leaf tasks)
             skip_validation: Skip all validation checks
             session_id: Session ID where task is being closed (auto-links to session)
             override_justification: Why agent bypassed validation (stored for audit).
-                Also used to explain why no commit was needed when no_commit_needed=True.
-            no_commit_needed: Set to True for tasks that don't produce code changes
-                (research, planning, documentation review). Requires override_justification.
             commit_sha: Git commit SHA to link before closing. Convenience for link + close in one call.
 
         Returns:
@@ -85,9 +82,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         cwd = repo_path or "."
 
         # Check for linked commits (unless task type doesn't require commits)
-        commit_result = validate_commit_requirements(
-            task, reason, no_commit_needed, override_justification
-        )
+        commit_result = validate_commit_requirements(task, reason, repo_path)
         if not commit_result.can_close:
             return {
                 "error": commit_result.error_type,
@@ -141,7 +136,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
         # Determine close outcome
         route_to_review, store_override = determine_close_outcome(
-            task, skip_validation, no_commit_needed, override_justification
+            task, skip_validation, override_justification
         )
 
         # Get git commit SHA (best-effort, dynamic short format for consistency)
@@ -194,6 +189,23 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
             except Exception:
                 pass  # nosec B110 - best-effort linking, don't fail the close
 
+        # Clear workflow task_claimed state if this was the claimed task
+        # Respects the clear_task_on_close variable (defaults to True if not set)
+        # This is done here because Claude Code's post-tool-use hook doesn't include
+        # the tool result, so the detection_helpers can't verify close succeeded
+        if session_id:
+            try:
+                state = ctx.workflow_state_manager.get_state(session_id)
+                if state and state.variables.get("claimed_task_id") == resolved_id:
+                    # Check if clear_task_on_close is enabled (default: True)
+                    clear_on_close = state.variables.get("clear_task_on_close", True)
+                    if clear_on_close:
+                        state.variables["task_claimed"] = False
+                        state.variables["claimed_task_id"] = None
+                        ctx.workflow_state_manager.save_state(state)
+            except Exception:
+                pass  # nosec B110 - best-effort state update
+
         # Update worktree status based on closure reason (case-insensitive)
         try:
             reason_normalized = reason.lower()
@@ -216,7 +228,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
     registry.register(
         name="close_task",
-        description="Close a task. Commits should use [#N] format (e.g., git commit -m '[#42] feat: add feature'). Requires commits to be linked (auto-detected from commit message or use link_commit). Parent tasks require all children closed. Leaf tasks validate with LLM. Validation auto-skipped for: duplicate, already_implemented, wont_fix, obsolete.",
+        description="Close a task. Pass commit_sha to link and close in one call: close_task(task_id, commit_sha='abc123'). Or include [#N] in commit message for auto-linking. Parent tasks require all children closed. Validation auto-skipped for: duplicate, already_implemented, wont_fix, obsolete.",
         input_schema={
             "type": "object",
             "properties": {
@@ -251,24 +263,14 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 "override_justification": {
                     "type": "string",
                     "description": (
-                        "Justification for bypassing validation or commit check. "
-                        "Required when skip_validation=True or no_commit_needed=True. "
+                        "Justification for bypassing validation. Required when skip_validation=True. "
                         "Example: 'Validation saw truncated diff - verified via git show that commit includes all changes'"
                     ),
                     "default": None,
                 },
-                "no_commit_needed": {
-                    "type": "boolean",
-                    "description": (
-                        "ONLY for tasks with NO code changes (pure research, planning, documentation review). "
-                        "Do NOT use this to bypass validation when a commit exists - use skip_validation instead. "
-                        "Requires override_justification."
-                    ),
-                    "default": False,
-                },
                 "commit_sha": {
                     "type": "string",
-                    "description": "Git commit SHA to link before closing. Convenience for commit + close in one call.",
+                    "description": "RECOMMENDED: Git commit SHA to link and close in one call. Use this instead of separate link_commit + close_task calls.",
                     "default": None,
                 },
             },
@@ -334,8 +336,12 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         func=reopen_task,
     )
 
-    def delete_task(task_id: str, cascade: bool = True) -> dict[str, Any]:
-        """Delete a task and its children by default."""
+    def delete_task(task_id: str, cascade: bool = True, unlink: bool = False) -> dict[str, Any]:
+        """Delete a task.
+
+        By default (cascade=True), deletes subtasks and dependent tasks.
+        Use unlink=True to remove dependency links but preserve dependent tasks.
+        """
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
@@ -347,9 +353,26 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
             return {"error": f"Task {task_id} not found"}
         ref = f"#{task.seq_num}" if task.seq_num else resolved_id[:8]
 
-        deleted = ctx.task_manager.delete_task(resolved_id, cascade=cascade)
-        if not deleted:
-            return {"error": f"Task {task_id} not found"}
+        try:
+            deleted = ctx.task_manager.delete_task(resolved_id, cascade=cascade, unlink=unlink)
+            if not deleted:
+                return {"error": f"Task {task_id} not found"}
+        except ValueError as e:
+            error_msg = str(e)
+            if "dependent task(s)" in error_msg:
+                return {
+                    "error": "has_dependents",
+                    "message": error_msg,
+                    "suggestion": f"Use cascade=True to delete task {ref} and its dependents, "
+                    f"or unlink=True to preserve dependent tasks.",
+                }
+            elif "has children" in error_msg:
+                return {
+                    "error": "has_children",
+                    "message": error_msg,
+                    "suggestion": f"Use cascade=True to delete task {ref} and all its subtasks.",
+                }
+            return {"error": error_msg}
 
         return {
             "ref": ref,
@@ -358,7 +381,9 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
     registry.register(
         name="delete_task",
-        description="Delete a task and its subtasks.",
+        description="Delete a task. By default (cascade=True), deletes subtasks and dependent tasks. "
+        "Set cascade=False to fail if task has children or dependents. "
+        "Use unlink=True to remove dependency links but preserve dependent tasks.",
         input_schema={
             "type": "object",
             "properties": {
@@ -368,9 +393,15 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "cascade": {
                     "type": "boolean",
-                    "description": "If True, delete all child tasks as well. Defaults to True.",
+                    "description": "If True, delete subtasks and dependent tasks. Defaults to True.",
                     "default": True,
                 },
+                "unlink": {
+                    "type": "boolean",
+                    "description": "If True, remove dependency links but preserve dependent tasks. "
+                    "Ignored if cascade=True.",
+                    "default": False,
+                },
             },
             "required": ["task_id"],
         },

gobby/mcp_proxy/tools/tasks/_lifecycle_validation.py

@@ -33,16 +33,14 @@ class ValidationResult:
 def validate_commit_requirements(
     task: Task,
     reason: str,
-    no_commit_needed: bool,
-    override_justification: str | None,
+    repo_path: str | None = None,
 ) -> ValidationResult:
     """Check if task meets commit requirements for closing.
 
     Args:
         task: The task to validate
         reason: Reason for closing
-        no_commit_needed: If True, allow closing without commits
-        override_justification: Justification for skipping commit check
+        repo_path: Path to the repository for git operations
 
     Returns:
         ValidationResult indicating if task can be closed
@@ -51,28 +49,21 @@ def validate_commit_requirements(
     requires_commit_check = reason.lower() not in SKIP_REASONS
 
     if requires_commit_check and not task.commits:
-        # No commits linked - require explicit acknowledgment
-        if no_commit_needed:
-            if not override_justification:
-                return ValidationResult(
-                    can_close=False,
-                    error_type="justification_required",
-                    message=(
-                        "When no_commit_needed=True, you must provide "
-                        "override_justification explaining why no commit was needed."
-                    ),
-                )
-            # Allowed to proceed - agent confirmed no commit needed
-        else:
-            return ValidationResult(
-                can_close=False,
-                error_type="no_commits_linked",
-                message=(
-                    "Cannot close task: no commits are linked. Either:\n"
-                    "1. Commit your changes and use link_commit() or include [task_id] in commit message\n"
-                    "2. Set no_commit_needed=True with override_justification if this task didn't require code changes"
-                ),
-            )
+        return ValidationResult(
+            can_close=False,
+            error_type="no_commits_linked",
+            message=(
+                "A commit is required before closing this task.\n\n"
+                "**Normal flow:**\n"
+                '1. Commit your changes: git commit -m "[#N] description"\n'
+                '2. Close with commit_sha: close_task(task_id="#N", commit_sha="<sha>")\n\n'
+                "**Edge cases (no work done):**\n"
+                '- Task was already done: reason="already_implemented"\n'
+                '- Task is no longer needed: reason="obsolete"\n'
+                '- Task duplicates another: reason="duplicate"\n'
+                '- Decided not to do it: reason="wont_fix"'
+            ),
+        )
 
     return ValidationResult(can_close=True)
 
@@ -277,7 +268,6 @@ async def validate_leaf_task_with_llm(
 def determine_close_outcome(
     task: Task,
     skip_validation: bool,
-    no_commit_needed: bool,
     override_justification: str | None,
 ) -> tuple[bool, bool]:
     """Determine the close outcome for a task.
@@ -285,14 +275,13 @@ def determine_close_outcome(
     Args:
         task: The task being closed
         skip_validation: Whether validation was skipped
-        no_commit_needed: Whether commit was not needed
         override_justification: Justification for override
 
     Returns:
         Tuple of (route_to_review, store_override)
     """
     # Determine if override should be stored
-    store_override = skip_validation or no_commit_needed
+    store_override = skip_validation
 
     # Route to review if task requires user review OR override was used
     # This ensures tasks with HITL flag or skipped validation go through human review

gobby/mcp_proxy/tools/workflows.py

@@ -808,7 +808,7 @@ def create_workflows_registry(
         shutil.copy(source, dest_path)
 
         # Clear loader cache so new workflow is discoverable
-        _loader.clear_discovery_cache()
+        _loader.clear_cache()
 
         return {
             "success": True,

gobby/mcp_proxy/tools/worktrees.py

@@ -1014,6 +1014,11 @@ def create_worktrees_registry(
         if isinstance(terminal, str):
             terminal = terminal.lower()
 
+        # Default to 'worktree-agent' workflow if not specified
+        # This workflow restricts tools available to spawned agents in worktrees
+        if workflow is None:
+            workflow = "worktree-agent"
+
         # Validate workflow (reject lifecycle workflows)
         if workflow:
             workflow_loader = WorkflowLoader()

gobby/memory/backends/__init__.py

@@ -76,7 +76,12 @@ def get_backend(backend_type: str, **kwargs: Any) -> MemoryBackendProtocol:
         return NullBackend()
 
     elif backend_type == "mem0":
-        from gobby.memory.backends.mem0 import Mem0Backend
+        try:
+            from gobby.memory.backends.mem0 import Mem0Backend
+        except ImportError as e:
+            raise ImportError(
+                "mem0ai is not installed. Install with: pip install gobby[mem0]"
+            ) from e
 
         api_key: str | None = kwargs.get("api_key")
         if api_key is None:

gobby/memory/backends/mem0.py

@@ -60,7 +60,12 @@ class Mem0Backend:
             **kwargs: Additional MemoryClient configuration
         """
         # Lazy import to avoid requiring mem0ai when not used
-        from mem0 import MemoryClient
+        try:
+            from mem0 import MemoryClient
+        except ImportError as e:
+            raise ImportError(
+                "Mem0 backend requires 'mem0ai' package. Install it with: pip install gobby[mem0]"
+            ) from e
 
         self._client: MemoryClient = MemoryClient(api_key=api_key, **kwargs)
         self._default_user_id = user_id