Task Master

https://docs.task-master.dev
Admin
Task Master is a platform or tool designed to help users manage, automate, and configure tasks,...
Tokens:34,901
Snippets:504
Trust Score:7.4
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example: Starting Workflow and Initial Status

Source: https://docs.task-master.dev/tdd-workflow/quickstart

Demonstrates the output after starting a workflow, showing the task ID, branch creation, current phase, and the next action.

```bash
$ tm autopilot start 7

✓ Workflow started for task 7
✓ Created branch: task-7
✓ Current phase: RED
✓ Subtask 1/5: Implement start command
→ Next action: Write a failing test
```

--------------------------------

### Example .env File

Source: https://docs.task-master.dev/configuration

A comprehensive example of a .env file showing required and optional configurations for Task Master.

```dotenv
# Required
ANTHROPIC_API_KEY=sk-ant-api03-your-api-key

# Optional - Claude Configuration
MODEL=claude-3-7-sonnet-20250219
MAX_TOKENS=4000
TEMPERATURE=0.7

# Optional - Perplexity API for Research
PERPLEXITY_API_KEY=pplx-your-api-key
PERPLEXITY_MODEL=sonar-medium-online

# Optional - Project Info
PROJECT_NAME=My Project
PROJECT_VERSION=1.0.0

# Optional - Application Configuration
DEFAULT_SUBTASKS=3
DEFAULT_PRIORITY=medium
DEBUG=false
LOG_LEVEL=info

# TDD Workflow
TM_MAX_ATTEMPTS=3
TM_AUTO_COMMIT=true
```

--------------------------------

### Install Node.js using winget

Source: https://docs.task-master.dev/getting-started/quick-start/requirements

Use winget to install the Node.js LTS version on Windows.

```bash
winget install OpenJS.NodeJS
```

--------------------------------

### Clone the Repository and Install Dependencies

Source: https://docs.task-master.dev/getting-started/contribute

Clone the Task Master repository and install necessary npm packages to begin development.

```bash
git clone https://github.com/YOUR_USERNAME/claude-task-master.git
cd claude-task-master
npm install
```

--------------------------------

### Copy Environment Template

Source: https://docs.task-master.dev/getting-started/contribute

Copy the example environment file to create a new environment file for local development.

```bash
cp .env.example .env
```

--------------------------------

### Install Node.js using Chocolatey

Source: https://docs.task-master.dev/getting-started/quick-start/requirements

Use Chocolatey to install the Node.js LTS version on Windows.

```bash
choco install nodejs
```

--------------------------------

### Install Task Master CLI

Source: https://docs.task-master.dev/getting-started/quick-start/installation

Install the Task Master command-line interface globally or locally using npm.

```bash
# Install globally
npm install -g task-master-ai

# OR install locally within your project
npm install task-master-ai
```

--------------------------------

### AI Agent Prompt: Start Task

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Example prompt for an AI agent to initiate the TDD workflow for a specific task.

```plaintext
I want to implement Task 7 using TDD workflow. Please:
1. Start the autopilot workflow
2. Show me the first subtask to implement
3. Begin the RED-GREEN-COMMIT cycle
```

--------------------------------

### Initiate Task Execution

Source: https://docs.task-master.dev/getting-started/quick-start/execute-quick

Once the agent has analyzed the task and files and presented a plan, use this command to tell the agent to start execution.

```text
You may begin. I believe in you.
```

--------------------------------

### CLI Configuration with .env File

Source: https://docs.task-master.dev/getting-started/quick-start/configuration-quick

Set up required API keys and optional endpoint overrides for Task Master providers in a `.env` file located at the project root for CLI usage. This example includes common provider keys and endpoint examples.

```dotenv
# Required API keys for providers configured in .taskmaster/config.json
ANTHROPIC_API_KEY=sk-ant-api03-your-key-here
PERPLEXITY_API_KEY=pplx-your-key-here
# OPENAI_API_KEY=sk-your-key-here
# GOOGLE_API_KEY=AIzaSy...
# AZURE_OPENAI_API_KEY=your-azure-openai-api-key-here
# etc.

# Optional Endpoint Overrides
# Use a specific provider's base URL, e.g., for an OpenAI-compatible API
# OPENAI_BASE_URL=https://api.third-party.com/v1
#
# Azure OpenAI Configuration
# AZURE_OPENAI_ENDPOINT=https://your-resource-name.openai.azure.com/ or https://your-endpoint-name.cognitiveservices.azure.com/openai/deployments
# OLLAMA_BASE_URL=http://custom-ollama-host:11434/api

# Google Vertex AI Configuration (Required if using 'vertex' provider)
# VERTEX_PROJECT_ID=your-gcp-project-id
```

--------------------------------

### Cursor One-Click Install Deeplink

Source: https://docs.task-master.dev/getting-started/quick-start/installation

Use this deeplink to initiate a one-click installation of Task Master within Cursor. You will need to manually add your API keys after installation.

```deeplink
cursor://anysphere.cursor-deeplink/mcp/install?name=taskmaster-ai&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIi0tcGFja2FnZT10YXNrLW1hc3Rlci1haSIsInRhc2stbWFzdGVyLWFpIl0sImVudiI6eyJBTlRIUk9QSUNfQVBJX0tFWSI6IllPVVJfQU5USFJPUElDX0FQSV9LRVlfSEVSRSIsIlBFUlBMRVhJVFlfQVBJX0tFWSI6IllPVVJfUEVSUExFWElUWV9BUElfS0VZX0hFUkUiLCJPUEVOQUlfQVBJX0tFWSI6IllPVVJfT1BFTkFJX0tFWV9IRVJFIiwiR09PR0xFX0FQSV9LRVkiOiJZT1VSX0dPT0dMRV9LRVlfSEVSRSIsIk1JU1RSQUxfQVBJX0tFWSI6IllPVVJfTUlTVFJBTF9LRVlfSEVSRSIsIk9QRU5ST1VURVJfQVBJX0tFWSI6IllPVVJfT1BFTlJPVVRFUl9LRVlfSEVSRSIsIlhBSV9BUElfS0VZIjoiWU9VUl9YQUlfS0VZX0hFUkUiLCJBWlVSRV9PUEVOQUlfQVBJX0tFWSI6IllPVVJfQVpVUkVfS0VZX0hFUkUiLCJPTExBTUFfQVBJX0tFWSI6IllPVVJfT0xMQU1BX0FQSV9LRVlfSEVSRSJ9fQo=
```

--------------------------------

### Setup and Set AI Models

Source: https://docs.task-master.dev/getting-started/api-keys

Commands to interactively set up and configure the main, research, and fallback AI models for Task Master.

```bash
# Interactive model setup
task-master models --setup

# Set specific models
task-master models --set-main claude-3-5-sonnet-20241022
task-master models --set-research perplexity-llama-3.1-sonar-large-128k-online
task-master models --set-fallback gpt-4o-mini
```

--------------------------------

### MCP Integration for AI Agents

Source: https://docs.task-master.dev/tdd-workflow/quickstart

Demonstrates how to use MCP tools to interact with Task Master's autopilot workflow from AI agents. Includes starting a workflow, getting the next action, completing a phase, and committing progress.

```typescript
// Start workflow
await mcp.call('autopilot_start', {
  taskId: '7',
  projectRoot: '/path/to/project'
});

// Get next action
const next = await mcp.call('autopilot_next', {
  projectRoot: '/path/to/project'
});

// Complete phase
await mcp.call('autopilot_complete_phase', {
  projectRoot: '/path/to/project',
  testResults: { total: 1, passed: 0, failed: 1, skipped: 0 }
});

// Commit
await mcp.call('autopilot_commit', {
  projectRoot: '/path/to/project'
});
```

--------------------------------

### MCP Tools: Autopilot Start Parameters

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Defines the parameters for starting the autopilot workflow programmatically. Requires taskId and projectRoot.

```typescript
{
  taskId: string;          // Required: Task ID (e.g., "7", "2.3")
  projectRoot: string;     // Required: Absolute path to project
  tag?: string;            // Optional: Tag context
  maxAttempts?: number;    // Optional: Default 3
  force?: boolean;         // Optional: Default false
}
```

--------------------------------

### Create and Edit .env File

Source: https://docs.task-master.dev/getting-started/api-keys

Steps to create a .env file from an example and edit it with your API keys. This is a common method for managing environment variables.

```bash
# Copy from .env.example
cp .env.example .env

# Edit with your keys
vim .env
```

--------------------------------

### TaskMaster Autopilot Start Command JSON Output

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Example JSON output when starting a TaskMaster autopilot workflow with the --json flag. It includes success status, messages, task details, branch name, workflow phase, progress indicators, and information about the current subtask.

```json
{
  "success": true,
  "message": "Workflow started for task 7",
  "taskId": "7",
  "branchName": "task-7",
  "phase": "SUBTASK_LOOP",
  "tddPhase": "RED",
  "progress": {
    "completed": 0,
    "total": 5,
    "percentage": 0
  },
  "currentSubtask": {
    "id": "1",
    "title": "Implement start command",
    "status": "in-progress",
    "attempts": 0
  },
  "nextAction": "generate_test"
}
```

--------------------------------

### Structural Decomposition Example

Source: https://docs.task-master.dev/capabilities/rpg-method

Maps a capability to its corresponding repository folder structure and files, showing which files implement specific features.

```text
Capability: Data Management
  → Maps to: src/data/
    ├── schema-validator.js    (Schema validation feature)
    ├── rule-validator.js      (Rule validation feature)
    └── index.js               (Exports)
```

--------------------------------

### Resume or Force Start Workflow

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Command-line options to either resume an existing workflow or force the start of a new one when a workflow is already in progress.

```bash
# Resume existing workflow
tm autopilot resume

# OR force start new workflow
tm autopilot start 7 --force
```

--------------------------------

### Dependency Graph Example

Source: https://docs.task-master.dev/capabilities/rpg-method

Illustrates how to define dependencies between modules across different layers. This is critical for Task Master to build the dependency graph.

```text
Foundation Layer (Phase 0):
  - error-handling: No dependencies
  - base-types: No dependencies

Data Layer (Phase 1):
  - schema-validator: Depends on [base-types, error-handling]
  - data-ingestion: Depends on [schema-validator]
```

--------------------------------

### Claude Code Quick Install Command

Source: https://docs.task-master.dev/getting-started/quick-start/installation

Use this command for a quick installation of Task Master via Claude Code. Ensure you configure your API keys in the project's root .env file and the MCP config.

```bash
claude mcp add taskmaster-ai -- npx -y task-master-ai
```

--------------------------------

### State Management File Example

Source: https://docs.task-master.dev/best-practices/configuration-advanced

This file tracks tagged system runtime information, including the current tag and last switch time. It is automatically managed and should not be edited manually.

```json
{
  "currentTag": "master",
  "lastSwitched": "2025-06-11T20:26:12.598Z",
  "migrationNoticeShown": true
}
```

--------------------------------

### Explicit Dependency Declaration Example

Source: https://docs.task-master.dev/capabilities/rpg-method

Demonstrates the correct way to declare module dependencies, ensuring clarity and enabling automated dependency analysis. Avoid implicit assumptions about existing modules.

```text
Good:
  Module: data-ingestion
  Depends on: [schema-validator, config-manager]

Bad:
  Module: data-ingestion
  (Assumes schema-validator exists somewhere)
```

--------------------------------

### Functional Decomposition Example

Source: https://docs.task-master.dev/capabilities/rpg-method

An example of how to break down a high-level capability into specific features, detailing their inputs, outputs, and behavior.

```text
Capability: Data Management
  Feature: Schema validation
    Description: Validate JSON against defined schemas
    Inputs: JSON object, schema definition
    Outputs: Validation result + error details
    Behavior: Iterate fields, check types, enforce constraints
```

--------------------------------

### Example Changeset vs Git Commit Message

Source: https://docs.task-master.dev/getting-started/contribute

Illustrates the difference between a user-facing changeset summary and a developer-facing Git commit message.

```bash
# Changeset summary (user-facing)
"Add support for custom Ollama models"

# Git commit message (developer-facing)
"feat(models): implement custom Ollama model validation

- Add model validation for custom Ollama endpoints
- Update configuration schema to support custom models
- Add tests for new validation logic"
```

--------------------------------

### Example .taskmaster/config.json Structure

Source: https://docs.task-master.dev/best-practices/configuration-advanced

This JSON file configures AI models, parameters, logging, and project defaults. It is recommended for new projects and can be managed interactively or manually.

```json
{
  "models": {
    "main": {
      "provider": "anthropic",
      "modelId": "claude-3-7-sonnet-20250219",
      "maxTokens": 64000,
      "temperature": 0.2,
      "baseURL": "https://api.anthropic.com/v1"
    },
    "research": {
      "provider": "perplexity",
      "modelId": "sonar-pro",
      "maxTokens": 8700,
      "temperature": 0.1,
      "baseURL": "https://api.perplexity.ai/v1"
    },
    "fallback": {
      "provider": "anthropic",
      "modelId": "claude-3-5-sonnet",
      "maxTokens": 64000,
      "temperature": 0.2
    }
  },
  "global": {
    "logLevel": "info",
    "debug": false,
    "defaultSubtasks": 5,
    "defaultPriority": "medium",
    "defaultTag": "master",
    "projectName": "Your Project Name",
    "ollamaBaseURL": "http://localhost:11434/api",
    "azureBaseURL": "https://your-endpoint.azure.com/openai/deployments",
    "vertexProjectId": "your-gcp-project-id",
    "vertexLocation": "us-central1"
  }
}
```

--------------------------------

### autopilot_start

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Starts a new AI Agent workflow. This is the SDK method for initiating a workflow.

```APIDOC
## autopilot_start

### Description
Starts a new AI Agent workflow programmatically.

### Method
SDK Method

### Endpoint
autopilot_start

### Parameters
#### Request Body
- **taskId** (string) - Required - Task ID (e.g., "7", "2.3").
- **projectRoot** (string) - Required - Absolute path to project.
- **tag** (string) - Optional - Tag context.
- **maxAttempts** (number) - Optional - Maximum attempts for a subtask, defaults to 3.
- **force** (boolean) - Optional - Force start, defaults to false.

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **message** (string) - A message describing the result.
- **taskId** (string) - The ID of the started task.
- **branchName** (string) - The Git branch name created for the task.
- **phase** (string) - The initial workflow phase.
- **tddPhase** (string) - The initial TDD phase.
- **progress** (object) - Initial progress details.
- **currentSubtask** (object) - Information about the first subtask.
- **nextAction** (string) - The first action to be performed.
```

--------------------------------

### AI Agent Workflow Integration Example

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

An example function demonstrating how an AI agent can orchestrate the TDD workflow using MCP tools, including generating tests, implementing code, and managing phases.

```typescript
// AI Agent using MCP tools

async function implementTask(taskId: string) {
  // Start workflow
  const start = await mcp.call('autopilot_start', {
    taskId,
    projectRoot: '/path/to/project'
  });

  console.log(`Started task ${start.taskId} on branch ${start.branchName}`);

  while (true) {
    // Get next action
    const next = await mcp.call('autopilot_next', {
      projectRoot: '/path/to/project'
    });

    console.log(`Next action: ${next.action}`);

    if (next.action === 'generate_test') {
      // AI generates test
      const testCode = await generateTest(next.currentSubtask);
      await writeFile(testCode);

      // Run tests
      const results = await runTests();

      // Complete RED phase
      await mcp.call('autopilot_complete_phase', {
        projectRoot: '/path/to/project',
        testResults: results
      });

    } else if (next.action === 'implement_code') {
      // AI generates implementation
      const implCode = await generateImplementation(next.currentSubtask);
      await writeFile(implCode);

      // Run tests
      const results = await runTests();

      // Complete GREEN phase
      await mcp.call('autopilot_complete_phase', {
        projectRoot: '/path/to/project',
        testResults: results
      });

    } else if (next.action === 'commit_changes') {
      // Commit
      const commit = await mcp.call('autopilot_commit', {
        projectRoot: '/path/to/project'
      });

      console.log(`Committed: ${commit.commit.hash}`);

      if (commit.isComplete) {
        console.log('Task complete!');
        break;
      }
    }
  }
}
```

--------------------------------

### Change AI Model Example

Source: https://docs.task-master.dev/getting-started/quick-start/installation

Example command to change the main, research, and fallback AI models in your editor's AI chat pane. This example uses Claude Code.

```txt
Change the main model to claude-code/sonnet
```

--------------------------------

### Start Cluster Session with Tmux

Source: https://docs.task-master.dev/capabilities/clusters

Initiates a Task Master cluster session within a tmux environment. This involves opening iTerm2, starting tmux control mode, and then executing the cluster start command.

```bash
# 4. Open iTerm2, start tmux control mode, and execute
tmux -CC
tm clusters start --tag backend
```

--------------------------------

### Preview Cluster Execution Plan

Source: https://docs.task-master.dev/capabilities/clusters

Allows you to preview the execution plan for starting a cluster with a specific tag without actually running the tasks. This is useful for verifying the intended workflow.

```bash
# 3. Preview the execution plan
tm clusters start --tag backend --dry-run
```

--------------------------------

### tm autopilot next

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Get the next action to perform with detailed context using the CLI.

```APIDOC
## tm autopilot next

### Description
Get the next action to perform with detailed context using the CLI.

### Method
CLI Command

### Endpoint
tm autopilot next

### Parameters
#### Query Parameters
- `--json` (boolean) - Optional - Output in JSON format.

### Request Example
```bash
tm autopilot next --json
```

### Response
#### Success Response (200)
- **action** (string) - The next action to perform (e.g., 'generate_test').
- **actionDescription** (string) - A description of the action.
- **phase** (string) - The current workflow phase.
- **tddPhase** (string) - The current TDD phase (e.g., 'RED', 'GREEN').
- **taskId** (string) - The ID of the current task.
- **branchName** (string) - The Git branch name for the task.
- **progress** (object) - Workflow progress details.
- **currentSubtask** (object) - Information about the current subtask.
- **expectedFiles** (array) - List of expected files for the current action.
- **context** (object) - Contextual information, including `canProceed` and `errors`.
```

--------------------------------

### Topological Order Example

Source: https://docs.task-master.dev/capabilities/rpg-method

Shows a phased approach to development, building foundational layers before dependent ones. Task Master uses this structure for topological ordering of tasks.

```text
Phase 0 (Foundation): error-handling, base-types, config
                
                
                Phase 1 (Data): validation, ingestion (depend on Phase 0)
                
                
                Phase 2 (Core): algorithms, pipelines (depend on Phase 1)
                
                
                Phase 3 (API): routes, handlers (depend on Phase 2)
```

--------------------------------

### autopilot_resume

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Resumes a previously started AI Agent workflow programmatically.

```APIDOC
## autopilot_resume

### Description
Resumes a previously started AI Agent workflow programmatically.

### Method
SDK Method

### Endpoint
autopilot_resume

### Parameters
#### Request Body
- **projectRoot** (string) - Required - Absolute path to the project root directory.
```

--------------------------------

### Get Next Task via CLI

Source: https://docs.task-master.dev/getting-started/quick-start/execute-quick

Execute this command in the CLI to retrieve the next task.

```bash
task-master next
```

--------------------------------

### Get Next Action in JSON Format

Source: https://docs.task-master.dev/tdd-workflow/quickstart

Queries the autopilot for the next recommended action in JSON format. Useful for scripting and automation.

```bash
# Check what to do next
$ tm autopilot next --json
{
  "action": "generate_test",
  "currentSubtask": {
    "id": "1",
    "title": "Implement start command"
  }
}
```

--------------------------------

### Start TDD Workflow

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Initiates the TDD workflow for a given task ID. Returns the initial workflow state, including the task ID, branch name, current TDD phase, and the next action for the AI agent.

```bash
$ tm autopilot start 7 --json
```

--------------------------------

### Initialize Project

Source: https://docs.task-master.dev/capabilities/cli-root-commands

Initializes a new project with the standard Task Master structure.

```bash
task-master init
```

--------------------------------

### Start Task Master Autopilot with JSON Output

Source: https://docs.task-master.dev/tdd-workflow/quickstart

Initiates the Task Master autopilot workflow for a given task ID and outputs the result in JSON format. Useful for CI/CD and automated processes.

```bash
$ tm autopilot start 7 --json | jq .
{
  "success": true,
  "taskId": "7",
  "branchName": "task-7",
  "phase": "SUBTASK_LOOP",
  "tddPhase": "RED",
  "progress": { ... },
  "currentSubtask": { ... },
  "nextAction": "generate_test"
}
```

--------------------------------

### Get Next Task via Natural Language

Source: https://docs.task-master.dev/getting-started/quick-start/execute-quick

Use this natural language prompt to ask for the next task to work on, considering dependencies and priorities.

```text
What's the next task I should work on? Please consider dependencies and priorities.
```

--------------------------------

### Task Metadata: Stable UUID Tracking

Source: https://docs.task-master.dev/capabilities/task-structure

Example of using the metadata field for stable UUID tracking, versioning, and tracking the creation source of a task.

```json
{
  "id": 4,
  "title": "Add user preferences",
  "metadata": {
    "uuid": "550e8400-e29b-41d4-a716-446655440000",
    "version": 2,
    "createdBy": "import-script"
  }
}
```

--------------------------------

### Task Metadata: External System Integration

Source: https://docs.task-master.dev/capabilities/task-structure

Example of using the metadata field to store integration data from external systems like Jira, including timestamps for import and sync.

```json
{
  "id": 3,
  "title": "Fix login bug",
  "metadata": {
    "jira": {
      "key": "PROJ-123",
      "type": "bug",
      "priority": "P1"
    },
    "importedAt": "2024-01-15T10:30:00Z",
    "lastSyncedAt": "2024-01-20T14:00:00Z"
  }
}
```

--------------------------------

### Functional vs. Structural Thinking Example

Source: https://docs.task-master.dev/capabilities/rpg-method

Illustrates the separation of functional requirements (WHAT) from structural implementation details (HOW). This principle is key to maintaining clear module boundaries and preventing mixed concerns in the PRD.

```text
Functional: "Data Validation capability with schema checking and rule enforcement"
                    
                    
                    Structural: "src/validation/ with schema-validator.js and rule-validator.js"
```

--------------------------------

### AI Agent Prompt: GREEN Phase - Implementing

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Example prompt for an AI agent to implement minimal code to pass a failing test during the GREEN phase of TDD.

```plaintext
We're in GREEN phase. The test is failing with: {ERROR_MESSAGE}

Please:
1. Implement the minimal code to make this test pass
2. Don't over-engineer or add untested features
3. Run tests and report results to complete the GREEN phase
```

--------------------------------

### Initialize a New Project

Source: https://docs.task-master.dev/command-reference

Initialize a new project with the standard Task Master structure using the `init` command.

```bash
# Initialize a new project with Task Master structure
task-master init
```

--------------------------------

### Start TaskMaster Autopilot Workflow

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Command to initialize a new TDD workflow for a specific task ID. Supports options for maximum attempts per subtask, forcing initialization, specifying the project root, and outputting results in JSON format.

```bash
tm autopilot start 7 --max-attempts 5 --json
```

--------------------------------

### Start Task Master Cluster Execution

Source: https://docs.task-master.dev/capabilities/clusters

Launches an interactive Claude Code session to execute the detected task clusters for the active tag. If no tag is specified, it defaults to the currently active tag.

```bash
tm clusters start --tag <tag>
```

```bash
tm clusters start
```

--------------------------------

### Initialize New Project via CLI

Source: https://docs.task-master.dev/getting-started/quick-start/installation

Initialize a new Task Master project using the command-line interface. This command prompts for project details and sets up the necessary structure.

```bash
# If installed globally
task-master init

# If installed locally
npx task-master init

# Initialize project with specific rules
task-master init --rules cursor,windsurf,vscode
```

--------------------------------

### Implement a Task

Source: https://docs.task-master.dev/best-practices/advanced-tasks

Initiate the implementation of a specific task. The agent will reference task details and dependencies.

```bash
Let's implement task 3. What does it involve?
```

--------------------------------

### Start an Autopilot Workflow

Source: https://docs.task-master.dev/tdd-workflow/quickstart

Initiates the autonomous TDD workflow for a given task ID. This command starts the process and creates a new Git branch for the task.

```bash
tm autopilot start <taskId>
```

--------------------------------

### Run Task Master Init Script from Cloned Repository

Source: https://docs.task-master.dev/configuration

Alternatively, clone the Task Master repository and run the initialization script from the cloned directory. This ensures you are using the latest code.

```bash
git clone https://github.com/eyaltoledano/claude-task-master.git
cd claude-task-master
node scripts/init.js
```

--------------------------------

### autopilot_status

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Gets the current status and progress of the AI Agent workflow.

```APIDOC
## autopilot_status

### Description
Gets the current status and progress of the AI Agent workflow programmatically.

### Method
SDK Method

### Endpoint
autopilot_status

### Parameters
#### Request Body
- **projectRoot** (string) - Required - Absolute path to the project root directory.

### Response
#### Success Response (200)
- **taskId** (string) - The ID of the current task.
- **branchName** (string) - The Git branch name for the task.
- **phase** (string) - The current workflow phase.
- **tddPhase** (string) - The current TDD phase.
- **progress** (object) - Workflow progress details.
- **currentSubtask** (object) - Information about the current subtask.
- **subtasks** (array) - List of all subtasks and their statuses.
- **errors** (array) - Any errors encountered during the workflow.
- **metadata** (object) - Additional metadata about the workflow.
- **canProceed** (boolean) - Indicates if the workflow can proceed.
```

--------------------------------

### Add New Task

Source: https://docs.task-master.dev/capabilities/cli-root-commands

Add new tasks to your project, optionally with descriptions, dependencies, or priority.

```bash
task-master add-task --prompt="Description of the new task"
```

```bash
task-master add-task --prompt="Description" --dependencies=1,2,3
```

```bash
task-master add-task --prompt="Description" --priority=high
```

--------------------------------

### Run Task Master Init Script Directly

Source: https://docs.task-master.dev/configuration

If `task-master init` fails, try running the initialization script directly using Node. This can help diagnose issues.

```bash
node node_modules/claude-task-master/scripts/init.js
```

--------------------------------

### tm autopilot resume

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Resume a previously started workflow from saved state using the CLI.

```APIDOC
## tm autopilot resume

### Description
Resume a previously started workflow from saved state using the CLI.

### Method
CLI Command

### Endpoint
tm autopilot resume

### Parameters
#### Query Parameters
- `--json` (boolean) - Optional - Output in JSON format.

### Request Example
```bash
tm autopilot resume --json
```
```

--------------------------------

### Configure API Keys

Source: https://docs.task-master.dev/getting-started/contribute

Add your API keys to the .env file for testing AI features. Include keys for services like Anthropic and OpenAI.

```bash
ANTHROPIC_API_KEY=your_key_here
OPENAI_API_KEY=your_key_here
# Add others as needed
```

--------------------------------

### tm autopilot status

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Get comprehensive workflow progress and state information using the CLI.

```APIDOC
## tm autopilot status

### Description
Get comprehensive workflow progress and state information using the CLI.

### Method
CLI Command

### Endpoint
tm autopilot status

### Parameters
#### Query Parameters
- `--json` (boolean) - Optional - Output in JSON format.

### Request Example
```bash
tm autopilot status --json
```
```

--------------------------------

### Configure All MCP Tools

Source: https://docs.task-master.dev/capabilities/mcp

Loads all 36 available tools, providing full Task Master functionality. Use this when you need access to every feature, including tag management and dependencies.

```json
{
  "mcpServers": {
    "task-master-ai": {
      "command": "npx",
      "args": ["-y", "task-master-ai"],
      "env": {
        "TASK_MASTER_TOOLS": "all",
        "ANTHROPIC_API_KEY": "your_key_here"
      }
    }
  }
}
```

--------------------------------

### Run All Tests

Source: https://docs.task-master.dev/getting-started/contribute

Execute all unit tests for the project.

```bash
npm test
```

--------------------------------

### Project and Configuration

Source: https://docs.task-master.dev/capabilities/mcp

Functions for initializing projects, generating task files, managing AI model configurations, and performing research.

```APIDOC
## Project and Configuration

### `initialize_project`

Initializes a new project.

### `generate`

Generates individual task files.

### `models`

Manages AI model configurations.

### `research`

Performs AI-powered research.
```

--------------------------------

### Update Tasks from ID

Source: https://docs.task-master.dev/capabilities/cli-root-commands

Updates tasks starting from a specified ID, using a prompt to provide new context or information.

```bash
# Update tasks from a specific ID and provide context
task-master update --from=<id> --prompt="<prompt>"
```

--------------------------------

### Set Ollama API Key

Source: https://docs.task-master.dev/getting-started/api-keys

Configure the API key for remote Ollama servers that require authentication. This is not needed for local installations.

```bash
OLLAMA_API_KEY="your-ollama-api-key-here"
```

--------------------------------

### Configure Core MCP Tools

Source: https://docs.task-master.dev/capabilities/mcp

Loads 7 essential tools for daily development, ideal for minimal context usage. This is the default mode if TASK_MASTER_TOOLS is not set.

```json
{
  "mcpServers": {
    "task-master-ai": {
      "command": "npx",
      "args": ["-y", "task-master-ai"],
      "env": {
        "TASK_MASTER_TOOLS": "core",
        "ANTHROPIC_API_KEY": "your_key_here"
      }
    }
  }
}
```

--------------------------------

### Run Tests and Check Formatting

Source: https://docs.task-master.dev/getting-started/contribute

Execute all tests, check code formatting, and fix any formatting issues before submitting your changes.

```bash
# Run all tests
npm test

# Check formatting
npm run format-check

# Fix formatting if needed
npm run format
```

--------------------------------

### Resume TDD workflow

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Resumes a previously started workflow from its saved state. Use the --json flag for JSON output.

```bash
tm autopilot resume --json
```

--------------------------------

### Show Individual Task Details

Source: https://docs.task-master.dev/getting-started/quick-start/tasks-quick

Display all implementation details of an individual task, including subtasks and testing strategy. Replace <##> with the specific task ID.

```bash
task-master show --id=<##>
```

--------------------------------

### Google Vertex AI Configuration with API Key

Source: https://docs.task-master.dev/best-practices/configuration-advanced

Sets up Google Vertex AI using an API key. Ensure the GOOGLE_API_KEY, VERTEX_PROJECT_ID, and VERTEX_LOCATION environment variables are correctly set in your .env file.

```bash
# In .env file
GOOGLE_API_KEY=AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXX
VERTEX_PROJECT_ID=my-gcp-project-123
VERTEX_LOCATION=us-central1
```

--------------------------------

### List Available Tasks

Source: https://docs.task-master.dev/best-practices/advanced-tasks

Ask the agent to list all available tasks. The agent will run 'task-master list' to retrieve this information.

```bash
What tasks are available to work on next?
```

--------------------------------

### Git Working Tree Not Clean Recovery

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Use these commands to clean the Git working tree by committing or stashing changes before starting a workflow.

```bash
git status
git add . && git commit -m "chore: save work"
# Then start workflow
```

--------------------------------

### MCP Tools: Autopilot Next Parameters and Return

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Defines the parameters for getting the next action in an autopilot workflow and the structure of the returned information.

```typescript
{
  projectRoot: string;  // Required: Absolute path to project
}

// Returns:
{
  action: string;              // 'generate_test' | 'implement_code' | 'commit_changes'
  actionDescription: string;
  phase: WorkflowPhase;
  tddPhase: TDDPhase;
  taskId: string;
  branchName: string;
  progress: ProgressInfo;
  currentSubtask: SubtaskInfo | null;
  expectedFiles: string[];
  context: {
    canProceed: boolean;
    errors: string[];
  };
}
```

--------------------------------

### Configure Standard MCP Tools

Source: https://docs.task-master.dev/capabilities/mcp

Loads 15 commonly used tools, balancing functionality with context efficiency. This mode includes all core tools plus additional ones for project management and analysis.

```json
{
  "mcpServers": {
    "task-master-ai": {
      "command": "npx",
      "args": ["-y", "task-master-ai"],
      "env": {
        "TASK_MASTER_TOOLS": "standard",
        "ANTHROPIC_API_KEY": "your_key_here"
      }
    }
  }
}
```

--------------------------------

### Workflow for Task Complexity Analysis and Expansion

Source: https://docs.task-master.dev/capabilities/task-structure

This sequence demonstrates generating a complexity report, reviewing it, and then expanding tasks based on the analysis. It highlights the research capabilities during analysis and the options for expanding individual or all tasks.

```bash
# Generate the complexity analysis report with research capabilities
task-master analyze-complexity --research

# Review the report in a readable format
task-master complexity-report

# Expand tasks using the optimized recommendations
task-master expand --id=8
# or expand all tasks
task-master expand --all
```

--------------------------------

### Task Metadata: GitHub Issue Linking

Source: https://docs.task-master.dev/capabilities/task-structure

Example of using the metadata field to link a task to a GitHub issue, including the issue number and URL.

```json
{
  "id": 1,
  "title": "Implement authentication",
  "metadata": {
    "githubIssue": 42,
    "githubIssueUrl": "https://github.com/org/repo/issues/42"
  }
}
```

--------------------------------

### Get next action in TDD workflow

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Retrieves the next action to perform in the TDD workflow, providing detailed context. The output is in JSON format.

```bash
tm autopilot next --json
```

--------------------------------

### Configure Groq API Key

Source: https://docs.task-master.dev/getting-started/api-keys

Set the GROQ_API_KEY environment variable to utilize high-performance inference for models like Llama and Mixtral through Groq.

```bash
GROQ_API_KEY="your-groq-key-here"
```

--------------------------------

### Break Down Task with Specific Prompt

Source: https://docs.task-master.dev/best-practices/advanced-tasks

When breaking down a task, you can provide a custom prompt to guide the subtask generation, focusing on specific aspects like security.

```bash
task-master expand --id=5 --prompt="Focus on security aspects"
```

--------------------------------

### AI Agent Prompt: RED Phase - Writing Failing Tests

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Example prompt for an AI agent to write a failing test during the RED phase of TDD.

```plaintext
We're in RED phase for subtask "{SUBTASK_TITLE}". Please:
1. Read the subtask requirements
2. Write a test that validates the behavior
3. The test MUST fail because the feature doesn't exist yet
4. Run the tests and report results to complete the RED phase
```

--------------------------------

### Troubleshooting State Persistence Failures

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Steps to diagnose and resolve state persistence issues, including checking file permissions, verifying state writing, and reinstalling if necessary.

```bash
# Check file system permissions
ls -la .taskmaster/workflow-state.json

# Verify state is being written
tm autopilot status --json | jq .

# If all else fails, reinstall
rm -rf .taskmaster/
tm init
```

--------------------------------

### Write a Failing Test (RED Phase)

Source: https://docs.task-master.dev/tdd-workflow/quickstart

Example of a failing test case written using Vitest. This test is designed to fail until the corresponding feature is implemented.

```typescript
// tests/start.test.ts
import { describe, it, expect } from 'vitest';
import { StartCommand } from '../src/commands/start';

describe('StartCommand', () => {
  it('should initialize workflow', async () => {
    const command = new StartCommand();
    const result = await command.execute({ taskId: '7' });
    expect(result.success).toBe(true);
  });
});
```

--------------------------------

### Configure Custom MCP Tool Selection

Source: https://docs.task-master.dev/capabilities/mcp

Allows specifying exactly which tools to load using a comma-separated list. Tool names are case-insensitive and support both underscores and hyphens.

```json
{
  "mcpServers": {
    "task-master-ai": {
      "command": "npx",
      "args": ["-y", "task-master-ai"],
      "env": {
        "TASK_MASTER_TOOLS": "get_tasks,next_task,set_task_status,update_subtask",
        "ANTHROPIC_API_KEY": "your_key_here"
      }
    }
  }
}
```

--------------------------------

### Get TDD workflow status

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Fetches comprehensive progress and state information for the current TDD workflow. Use the --json flag for JSON output.

```bash
tm autopilot status --json
```

--------------------------------

### Set Azure as Main Provider via CLI

Source: https://docs.task-master.dev/providers/azure

Configure Task Master to use Azure as the main AI provider with a specific model.

```bash
task-master models --set-main azure:gpt-4o
```

--------------------------------

### Show Next Task

Source: https://docs.task-master.dev/capabilities/cli-root-commands

Displays the next task to work on, considering task dependencies and their current status.

```bash
# Show the next task to work on based on dependencies and status
task-master next
```

--------------------------------

### TDD Workflow Next Action JSON Output

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Example JSON output detailing the next action to be performed in the TDD workflow, including task and progress information.

```json
{
  "action": "generate_test",
  "actionDescription": "Write a failing test for the current subtask",
  "phase": "SUBTASK_LOOP",
  "tddPhase": "RED",
  "taskId": "7",
  "branchName": "task-7",
  "progress": {
    "completed": 0,
    "total": 5,
    "current": 1,
    "percentage": 0
  },
  "currentSubtask": {
    "id": "1",
    "title": "Implement start command",
    "status": "in-progress",
    "attempts": 0,
    "maxAttempts": 3
  },
  "expectedFiles": ["test file"],
  "context": {
    "canProceed": false,
    "errors": []
  }
}
```

--------------------------------

### Task Metadata: Sprint & Project Management

Source: https://docs.task-master.dev/capabilities/task-structure

Example of using the metadata field for sprint and project management details like sprint name, story points, and epic.

```json
{
  "id": 2,
  "title": "Refactor API endpoints",
  "metadata": {
    "sprint": "Q1-S3",
    "storyPoints": 5,
    "epic": "API Modernization"
  }
}
```

--------------------------------

### Run Tests with Coverage

Source: https://docs.task-master.dev/getting-started/contribute

Execute tests and generate a code coverage report.

```bash
npm run test:coverage
```

--------------------------------

### Expand All Tasks

Source: https://docs.task-master.dev/getting-started/quick-start/tasks-quick

Use this command to add detail to tasks and create subtasks. It's recommended to expand all tasks for accurate task management.

```bash
task-master expand --all
```

--------------------------------

### Generate Raw Mermaid Syntax for Execution Plan

Source: https://docs.task-master.dev/capabilities/clusters

Outputs the raw Mermaid syntax for the execution plan, suitable for copying into documentation, pull requests, or online editors like mermaid.live.

```bash
tm clusters --diagram mermaid-raw > execution-plan.mmd
```

--------------------------------

### Initial Workflow State

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

The JSON response after starting the workflow, indicating success, task details, the current TDD phase (RED), the current subtask, and the next AI action.

```json
{
  "success": true,
  "taskId": "7",
  "branchName": "task-7",
  "tddPhase": "RED",
  "currentSubtask": {
    "id": "1",
    "title": "Implement start command",
    "status": "in-progress"
  },
  "nextAction": "generate_test"
}
```

--------------------------------

### Initialize Task Master via Editor

Source: https://docs.task-master.dev/getting-started/quick-start/installation

Command to initialize Task Master within your project using the editor's AI chat pane.

```txt
Initialize taskmaster-ai in my project
```

--------------------------------

### Start Autonomous TDD Workflow

Source: https://docs.task-master.dev/command-reference

Initiate an autonomous Test-Driven Development workflow for a given task ID. This process enforces RED → GREEN → COMMIT cycles.

```bash
# Start autonomous TDD workflow for a task
task-master autopilot start <taskId>
```

```bash
# Get next action with context
task-master autopilot next
```

```bash
# Complete phase with test results
task-master autopilot complete --results '{"total":N,"passed":N,"failed":N}'
```

```bash
# Commit changes
task-master autopilot commit
```

```bash
# Check workflow status
task-master autopilot status
```

```bash
# Resume interrupted workflow
task-master autopilot resume
```

```bash
# Abort workflow
task-master autopilot abort
```

--------------------------------

### Resolve Merge Conflicts in Tasks.json

Source: https://docs.task-master.dev/best-practices/advanced-tasks

Use the 'move' command to resolve merge conflicts in tasks.json when working with a team. This example shows how to keep teammates' tasks and move your own to new positions.

```bash
I just merged the main branch and there's a conflict with tasks.json. My teammates created tasks 10-15 while I created tasks 10-12 on my branch. Can you help me resolve this?
```

```bash
task-master move --from=10,11,12 --to=16,17,18
```

--------------------------------

### Set Project Metadata

Source: https://docs.task-master.dev/configuration

Define project name and version for metadata. These help in identifying the project within Task Master.

```bash
PROJECT_NAME=My Awesome Project
```

```bash
PROJECT_VERSION=2.1.0
```

--------------------------------

### Basic Azure OpenAI Configuration

Source: https://docs.task-master.dev/providers/azure

A basic configuration for using Azure OpenAI with a specified model, max tokens, and temperature.

```json
{
  "models": {
    "main": {
      "provider": "azure",
      "modelId": "gpt-4o",
      "maxTokens": 16384,
      "temperature": 0.2
    }
  },
  "global": {
    "azureBaseURL": "https://my-resource.openai.azure.com/openai"
  }
}
```

--------------------------------

### Run Tests and Expect Pass

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

After implementing the code, run tests again using npm test. The output should now show that all tests are passing.

```bash
$ npm test
# Output: 1 test passed
```

--------------------------------

### Set Application Configuration

Source: https://docs.task-master.dev/configuration

Configure application-specific settings such as default subtasks, priority, debug logging, and log level.

```bash
DEBUG=true
```

```bash
LOG_LEVEL=debug
```

```bash
DEFAULT_SUBTASKS=5
```

```bash
DEFAULT_PRIORITY=high
```

--------------------------------

### Dry Run Task Master Cluster Execution

Source: https://docs.task-master.dev/capabilities/clusters

Previews the execution plan generated by `tm clusters start` without actually launching a Claude session. This is useful for verifying the plan before execution.

```bash
tm clusters start --tag backend --dry-run
```

--------------------------------

### Configure Google API Key

Source: https://docs.task-master.dev/getting-started/api-keys

Set the GOOGLE_API_KEY environment variable for Google Gemini models. Alternatively, use GOOGLE_APPLICATION_CREDENTIALS for service account authentication with Google Vertex.

```bash
GOOGLE_API_KEY="your-google-api-key-here"
```

--------------------------------

### Get Next AI Action

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Requests the next action from the AI agent within the TDD workflow. Returns the action to be performed, a description, the current TDD phase, and details about the current subtask.

```bash
$ tm autopilot next --json
```

--------------------------------

### List All Pending Tasks

Source: https://docs.task-master.dev/getting-started/quick-start/tasks-quick

View a list of all pending tasks and their descriptions to review the plan. This helps ensure correct folder structures and dependencies.

```bash
task-master list
```

--------------------------------

### Optimizing Task Master Tools in MCP

Source: https://docs.task-master.dev/getting-started/quick-start/configuration-quick

Control which Task Master MCP tools are loaded using the `TASK_MASTER_TOOLS` environment variable to reduce LLM context usage. This example shows setting it to 'standard'.

```json
{
  "env": {
    "TASK_MASTER_TOOLS": "standard",
    "ANTHROPIC_API_KEY": "your_key_here"
  }
}
```

--------------------------------

### Create a Changeset

Source: https://docs.task-master.dev/getting-started/contribute

Generate a changeset file to manage versioning and changelogs for your contributions. This is required for most types of changes.

```bash
npm run changeset
```

--------------------------------

### GREEN Phase Error Handling

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

This message indicates a failure in the GREEN phase of TDD, meaning tests are still failing after implementation. It guides the user to review failing tests and fix the implementation to pass them.

```text
GREEN phase validation failed - {N} tests still failing.

Please:
1. Review the failing test output
2. Fix the implementation to pass all tests
3. Try completing the GREEN phase again
```

--------------------------------

### Visualize All Execution Tags

Source: https://docs.task-master.dev/capabilities/clusters

Displays all tags in the project organized into execution phases. Tags at the same level can run in parallel, while higher levels depend on lower levels completing first.

```bash
tm clusters
```

--------------------------------

### View Task Master Cluster Overview

Source: https://docs.task-master.dev/capabilities/clusters

Displays a high-level overview of all Task Master clusters, organized by tags. Useful for understanding the overall execution phases.

```bash
# 1. See the big picture — tag-level execution phases
tm clusters
```

--------------------------------

### TaskMaster Autopilot Workflow Commands

Source: https://docs.task-master.dev/tdd-workflow/ai-agent-integration

Sequence of commands to initiate and manage an autonomous TDD workflow using TaskMaster's autopilot feature. This includes starting a workflow, checking the next action, completing phases (RED/GREEN), and committing changes.

```bash
# 1. Initialize workflow for a task
tm autopilot start 7

# 2. Check what to do next
tm autopilot next

# 3. Write failing test (RED phase)
# ... create test file ...

# 4. Run tests and complete RED phase
tm autopilot complete --results '{"total":1,"passed":0,"failed":1,"skipped":0}'

# 5. Implement code to pass tests (GREEN phase)
# ... write implementation ...

# 6. Run tests and complete GREEN phase
tm autopilot complete --results '{"total":1,"passed":1,"failed":0,"skipped":0}'

# 7. Commit changes
tm autopilot commit

# 8. Repeat for next subtask (automatically advanced)
tm autopilot next
```
Tokens:
Raw