Feature Request: Integrated Parallel Task Management and Worktree Orchestration

Title: Feature Request: Integrated Parallel Task Management and Worktree Orchestration

Labels: feature-request, enhancement, cli, agent-capabilities, workflow

---

Is your feature request related to a problem? Please describe.

The official documentation under Common Workflows suggests using git worktree to run parallel Claude Code sessions. While this highlights a powerful pattern, the current implementation is entirely manual and presents several significant problems for the user:

• High Cognitive Load: The developer must manually create worktrees, navigate between directories, and manage multiple terminal windows, each with its own Claude Code instance. This process is complex and error-prone.
• Manual Orchestration: The user is forced to be the orchestrator of parallel work. This detracts from the "agentic" nature of the tool, where the AI assistant should be handling such automatable tasks.
• Clunky and Disjointed Workflow: Switching between tasks, checking their status, and merging results is a cumbersome process that happens outside of a unified Claude Code interface, breaking the user's flow.

The current approach is a workaround, not a first-class feature. The tool itself should be capable of managing this complexity on the user's behalf.

Describe the solution you'd like

I propose adding native support for managing parallel, long-running tasks directly within a single Claude Code interface. The agent should become the orchestrator of these tasks, leveraging git worktrees and background processes seamlessly.

This would transform Claude Code from a single-threaded assistant into a true work dispatcher, allowing a developer to delegate multiple complex tasks and continue their own work without interruption.

Proposed Command Interface and Workflow

The proposed solution would be managed through a new, intuitive set of slash commands:

1. Initiating a Parallel Task (/fork)

A new command, /fork, would be used to delegate a task to a background agent.

• Syntax:
• /fork "<prompt>"
• /fork --issue=<issue_number> "<prompt>"
• Examples:
• > /fork "Implement the new caching layer based on the specs in README.md"
• > /fork --issue=123 "Fix the login bug described in GitHub issue 123"

When /fork is executed, Claude Code would automatically:

1. Create a new git worktree with a descriptive branch (e.g., ../project-fork-caching-layer).
2. Start a headless, non-interactive Claude Code agent (potentially using the [SDK](/en/docs/claude-code/sdk)) in that worktree with the given prompt.
3. The main interactive session would immediately return control to the user.

2. Managing Ongoing Tasks (/tasks)

A new command, /tasks, would serve as the central hub for managing all forked agents.

• > /tasks list (or just > /tasks): Displays a summary of all active and completed background tasks in a clear, table-based format.

| ID | Status | Summary | Worktree Path |
|:--- |:---------------- |:------------------------------------|:------------------------------|
| 1 | Running Tests | Implementing new caching layer... | ../project-fork-1-caching |
| 2 | Awaiting Input | Fixing issue ... | ../project-fork-2-issue-123 |
| 3 | Done (PR Ready)| Refactoring the auth module... | ../project-fork-3-refactor |

• > /tasks view <ID>: Dives into a specific task, showing its full transcript, logs, and current state. If a task is Awaiting Input, the user can provide feedback or grant permissions here.

• > /tasks kill <ID>: Terminates a background agent and offers to clean up the associated worktree and branch.

3. Completing and Merging a Task (/tasks merge)

Once a background agent completes its work, its status changes to Done (PR Ready).

• > /tasks merge <ID>: Instructs Claude Code to finalize the task. The agent would:

1. Ensure all tests pass on the task's branch.
2. Generate a comprehensive Pull Request title and description based on the task's history.
3. Create the pull request on GitHub.
4. Present the user with the PR link in the main session.
5. Clean up the associated git worktree.

Describe alternatives you've considered

• Current Manual Workflow: This is the process described in the documentation, which this feature aims to replace due to its high friction and cognitive load.
• Simple Backgrounding (claude &): This is a simpler alternative but lacks the critical code isolation provided by git worktree and offers no integrated way to manage, inspect, or interact with the backgrounded task.

Key Benefits

• True Agentic Parallelism: Empowers developers to delegate multiple complex, long-running tasks (e.g., feature implementation, large-scale refactoring) without blocking their own interactive workflow.
• Reduced Cognitive Load: Abstracts away the tedious and error-prone mechanics of managing git worktrees, multiple shells, and background processes into a single, clean interface.
• Streamlined Workflow: Integrates a powerful development pattern directly into the tool with a simple, intuitive set of commands (/fork, /tasks, /merge).
• Increased Developer Productivity: Maximizes developer efficiency by turning agent wait times (e.g., during builds, tests, or long thinking cycles) into productive time for the user on other tasks.

This feature would represent a significant leap in Claude Code's capabilities, evolving it from a conversational pair-programmer to a true agentic work orchestrator.