Merge branch 'next' of https://github.com/eyaltoledano/claude-task-master into joedanz/flexible-brand-rules

# Conflicts: # .cursor/rules/dev_workflow.mdc # mcp-server/src/tools/index.js # scripts/init.js
2025-06-15 13:25:59 -04:00
parent af76613eb8 46d4f273f5
commit 3bf24962c3
263 changed files with 25128 additions and 21840 deletions
--- a/docs/README.md
+++ b/docs/README.md
@@ -9,7 +9,7 @@ Welcome to the Task Master documentation. Use the links below to navigate to the

 ## Reference

- [Command Reference](command-reference.md) - Complete list of all available commands
+- [Command Reference](command-reference.md) - Complete list of all available commands (including research and multi-task viewing)
 - [Task Structure](task-structure.md) - Understanding the task format and features

 ## Examples & Licensing
--- a/docs/command-reference.md
+++ b/docs/command-reference.md
@@ -43,10 +43,28 @@ task-master show <id>
 # or
 task-master show --id=<id>

+# View multiple tasks with comma-separated IDs
+task-master show 1,3,5
+task-master show 44,55
+
 # View a specific subtask (e.g., subtask 2 of task 1)
 task-master show 1.2
+
+# Mix parent tasks and subtasks
+task-master show 44,44.1,55,55.2
 ```

+**Multiple Task Display:**
+
+- **Single ID**: Shows detailed task view with full implementation details
+- **Multiple IDs**: Shows compact summary table with interactive action menu
+- **Action Menu**: Provides copy-paste ready commands for batch operations:
+  - Mark all as in-progress/done
+  - Show next available task
+  - Expand all tasks (generate subtasks)
+  - View dependency relationships
+  - Generate task files
+
 ## Update Tasks

 ```bash
@@ -229,6 +247,56 @@ task-master add-task --prompt="Description" --dependencies=1,2,3
 task-master add-task --prompt="Description" --priority=high
 ```

+## Tag Management
+
+Task Master supports tagged task lists for multi-context task management. Each tag represents a separate, isolated context for tasks.
+
+```bash
+# List all available tags with task counts and status
+task-master tags
+
+# List tags with detailed metadata
+task-master tags --show-metadata
+
+# Create a new empty tag
+task-master add-tag <tag-name>
+
+# Create a new tag with a description
+task-master add-tag <tag-name> --description="Feature development tasks"
+
+# Create a tag based on current git branch name
+task-master add-tag --from-branch
+
+# Create a new tag by copying tasks from the current tag
+task-master add-tag <new-tag> --copy-from-current
+
+# Create a new tag by copying from a specific tag
+task-master add-tag <new-tag> --copy-from=<source-tag>
+
+# Switch to a different tag context
+task-master use-tag <tag-name>
+
+# Rename an existing tag
+task-master rename-tag <old-name> <new-name>
+
+# Copy an entire tag to create a new one
+task-master copy-tag <source-tag> <target-tag>
+
+# Copy a tag with a description
+task-master copy-tag <source-tag> <target-tag> --description="Copied for testing"
+
+# Delete a tag and all its tasks (with confirmation)
+task-master delete-tag <tag-name>
+
+# Delete a tag without confirmation prompt
+task-master delete-tag <tag-name> --yes
+```
+
+**Tag Context:**
+- All task operations (list, show, add, update, etc.) work within the currently active tag
+- Use `--tag=<name>` flag with most commands to operate on a specific tag context
+- Tags provide complete isolation - tasks in different tags don't interfere with each other
+
 ## Initialize a Project

 ```bash
@@ -313,4 +381,70 @@ task-master models --set-research=google/gemini-pro --openrouter
 task-master models --setup
 ```

-Configuration is stored in `.taskmasterconfig` in your project root. API keys are still managed via `.env` or MCP configuration. Use `task-master models` without flags to see available built-in models. Use `--setup` for a guided experience.
+Configuration is stored in `.taskmaster/config.json` in your project root (legacy `.taskmasterconfig` files are automatically migrated). API keys are still managed via `.env` or MCP configuration. Use `task-master models` without flags to see available built-in models. Use `--setup` for a guided experience.
+
+State is stored in `.taskmaster/state.json` in your project root. It maintains important information like the current tag. Do not manually edit this file.
+
+## Research Fresh Information
+
+```bash
+# Perform AI-powered research with fresh, up-to-date information
+task-master research "What are the latest best practices for JWT authentication in Node.js?"
+
+# Research with specific task context
+task-master research "How to implement OAuth 2.0?" --id=15,16
+
+# Research with file context for code-aware suggestions
+task-master research "How can I optimize this API implementation?" --files=src/api.js,src/auth.js
+
+# Research with custom context and project tree
+task-master research "Best practices for error handling" --context="We're using Express.js" --tree
+
+# Research with different detail levels
+task-master research "React Query v5 migration guide" --detail=high
+
+# Disable interactive follow-up questions (useful for scripting, is the default for MCP)
+# Use a custom tasks file location
+task-master research "How to implement this feature?" --file=custom-tasks.json
+
+# Research within a specific tag context
+task-master research "Database optimization strategies" --tag=feature-branch
+
+# Save research conversation to .taskmaster/docs/research/ directory (for later reference)
+task-master research "Database optimization techniques" --save-file
+
+# Save key findings directly to a task or subtask (recommended for actionable insights)
+task-master research "How to implement OAuth?" --save-to=15
+task-master research "API optimization strategies" --save-to=15.2
+
+# Combine context gathering with automatic saving of findings
+task-master research "Best practices for this implementation" --id=15,16 --files=src/auth.js --save-to=15.3
+```
+
+**The research command is a powerful exploration tool that provides:**
+
+- **Fresh information beyond AI knowledge cutoffs**
+- **Project-aware context** from your tasks and files
+- **Automatic task discovery** using fuzzy search
+- **Multiple detail levels** (low, medium, high)
+- **Token counting and cost tracking**
+- **Interactive follow-up questions** for deep exploration
+- **Flexible save options** (commit findings to tasks or preserve conversations)
+- **Iterative discovery** through continuous questioning and refinement
+
+**Use research frequently to:**
+
+- Get current best practices before implementing features
+- Research new technologies and libraries
+- Find solutions to complex problems
+- Validate your implementation approaches
+- Stay updated with latest security recommendations
+
+**Interactive Features (CLI):**
+
+- **Follow-up questions** that maintain conversation context and allow deep exploration
+- **Save menu** during or after research with flexible options:
+  - **Save to task/subtask**: Commit key findings and actionable insights (recommended)
+  - **Save to file**: Preserve entire conversation for later reference if needed
+  - **Continue exploring**: Ask more follow-up questions to dig deeper
+- **Automatic file naming** with timestamps and query-based slugs when saving conversations
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -2,6 +2,7 @@

 Taskmaster uses two primary methods for configuration:

+1.  **`.taskmaster/config.json` File (Recommended - New Structure)**
 1.  **`.taskmaster/config.json` File (Recommended - New Structure)**

    - This JSON file stores most configuration settings, including AI model selections, parameters, logging levels, and project defaults.
@@ -38,6 +39,7 @@ Taskmaster uses two primary methods for configuration:
          "debug": false,
          "defaultSubtasks": 5,
          "defaultPriority": "medium",
+          "defaultTag": "master",
          "projectName": "Your Project Name",
          "ollamaBaseURL": "http://localhost:11434/api",
          "azureBaseURL": "https://your-endpoint.azure.com/",
@@ -79,10 +81,50 @@ Taskmaster uses two primary methods for configuration:

 **Important:** Settings like model ID selections (`main`, `research`, `fallback`), `maxTokens`, `temperature`, `logLevel`, `defaultSubtasks`, `defaultPriority`, and `projectName` are **managed in `.taskmaster/config.json`** (or `.taskmasterconfig` for unmigrated projects), not environment variables.

+## Tagged Task Lists Configuration (v0.17+)
+
+Taskmaster includes a tagged task lists system for multi-context task management.
+
+### Global Tag Settings
+
+```json
+"global": {
+  "defaultTag": "master"
+}
+```
+
+- **`defaultTag`** (string): Default tag context for new operations (default: "master")
+
+### Git Integration
+
+Task Master provides manual git integration through the `--from-branch` option:
+
+- **Manual Tag Creation**: Use `task-master add-tag --from-branch` to create a tag based on your current git branch name
+- **User Control**: No automatic tag switching - you control when and how tags are created
+- **Flexible Workflow**: Supports any git workflow without imposing rigid branch-tag mappings
+
+## State Management File
+
+Taskmaster uses `.taskmaster/state.json` to track tagged system runtime information:
+
+```json
+{
+  "currentTag": "master",
+  "lastSwitched": "2025-06-11T20:26:12.598Z",
+  "migrationNoticeShown": true
+}
+```
+
+- **`currentTag`**: Currently active tag context
+- **`lastSwitched`**: Timestamp of last tag switch
+- **`migrationNoticeShown`**: Whether migration notice has been displayed
+
+This file is automatically created during tagged system migration and should not be manually edited.
+
 ## Example `.env` File (for API Keys)

 ```
-# Required API keys for providers configured in .taskmasterconfig
+# 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
@@ -157,7 +199,7 @@ Google Vertex AI is Google Cloud's enterprise AI platform and requires specific
   VERTEX_LOCATION=us-central1
   ```

-5. **In .taskmasterconfig**:
+5. **In .taskmaster/config.json**:
   ```json
   "global": {
     "vertexProjectId": "my-gcp-project-123",
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -21,6 +21,20 @@ What's the next task I should work on? Please consider dependencies and prioriti
 I'd like to implement task 4. Can you help me understand what needs to be done and how to approach it?
 ```

+## Viewing multiple tasks
+
+```
+Can you show me tasks 1, 3, and 5 so I can understand their relationship?
+```
+
+```
+I need to see the status of tasks 44, 55, and their subtasks. Can you show me those?
+```
+
+```
+Show me tasks 10, 12, and 15 and give me some batch actions I can perform on them.
+```
+
 ## Managing subtasks

 ```
@@ -109,3 +123,136 @@ Please add a new task to implement user profile image uploads using Cloudinary,
 ```

 (Agent runs: `task-master add-task --prompt="Implement user profile image uploads using Cloudinary" --research`)
+
+## Research-Driven Development
+
+### Getting Fresh Information
+
+```
+Research the latest best practices for implementing JWT authentication in Node.js applications.
+```
+
+(Agent runs: `task-master research "Latest best practices for JWT authentication in Node.js"`)
+
+### Research with Project Context
+
+```
+I'm working on task 15 which involves API optimization. Can you research current best practices for our specific implementation?
+```
+
+(Agent runs: `task-master research "API optimization best practices" --id=15 --files=src/api.js`)
+
+### Research Before Implementation
+
+```
+Before I implement task 8 (React Query integration), can you research the latest React Query v5 patterns and any breaking changes?
+```
+
+(Agent runs: `task-master research "React Query v5 patterns and breaking changes" --id=8`)
+
+### Research and Update Pattern
+
+```
+Research the latest security recommendations for Express.js applications and update our authentication task with the findings.
+```
+
+(Agent runs:
+
+1. `task-master research "Latest Express.js security recommendations" --id=12`
+2. `task-master update-subtask --id=12.3 --prompt="Updated with latest security findings: [research results]"`)
+
+### Research for Debugging
+
+```
+I'm having issues with our WebSocket implementation in task 20. Can you research common WebSocket problems and solutions?
+```
+
+(Agent runs: `task-master research "Common WebSocket implementation problems and solutions" --id=20 --files=src/websocket.js`)
+
+### Research Technology Comparisons
+
+```
+We need to choose between Redis and Memcached for caching. Can you research the current recommendations for our use case?
+```
+
+(Agent runs: `task-master research "Redis vs Memcached 2024 comparison for session caching" --tree`)
+
+## Git Integration and Tag Management
+
+### Creating Tags for Feature Branches
+
+```
+I'm starting work on a new feature branch for user authentication. Can you create a matching task tag?
+```
+
+(Agent runs: `task-master add-tag --from-branch`)
+
+### Creating Named Tags
+
+```
+Create a new tag called 'api-v2' for our API redesign work.
+```
+
+(Agent runs: `task-master add-tag api-v2 --description="API v2 redesign tasks"`)
+
+### Switching Tag Contexts
+
+```
+Switch to the 'testing' tag so I can work on QA tasks.
+```
+
+(Agent runs: `task-master use-tag testing`)
+
+### Copying Tasks Between Tags
+
+```
+I need to copy the current tasks to a new 'hotfix' tag for urgent fixes.
+```
+
+(Agent runs: `task-master add-tag hotfix --copy-from-current --description="Urgent hotfix tasks"`)
+
+### Managing Multiple Contexts
+
+```
+Show me all available tags and their current status.
+```
+
+(Agent runs: `task-master tags --show-metadata`)
+
+### Tag Cleanup
+
+```
+I've finished the 'user-auth' feature and merged the branch. Can you clean up the tag?
+```
+
+(Agent runs: `task-master delete-tag user-auth`)
+
+### Working with Tag-Specific Tasks
+
+```
+List all tasks in the 'api-v2' tag context.
+```
+
+(Agent runs: `task-master use-tag api-v2` then `task-master list`)
+
+### Branch-Based Development Workflow
+
+```
+I'm switching to work on the 'feature/payments' branch. Can you set up the task context for this?
+```
+
+(Agent runs:
+1. `git checkout feature/payments`
+2. `task-master add-tag --from-branch --description="Payment system implementation"`
+3. `task-master list` to show tasks in the new context)
+
+### Parallel Feature Development
+
+```
+I need to work on both authentication and payment features simultaneously. How should I organize the tasks?
+```
+
+(Agent suggests and runs:
+1. `task-master add-tag auth --description="Authentication feature tasks"`
+2. `task-master add-tag payments --description="Payment system tasks"`
+3. `task-master use-tag auth` to start with authentication work)
--- a/docs/migration-guide.md
+++ b/docs/migration-guide.md
@@ -232,4 +232,4 @@ If you encounter issues during migration:

 ---

-_This migration guide applies to Task Master v3.x and later. For older versions, please upgrade to the latest version first._
+_This migration guide applies to Task Master v0.15.x and later. For older versions, please upgrade to the latest version first._
--- a/docs/models.md
+++ b/docs/models.md
@@ -1,4 +1,4 @@
-# Available Models as of June 8, 2025
+# Available Models as of June 15, 2025

 ## Main Models

@@ -10,7 +10,7 @@
 | anthropic  | claude-3-5-sonnet-20241022                     | 0.49      | 3          | 15          |
 | openai     | gpt-4o                                         | 0.332     | 2.5        | 10          |
 | openai     | o1                                             | 0.489     | 15         | 60          |
-| openai     | o3                                             | 0.5       | 10         | 40          |
+| openai     | o3                                             | 0.5       | 2          | 8           |
 | openai     | o3-mini                                        | 0.493     | 1.1        | 4.4         |
 | openai     | o4-mini                                        | 0.45      | 1.1        | 4.4         |
 | openai     | o1-mini                                        | 0.4       | 1.1        | 4.4         |
@@ -85,7 +85,7 @@
 | anthropic  | claude-3-7-sonnet-20250219                     | 0.623     | 3          | 15          |
 | anthropic  | claude-3-5-sonnet-20241022                     | 0.49      | 3          | 15          |
 | openai     | gpt-4o                                         | 0.332     | 2.5        | 10          |
-| openai     | o3                                             | 0.5       | 10         | 40          |
+| openai     | o3                                             | 0.5       | 2          | 8           |
 | openai     | o4-mini                                        | 0.45      | 1.1        | 4.4         |
 | google     | gemini-2.5-pro-preview-05-06                   | 0.638     | —          | —           |
 | google     | gemini-2.5-pro-preview-03-25                   | 0.638     | —          | —           |
--- a/docs/task-structure.md
+++ b/docs/task-structure.md
@@ -137,3 +137,290 @@ The `show` command:
 8. **Communicate context to the agent**: When asking the Cursor agent to help with a task, provide context about what you're trying to achieve.

 9. **Validate dependencies**: Periodically run the validate-dependencies command to check for invalid or circular dependencies.
+
+# Task Structure Documentation
+
+Task Master uses a structured JSON format to organize and manage tasks. As of version 0.16.2, Task Master introduces **Tagged Task Lists** for multi-context task management while maintaining full backward compatibility.
+
+## Tagged Task Lists System
+
+Task Master now organizes tasks into separate contexts called **tags**. This enables working across multiple contexts such as different branches, environments, or project phases without conflicts.
+
+### Data Structure Overview
+
+**Tagged Format (Current)**:
+
+```json
+{
+  "master": {
+    "tasks": [
+      { "id": 1, "title": "Setup API", "status": "pending", ... }
+    ]
+  },
+  "feature-branch": {
+    "tasks": [
+      { "id": 1, "title": "New Feature", "status": "pending", ... }
+    ]
+  }
+}
+```
+
+**Legacy Format (Automatically Migrated)**:
+
+```json
+{
+  "tasks": [
+    { "id": 1, "title": "Setup API", "status": "pending", ... }
+  ]
+}
+```
+
+### Tag-based Task Lists (v0.17+) and Compatibility
+
+- **Seamless Migration**: Existing `tasks.json` files are automatically migrated to use a "master" tag
+- **Zero Disruption**: All existing commands continue to work exactly as before
+- **Backward Compatibility**: Existing workflows remain unchanged
+- **Silent Process**: Migration happens transparently on first use with a friendly notification
+
+## Core Task Properties
+
+Each task within a tag context contains the following properties:
+
+### Required Properties
+
+- **`id`** (number): Unique identifier within the tag context
+
+  ```json
+  "id": 1
+  ```
+
+- **`title`** (string): Brief, descriptive title
+
+  ```json
+  "title": "Implement user authentication"
+  ```
+
+- **`description`** (string): Concise summary of what the task involves
+
+  ```json
+  "description": "Create a secure authentication system using JWT tokens"
+  ```
+
+- **`status`** (string): Current state of the task
+  - Valid values: `"pending"`, `"in-progress"`, `"done"`, `"review"`, `"deferred"`, `"cancelled"`
+  ```json
+  "status": "pending"
+  ```
+
+### Optional Properties
+
+- **`dependencies`** (array): IDs of prerequisite tasks that must be completed first
+
+  ```json
+  "dependencies": [2, 3]
+  ```
+
+- **`priority`** (string): Importance level
+
+  - Valid values: `"high"`, `"medium"`, `"low"`
+  - Default: `"medium"`
+
+  ```json
+  "priority": "high"
+  ```
+
+- **`details`** (string): In-depth implementation instructions
+
+  ```json
+  "details": "Use GitHub OAuth client ID/secret, handle callback, set session token"
+  ```
+
+- **`testStrategy`** (string): Verification approach
+
+  ```json
+  "testStrategy": "Deploy and call endpoint to confirm authentication flow"
+  ```
+
+- **`subtasks`** (array): List of smaller, more specific tasks
+  ```json
+  "subtasks": [
+    {
+      "id": 1,
+      "title": "Configure OAuth",
+      "description": "Set up OAuth configuration",
+      "status": "pending",
+      "dependencies": [],
+      "details": "Configure GitHub OAuth app and store credentials"
+    }
+  ]
+  ```
+
+## Subtask Structure
+
+Subtasks follow a similar structure to main tasks but with some differences:
+
+### Subtask Properties
+
+- **`id`** (number): Unique identifier within the parent task
+- **`title`** (string): Brief, descriptive title
+- **`description`** (string): Concise summary of the subtask
+- **`status`** (string): Current state (same values as main tasks)
+- **`dependencies`** (array): Can reference other subtasks or main task IDs
+- **`details`** (string): Implementation instructions and notes
+
+### Subtask Example
+
+```json
+{
+  "id": 2,
+  "title": "Handle OAuth callback",
+  "description": "Process the OAuth callback and extract user data",
+  "status": "pending",
+  "dependencies": [1],
+  "details": "Parse callback parameters, exchange code for token, fetch user profile"
+}
+```
+
+## Complete Example
+
+Here's a complete example showing the tagged task structure:
+
+```json
+{
+  "master": {
+    "tasks": [
+      {
+        "id": 1,
+        "title": "Setup Express Server",
+        "description": "Initialize and configure Express.js server with middleware",
+        "status": "done",
+        "dependencies": [],
+        "priority": "high",
+        "details": "Create Express app with CORS, body parser, and error handling",
+        "testStrategy": "Start server and verify health check endpoint responds",
+        "subtasks": [
+          {
+            "id": 1,
+            "title": "Initialize npm project",
+            "description": "Set up package.json and install dependencies",
+            "status": "done",
+            "dependencies": [],
+            "details": "Run npm init, install express, cors, body-parser"
+          },
+          {
+            "id": 2,
+            "title": "Configure middleware",
+            "description": "Set up CORS and body parsing middleware",
+            "status": "done",
+            "dependencies": [1],
+            "details": "Add app.use() calls for cors() and express.json()"
+          }
+        ]
+      },
+      {
+        "id": 2,
+        "title": "Implement user authentication",
+        "description": "Create secure authentication system",
+        "status": "pending",
+        "dependencies": [1],
+        "priority": "high",
+        "details": "Use JWT tokens for session management",
+        "testStrategy": "Test login/logout flow with valid and invalid credentials",
+        "subtasks": []
+      }
+    ]
+  },
+  "feature-auth": {
+    "tasks": [
+      {
+        "id": 1,
+        "title": "OAuth Integration",
+        "description": "Add OAuth authentication support",
+        "status": "pending",
+        "dependencies": [],
+        "priority": "medium",
+        "details": "Integrate with GitHub OAuth for user authentication",
+        "testStrategy": "Test OAuth flow with GitHub account",
+        "subtasks": []
+      }
+    ]
+  }
+}
+```
+
+## Tag Context Management
+
+### Current Tag Resolution
+
+Task Master automatically determines the current tag context based on:
+
+1. **State Configuration**: Current tag stored in `.taskmaster/state.json`
+2. **Default Fallback**: "master" tag when no context is specified
+3. **Future Enhancement**: Git branch-based tag switching (Part 2)
+
+### Tag Isolation
+
+- **Context Separation**: Tasks in different tags are completely isolated
+- **Independent Numbering**: Each tag has its own task ID sequence starting from 1
+- **Parallel Development**: Multiple team members can work on separate tags without conflicts
+
+## Data Validation
+
+Task Master validates the following aspects of task data:
+
+### Required Validations
+
+- **Unique IDs**: Task IDs must be unique within each tag context
+- **Valid Status**: Status values must be from the allowed set
+- **Dependency References**: Dependencies must reference existing task IDs within the same tag
+- **Subtask IDs**: Subtask IDs must be unique within their parent task
+
+### Optional Validations
+
+- **Circular Dependencies**: System detects and prevents circular dependency chains
+- **Priority Values**: Priority must be one of the allowed values if specified
+- **Data Types**: All properties must match their expected data types
+
+## File Generation
+
+Task Master can generate individual markdown files for each task based on the JSON structure. These files include:
+
+- **Task Overview**: ID, title, status, dependencies
+- **Tag Context**: Which tag the task belongs to
+- **Implementation Details**: Full task details and test strategy
+- **Subtask Breakdown**: All subtasks with their current status
+- **Dependency Status**: Visual indicators showing which dependencies are complete
+
+## Migration Process
+
+When Task Master encounters a legacy format `tasks.json` file:
+
+1. **Detection**: Automatically detects `{"tasks": [...]}` format
+2. **Transformation**: Converts to `{"master": {"tasks": [...]}}` format
+3. **Configuration**: Updates `.taskmaster/config.json` with tagged system settings
+4. **State Creation**: Creates `.taskmaster/state.json` for tag management
+5. **Notification**: Shows one-time friendly notice about the new system
+6. **Preservation**: All existing task data is preserved exactly as-is
+
+## Best Practices
+
+### Task Organization
+
+- **Logical Grouping**: Use tags to group related tasks (e.g., by feature, branch, or milestone)
+- **Clear Titles**: Use descriptive titles that explain the task's purpose
+- **Proper Dependencies**: Define dependencies to ensure correct execution order
+- **Detailed Instructions**: Include sufficient detail in the `details` field for implementation
+
+### Tag Management
+
+- **Meaningful Names**: Use descriptive tag names that reflect their purpose
+- **Consistent Naming**: Establish naming conventions for tags (e.g., branch names, feature names)
+- **Context Switching**: Be aware of which tag context you're working in
+- **Isolation Benefits**: Leverage tag isolation to prevent merge conflicts
+
+### Subtask Design
+
+- **Granular Tasks**: Break down complex tasks into manageable subtasks
+- **Clear Dependencies**: Define subtask dependencies to show implementation order
+- **Implementation Notes**: Use subtask details to track progress and decisions
+- **Status Tracking**: Keep subtask status updated as work progresses
--- a/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -198,10 +198,15 @@ Ask the agent to list available tasks:
 What tasks are available to work on next?
 ```

+```
+Can you show me tasks 1, 3, and 5 to understand their current status?
+```
+
 The agent will:

 - Run `task-master list` to see all tasks
 - Run `task-master next` to determine the next task to work on
+- Run `task-master show 1,3,5` to display multiple tasks with interactive options
 - Analyze dependencies to determine which tasks are ready to be worked on
 - Prioritize tasks based on priority level and ID order
 - Suggest the next task(s) to implement
@@ -221,6 +226,21 @@ You can ask:
 Let's implement task 3. What does it involve?
 ```

+### 2.1. Viewing Multiple Tasks
+
+For efficient context gathering and batch operations:
+
+```
+Show me tasks 5, 7, and 9 so I can plan my implementation approach.
+```
+
+The agent will:
+
+- Run `task-master show 5,7,9` to display a compact summary table
+- Show task status, priority, and progress indicators
+- Provide an interactive action menu with batch operations
+- Allow you to perform group actions like marking multiple tasks as in-progress
+
 ### 3. Task Verification

 Before marking a task as complete, verify it according to:
@@ -423,3 +443,148 @@ Can you analyze the complexity of our tasks to help me understand which ones nee
 ```
 Can you show me the complexity report in a more readable format?
 ```
+
+### Research-Driven Development
+
+Task Master includes a powerful research tool that provides fresh, up-to-date information beyond the AI's knowledge cutoff. This is particularly valuable for:
+
+#### Getting Current Best Practices
+
+```
+Before implementing task 5 (authentication), research the latest JWT security recommendations.
+```
+
+The agent will execute:
+
+```bash
+task-master research "Latest JWT security recommendations 2024" --id=5
+```
+
+#### Research with Project Context
+
+```
+Research React Query v5 migration strategies for our current API implementation.
+```
+
+The agent will execute:
+
+```bash
+task-master research "React Query v5 migration strategies" --files=src/api.js,src/hooks.js
+```
+
+#### Research and Update Pattern
+
+A powerful workflow is to research first, then update tasks with findings:
+
+```
+Research the latest Node.js performance optimization techniques and update task 12 with the findings.
+```
+
+The agent will:
+
+1. Run research: `task-master research "Node.js performance optimization 2024" --id=12`
+2. Update the task: `task-master update-subtask --id=12.2 --prompt="Updated with latest performance findings: [research results]"`
+
+#### When to Use Research
+
+- **Before implementing any new technology**
+- **When encountering security-related tasks**
+- **For performance optimization tasks**
+- **When debugging complex issues**
+- **Before making architectural decisions**
+- **When updating dependencies**
+
+The research tool automatically includes relevant project context and provides fresh information that can significantly improve implementation quality.
+
+## Git Integration and Tag Management
+
+Task Master supports tagged task lists for multi-context development, which is particularly useful when working with git branches or different project phases.
+
+### Working with Tags
+
+Tags provide isolated task contexts, allowing you to maintain separate task lists for different features, branches, or experiments:
+
+```
+I'm starting work on a new feature branch. Can you create a new tag for this work?
+```
+
+The agent will execute:
+
+```bash
+# Create a tag based on your current git branch
+task-master add-tag --from-branch
+```
+
+Or you can create a tag with a specific name:
+
+```
+Create a new tag called 'user-auth' for authentication-related tasks.
+```
+
+The agent will execute:
+
+```bash
+task-master add-tag user-auth --description="User authentication feature tasks"
+```
+
+### Switching Between Contexts
+
+When working on different features or branches:
+
+```
+Switch to the 'user-auth' tag context so I can work on authentication tasks.
+```
+
+The agent will execute:
+
+```bash
+task-master use-tag user-auth
+```
+
+### Copying Tasks Between Tags
+
+When you need to duplicate work across contexts:
+
+```
+Copy all tasks from the current tag to a new 'testing' tag for QA work.
+```
+
+The agent will execute:
+
+```bash
+task-master add-tag testing --copy-from-current --description="QA and testing tasks"
+```
+
+### Tag Management
+
+View and manage your tag contexts:
+
+```
+Show me all available tags and their current status.
+```
+
+The agent will execute:
+
+```bash
+task-master tags --show-metadata
+```
+
+### Benefits of Tagged Task Lists
+
+- **Branch Isolation**: Each git branch can have its own task context
+- **Merge Conflict Prevention**: Tasks in different tags don't interfere with each other
+- **Parallel Development**: Multiple team members can work on separate contexts
+- **Context Switching**: Easily switch between different project phases or features
+- **Experimentation**: Create experimental task lists without affecting main work
+
+### Git Workflow Integration
+
+A typical git workflow with Task Master tags:
+
+1. **Create feature branch**: `git checkout -b feature/user-auth`
+2. **Create matching tag**: Ask agent to run `task-master add-tag --from-branch`
+3. **Work in isolated context**: All task operations work within the new tag
+4. **Switch contexts as needed**: Use `task-master use-tag <name>` to switch between different work streams
+5. **Merge and cleanup**: After merging the branch, optionally delete the tag with `task-master delete-tag <name>`
+
+This workflow ensures your task management stays organized and conflicts are minimized when working with teams or multiple features simultaneously.