gobby 0.2.5__py3-none-any.whl → 0.2.7__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:
@@ -68,13 +65,13 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except TaskNotFoundError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         except ValueError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         task = ctx.task_manager.get_task(resolved_id)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
 
         # Link commit if provided (convenience for link + close in one call)
         if commit_sha:
@@ -85,11 +82,10 @@ 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 {
+                "success": False,
                 "error": commit_result.error_type,
                 "message": commit_result.message,
             }
@@ -97,11 +93,40 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Auto-skip validation for certain close reasons
         should_skip = skip_validation or reason.lower() in SKIP_REASONS
 
+        # Enforce commits if session had edits
+        if session_id and not should_skip:
+            try:
+                from gobby.storage.sessions import LocalSessionManager
+
+                session_manager = LocalSessionManager(ctx.task_manager.db)
+                session = session_manager.get(session_id)
+
+                # Check if task has commits (including the one being linked right now)
+                has_commits = bool(task.commits) or bool(commit_sha)
+
+                if session and session.had_edits and not has_commits:
+                    return {
+                        "success": False,
+                        "error": "missing_commits_for_edits",
+                        "message": (
+                            "This session made edits but no commits are linked to the task. "
+                            "You must commit your changes and link them to the task before closing."
+                        ),
+                        "suggestion": (
+                            "Commit your changes with `[#task_id]` in the message, "
+                            "or pass `commit_sha` to `close_task`."
+                        ),
+                    }
+            except Exception:
+                # Don't block close on internal error
+                pass  # nosec B110 - best-effort session edit check
+
         if not should_skip:
             # Check if task has children (is a parent task)
             parent_result = validate_parent_task(ctx, resolved_id)
             if not parent_result.can_close:
-                response = {
+                response: dict[str, Any] = {
+                    "success": False,
                     "error": parent_result.error_type,
                     "message": parent_result.message,
                 }
@@ -132,6 +157,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                     )
                     if not llm_result.can_close:
                         response = {
+                            "success": False,
                             "error": llm_result.error_type,
                             "message": llm_result.message,
                         }
@@ -141,7 +167,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 +220,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 +259,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 +294,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,
                 },
             },
@@ -290,7 +323,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         try:
             ctx.task_manager.reopen_task(resolved_id, reason=reason)
@@ -311,7 +344,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
             return {}
         except ValueError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
     registry.register(
         name="reopen_task",
@@ -334,22 +367,45 @@ 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:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         # Get task before deleting to capture seq_num for ref
         task = ctx.task_manager.get_task(resolved_id)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "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 {"success": False, "error": f"Task {task_id} not found"}
+        except ValueError as e:
+            error_msg = str(e)
+            if "dependent task(s)" in error_msg:
+                return {
+                    "success": False,
+                    "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 {
+                    "success": False,
+                    "error": "has_children",
+                    "message": error_msg,
+                    "suggestion": f"Use cascade=True to delete task {ref} and all its subtasks.",
+                }
+            return {"success": False, "error": error_msg}
 
         return {
             "ref": ref,
@@ -358,7 +414,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 +426,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"],
         },
@@ -382,10 +446,10 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         task = ctx.task_manager.add_label(resolved_id, label)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
         return {}
 
     registry.register(
@@ -410,10 +474,10 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         task = ctx.task_manager.remove_label(resolved_id, label)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
         return {}
 
     registry.register(
@@ -456,17 +520,18 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except TaskNotFoundError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         except ValueError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         task = ctx.task_manager.get_task(resolved_id)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
 
         # Check if already claimed by another session
         if task.assignee and task.assignee != session_id and not force:
             return {
+                "success": False,
                 "error": "Task already claimed by another session",
                 "claimed_by": task.assignee,
                 "message": f"Task is already claimed by session '{task.assignee}'. Use force=True to override.",
@@ -479,7 +544,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
             status="in_progress",
         )
         if not updated:
-            return {"error": f"Failed to claim task {task_id}"}
+            return {"success": False, "error": f"Failed to claim task {task_id}"}
 
         # Link task to session (best-effort, don't fail the claim if this fails)
         try:

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=(
+                "\nA 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,