task-agent 0.1.311__tar.gz → 0.1.321__tar.gz

{task_agent-0.1.311 → task_agent-0.1.321}/CLAUDE.md

@@ -214,30 +214,32 @@ Dev dependencies:
 
 ## Release & Versioning
 
-Versions in `pyproject.toml` follow semver. The release workflow is **atomic**:
+Versions in `pyproject.toml` follow semver. The release workflow is **two commands**:
 
 ```bash
-ta version promote patch   # or minor/major
-                           # Auto-commits: pyproject.toml, uv.lock
-                           # Shows success/failure of commit
-ta version tag             # Create git tag (matches code version)
-git push origin vX.Y.Z     # Push tag to trigger CI publish
+ta version promote patch   # or minor/major: bumps version AND amends previous commit
+ta version tag             # Creates tag AND pushes to trigger CI publish
 ```
 
 ### How It Works
 
-1. **`ta version promote`**: Bumps version, auto-commits with message `chore: bump version to X.Y.Z`, warns if auto-commit fails
-2. **`ta version tag`**: Creates git tag matching the version in code
-3. **`git push origin vX.Y.Z`**: Triggers GitHub Actions publish workflow
+1. **Commit your work** with a meaningful message (e.g., `feat: add new feature`, `fix: resolve issue`)
+2. **`ta version promote patch`**: 
+   - Bumps version in `pyproject.toml` and `uv.lock`
+   - **Amends previous commit** with `--amend --no-edit` (preserves original message)
+   - Version bump is metadata—release notes on PyPI reflect your actual work
+3. **`ta version tag`**: 
+   - Creates git tag matching the version in code
+   - Pushes tag to trigger GitHub Actions publish to PyPI
 
 ### Critical: Version-Tag Matching
 
-The tag **must** point to a commit where `pyproject.toml` has the matching version. If they mismatch, PyPI will reject with "File already exists" (different file hash for same version).
+The tag **must** point to a commit where `pyproject.toml` has the matching version. The amended commit ensures they always stay in sync.
 
 **If publishing fails:**
 - Check PyPI version: `ta version` shows "Latest PyPI version"
+- Verify with: `git show HEAD:pyproject.toml | grep version`
 - If mismatch: delete bad tag (`git tag -d vX.Y.Z`), bump to next version, re-tag
-- The `ta version` command queries PyPI in real-time, so you always know what's published
 
 ## Common Tasks for Claude
 

{task_agent-0.1.311 → task_agent-0.1.321}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: task-agent
-Version: 0.1.311
+Version: 0.1.321
 Summary: A prioritized, file-based task queue for autonomous agentic workers
 Author-email: Mark Stouffer <1802850+InTEGr8or@users.noreply.github.com>
 License: MIT

{task_agent-0.1.311 → task_agent-0.1.321}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "task-agent"
-version = "0.1.311"
+version = "0.1.321"
 description = "A prioritized, file-based task queue for autonomous agentic workers"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -39,7 +39,7 @@ dev = [
 ]
 
 [tool.bumpversion]
-current_version = "0.1.311"
+current_version = "0.1.321"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "version = \"{current_version}\""

{task_agent-0.1.311 → task_agent-0.1.321}/src/taskagent/cli.py

@@ -87,8 +87,43 @@ def display_version_info(console: Console):
         pass
 
 
+def get_committed_version() -> Tuple[str, Optional[str]]:
+    """Read the version from HEAD (committed code), not working tree."""
+    files_to_check = [
+        ("pyproject.toml", r'version\s*=\s*"(.*?)"'),
+        ("package.json", None),  # Special handling below
+        ("Cargo.toml", r'^version\s*=\s*"(.*?)"'),
+    ]
+
+    for filename, pattern in files_to_check:
+        try:
+            result = subprocess.run(
+                ["git", "show", f"HEAD:{filename}"],
+                capture_output=True,
+                text=True,
+                check=False,
+                shell=(os.name == "nt"),
+            )
+            if result.returncode == 0:
+                if filename == "package.json":
+                    try:
+                        data = json.loads(result.stdout)
+                        if "version" in data:
+                            return data["version"], "package.json"
+                    except Exception:
+                        pass
+                elif pattern:
+                    match = re.search(pattern, result.stdout, re.MULTILINE)
+                    if match:
+                        return match.group(1), filename
+        except Exception:
+            pass
+
+    return "unknown", None
+
+
 def get_project_version(root: Optional[Path] = None) -> Tuple[str, Optional[str]]:
-    """Read the current project version from various project files."""
+    """Read the current project version from various project files (working tree)."""
     root = root or Path.cwd()
 
     # Check pyproject.toml
@@ -684,16 +719,78 @@ def cmd_soft_delete(console: Console, manager: TaskAgent, slug: str):
         sys.exit(1)
 
 
+def detect_current_slug_from_git() -> Optional[str]:
+    """Detect the current task slug from the current git branch name."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        branch = result.stdout.strip()
+        if branch.startswith("issue/"):
+            return branch[len("issue/") :]
+    except Exception:
+        pass
+    return None
+
+
+def find_worktree_path_for_slug(slug: str) -> Optional[Path]:
+    """Find the registered worktree path for a given task slug."""
+    try:
+        result = subprocess.run(
+            ["git", "worktree", "list", "--porcelain"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        current_worktree = None
+        for line in result.stdout.splitlines():
+            if line.startswith("worktree "):
+                current_worktree = Path(line[len("worktree ") :].strip())
+            elif line.startswith("branch refs/heads/issue/"):
+                branch_slug = line[len("branch refs/heads/issue/") :].strip()
+                if branch_slug == slug:
+                    return current_worktree
+    except Exception:
+        pass
+    # Fallback to local .gwt/slug if it exists
+    p = Path(".gwt") / slug
+    if p.exists():
+        return p
+    return None
+
+
 def cmd_done(
     console: Console,
     manager: TaskAgent,
-    slug: str,
+    slug: Optional[str] = None,
     commit_message: Optional[str] = None,
     should_commit: bool = True,
     push_mission: bool = False,
     solution: Optional[str] = None,
 ):
     """Mark an issue as done."""
+    if not slug:
+        slug = detect_current_slug_from_git()
+        if not slug:
+            console.print(
+                "[red]Error: Please specify the task slug or run this command from within the task's worktree/branch.[/red]"
+            )
+            sys.exit(1)
+
+    worktree_path = find_worktree_path_for_slug(slug)
+    abs_worktree = (
+        worktree_path.resolve() if worktree_path and worktree_path.exists() else None
+    )
+    is_cwd_inside_worktree = False
+    if abs_worktree:
+        try:
+            is_cwd_inside_worktree = Path.cwd().resolve().is_relative_to(abs_worktree)
+        except Exception:
+            pass
+
     try:
         issue, commit_hash = manager.complete_issue(
             slug,
@@ -717,6 +814,78 @@ def cmd_done(
         # Destroy per-task agent even if commit fails
         agent.destroy_per_task_agent(slug)
 
+    # Perform git worktree and branch cleanup after successful completion
+    if worktree_path and worktree_path.exists():
+        if is_cwd_inside_worktree:
+            console.print(
+                f"[yellow]Note: Worktree at '{worktree_path}' and branch 'issue/{slug}' were not removed because your shell is currently inside the worktree directory.[/yellow]"
+            )
+            console.print(
+                "[yellow]To clean up, please change directory to the main repository directory and run:[/yellow]"
+            )
+            console.print("  [bold]git worktree prune[/bold]")
+            console.print(f"  [bold]git branch -D issue/{slug}[/bold]")
+        else:
+            console.print(f"[blue]Cleaning up git worktree for '{slug}'...[/blue]")
+            try:
+                # Remove worktree
+                subprocess.run(
+                    ["git", "worktree", "remove", str(worktree_path)],
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+                console.print(
+                    f"[green]Successfully removed worktree at '{worktree_path}'.[/green]"
+                )
+
+                # Delete branch
+                branch_name = f"issue/{slug}"
+                console.print(f"[blue]Deleting local branch '{branch_name}'...[/blue]")
+                subprocess.run(
+                    ["git", "branch", "-d", branch_name],
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+                console.print(
+                    f"[green]Successfully deleted branch '{branch_name}'.[/green]"
+                )
+            except subprocess.CalledProcessError as e:
+                console.print(
+                    f"[yellow]Warning: Cleanup failed. {e.stderr.strip()}[/yellow]"
+                )
+                console.print(
+                    f"[yellow]You can clean up manually by running: git worktree remove --force {worktree_path} && git branch -D issue/{slug}[/yellow]"
+                )
+    else:
+        # If worktree doesn't exist, we still try to delete the branch if it exists
+        branch_name = f"issue/{slug}"
+        try:
+            result = subprocess.run(
+                ["git", "show-ref", "--verify", f"refs/heads/{branch_name}"],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                console.print(f"[blue]Deleting local branch '{branch_name}'...[/blue]")
+                subprocess.run(
+                    ["git", "branch", "-d", branch_name],
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+                console.print(
+                    f"[green]Successfully deleted branch '{branch_name}'.[/green]"
+                )
+        except subprocess.CalledProcessError as e:
+            console.print(
+                f"[yellow]Warning: Could not delete branch '{branch_name}' safely: {e.stderr.strip()}[/yellow]"
+            )
+            console.print(
+                f"[yellow]Run 'git branch -D {branch_name}' to force delete it.[/yellow]"
+            )
+
 
 def cmd_push(console: Console, manager: TaskAgent):
     """Push the mission repository."""
@@ -1382,9 +1551,28 @@ def cmd_active(
     manager: TaskAgent,
     slug_part: Optional[str] = None,
     silent: bool = False,
+    list_if_none: bool = False,
 ) -> Optional[Issue]:
-    """Move an issue to active status."""
+    """Move an issue to active status, or list active tasks."""
     issues = manager.load_mission()
+    if not slug_part and list_if_none:
+        active_issues = [i for i in issues if i.status == "active"]
+        if not silent:
+            if active_issues:
+                from rich.table import Table
+
+                table = Table(title="Active Tasks")
+                table.add_column("Priority")
+                table.add_column("Slug")
+                table.add_column("Dependencies")
+                for i in active_issues:
+                    deps = ", ".join(i.dependencies) if i.dependencies else "-"
+                    table.add_row(str(i.priority), i.slug, deps)
+                console.print(table)
+            else:
+                console.print("[yellow]No active tasks found.[/yellow]")
+        return None
+
     target = select_issue(
         console, issues, slug_part, status_filter=["pending", "draft", "active"]
     )
@@ -1410,6 +1598,38 @@ def cmd_active(
         return None
 
 
+def cmd_update(
+    console: Console,
+    manager: TaskAgent,
+    slug_part: str,
+    depends_on: Optional[str] = None,
+):
+    """Update task properties."""
+    issues = manager.load_mission()
+    target = select_issue(
+        console, issues, slug_part, status_filter=["pending", "draft", "active"]
+    )
+    if not target:
+        console.print(
+            f"[red]No active/pending/draft task found matching '{slug_part}'.[/red]"
+        )
+        sys.exit(1)
+
+    if depends_on is not None:
+        try:
+            manager.update_dependencies(target.slug, depends_on)
+            console.print(
+                f"[bold green]Successfully updated dependencies for task '{target.slug}'.[/bold green]"
+            )
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            sys.exit(1)
+    else:
+        console.print(
+            "[yellow]No updates specified. Use --depends-on to update dependencies.[/yellow]"
+        )
+
+
 def cmd_start(
     console: Console,
     manager: TaskAgent,
@@ -1855,13 +2075,24 @@ def cmd_version(
     display_version_info(console)
 
     if tag:
-        v, _ = get_project_version()
+        v, source = get_committed_version()
         if v == "unknown":
             console.print(
                 "[red]Error: Could not determine project version to tag.[/red]"
             )
             return
 
+        # Warn if working tree differs from committed version
+        working_v, _ = get_project_version()
+        if working_v != v:
+            console.print(
+                f"[yellow]Warning: Working tree has version {working_v}, "
+                f"but HEAD has {v}[/yellow]"
+            )
+            console.print(
+                "[yellow]Committing changes with 'ta version promote' first is recommended.[/yellow]"
+            )
+
         tag_name = f"v{v}"
         result = subprocess.run(
             ["git", "tag", tag_name],
@@ -1911,7 +2142,7 @@ def cmd_version(
         new_v, _ = get_project_version()
         console.print(f"[bold green]Promoted to version {new_v}[/bold green]")
 
-        # Auto-commit version bump
+        # Auto-amend version bump into previous commit
         try:
             for file in ["pyproject.toml", "package.json", "uv.lock"]:
                 if Path(file).exists():
@@ -1922,30 +2153,30 @@ def cmd_version(
                         shell=(os.name == "nt"),
                     )
             result = subprocess.run(
-                ["git", "commit", "-m", f"chore: bump version to {new_v}"],
+                ["git", "commit", "--amend", "--no-edit"],
                 capture_output=True,
                 shell=(os.name == "nt"),
             )
             if result.returncode == 0:
-                console.print("[dim]Committed version bump[/dim]")
+                console.print("[dim]Version bump amended into previous commit[/dim]")
             elif (
                 b"nothing to commit" in result.stdout
                 or b"nothing to commit" in result.stderr
             ):
                 console.print(
-                    "[yellow]No changes to commit (already committed?)[/yellow]"
+                    "[yellow]No changes to commit (already amended?)[/yellow]"
                 )
             else:
                 console.print(
-                    "[yellow]Warning: Could not auto-commit version bump. "
-                    "Run 'git add' and 'git commit' manually.[/yellow]"
+                    "[yellow]Warning: Could not auto-amend version bump. "
+                    "Run 'git add' and 'git commit --amend --no-edit' manually.[/yellow]"
                 )
                 if result.stderr:
                     console.print(f"[dim]{result.stderr.decode()}[/dim]")
         except Exception as e:
             console.print(
-                f"[yellow]Warning: Auto-commit failed: {e}. "
-                "Run 'git commit' manually.[/yellow]"
+                f"[yellow]Warning: Auto-amend failed: {e}. "
+                "Run 'git commit --amend --no-edit' manually.[/yellow]"
             )
 
 
@@ -2870,10 +3101,42 @@ def main():
     promote_parser.add_argument("slug")
     demote_parser = subparsers.add_parser("demote")
     demote_parser.add_argument("slug")
-    active_parser = subparsers.add_parser("active")
-    active_parser.add_argument("slug", nargs="?")
-    start_parser = subparsers.add_parser("start")
-    start_parser.add_argument("slug", nargs="?")
+    active_parser = subparsers.add_parser(
+        "active",
+        help="Move an issue to active status, or list active tasks if no slug is provided",
+    )
+    active_parser.add_argument(
+        "slug", nargs="?", help="Optional slug of the task to mark as active"
+    )
+    update_parser = subparsers.add_parser(
+        "update", help="Update task properties (e.g. dependencies)"
+    )
+    update_parser.add_argument("slug", help="Slug of the task to update")
+    update_parser.add_argument(
+        "-d",
+        "--depends-on",
+        help="Comma-separated list of task slugs this task depends on (use empty string to clear)",
+    )
+    start_parser = subparsers.add_parser(
+        "start",
+        help="Activate a task and set up its git worktree/branch",
+        description="""
+Start working on a task. This command automates the following workflow:
+  1. Marks the task (identified by its slug) as ACTIVE in the task manager.
+     If no slug is provided, prompts you to select one from pending tasks.
+  2. Creates a new git branch named 'issue/<slug>' (branched from main/current).
+  3. Creates and checks out a new git worktree located at '.gwt/<slug>'.
+  4. If --agent is specified:
+     - If it matches a template in '.ta/agents/<agent_name>/meta.toml',
+       creates a dedicated per-task agent user 'agent-<slug>-<agent_name>'.
+     - Otherwise, configures worktree permissions for an existing agent user.
+  5. If --run is specified, immediately runs the sidecar worker on the worktree.
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    start_parser.add_argument(
+        "slug", nargs="?", help="Slug or partial slug of the task to start"
+    )
     start_parser.add_argument(
         "--run", action="store_true", help="Immediately run the sidecar worker"
     )
@@ -3094,7 +3357,9 @@ def main():
     elif args.command == "demote":
         cmd_demote(console, manager, args.slug)
     elif args.command == "active":
-        cmd_active(console, manager, args.slug)
+        cmd_active(console, manager, args.slug, list_if_none=True)
+    elif args.command == "update":
+        cmd_update(console, manager, args.slug, depends_on=args.depends_on)
     elif args.command == "start":
         cmd_start(console, manager, args.slug, run=args.run, agent_name=args.agent)
     elif args.command == "run":

{task_agent-0.1.311 → task_agent-0.1.321}/src/taskagent/manager.py

@@ -35,6 +35,36 @@ class TaskAgent:
         except subprocess.CalledProcessError:
             return None
 
+    @staticmethod
+    def _check_dependency_cycle(
+        issues: List[Issue], target_slug: str, new_deps: List[str]
+    ) -> bool:
+        """Check if adding new_deps to target_slug creates a cycle.
+
+        Returns True if a cycle is detected, False otherwise.
+        """
+        dep_map = {i.slug: list(i.dependencies) for i in issues}
+        dep_map[target_slug] = list(new_deps)
+        visited = {}  # None: unvisited, 0: visiting, 1: visited
+
+        def has_cycle(node: str) -> bool:
+            visited[node] = 0
+            for neighbor in dep_map.get(node, []):
+                state = visited.get(neighbor)
+                if state == 0:
+                    return True
+                elif state is None:
+                    if has_cycle(neighbor):
+                        return True
+            visited[node] = 1
+            return False
+
+        for node in dep_map:
+            if visited.get(node) is None:
+                if has_cycle(node):
+                    return True
+        return False
+
     @property
     def is_dual_repo(self) -> bool:
         """Check if mission files live in a different repo than the code."""
@@ -1019,10 +1049,27 @@ class TaskAgent:
         if not issue_file:
             raise FileNotFoundError(f"Issue '{slug}' not found.")
 
+        # Extract temporary deps from new content to validate them
+        match = re.search(r"\*\*Depends on:\*\*\s*(.*)", content)
+        new_deps = []
+        if match:
+            new_deps = [d.strip() for d in match.group(1).split(",") if d.strip()]
+
+        if slug in new_deps:
+            raise ValueError("A task cannot depend on itself.")
+
+        issues = self.load_mission()
+        existing_slugs = {i.slug for i in issues}
+        for dep in new_deps:
+            if dep not in existing_slugs:
+                raise ValueError(f"Dependency task '{dep}' does not exist.")
+
+        if self._check_dependency_cycle(issues, slug, new_deps):
+            raise ValueError("Adding these dependencies would introduce a cycle.")
+
         issue_file.write_text(content, encoding="utf-8")
 
         # Re-extract name and deps in case they changed
-        issues = self.load_mission()
         updated = False
         for i in issues:
             if i.slug == slug:
@@ -1040,7 +1087,87 @@ class TaskAgent:
                 return i
 
         # If it was completed, it's not in mission.usv
-        return Issue(name=self.extract_title(issue_file), slug=slug, status="completed")
+        return Issue(
+            name=self.extract_title(issue_file),
+            slug=slug,
+            dependencies=self.extract_deps(issue_file),
+            status="completed",
+        )
+
+    def update_dependencies(self, slug: str, depends_on: str) -> Issue:
+        """Update dependencies of an issue."""
+        issue_file = self.find_issue_file(slug, include_completed=True)
+        if not issue_file:
+            raise FileNotFoundError(f"Issue '{slug}' not found.")
+
+        # Parse new dependencies
+        new_deps = [d.strip() for d in depends_on.split(",") if d.strip()]
+
+        if slug in new_deps:
+            raise ValueError("A task cannot depend on itself.")
+
+        issues = self.load_mission()
+        existing_slugs = {i.slug for i in issues}
+        for dep in new_deps:
+            if dep not in existing_slugs:
+                raise ValueError(f"Dependency task '{dep}' does not exist.")
+
+        # Check for cycles
+        if self._check_dependency_cycle(issues, slug, new_deps):
+            raise ValueError("Adding these dependencies would introduce a cycle.")
+
+        # Update Markdown content
+        content = issue_file.read_text(encoding="utf-8")
+        if re.search(r"\*\*Depends on:\*\*\s*(.*)", content):
+            if new_deps:
+                content = re.sub(
+                    r"\*\*Depends on:\*\*\s*(.*)",
+                    f"**Depends on:** {', '.join(new_deps)}",
+                    content,
+                )
+            else:
+                # Remove the line and any trailing blank lines
+                content = re.sub(r"\*\*Depends on:\*\*\s*(.*)\n*", "", content)
+        else:
+            if new_deps:
+                # Insert it right after the H1 title
+                lines = content.splitlines()
+                inserted = False
+                for idx, line in enumerate(lines):
+                    if line.strip().startswith("# "):
+                        lines.insert(idx + 1, "")
+                        lines.insert(idx + 2, f"**Depends on:** {', '.join(new_deps)}")
+                        inserted = True
+                        break
+                if inserted:
+                    content = "\n".join(lines) + "\n"
+                else:
+                    content = f"**Depends on:** {', '.join(new_deps)}\n\n" + content
+
+        issue_file.write_text(content, encoding="utf-8")
+
+        # Sync and reload
+        updated = False
+        for i in issues:
+            if i.slug == slug:
+                i.dependencies = new_deps
+                updated = True
+                break
+
+        if updated:
+            self.save_mission(issues)
+
+        # Return the updated issue object
+        for i in issues:
+            if i.slug == slug:
+                return i
+
+        return Issue(
+            name=self.extract_title(issue_file),
+            slug=slug,
+            dependencies=new_deps,
+            status="completed",
+        )
 
     def ingest_issues(self) -> Tuple[int, int]:
         """Ingest existing markdown files. Returns (num_new, num_removed)."""

{task_agent-0.1.311 → task_agent-0.1.321}/src/taskagent/mcp.py

@@ -37,6 +37,22 @@ def list_tasks() -> str:
     return "\n".join(lines)
 
 
+@mcp.tool()
+def list_active_tasks() -> str:
+    """List only the currently active tasks in the mission queue."""
+    manager = get_manager()
+    issues = manager.sync_mission()
+    active_issues = [i for i in issues if i.status == "active"]
+    if not active_issues:
+        return "No active tasks found."
+
+    lines = []
+    for i in active_issues:
+        deps = f" (depends on: {', '.join(i.dependencies)})" if i.dependencies else ""
+        lines.append(f"[{i.priority}] ACTIVE: {i.name}{deps}")
+    return "\n".join(lines)
+
+
 @mcp.tool()
 def create_task(
     title: str,
@@ -226,6 +242,23 @@ def update_task(name: str, content: str) -> str:
         return f"Error updating task: {e}"
 
 
+@mcp.tool()
+def update_task_dependencies(name: str, depends_on: str) -> str:
+    """Update the dependencies of a task.
+
+    Args:
+        name: The title or partial name of the task to update.
+        depends_on: Comma-separated list of task slugs this task depends on (use empty string to clear).
+    """
+    manager = get_manager()
+    slug = manager.slugify(name)
+    try:
+        manager.update_dependencies(slug, depends_on)
+        return f"Successfully updated dependencies for task '{slug}'."
+    except Exception as e:
+        return f"Error updating task dependencies: {e}"
+
+
 @mcp.tool()
 def commit_repo(message: str = "", push: bool = False) -> str:
     """Commit changes to the current project's tasks directory (host repo).

{task_agent-0.1.311 → task_agent-0.1.321}/tests/test_cli.py

@@ -1,4 +1,5 @@
 import pytest
+from pathlib import Path
 from taskagent.cli import (
     cmd_new,
     cmd_done,
@@ -285,3 +286,80 @@ def test_cmd_init_mcp_claude(tmp_path):
         assert call_args[4] == "--"
         assert call_args[5] == "uv"
         assert "run" in call_args
+
+
+def test_detect_current_slug_from_git():
+    from unittest.mock import patch, MagicMock
+    from taskagent.cli import detect_current_slug_from_git
+
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(stdout="issue/my-cool-task\n", returncode=0)
+        assert detect_current_slug_from_git() == "my-cool-task"
+
+        mock_run.return_value = MagicMock(stdout="main\n", returncode=0)
+        assert detect_current_slug_from_git() is None
+
+        mock_run.side_effect = Exception("git failed")
+        assert detect_current_slug_from_git() is None
+
+
+def test_find_worktree_path_for_slug(tmp_path):
+    from unittest.mock import patch, MagicMock
+    from taskagent.cli import find_worktree_path_for_slug
+
+    with patch("subprocess.run") as mock_run:
+        mock_output = (
+            "worktree /path/to/main-repo\n"
+            "branch refs/heads/main\n"
+            "\n"
+            "worktree /path/to/worktrees/some-slug\n"
+            "branch refs/heads/issue/some-slug\n"
+        )
+        mock_run.return_value = MagicMock(stdout=mock_output, returncode=0)
+        assert find_worktree_path_for_slug("some-slug") == Path(
+            "/path/to/worktrees/some-slug"
+        )
+        assert find_worktree_path_for_slug("other-slug") is None
+
+
+def test_cmd_done_cleanup(manager, temp_issues_dir, tmp_path):
+    from unittest.mock import patch
+    from taskagent.cli import cmd_done
+
+    console = Console()
+    cmd_new(console, manager, "Done Clean Task", "Body", draft=False)
+
+    # Let's mock subprocess.run to simulate:
+    # 1. find_worktree_path_for_slug finds a registered worktree under tmp_path
+    # 2. CWD is NOT inside the worktree
+    # 3. Removing the worktree and branch succeeds
+    worktree_mock_path = tmp_path / "gwt-mock"
+    worktree_mock_path.mkdir()
+
+    mock_worktree_output = (
+        f"worktree {worktree_mock_path}\nbranch refs/heads/issue/done-clean-task\n"
+    )
+
+    def mock_run(cmd, **kwargs):
+        cmd_str = " ".join(cmd) if isinstance(cmd, list) else cmd
+
+        class MockCompletedProcess:
+            returncode = 0
+            stdout = ""
+            stderr = ""
+
+        res = MockCompletedProcess()
+        if "worktree list" in cmd_str:
+            res.stdout = mock_worktree_output
+        elif "worktree remove" in cmd_str:
+            # Delete mock directory to simulate success
+            import shutil
+
+            shutil.rmtree(worktree_mock_path)
+        elif "rev-parse" in cmd_str:
+            res.stdout = "abcdef12"
+        return res
+
+    with patch("subprocess.run", side_effect=mock_run):
+        cmd_done(console, manager, "done-clean-task", should_commit=False)
+        assert not worktree_mock_path.exists()

{task_agent-0.1.311 → task_agent-0.1.321}/tests/test_manager.py

@@ -353,3 +353,34 @@ def test_api_soft_delete(manager):
     # Should be removed from mission
     issues = manager.load_mission()
     assert not any(i.slug == "delete-me" for i in issues)
+
+
+def test_api_update_dependencies(manager):
+    manager.create_issue("Task A")
+    manager.create_issue("Task B")
+    manager.create_issue("Task C")
+
+    # Update dependencies of B to depend on A
+    manager.update_dependencies("task-b", "task-a")
+    issue_file = manager.find_issue_file("task-b")
+    assert manager.extract_deps(issue_file) == ["task-a"]
+
+    # Try updating B to depend on C and A
+    manager.update_dependencies("task-b", "task-c, task-a")
+    assert manager.extract_deps(issue_file) == ["task-c", "task-a"]
+
+    # Try introducing a self-loop (should fail)
+    with pytest.raises(ValueError, match="cannot depend on itself"):
+        manager.update_dependencies("task-b", "task-b")
+
+    # Try introducing a cycle: A depends on B (B already depends on A)
+    with pytest.raises(ValueError, match="introduce a cycle"):
+        manager.update_dependencies("task-a", "task-b")
+
+    # Try updating with non-existent task
+    with pytest.raises(ValueError, match="does not exist"):
+        manager.update_dependencies("task-b", "non-existent-task")
+
+    # Clear dependencies
+    manager.update_dependencies("task-b", "")
+    assert manager.extract_deps(issue_file) == []

{task_agent-0.1.311 → task_agent-0.1.321}/tests/test_mcp.py

@@ -159,8 +159,48 @@ def test_mcp_commit_tasks_success():
         assert "Committed: test commit" in result
 
 
+def test_mcp_list_active_tasks(monkeypatch):
+    class DummyIssue:
+        def __init__(self, priority, status, name, dependencies=None):
+            self.priority = priority
+            self.status = status
+            self.name = name
+            self.dependencies = dependencies or []
+
+    class DummyManager:
+        def sync_mission(self):
+            return [
+                DummyIssue(1, "active", "Task 1"),
+                DummyIssue(2, "pending", "Task 2"),
+                DummyIssue(3, "active", "Task 3", ["Task 1"]),
+            ]
+
+    monkeypatch.setattr(mcp, "get_manager", lambda: DummyManager())
+    result = mcp.list_active_tasks()
+    assert "[1] ACTIVE: Task 1" in result
+    assert "Task 2" not in result
+    assert "[3] ACTIVE: Task 3 (depends on: Task 1)" in result
+
+
+def test_mcp_update_task_dependencies(monkeypatch):
+    called = []
+
+    class DummyManager:
+        def slugify(self, name):
+            return name.lower().replace(" ", "-")
+
+        def update_dependencies(self, slug, depends_on):
+            called.append((slug, depends_on))
+
+    monkeypatch.setattr(mcp, "get_manager", lambda: DummyManager())
+    result = mcp.update_task_dependencies("Task One", "task-two,task-three")
+    assert result == "Successfully updated dependencies for task 'task-one'."
+    assert called == [("task-one", "task-two,task-three")]
+
+
 EXPECTED_TOOLS = {
     "list_tasks",
+    "list_active_tasks",
     "create_task",
     "promote_task",
     "demote_task",
@@ -170,6 +210,7 @@ EXPECTED_TOOLS = {
     "restore_task",
     "get_task_details",
     "update_task",
+    "update_task_dependencies",
     "commit_repo",
     "commit_tasks",
 }

{task_agent-0.1.311 → task_agent-0.1.321}/uv.lock

@@ -1080,7 +1080,7 @@ wheels = [
 
 [[package]]
 name = "task-agent"
-version = "0.1.311"
+version = "0.1.321"
 source = { editable = "." }
 dependencies = [
     { name = "githubkit" },