Merge pull request #1015 from eyaltoledano/changeset-release/main

Version Packages

.changeset/add-kiro-profile.md

@@ -1,9 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add Kiro editor rule profile support
-
-- Add support for Kiro IDE with custom rule files and MCP configuration
-- Generate rule files in `.kiro/steering/` directory with markdown format
-- Include MCP server configuration with enhanced file inclusion patterns

.changeset/claude-import-fix-new.md

@@ -1,12 +0,0 @@
----
-"task-master-ai": patch
----
-
-Prevent CLAUDE.md overwrite by using Claude Code's import feature
-
-- Task Master now creates its instructions in `.taskmaster/CLAUDE.md` instead of overwriting the user's `CLAUDE.md`
-- Adds an import section to the user's CLAUDE.md that references the Task Master instructions
-- Preserves existing user content in CLAUDE.md files
-- Provides clean uninstall that only removes Task Master's additions
-
-**Breaking Change**: Task Master instructions for Claude Code are now stored in `.taskmaster/CLAUDE.md` and imported into the main CLAUDE.md file. Users who previously had Task Master content directly in their CLAUDE.md will need to run `task-master rules remove claude` followed by `task-master rules add claude` to migrate to the new structure.

.changeset/cool-glasses-invite.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Implement Boundary-First Tag Resolution to ensure consistent and deterministic tag handling across CLI and MCP, resolving potential race conditions.

.changeset/fix-show-command-complexity.md

@@ -1,7 +0,0 @@
----
-"task-master-ai": patch
----
-
-Fix: show command no longer requires complexity report file to exist
-
-The `tm show` command was incorrectly requiring the complexity report file to exist even when not needed. Now it only validates the complexity report path when a custom report file is explicitly provided via the -r/--report option.

.changeset/gentle-beds-beam.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Update VS Code profile with MCP config transformation

.changeset/groq-kimi-k2-support.md

@@ -1,10 +0,0 @@
----
-"task-master-ai": minor
----
-
-Complete Groq provider integration and add MoonshotAI Kimi K2 model support
-
-- Fixed Groq provider registration
-- Added Groq API key validation
-- Added GROQ_API_KEY to .env.example
-- Added moonshotai/kimi-k2-instruct model with $1/$3 per 1M token pricing and 16k max output

.changeset/metal-papers-stay.md

@@ -1,7 +0,0 @@
----
-"task-master-ai": minor
----
-
-feat: Add Zed editor rule profile with agent rules and MCP config
-
-- Resolves #637

.changeset/public-crabs-ask.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add Amp rule profile with AGENT.md and MCP config

.changeset/puny-friends-give.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Fix MCP server error when retrieving tools and resources

.changeset/swift-turtles-sit.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Add MCP configuration support to Claude Code rules

.changeset/ten-glasses-feel.md

@@ -1,7 +0,0 @@
----
-"task-master-ai": patch
----
-
-Fixed the comprehensive taskmaster system integration via custom slash commands with proper syntax
-
-- Provide claude clode with a complete set of of commands that can trigger task master events directly within Claude Code

.changeset/update-mcp-readme.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Correct MCP server name and use 'Add to Cursor' button with updated placeholder keys.

.changeset/yellow-showers-heal.md

@@ -1,7 +0,0 @@
----
-"task-master-ai": minor
----
-
-Add OpenCode profile with AGENTS.md and MCP config
-
-- Resolves #965

.changeset/yummy-walls-eat.md

@@ -1,5 +0,0 @@
----
-"task-master-ai": patch
----
-
-Add missing API keys to .env.example and README.md

.cursor/rules/taskmaster/dev_workflow.mdc

@@ -1,424 +0,0 @@
----
-description: Guide for using Taskmaster to manage task-driven development workflows
-globs: **/*
-alwaysApply: true
----
-
-# Taskmaster Development Workflow
-
-This guide outlines the standard process for using Taskmaster to manage software development projects. It is written as a set of instructions for you, the AI agent.
-
-- **Your Default Stance**: For most projects, the user can work directly within the `master` task context. Your initial actions should operate on this default context unless a clear pattern for multi-context work emerges.
-- **Your Goal**: Your role is to elevate the user's workflow by intelligently introducing advanced features like **Tagged Task Lists** when you detect the appropriate context. Do not force tags on the user; suggest them as a helpful solution to a specific need.
-
-## The Basic Loop
-The fundamental development cycle you will facilitate is:
-1.  **`list`**: Show the user what needs to be done.
-2.  **`next`**: Help the user decide what to work on.
-3.  **`show <id>`**: Provide details for a specific task.
-4.  **`expand <id>`**: Break down a complex task into smaller, manageable subtasks.
-5.  **Implement**: The user writes the code and tests.
-6.  **`update-subtask`**: Log progress and findings on behalf of the user.
-7.  **`set-status`**: Mark tasks and subtasks as `done` as work is completed.
-8.  **Repeat**.
-
-All your standard command executions should operate on the user's current task context, which defaults to `master`.
-
----
-
-## Standard Development Workflow Process
-
-### Simple Workflow (Default Starting Point)
-
-For new projects or when users are getting started, operate within the `master` tag context:
-
--   Start new projects by running `initialize_project` tool / `task-master init` or `parse_prd` / `task-master parse-prd --input='<prd-file.txt>'` (see @`taskmaster.mdc`) to generate initial tasks.json with tagged structure
--   Configure rule sets during initialization with `--rules` flag (e.g., `task-master init --rules cursor,windsurf`) or manage them later with `task-master rules add/remove` commands  
--   Begin coding sessions with `get_tasks` / `task-master list` (see @`taskmaster.mdc`) to see current tasks, status, and IDs
--   Determine the next task to work on using `next_task` / `task-master next` (see @`taskmaster.mdc`)
--   Analyze task complexity with `analyze_project_complexity` / `task-master analyze-complexity --research` (see @`taskmaster.mdc`) before breaking down tasks
--   Review complexity report using `complexity_report` / `task-master complexity-report` (see @`taskmaster.mdc`)
--   Select tasks based on dependencies (all marked 'done'), priority level, and ID order
--   View specific task details using `get_task` / `task-master show <id>` (see @`taskmaster.mdc`) to understand implementation requirements
--   Break down complex tasks using `expand_task` / `task-master expand --id=<id> --force --research` (see @`taskmaster.mdc`) with appropriate flags like `--force` (to replace existing subtasks) and `--research`
--   Implement code following task details, dependencies, and project standards
--   Mark completed tasks with `set_task_status` / `task-master set-status --id=<id> --status=done` (see @`taskmaster.mdc`)
--   Update dependent tasks when implementation differs from original plan using `update` / `task-master update --from=<id> --prompt="..."` or `update_task` / `task-master update-task --id=<id> --prompt="..."` (see @`taskmaster.mdc`)
-
----
-
-## Leveling Up: Agent-Led Multi-Context Workflows
-
-While the basic workflow is powerful, your primary opportunity to add value is by identifying when to introduce **Tagged Task Lists**. These patterns are your tools for creating a more organized and efficient development environment for the user, especially if you detect agentic or parallel development happening across the same session.
-
-**Critical Principle**: Most users should never see a difference in their experience. Only introduce advanced workflows when you detect clear indicators that the project has evolved beyond simple task management.
-
-### When to Introduce Tags: Your Decision Patterns
-
-Here are the patterns to look for. When you detect one, you should propose the corresponding workflow to the user.
-
-#### Pattern 1: Simple Git Feature Branching
-This is the most common and direct use case for tags.
-
-- **Trigger**: The user creates a new git branch (e.g., `git checkout -b feature/user-auth`).
-- **Your Action**: Propose creating a new tag that mirrors the branch name to isolate the feature's tasks from `master`.
-- **Your Suggested Prompt**: *"I see you've created a new branch named 'feature/user-auth'. To keep all related tasks neatly organized and separate from your main list, I can create a corresponding task tag for you. This helps prevent merge conflicts in your `tasks.json` file later. Shall I create the 'feature-user-auth' tag?"*
-- **Tool to Use**: `task-master add-tag --from-branch`
-
-#### Pattern 2: Team Collaboration
-- **Trigger**: The user mentions working with teammates (e.g., "My teammate Alice is handling the database schema," or "I need to review Bob's work on the API.").
-- **Your Action**: Suggest creating a separate tag for the user's work to prevent conflicts with shared master context.
-- **Your Suggested Prompt**: *"Since you're working with Alice, I can create a separate task context for your work to avoid conflicts. This way, Alice can continue working with the master list while you have your own isolated context. When you're ready to merge your work, we can coordinate the tasks back to master. Shall I create a tag for your current work?"*
-- **Tool to Use**: `task-master add-tag my-work --copy-from-current --description="My tasks while collaborating with Alice"`
-
-#### Pattern 3: Experiments or Risky Refactors
-- **Trigger**: The user wants to try something that might not be kept (e.g., "I want to experiment with switching our state management library," or "Let's refactor the old API module, but I want to keep the current tasks as a reference.").
-- **Your Action**: Propose creating a sandboxed tag for the experimental work.
-- **Your Suggested Prompt**: *"This sounds like a great experiment. To keep these new tasks separate from our main plan, I can create a temporary 'experiment-zustand' tag for this work. If we decide not to proceed, we can simply delete the tag without affecting the main task list. Sound good?"*
-- **Tool to Use**: `task-master add-tag experiment-zustand --description="Exploring Zustand migration"`
-
-#### Pattern 4: Large Feature Initiatives (PRD-Driven)
-This is a more structured approach for significant new features or epics.
-
-- **Trigger**: The user describes a large, multi-step feature that would benefit from a formal plan.
-- **Your Action**: Propose a comprehensive, PRD-driven workflow.
-- **Your Suggested Prompt**: *"This sounds like a significant new feature. To manage this effectively, I suggest we create a dedicated task context for it. Here's the plan: I'll create a new tag called 'feature-xyz', then we can draft a Product Requirements Document (PRD) together to scope the work. Once the PRD is ready, I'll automatically generate all the necessary tasks within that new tag. How does that sound?"*
-- **Your Implementation Flow**:
-    1.  **Create an empty tag**: `task-master add-tag feature-xyz --description "Tasks for the new XYZ feature"`. You can also start by creating a git branch if applicable, and then create the tag from that branch.
-    2.  **Collaborate & Create PRD**: Work with the user to create a detailed PRD file (e.g., `.taskmaster/docs/feature-xyz-prd.txt`).
-    3.  **Parse PRD into the new tag**: `task-master parse-prd .taskmaster/docs/feature-xyz-prd.txt --tag feature-xyz`
-    4.  **Prepare the new task list**: Follow up by suggesting `analyze-complexity` and `expand-all` for the newly created tasks within the `feature-xyz` tag.
-
-#### Pattern 5: Version-Based Development
-Tailor your approach based on the project maturity indicated by tag names.
-
-- **Prototype/MVP Tags** (`prototype`, `mvp`, `poc`, `v0.x`):
-  - **Your Approach**: Focus on speed and functionality over perfection
-  - **Task Generation**: Create tasks that emphasize "get it working" over "get it perfect"
-  - **Complexity Level**: Lower complexity, fewer subtasks, more direct implementation paths
-  - **Research Prompts**: Include context like "This is a prototype - prioritize speed and basic functionality over optimization"
-  - **Example Prompt Addition**: *"Since this is for the MVP, I'll focus on tasks that get core functionality working quickly rather than over-engineering."*
-
-- **Production/Mature Tags** (`v1.0+`, `production`, `stable`):
-  - **Your Approach**: Emphasize robustness, testing, and maintainability
-  - **Task Generation**: Include comprehensive error handling, testing, documentation, and optimization
-  - **Complexity Level**: Higher complexity, more detailed subtasks, thorough implementation paths
-  - **Research Prompts**: Include context like "This is for production - prioritize reliability, performance, and maintainability"
-  - **Example Prompt Addition**: *"Since this is for production, I'll ensure tasks include proper error handling, testing, and documentation."*
-
-### Advanced Workflow (Tag-Based & PRD-Driven)
-
-**When to Transition**: Recognize when the project has evolved (or has initiated a project which existing code) beyond simple task management. Look for these indicators:
-- User mentions teammates or collaboration needs
-- Project has grown to 15+ tasks with mixed priorities
-- User creates feature branches or mentions major initiatives
-- User initializes Taskmaster on an existing, complex codebase
-- User describes large features that would benefit from dedicated planning
-
-**Your Role in Transition**: Guide the user to a more sophisticated workflow that leverages tags for organization and PRDs for comprehensive planning.
-
-#### Master List Strategy (High-Value Focus)
-Once you transition to tag-based workflows, the `master` tag should ideally contain only:
-- **High-level deliverables** that provide significant business value
-- **Major milestones** and epic-level features
-- **Critical infrastructure** work that affects the entire project
-- **Release-blocking** items
-
-**What NOT to put in master**:
-- Detailed implementation subtasks (these go in feature-specific tags' parent tasks)
-- Refactoring work (create dedicated tags like `refactor-auth`)
-- Experimental features (use `experiment-*` tags)
-- Team member-specific tasks (use person-specific tags)
-
-#### PRD-Driven Feature Development
-
-**For New Major Features**:
-1. **Identify the Initiative**: When user describes a significant feature
-2. **Create Dedicated Tag**: `add_tag feature-[name] --description="[Feature description]"`
-3. **Collaborative PRD Creation**: Work with user to create comprehensive PRD in `.taskmaster/docs/feature-[name]-prd.txt`
-4. **Parse & Prepare**: 
-   - `parse_prd .taskmaster/docs/feature-[name]-prd.txt --tag=feature-[name]`
-   - `analyze_project_complexity --tag=feature-[name] --research`
-   - `expand_all --tag=feature-[name] --research`
-5. **Add Master Reference**: Create a high-level task in `master` that references the feature tag
-
-**For Existing Codebase Analysis**:
-When users initialize Taskmaster on existing projects:
-1. **Codebase Discovery**: Use your native tools for producing deep context about the code base. You may use `research` tool with `--tree` and `--files` to collect up to date information using the existing architecture as context.
-2. **Collaborative Assessment**: Work with user to identify improvement areas, technical debt, or new features
-3. **Strategic PRD Creation**: Co-author PRDs that include:
-   - Current state analysis (based on your codebase research)
-   - Proposed improvements or new features
-   - Implementation strategy considering existing code
-4. **Tag-Based Organization**: Parse PRDs into appropriate tags (`refactor-api`, `feature-dashboard`, `tech-debt`, etc.)
-5. **Master List Curation**: Keep only the most valuable initiatives in master
-
-The parse-prd's `--append` flag enables the user to parse multiple PRDs within tags or across tags. PRDs should be focused and the number of tasks they are parsed into should be strategically chosen relative to the PRD's complexity and level of detail.
-
-### Workflow Transition Examples
-
-**Example 1: Simple → Team-Based**
-```
-User: "Alice is going to help with the API work"
-Your Response: "Great! To avoid conflicts, I'll create a separate task context for your work. Alice can continue with the master list while you work in your own context. When you're ready to merge, we can coordinate the tasks back together."
-Action: add_tag my-api-work --copy-from-current --description="My API tasks while collaborating with Alice"
-```
-
-**Example 2: Simple → PRD-Driven**
-```
-User: "I want to add a complete user dashboard with analytics, user management, and reporting"
-Your Response: "This sounds like a major feature that would benefit from detailed planning. Let me create a dedicated context for this work and we can draft a PRD together to ensure we capture all requirements."
-Actions: 
-1. add_tag feature-dashboard --description="User dashboard with analytics and management"
-2. Collaborate on PRD creation
-3. parse_prd dashboard-prd.txt --tag=feature-dashboard
-4. Add high-level "User Dashboard" task to master
-```
-
-**Example 3: Existing Project → Strategic Planning**
-```
-User: "I just initialized Taskmaster on my existing React app. It's getting messy and I want to improve it."
-Your Response: "Let me research your codebase to understand the current architecture, then we can create a strategic plan for improvements."
-Actions:
-1. research "Current React app architecture and improvement opportunities" --tree --files=src/
-2. Collaborate on improvement PRD based on findings
-3. Create tags for different improvement areas (refactor-components, improve-state-management, etc.)
-4. Keep only major improvement initiatives in master
-```
-
----
-
-## Primary Interaction: MCP Server vs. CLI
-
-Taskmaster offers two primary ways to interact:
-
-1.  **MCP Server (Recommended for Integrated Tools)**:
-    - For AI agents and integrated development environments (like Cursor), interacting via the **MCP server is the preferred method**.
-    - The MCP server exposes Taskmaster functionality through a set of tools (e.g., `get_tasks`, `add_subtask`).
-    - This method offers better performance, structured data exchange, and richer error handling compared to CLI parsing.
-    - Refer to @`mcp.mdc` for details on the MCP architecture and available tools.
-    - A comprehensive list and description of MCP tools and their corresponding CLI commands can be found in @`taskmaster.mdc`.
-    - **Restart the MCP server** if core logic in `scripts/modules` or MCP tool/direct function definitions change.
-    - **Note**: MCP tools fully support tagged task lists with complete tag management capabilities.
-
-2.  **`task-master` CLI (For Users & Fallback)**:
-    - The global `task-master` command provides a user-friendly interface for direct terminal interaction.
-    - It can also serve as a fallback if the MCP server is inaccessible or a specific function isn't exposed via MCP.
-    - Install globally with `npm install -g task-master-ai` or use locally via `npx task-master-ai ...`.
-    - The CLI commands often mirror the MCP tools (e.g., `task-master list` corresponds to `get_tasks`).
-    - Refer to @`taskmaster.mdc` for a detailed command reference.
-    - **Tagged Task Lists**: CLI fully supports the new tagged system with seamless migration.
-
-## How the Tag System Works (For Your Reference)
-
-- **Data Structure**: Tasks are organized into separate contexts (tags) like "master", "feature-branch", or "v2.0".
-- **Silent Migration**: Existing projects automatically migrate to use a "master" tag with zero disruption.
-- **Context Isolation**: Tasks in different tags are completely separate. Changes in one tag do not affect any other tag.
-- **Manual Control**: The user is always in control. There is no automatic switching. You facilitate switching by using `use-tag <name>`.
-- **Full CLI & MCP Support**: All tag management commands are available through both the CLI and MCP tools for you to use. Refer to @`taskmaster.mdc` for a full command list.
-
----
-
-## Task Complexity Analysis
-
--   Run `analyze_project_complexity` / `task-master analyze-complexity --research` (see @`taskmaster.mdc`) for comprehensive analysis
--   Review complexity report via `complexity_report` / `task-master complexity-report` (see @`taskmaster.mdc`) for a formatted, readable version.
--   Focus on tasks with highest complexity scores (8-10) for detailed breakdown
--   Use analysis results to determine appropriate subtask allocation
--   Note that reports are automatically used by the `expand_task` tool/command
-
-## Task Breakdown Process
-
--   Use `expand_task` / `task-master expand --id=<id>`. It automatically uses the complexity report if found, otherwise generates default number of subtasks.
--   Use `--num=<number>` to specify an explicit number of subtasks, overriding defaults or complexity report recommendations.
--   Add `--research` flag to leverage Perplexity AI for research-backed expansion.
--   Add `--force` flag to clear existing subtasks before generating new ones (default is to append).
--   Use `--prompt="<context>"` to provide additional context when needed.
--   Review and adjust generated subtasks as necessary.
--   Use `expand_all` tool or `task-master expand --all` to expand multiple pending tasks at once, respecting flags like `--force` and `--research`.
--   If subtasks need complete replacement (regardless of the `--force` flag on `expand`), clear them first with `clear_subtasks` / `task-master clear-subtasks --id=<id>`.
-
-## Implementation Drift Handling
-
--   When implementation differs significantly from planned approach
--   When future tasks need modification due to current implementation choices
--   When new dependencies or requirements emerge
--   Use `update` / `task-master update --from=<futureTaskId> --prompt='<explanation>\nUpdate context...' --research` to update multiple future tasks.
--   Use `update_task` / `task-master update-task --id=<taskId> --prompt='<explanation>\nUpdate context...' --research` to update a single specific task.
-
-## Task Status Management
-
--   Use 'pending' for tasks ready to be worked on
--   Use 'done' for completed and verified tasks
--   Use 'deferred' for postponed tasks
--   Add custom status values as needed for project-specific workflows
-
-## Task Structure Fields
-
-- **id**: Unique identifier for the task (Example: `1`, `1.1`)
-- **title**: Brief, descriptive title (Example: `"Initialize Repo"`)
-- **description**: Concise summary of what the task involves (Example: `"Create a new repository, set up initial structure."`)
-- **status**: Current state of the task (Example: `"pending"`, `"done"`, `"deferred"`)
-- **dependencies**: IDs of prerequisite tasks (Example: `[1, 2.1]`)
-    - Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending)
-    - This helps quickly identify which prerequisite tasks are blocking work
-- **priority**: Importance level (Example: `"high"`, `"medium"`, `"low"`)
-- **details**: In-depth implementation instructions (Example: `"Use GitHub client ID/secret, handle callback, set session token."`) 
-- **testStrategy**: Verification approach (Example: `"Deploy and call endpoint to confirm 'Hello World' response."`) 
-- **subtasks**: List of smaller, more specific tasks (Example: `[{"id": 1, "title": "Configure OAuth", ...}]`) 
-- Refer to task structure details (previously linked to `tasks.mdc`).
-
-## Configuration Management (Updated)
-
-Taskmaster configuration is managed through two main mechanisms:
-
-1.  **`.taskmaster/config.json` File (Primary):**
-    *   Located in the project root directory.
-    *   Stores most configuration settings: AI model selections (main, research, fallback), parameters (max tokens, temperature), logging level, default subtasks/priority, project name, etc.
-    *   **Tagged System Settings**: Includes `global.defaultTag` (defaults to "master") and `tags` section for tag management configuration.
-    *   **Managed via `task-master models --setup` command.** Do not edit manually unless you know what you are doing.
-    *   **View/Set specific models via `task-master models` command or `models` MCP tool.**
-    *   Created automatically when you run `task-master models --setup` for the first time or during tagged system migration.
-
-2.  **Environment Variables (`.env` / `mcp.json`):**
-    *   Used **only** for sensitive API keys and specific endpoint URLs.
-    *   Place API keys (one per provider) in a `.env` file in the project root for CLI usage.
-    *   For MCP/Cursor integration, configure these keys in the `env` section of `.cursor/mcp.json`.
-    *   Available keys/variables: See `assets/env.example` or the Configuration section in the command reference (previously linked to `taskmaster.mdc`).
-
-3.  **`.taskmaster/state.json` File (Tagged System State):**
-    *   Tracks current tag context and migration status.
-    *   Automatically created during tagged system migration.
-    *   Contains: `currentTag`, `lastSwitched`, `migrationNoticeShown`.
-
-**Important:** Non-API key settings (like model selections, `MAX_TOKENS`, `TASKMASTER_LOG_LEVEL`) are **no longer configured via environment variables**. Use the `task-master models` command (or `--setup` for interactive configuration) or the `models` MCP tool.
-**If AI commands FAIL in MCP** verify that the API key for the selected provider is present in the `env` section of `.cursor/mcp.json`.
-**If AI commands FAIL in CLI** verify that the API key for the selected provider is present in the `.env` file in the root of the project.
-
-## Rules Management
-
-Taskmaster supports multiple AI coding assistant rule sets that can be configured during project initialization or managed afterward:
-
-- **Available Profiles**: Claude Code, Cline, Codex, Cursor, Roo Code, Trae, Windsurf (claude, cline, codex, cursor, roo, trae, windsurf)
-- **During Initialization**: Use `task-master init --rules cursor,windsurf` to specify which rule sets to include
-- **After Initialization**: Use `task-master rules add <profiles>` or `task-master rules remove <profiles>` to manage rule sets
-- **Interactive Setup**: Use `task-master rules setup` to launch an interactive prompt for selecting rule profiles
-- **Default Behavior**: If no `--rules` flag is specified during initialization, all available rule profiles are included
-- **Rule Structure**: Each profile creates its own directory (e.g., `.cursor/rules`, `.roo/rules`) with appropriate configuration files
-
-## Determining the Next Task
-
-- Run `next_task` / `task-master next` to show the next task to work on.
-- The command identifies tasks with all dependencies satisfied
-- Tasks are prioritized by priority level, dependency count, and ID
-- The command shows comprehensive task information including:
-    - Basic task details and description
-    - Implementation details
-    - Subtasks (if they exist)
-    - Contextual suggested actions
-- Recommended before starting any new development work
-- Respects your project's dependency structure
-- Ensures tasks are completed in the appropriate sequence
-- Provides ready-to-use commands for common task actions
-
-## Viewing Specific Task Details
-
-- Run `get_task` / `task-master show <id>` to view a specific task.
-- Use dot notation for subtasks: `task-master show 1.2` (shows subtask 2 of task 1)
-- Displays comprehensive information similar to the next command, but for a specific task
-- For parent tasks, shows all subtasks and their current status
-- For subtasks, shows parent task information and relationship
-- Provides contextual suggested actions appropriate for the specific task
-- Useful for examining task details before implementation or checking status
-
-## Managing Task Dependencies
-
-- Use `add_dependency` / `task-master add-dependency --id=<id> --depends-on=<id>` to add a dependency.
-- Use `remove_dependency` / `task-master remove-dependency --id=<id> --depends-on=<id>` to remove a dependency.
-- The system prevents circular dependencies and duplicate dependency entries
-- Dependencies are checked for existence before being added or removed
-- Task files are automatically regenerated after dependency changes
-- Dependencies are visualized with status indicators in task listings and files
-
-## Task Reorganization
-
-- Use `move_task` / `task-master move --from=<id> --to=<id>` to move tasks or subtasks within the hierarchy
-- This command supports several use cases:
-  - Moving a standalone task to become a subtask (e.g., `--from=5 --to=7`)
-  - Moving a subtask to become a standalone task (e.g., `--from=5.2 --to=7`) 
-  - Moving a subtask to a different parent (e.g., `--from=5.2 --to=7.3`)
-  - Reordering subtasks within the same parent (e.g., `--from=5.2 --to=5.4`)
-  - Moving a task to a new, non-existent ID position (e.g., `--from=5 --to=25`)
-  - Moving multiple tasks at once using comma-separated IDs (e.g., `--from=10,11,12 --to=16,17,18`)
-- The system includes validation to prevent data loss:
-  - Allows moving to non-existent IDs by creating placeholder tasks
-  - Prevents moving to existing task IDs that have content (to avoid overwriting)
-  - Validates source tasks exist before attempting to move them
-- The system maintains proper parent-child relationships and dependency integrity
-- Task files are automatically regenerated after the move operation
-- This provides greater flexibility in organizing and refining your task structure as project understanding evolves
-- This is especially useful when dealing with potential merge conflicts arising from teams creating tasks on separate branches. Solve these conflicts very easily by moving your tasks and keeping theirs.
-
-## Iterative Subtask Implementation
-
-Once a task has been broken down into subtasks using `expand_task` or similar methods, follow this iterative process for implementation:
-
-1.  **Understand the Goal (Preparation):**
-    *   Use `get_task` / `task-master show <subtaskId>` (see @`taskmaster.mdc`) to thoroughly understand the specific goals and requirements of the subtask.
-
-2.  **Initial Exploration & Planning (Iteration 1):**
-    *   This is the first attempt at creating a concrete implementation plan.
-    *   Explore the codebase to identify the precise files, functions, and even specific lines of code that will need modification.
-    *   Determine the intended code changes (diffs) and their locations.
-    *   Gather *all* relevant details from this exploration phase.
-
-3.  **Log the Plan:**
-    *   Run `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<detailed plan>'`.
-    *   Provide the *complete and detailed* findings from the exploration phase in the prompt. Include file paths, line numbers, proposed diffs, reasoning, and any potential challenges identified. Do not omit details. The goal is to create a rich, timestamped log within the subtask's `details`.
-
-4.  **Verify the Plan:**
-    *   Run `get_task` / `task-master show <subtaskId>` again to confirm that the detailed implementation plan has been successfully appended to the subtask's details.
-
-5.  **Begin Implementation:**
-    *   Set the subtask status using `set_task_status` / `task-master set-status --id=<subtaskId> --status=in-progress`.
-    *   Start coding based on the logged plan.
-
-6.  **Refine and Log Progress (Iteration 2+):**
-    *   As implementation progresses, you will encounter challenges, discover nuances, or confirm successful approaches.
-    *   **Before appending new information**: Briefly review the *existing* details logged in the subtask (using `get_task` or recalling from context) to ensure the update adds fresh insights and avoids redundancy.
-    *   **Regularly** use `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<update details>\n- What worked...\n- What didn't work...'` to append new findings.
-    *   **Crucially, log:**
-        *   What worked ("fundamental truths" discovered).
-        *   What didn't work and why (to avoid repeating mistakes).
-        *   Specific code snippets or configurations that were successful.
-        *   Decisions made, especially if confirmed with user input.
-        *   Any deviations from the initial plan and the reasoning.
-    *   The objective is to continuously enrich the subtask's details, creating a log of the implementation journey that helps the AI (and human developers) learn, adapt, and avoid repeating errors.
-
-7.  **Review & Update Rules (Post-Implementation):**
-    *   Once the implementation for the subtask is functionally complete, review all code changes and the relevant chat history.
-    *   Identify any new or modified code patterns, conventions, or best practices established during the implementation.
-    *   Create new or update existing rules following internal guidelines (previously linked to `cursor_rules.mdc` and `self_improve.mdc`).
-
-8.  **Mark Task Complete:**
-    *   After verifying the implementation and updating any necessary rules, mark the subtask as completed: `set_task_status` / `task-master set-status --id=<subtaskId> --status=done`.
-
-9.  **Commit Changes (If using Git):**
-    *   Stage the relevant code changes and any updated/new rule files (`git add .`).
-    *   Craft a comprehensive Git commit message summarizing the work done for the subtask, including both code implementation and any rule adjustments.
-    *   Execute the commit command directly in the terminal (e.g., `git commit -m 'feat(module): Implement feature X for subtask <subtaskId>\n\n- Details about changes...\n- Updated rule Y for pattern Z'`).
-    *   Consider if a Changeset is needed according to internal versioning guidelines (previously linked to `changeset.mdc`). If so, run `npm run changeset`, stage the generated file, and amend the commit or create a new one.
-
-10. **Proceed to Next Subtask:**
-    *   Identify the next subtask (e.g., using `next_task` / `task-master next`).
-
-## Code Analysis & Refactoring Techniques
-
-- **Top-Level Function Search**:
-    - Useful for understanding module structure or planning refactors.
-    - Use grep/ripgrep to find exported functions/constants:
-      `rg "export (async function|function|const) \w+"` or similar patterns.
-    - Can help compare functions between files during migrations or identify potential naming conflicts.
-
----
-*This workflow provides a general guideline. Adapt it based on your specific project needs and team practices.*

.cursor/rules/taskmaster/taskmaster.mdc

@@ -1,558 +0,0 @@
----
-description: Comprehensive reference for Taskmaster MCP tools and CLI commands.
-globs: **/*
-alwaysApply: true
----
-
-# Taskmaster Tool & Command Reference
-
-This document provides a detailed reference for interacting with Taskmaster, covering both the recommended MCP tools, suitable for integrations like Cursor, and the corresponding `task-master` CLI commands, designed for direct user interaction or fallback.
-
-**Note:** For interacting with Taskmaster programmatically or via integrated tools, using the **MCP tools is strongly recommended** due to better performance, structured data, and error handling. The CLI commands serve as a user-friendly alternative and fallback. 
-
-**Important:** Several MCP tools involve AI processing... The AI-powered tools include `parse_prd`, `analyze_project_complexity`, `update_subtask`, `update_task`, `update`, `expand_all`, `expand_task`, and `add_task`.
-
-**🏷️ Tagged Task Lists System:** Task Master now supports **tagged task lists** for multi-context task management. This allows you to maintain separate, isolated lists of tasks for different features, branches, or experiments. Existing projects are seamlessly migrated to use a default "master" tag. Most commands now support a `--tag <name>` flag to specify which context to operate on. If omitted, commands use the currently active tag.
-
----
-
-## Initialization & Setup
-
-### 1. Initialize Project (`init`)
-
-*   **MCP Tool:** `initialize_project`
-*   **CLI Command:** `task-master init [options]`
-*   **Description:** `Set up the basic Taskmaster file structure and configuration in the current directory for a new project.`
-*   **Key CLI Options:**
-    *   `--name <name>`: `Set the name for your project in Taskmaster's configuration.`
-    *   `--description <text>`: `Provide a brief description for your project.`
-    *   `--version <version>`: `Set the initial version for your project, e.g., '0.1.0'.`
-    *   `-y, --yes`: `Initialize Taskmaster quickly using default settings without interactive prompts.`
-*   **Usage:** Run this once at the beginning of a new project.
-*   **MCP Variant Description:** `Set up the basic Taskmaster file structure and configuration in the current directory for a new project by running the 'task-master init' command.`
-*   **Key MCP Parameters/Options:**
-    *   `projectName`: `Set the name for your project.` (CLI: `--name <name>`)
-    *   `projectDescription`: `Provide a brief description for your project.` (CLI: `--description <text>`)
-    *   `projectVersion`: `Set the initial version for your project, e.g., '0.1.0'.` (CLI: `--version <version>`)
-    *   `authorName`: `Author name.` (CLI: `--author <author>`)
-    *   `skipInstall`: `Skip installing dependencies. Default is false.` (CLI: `--skip-install`)
-    *   `addAliases`: `Add shell aliases tm and taskmaster. Default is false.` (CLI: `--aliases`)
-    *   `yes`: `Skip prompts and use defaults/provided arguments. Default is false.` (CLI: `-y, --yes`)
-*   **Usage:** Run this once at the beginning of a new project, typically via an integrated tool like Cursor. Operates on the current working directory of the MCP server. 
-*   **Important:** Once complete, you *MUST* parse a prd in order to generate tasks. There will be no tasks files until then. The next step after initializing should be to create a PRD using the example PRD in .taskmaster/templates/example_prd.txt. 
-*   **Tagging:** Use the `--tag` option to parse the PRD into a specific, non-default tag context. If the tag doesn't exist, it will be created automatically. Example: `task-master parse-prd spec.txt --tag=new-feature`.
-
-### 2. Parse PRD (`parse_prd`)
-
-*   **MCP Tool:** `parse_prd`
-*   **CLI Command:** `task-master parse-prd [file] [options]`
-*   **Description:** `Parse a Product Requirements Document, PRD, or text file with Taskmaster to automatically generate an initial set of tasks in tasks.json.`
-*   **Key Parameters/Options:**
-    *   `input`: `Path to your PRD or requirements text file that Taskmaster should parse for tasks.` (CLI: `[file]` positional or `-i, --input <file>`)
-    *   `output`: `Specify where Taskmaster should save the generated 'tasks.json' file. Defaults to '.taskmaster/tasks/tasks.json'.` (CLI: `-o, --output <file>`)
-    *   `numTasks`: `Approximate number of top-level tasks Taskmaster should aim to generate from the document.` (CLI: `-n, --num-tasks <number>`)
-    *   `force`: `Use this to allow Taskmaster to overwrite an existing 'tasks.json' without asking for confirmation.` (CLI: `-f, --force`)
-*   **Usage:** Useful for bootstrapping a project from an existing requirements document.
-*   **Notes:** Task Master will strictly adhere to any specific requirements mentioned in the PRD, such as libraries, database schemas, frameworks, tech stacks, etc., while filling in any gaps where the PRD isn't fully specified. Tasks are designed to provide the most direct implementation path while avoiding over-engineering.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress. If the user does not have a PRD, suggest discussing their idea and then use the example PRD in `.taskmaster/templates/example_prd.txt` as a template for creating the PRD based on their idea, for use with `parse-prd`.
-
----
-
-## AI Model Configuration
-
-### 2. Manage Models (`models`)
-*   **MCP Tool:** `models`
-*   **CLI Command:** `task-master models [options]`
-*   **Description:** `View the current AI model configuration or set specific models for different roles (main, research, fallback). Allows setting custom model IDs for Ollama and OpenRouter.`
-*   **Key MCP Parameters/Options:**
-    *   `setMain <model_id>`: `Set the primary model ID for task generation/updates.` (CLI: `--set-main <model_id>`)
-    *   `setResearch <model_id>`: `Set the model ID for research-backed operations.` (CLI: `--set-research <model_id>`)
-    *   `setFallback <model_id>`: `Set the model ID to use if the primary fails.` (CLI: `--set-fallback <model_id>`)
-    *   `ollama <boolean>`: `Indicates the set model ID is a custom Ollama model.` (CLI: `--ollama`)
-    *   `openrouter <boolean>`: `Indicates the set model ID is a custom OpenRouter model.` (CLI: `--openrouter`)
-    *   `listAvailableModels <boolean>`: `If true, lists available models not currently assigned to a role.` (CLI: No direct equivalent; CLI lists available automatically)
-    *   `projectRoot <string>`: `Optional. Absolute path to the project root directory.` (CLI: Determined automatically)
-*   **Key CLI Options:**
-    *   `--set-main <model_id>`: `Set the primary model.`
-    *   `--set-research <model_id>`: `Set the research model.`
-    *   `--set-fallback <model_id>`: `Set the fallback model.`
-    *   `--ollama`: `Specify that the provided model ID is for Ollama (use with --set-*).`
-    *   `--openrouter`: `Specify that the provided model ID is for OpenRouter (use with --set-*). Validates against OpenRouter API.`
-    *   `--bedrock`: `Specify that the provided model ID is for AWS Bedrock (use with --set-*).`
-    *   `--setup`: `Run interactive setup to configure models, including custom Ollama/OpenRouter IDs.`
-*   **Usage (MCP):** Call without set flags to get current config. Use `setMain`, `setResearch`, or `setFallback` with a valid model ID to update the configuration. Use `listAvailableModels: true` to get a list of unassigned models. To set a custom model, provide the model ID and set `ollama: true` or `openrouter: true`.
-*   **Usage (CLI):** Run without flags to view current configuration and available models. Use set flags to update specific roles. Use `--setup` for guided configuration, including custom models. To set a custom model via flags, use `--set-<role>=<model_id>` along with either `--ollama` or `--openrouter`.
-*   **Notes:** Configuration is stored in `.taskmaster/config.json` in the project root. This command/tool modifies that file. Use `listAvailableModels` or `task-master models` to see internally supported models. OpenRouter custom models are validated against their live API. Ollama custom models are not validated live.
-*   **API note:** API keys for selected AI providers (based on their model) need to exist in the mcp.json file to be accessible in MCP context. The API keys must be present in the local .env file for the CLI to be able to read them.
-*   **Model costs:** The costs in supported models are expressed in dollars. An input/output value of 3 is $3.00. A value of 0.8 is $0.80. 
-*   **Warning:** DO NOT MANUALLY EDIT THE .taskmaster/config.json FILE. Use the included commands either in the MCP or CLI format as needed. Always prioritize MCP tools when available and use the CLI as a fallback.
-
----
-
-## Task Listing & Viewing
-
-### 3. Get Tasks (`get_tasks`)
-
-*   **MCP Tool:** `get_tasks`
-*   **CLI Command:** `task-master list [options]`
-*   **Description:** `List your Taskmaster tasks, optionally filtering by status and showing subtasks.`
-*   **Key Parameters/Options:**
-    *   `status`: `Show only Taskmaster tasks matching this status (or multiple statuses, comma-separated), e.g., 'pending' or 'done,in-progress'.` (CLI: `-s, --status <status>`)
-    *   `withSubtasks`: `Include subtasks indented under their parent tasks in the list.` (CLI: `--with-subtasks`)
-    *   `tag`: `Specify which tag context to list tasks from. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Get an overview of the project status, often used at the start of a work session.
-
-### 4. Get Next Task (`next_task`)
-
-*   **MCP Tool:** `next_task`
-*   **CLI Command:** `task-master next [options]`
-*   **Description:** `Ask Taskmaster to show the next available task you can work on, based on status and completed dependencies.`
-*   **Key Parameters/Options:**
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-    *   `tag`: `Specify which tag context to use. Defaults to the current active tag.` (CLI: `--tag <name>`)
-*   **Usage:** Identify what to work on next according to the plan.
-
-### 5. Get Task Details (`get_task`)
-
-*   **MCP Tool:** `get_task`
-*   **CLI Command:** `task-master show [id] [options]`
-*   **Description:** `Display detailed information for one or more specific Taskmaster tasks or subtasks by ID.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The ID of the Taskmaster task (e.g., '15'), subtask (e.g., '15.2'), or a comma-separated list of IDs ('1,5,10.2') you want to view.` (CLI: `[id]` positional or `-i, --id <id>`)
-    *   `tag`: `Specify which tag context to get the task(s) from. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Understand the full details for a specific task. When multiple IDs are provided, a summary table is shown.
-*   **CRITICAL INFORMATION** If you need to collect information from multiple tasks, use comma-separated IDs (i.e. 1,2,3) to receive an array of tasks. Do not needlessly get tasks one at a time if you need to get many as that is wasteful.
-
----
-
-## Task Creation & Modification
-
-### 6. Add Task (`add_task`)
-
-*   **MCP Tool:** `add_task`
-*   **CLI Command:** `task-master add-task [options]`
-*   **Description:** `Add a new task to Taskmaster by describing it; AI will structure it.`
-*   **Key Parameters/Options:**
-    *   `prompt`: `Required. Describe the new task you want Taskmaster to create, e.g., "Implement user authentication using JWT".` (CLI: `-p, --prompt <text>`)
-    *   `dependencies`: `Specify the IDs of any Taskmaster tasks that must be completed before this new one can start, e.g., '12,14'.` (CLI: `-d, --dependencies <ids>`)
-    *   `priority`: `Set the priority for the new task: 'high', 'medium', or 'low'. Default is 'medium'.` (CLI: `--priority <priority>`)
-    *   `research`: `Enable Taskmaster to use the research role for potentially more informed task creation.` (CLI: `-r, --research`)
-    *   `tag`: `Specify which tag context to add the task to. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Quickly add newly identified tasks during development.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
-
-### 7. Add Subtask (`add_subtask`)
-
-*   **MCP Tool:** `add_subtask`
-*   **CLI Command:** `task-master add-subtask [options]`
-*   **Description:** `Add a new subtask to a Taskmaster parent task, or convert an existing task into a subtask.`
-*   **Key Parameters/Options:**
-    *   `id` / `parent`: `Required. The ID of the Taskmaster task that will be the parent.` (MCP: `id`, CLI: `-p, --parent <id>`)
-    *   `taskId`: `Use this if you want to convert an existing top-level Taskmaster task into a subtask of the specified parent.` (CLI: `-i, --task-id <id>`)
-    *   `title`: `Required if not using taskId. The title for the new subtask Taskmaster should create.` (CLI: `-t, --title <title>`)
-    *   `description`: `A brief description for the new subtask.` (CLI: `-d, --description <text>`)
-    *   `details`: `Provide implementation notes or details for the new subtask.` (CLI: `--details <text>`)
-    *   `dependencies`: `Specify IDs of other tasks or subtasks, e.g., '15' or '16.1', that must be done before this new subtask.` (CLI: `--dependencies <ids>`)
-    *   `status`: `Set the initial status for the new subtask. Default is 'pending'.` (CLI: `-s, --status <status>`)
-    *   `skipGenerate`: `Prevent Taskmaster from automatically regenerating markdown task files after adding the subtask.` (CLI: `--skip-generate`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Break down tasks manually or reorganize existing tasks.
-
-### 8. Update Tasks (`update`)
-
-*   **MCP Tool:** `update`
-*   **CLI Command:** `task-master update [options]`
-*   **Description:** `Update multiple upcoming tasks in Taskmaster based on new context or changes, starting from a specific task ID.`
-*   **Key Parameters/Options:**
-    *   `from`: `Required. The ID of the first task Taskmaster should update. All tasks with this ID or higher that are not 'done' will be considered.` (CLI: `--from <id>`)
-    *   `prompt`: `Required. Explain the change or new context for Taskmaster to apply to the tasks, e.g., "We are now using React Query instead of Redux Toolkit for data fetching".` (CLI: `-p, --prompt <text>`)
-    *   `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Handle significant implementation changes or pivots that affect multiple future tasks. Example CLI: `task-master update --from='18' --prompt='Switching to React Query.\nNeed to refactor data fetching...'`
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
-
-### 9. Update Task (`update_task`)
-
-*   **MCP Tool:** `update_task`
-*   **CLI Command:** `task-master update-task [options]`
-*   **Description:** `Modify a specific Taskmaster task by ID, incorporating new information or changes. By default, this replaces the existing task details.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The specific ID of the Taskmaster task, e.g., '15', you want to update.` (CLI: `-i, --id <id>`)
-    *   `prompt`: `Required. Explain the specific changes or provide the new information Taskmaster should incorporate into this task.` (CLI: `-p, --prompt <text>`)
-    *   `append`: `If true, appends the prompt content to the task's details with a timestamp, rather than replacing them. Behaves like update-subtask.` (CLI: `--append`)
-    *   `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `tag`: `Specify which tag context the task belongs to. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Refine a specific task based on new understanding. Use `--append` to log progress without creating subtasks.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
-
-### 10. Update Subtask (`update_subtask`)
-
-*   **MCP Tool:** `update_subtask`
-*   **CLI Command:** `task-master update-subtask [options]`
-*   **Description:** `Append timestamped notes or details to a specific Taskmaster subtask without overwriting existing content. Intended for iterative implementation logging.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The ID of the Taskmaster subtask, e.g., '5.2', to update with new information.` (CLI: `-i, --id <id>`)
-    *   `prompt`: `Required. The information, findings, or progress notes to append to the subtask's details with a timestamp.` (CLI: `-p, --prompt <text>`)
-    *   `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `tag`: `Specify which tag context the subtask belongs to. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Log implementation progress, findings, and discoveries during subtask development. Each update is timestamped and appended to preserve the implementation journey.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
-
-### 11. Set Task Status (`set_task_status`)
-
-*   **MCP Tool:** `set_task_status`
-*   **CLI Command:** `task-master set-status [options]`
-*   **Description:** `Update the status of one or more Taskmaster tasks or subtasks, e.g., 'pending', 'in-progress', 'done'.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The ID(s) of the Taskmaster task(s) or subtask(s), e.g., '15', '15.2', or '16,17.1', to update.` (CLI: `-i, --id <id>`)
-    *   `status`: `Required. The new status to set, e.g., 'done', 'pending', 'in-progress', 'review', 'cancelled'.` (CLI: `-s, --status <status>`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Mark progress as tasks move through the development cycle.
-
-### 12. Remove Task (`remove_task`)
-
-*   **MCP Tool:** `remove_task`
-*   **CLI Command:** `task-master remove-task [options]`
-*   **Description:** `Permanently remove a task or subtask from the Taskmaster tasks list.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The ID of the Taskmaster task, e.g., '5', or subtask, e.g., '5.2', to permanently remove.` (CLI: `-i, --id <id>`)
-    *   `yes`: `Skip the confirmation prompt and immediately delete the task.` (CLI: `-y, --yes`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Permanently delete tasks or subtasks that are no longer needed in the project.
-*   **Notes:** Use with caution as this operation cannot be undone. Consider using 'blocked', 'cancelled', or 'deferred' status instead if you just want to exclude a task from active planning but keep it for reference. The command automatically cleans up dependency references in other tasks.
-
----
-
-## Task Structure & Breakdown
-
-### 13. Expand Task (`expand_task`)
-
-*   **MCP Tool:** `expand_task`
-*   **CLI Command:** `task-master expand [options]`
-*   **Description:** `Use Taskmaster's AI to break down a complex task into smaller, manageable subtasks. Appends subtasks by default.`
-*   **Key Parameters/Options:**
-    *   `id`: `The ID of the specific Taskmaster task you want to break down into subtasks.` (CLI: `-i, --id <id>`)
-    *   `num`: `Optional: Suggests how many subtasks Taskmaster should aim to create. Uses complexity analysis/defaults otherwise.` (CLI: `-n, --num <number>`)
-    *   `research`: `Enable Taskmaster to use the research role for more informed subtask generation. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `prompt`: `Optional: Provide extra context or specific instructions to Taskmaster for generating the subtasks.` (CLI: `-p, --prompt <text>`)
-    *   `force`: `Optional: If true, clear existing subtasks before generating new ones. Default is false (append).` (CLI: `--force`)
-    *   `tag`: `Specify which tag context the task belongs to. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Generate a detailed implementation plan for a complex task before starting coding. Automatically uses complexity report recommendations if available and `num` is not specified.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
-
-### 14. Expand All Tasks (`expand_all`)
-
-*   **MCP Tool:** `expand_all`
-*   **CLI Command:** `task-master expand --all [options]` (Note: CLI uses the `expand` command with the `--all` flag)
-*   **Description:** `Tell Taskmaster to automatically expand all eligible pending/in-progress tasks based on complexity analysis or defaults. Appends subtasks by default.`
-*   **Key Parameters/Options:**
-    *   `num`: `Optional: Suggests how many subtasks Taskmaster should aim to create per task.` (CLI: `-n, --num <number>`)
-    *   `research`: `Enable research role for more informed subtask generation. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `prompt`: `Optional: Provide extra context for Taskmaster to apply generally during expansion.` (CLI: `-p, --prompt <text>`)
-    *   `force`: `Optional: If true, clear existing subtasks before generating new ones for each eligible task. Default is false (append).` (CLI: `--force`)
-    *   `tag`: `Specify which tag context to expand. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Useful after initial task generation or complexity analysis to break down multiple tasks at once.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
-
-### 15. Clear Subtasks (`clear_subtasks`)
-
-*   **MCP Tool:** `clear_subtasks`
-*   **CLI Command:** `task-master clear-subtasks [options]`
-*   **Description:** `Remove all subtasks from one or more specified Taskmaster parent tasks.`
-*   **Key Parameters/Options:**
-    *   `id`: `The ID(s) of the Taskmaster parent task(s) whose subtasks you want to remove, e.g., '15' or '16,18'. Required unless using 'all'.` (CLI: `-i, --id <ids>`)
-    *   `all`: `Tell Taskmaster to remove subtasks from all parent tasks.` (CLI: `--all`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Used before regenerating subtasks with `expand_task` if the previous breakdown needs replacement.
-
-### 16. Remove Subtask (`remove_subtask`)
-
-*   **MCP Tool:** `remove_subtask`
-*   **CLI Command:** `task-master remove-subtask [options]`
-*   **Description:** `Remove a subtask from its Taskmaster parent, optionally converting it into a standalone task.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The ID(s) of the Taskmaster subtask(s) to remove, e.g., '15.2' or '16.1,16.3'.` (CLI: `-i, --id <id>`)
-    *   `convert`: `If used, Taskmaster will turn the subtask into a regular top-level task instead of deleting it.` (CLI: `-c, --convert`)
-    *   `skipGenerate`: `Prevent Taskmaster from automatically regenerating markdown task files after removing the subtask.` (CLI: `--skip-generate`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Delete unnecessary subtasks or promote a subtask to a top-level task.
-
-### 17. Move Task (`move_task`)
-
-*   **MCP Tool:** `move_task`
-*   **CLI Command:** `task-master move [options]`
-*   **Description:** `Move a task or subtask to a new position within the task hierarchy.`
-*   **Key Parameters/Options:**
-    *   `from`: `Required. ID of the task/subtask to move (e.g., "5" or "5.2"). Can be comma-separated for multiple tasks.` (CLI: `--from <id>`)
-    *   `to`: `Required. ID of the destination (e.g., "7" or "7.3"). Must match the number of source IDs if comma-separated.` (CLI: `--to <id>`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Reorganize tasks by moving them within the hierarchy. Supports various scenarios like:
-    *   Moving a task to become a subtask
-    *   Moving a subtask to become a standalone task
-    *   Moving a subtask to a different parent
-    *   Reordering subtasks within the same parent
-    *   Moving a task to a new, non-existent ID (automatically creates placeholders)
-    *   Moving multiple tasks at once with comma-separated IDs
-*   **Validation Features:**
-    *   Allows moving tasks to non-existent destination IDs (creates placeholder tasks)
-    *   Prevents moving to existing task IDs that already have content (to avoid overwriting)
-    *   Validates that source tasks exist before attempting to move them
-    *   Maintains proper parent-child relationships
-*   **Example CLI:** `task-master move --from=5.2 --to=7.3` to move subtask 5.2 to become subtask 7.3.
-*   **Example Multi-Move:** `task-master move --from=10,11,12 --to=16,17,18` to move multiple tasks to new positions.
-*   **Common Use:** Resolving merge conflicts in tasks.json when multiple team members create tasks on different branches.
-
----
-
-## Dependency Management
-
-### 18. Add Dependency (`add_dependency`)
-
-*   **MCP Tool:** `add_dependency`
-*   **CLI Command:** `task-master add-dependency [options]`
-*   **Description:** `Define a dependency in Taskmaster, making one task a prerequisite for another.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The ID of the Taskmaster task that will depend on another.` (CLI: `-i, --id <id>`)
-    *   `dependsOn`: `Required. The ID of the Taskmaster task that must be completed first, the prerequisite.` (CLI: `-d, --depends-on <id>`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <path>`)
-*   **Usage:** Establish the correct order of execution between tasks.
-
-### 19. Remove Dependency (`remove_dependency`)
-
-*   **MCP Tool:** `remove_dependency`
-*   **CLI Command:** `task-master remove-dependency [options]`
-*   **Description:** `Remove a dependency relationship between two Taskmaster tasks.`
-*   **Key Parameters/Options:**
-    *   `id`: `Required. The ID of the Taskmaster task you want to remove a prerequisite from.` (CLI: `-i, --id <id>`)
-    *   `dependsOn`: `Required. The ID of the Taskmaster task that should no longer be a prerequisite.` (CLI: `-d, --depends-on <id>`)
-    *   `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Update task relationships when the order of execution changes.
-
-### 20. Validate Dependencies (`validate_dependencies`)
-
-*   **MCP Tool:** `validate_dependencies`
-*   **CLI Command:** `task-master validate-dependencies [options]`
-*   **Description:** `Check your Taskmaster tasks for dependency issues (like circular references or links to non-existent tasks) without making changes.`
-*   **Key Parameters/Options:**
-    *   `tag`: `Specify which tag context to validate. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Audit the integrity of your task dependencies.
-
-### 21. Fix Dependencies (`fix_dependencies`)
-
-*   **MCP Tool:** `fix_dependencies`
-*   **CLI Command:** `task-master fix-dependencies [options]`
-*   **Description:** `Automatically fix dependency issues (like circular references or links to non-existent tasks) in your Taskmaster tasks.`
-*   **Key Parameters/Options:**
-    *   `tag`: `Specify which tag context to fix dependencies in. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Clean up dependency errors automatically.
-
----
-
-## Analysis & Reporting
-
-### 22. Analyze Project Complexity (`analyze_project_complexity`)
-
-*   **MCP Tool:** `analyze_project_complexity`
-*   **CLI Command:** `task-master analyze-complexity [options]`
-*   **Description:** `Have Taskmaster analyze your tasks to determine their complexity and suggest which ones need to be broken down further.`
-*   **Key Parameters/Options:**
-    *   `output`: `Where to save the complexity analysis report. Default is '.taskmaster/reports/task-complexity-report.json' (or '..._tagname.json' if a tag is used).` (CLI: `-o, --output <file>`)
-    *   `threshold`: `The minimum complexity score (1-10) that should trigger a recommendation to expand a task.` (CLI: `-t, --threshold <number>`)
-    *   `research`: `Enable research role for more accurate complexity analysis. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `tag`: `Specify which tag context to analyze. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Used before breaking down tasks to identify which ones need the most attention.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
-
-### 23. View Complexity Report (`complexity_report`)
-
-*   **MCP Tool:** `complexity_report`
-*   **CLI Command:** `task-master complexity-report [options]`
-*   **Description:** `Display the task complexity analysis report in a readable format.`
-*   **Key Parameters/Options:**
-    *   `tag`: `Specify which tag context to show the report for. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to the complexity report (default: '.taskmaster/reports/task-complexity-report.json').` (CLI: `-f, --file <file>`)
-*   **Usage:** Review and understand the complexity analysis results after running analyze-complexity.
-
----
-
-## File Management
-
-### 24. Generate Task Files (`generate`)
-
-*   **MCP Tool:** `generate`
-*   **CLI Command:** `task-master generate [options]`
-*   **Description:** `Create or update individual Markdown files for each task based on your tasks.json.`
-*   **Key Parameters/Options:**
-    *   `output`: `The directory where Taskmaster should save the task files (default: in a 'tasks' directory).` (CLI: `-o, --output <directory>`)
-    *   `tag`: `Specify which tag context to generate files for. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-*   **Usage:** Run this after making changes to tasks.json to keep individual task files up to date. This command is now manual and no longer runs automatically.
-
----
-
-## AI-Powered Research
-
-### 25. Research (`research`)
-
-*   **MCP Tool:** `research`
-*   **CLI Command:** `task-master research [options]`
-*   **Description:** `Perform AI-powered research queries with project context to get fresh, up-to-date information beyond the AI's knowledge cutoff.`
-*   **Key Parameters/Options:**
-    *   `query`: `Required. Research query/prompt (e.g., "What are the latest best practices for React Query v5?").` (CLI: `[query]` positional or `-q, --query <text>`)
-    *   `taskIds`: `Comma-separated list of task/subtask IDs from the current tag context (e.g., "15,16.2,17").` (CLI: `-i, --id <ids>`)
-    *   `filePaths`: `Comma-separated list of file paths for context (e.g., "src/api.js,docs/readme.md").` (CLI: `-f, --files <paths>`)
-    *   `customContext`: `Additional custom context text to include in the research.` (CLI: `-c, --context <text>`)
-    *   `includeProjectTree`: `Include project file tree structure in context (default: false).` (CLI: `--tree`)
-    *   `detailLevel`: `Detail level for the research response: 'low', 'medium', 'high' (default: medium).` (CLI: `--detail <level>`)
-    *   `saveTo`: `Task or subtask ID (e.g., "15", "15.2") to automatically save the research conversation to.` (CLI: `--save-to <id>`)
-    *   `saveFile`: `If true, saves the research conversation to a markdown file in '.taskmaster/docs/research/'.` (CLI: `--save-file`)
-    *   `noFollowup`: `Disables the interactive follow-up question menu in the CLI.` (CLI: `--no-followup`)
-    *   `tag`: `Specify which tag context to use for task-based context gathering. Defaults to the current active tag.` (CLI: `--tag <name>`)
-    *   `projectRoot`: `The directory of the project. Must be an absolute path.` (CLI: Determined automatically)
-*   **Usage:** **This is a POWERFUL tool that agents should use FREQUENTLY** to:
-    *   Get fresh information beyond knowledge cutoff dates
-    *   Research latest best practices, library updates, security patches
-    *   Find implementation examples for specific technologies
-    *   Validate approaches against current industry standards
-    *   Get contextual advice based on project files and tasks
-*   **When to Consider Using Research:**
-    *   **Before implementing any task** - Research current best practices
-    *   **When encountering new technologies** - Get up-to-date implementation guidance (libraries, apis, etc)
-    *   **For security-related tasks** - Find latest security recommendations
-    *   **When updating dependencies** - Research breaking changes and migration guides
-    *   **For performance optimization** - Get current performance best practices
-    *   **When debugging complex issues** - Research known solutions and workarounds
-*   **Research + Action Pattern:**
-    *   Use `research` to gather fresh information
-    *   Use `update_subtask` to commit findings with timestamps
-    *   Use `update_task` to incorporate research into task details
-    *   Use `add_task` with research flag for informed task creation
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. The research provides FRESH data beyond the AI's training cutoff, making it invaluable for current best practices and recent developments.
-
----
-
-## Tag Management
-
-This new suite of commands allows you to manage different task contexts (tags).
-
-### 26. List Tags (`tags`)
-
-*   **MCP Tool:** `list_tags`
-*   **CLI Command:** `task-master tags [options]`
-*   **Description:** `List all available tags with task counts, completion status, and other metadata.`
-*   **Key Parameters/Options:**
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-    *   `--show-metadata`: `Include detailed metadata in the output (e.g., creation date, description).` (CLI: `--show-metadata`)
-
-### 27. Add Tag (`add_tag`)
-
-*   **MCP Tool:** `add_tag`
-*   **CLI Command:** `task-master add-tag <tagName> [options]`
-*   **Description:** `Create a new, empty tag context, or copy tasks from another tag.`
-*   **Key Parameters/Options:**
-    *   `tagName`: `Name of the new tag to create (alphanumeric, hyphens, underscores).` (CLI: `<tagName>` positional)
-    *   `--from-branch`: `Creates a tag with a name derived from the current git branch, ignoring the <tagName> argument.` (CLI: `--from-branch`)
-    *   `--copy-from-current`: `Copy tasks from the currently active tag to the new tag.` (CLI: `--copy-from-current`)
-    *   `--copy-from <tag>`: `Copy tasks from a specific source tag to the new tag.` (CLI: `--copy-from <tag>`)
-    *   `--description <text>`: `Provide an optional description for the new tag.` (CLI: `-d, --description <text>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-
-### 28. Delete Tag (`delete_tag`)
-
-*   **MCP Tool:** `delete_tag`
-*   **CLI Command:** `task-master delete-tag <tagName> [options]`
-*   **Description:** `Permanently delete a tag and all of its associated tasks.`
-*   **Key Parameters/Options:**
-    *   `tagName`: `Name of the tag to delete.` (CLI: `<tagName>` positional)
-    *   `--yes`: `Skip the confirmation prompt.` (CLI: `-y, --yes`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-
-### 29. Use Tag (`use_tag`)
-
-*   **MCP Tool:** `use_tag`
-*   **CLI Command:** `task-master use-tag <tagName>`
-*   **Description:** `Switch your active task context to a different tag.`
-*   **Key Parameters/Options:**
-    *   `tagName`: `Name of the tag to switch to.` (CLI: `<tagName>` positional)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-
-### 30. Rename Tag (`rename_tag`)
-
-*   **MCP Tool:** `rename_tag`
-*   **CLI Command:** `task-master rename-tag <oldName> <newName>`
-*   **Description:** `Rename an existing tag.`
-*   **Key Parameters/Options:**
-    *   `oldName`: `The current name of the tag.` (CLI: `<oldName>` positional)
-    *   `newName`: `The new name for the tag.` (CLI: `<newName>` positional)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
-
-### 31. Copy Tag (`copy_tag`)
-
-*   **MCP Tool:** `copy_tag`
-*   **CLI Command:** `task-master copy-tag <sourceName> <targetName> [options]`
-*   **Description:** `Copy an entire tag context, including all its tasks and metadata, to a new tag.`
-*   **Key Parameters/Options:**
-    *   `sourceName`: `Name of the tag to copy from.` (CLI: `<sourceName>` positional)
-    *   `targetName`: `Name of the new tag to create.` (CLI: `<targetName>` positional)
-    *   `--description <text>`: `Optional description for the new tag.` (CLI: `-d, --description <text>`)
-
----
-
-## Miscellaneous
-
-### 32. Sync Readme (`sync-readme`) -- experimental
-
-*   **MCP Tool:** N/A
-*   **CLI Command:** `task-master sync-readme [options]`
-*   **Description:** `Exports your task list to your project's README.md file, useful for showcasing progress.`
-*   **Key Parameters/Options:**
-    *   `status`: `Filter tasks by status (e.g., 'pending', 'done').` (CLI: `-s, --status <status>`)
-    *   `withSubtasks`: `Include subtasks in the export.` (CLI: `--with-subtasks`)
-    *   `tag`: `Specify which tag context to export from. Defaults to the current active tag.` (CLI: `--tag <name>`)
-
----
-
-## Environment Variables Configuration (Updated)
-
-Taskmaster primarily uses the **`.taskmaster/config.json`** file (in project root) for configuration (models, parameters, logging level, etc.), managed via `task-master models --setup`.
-
-Environment variables are used **only** for sensitive API keys related to AI providers and specific overrides like the Ollama base URL:
-
-*   **API Keys (Required for corresponding provider):**
-    *   `ANTHROPIC_API_KEY`
-    *   `PERPLEXITY_API_KEY`
-    *   `OPENAI_API_KEY`
-    *   `GOOGLE_API_KEY`
-    *   `MISTRAL_API_KEY`
-    *   `AZURE_OPENAI_API_KEY` (Requires `AZURE_OPENAI_ENDPOINT` too)
-    *   `OPENROUTER_API_KEY`
-    *   `XAI_API_KEY`
-    *   `OLLAMA_API_KEY` (Requires `OLLAMA_BASE_URL` too)
-*   **Endpoints (Optional/Provider Specific inside .taskmaster/config.json):**
-    *   `AZURE_OPENAI_ENDPOINT`
-    *   `OLLAMA_BASE_URL` (Default: `http://localhost:11434/api`)
-
-**Set API keys** in your **`.env`** file in the project root (for CLI use) or within the `env` section of your **`.cursor/mcp.json`** file (for MCP/Cursor integration). All other settings (model choice, max tokens, temperature, log level, custom endpoints) are managed in `.taskmaster/config.json` via `task-master models` command or `models` MCP tool.
-
----
-
-For details on how these commands fit into the development process, see the [dev_workflow.mdc](mdc:.cursor/rules/taskmaster/dev_workflow.mdc).

.gitignore

@@ -22,17 +22,11 @@ lerna-debug.log*
 
 # Coverage directory used by tools like istanbul
 coverage/
-coverage-e2e/
 *.lcov
 
 # Jest cache
 .jest/
 
-# Test results and reports
-test-results/
-jest-results.json
-junit.xml
-
 # Test temporary files and directories
 tests/temp/
 tests/e2e/_runs/
@@ -93,9 +87,3 @@ dev-debug.log
 *.njsproj
 *.sln
 *.sw?
-
-# OS specific
-
-# Task files
-# tasks.json
-# tasks/ 

CHANGELOG.md

@@ -1,5 +1,139 @@
 # task-master-ai
 
+## 0.21.0
+
+### Minor Changes
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`9c58a92`](https://github.com/eyaltoledano/claude-task-master/commit/9c58a922436c0c5e7ff1b20ed2edbc269990c772) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Kiro editor rule profile support
+  - Add support for Kiro IDE with custom rule files and MCP configuration
+  - Generate rule files in `.kiro/steering/` directory with markdown format
+  - Include MCP server configuration with enhanced file inclusion patterns
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`444aa5a`](https://github.com/eyaltoledano/claude-task-master/commit/444aa5ae1943ba72d012b3f01b1cc9362a328248) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Created a comprehensive documentation site for Task Master AI. Visit https://docs.task-master.dev to explore guides, API references, and examples.
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`58a301c`](https://github.com/eyaltoledano/claude-task-master/commit/58a301c380d18a9d9509137f3e989d24200a5faa) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Complete Groq provider integration and add MoonshotAI Kimi K2 model support
+  - Fixed Groq provider registration
+  - Added Groq API key validation
+  - Added GROQ_API_KEY to .env.example
+  - Added moonshotai/kimi-k2-instruct model with $1/$3 per 1M token pricing and 16k max output
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`b0e09c7`](https://github.com/eyaltoledano/claude-task-master/commit/b0e09c76ed73b00434ac95606679f570f1015a3d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - feat: Add Zed editor rule profile with agent rules and MCP config
+  - Resolves #637
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`6c5e0f9`](https://github.com/eyaltoledano/claude-task-master/commit/6c5e0f97f8403c4da85c1abba31cb8b1789511a7) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Amp rule profile with AGENT.md and MCP config
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`444aa5a`](https://github.com/eyaltoledano/claude-task-master/commit/444aa5ae1943ba72d012b3f01b1cc9362a328248) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve project root detection
+  - No longer creates an infinite loop when unable to detect your code workspace
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`36c4a7a`](https://github.com/eyaltoledano/claude-task-master/commit/36c4a7a86924c927ad7f86a4f891f66ad55eb4d2) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add OpenCode profile with AGENTS.md and MCP config
+  - Resolves #965
+
+### Patch Changes
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`444aa5a`](https://github.com/eyaltoledano/claude-task-master/commit/444aa5ae1943ba72d012b3f01b1cc9362a328248) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Make `task-master update` more reliable with AI responses
+
+  The `update` command now handles AI responses more robustly. If the AI forgets to include certain task fields, the command will automatically fill in the missing data from your original tasks instead of failing. This means smoother bulk task updates without losing important information like IDs, dependencies, or completed subtasks.
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`444aa5a`](https://github.com/eyaltoledano/claude-task-master/commit/444aa5ae1943ba72d012b3f01b1cc9362a328248) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix subtask dependency validation when expanding tasks
+
+  When using `task-master expand` to break down tasks into subtasks, dependencies between subtasks are now properly validated. Previously, subtasks with dependencies would fail validation. Now subtasks can correctly depend on their siblings within the same parent task.
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`6d69d02`](https://github.com/eyaltoledano/claude-task-master/commit/6d69d02fe03edcc785380415995d5cfcdd97acbb) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Prevent CLAUDE.md overwrite by using Claude Code's import feature
+  - Task Master now creates its instructions in `.taskmaster/CLAUDE.md` instead of overwriting the user's `CLAUDE.md`
+  - Adds an import section to the user's CLAUDE.md that references the Task Master instructions
+  - Preserves existing user content in CLAUDE.md files
+  - Provides clean uninstall that only removes Task Master's additions
+
+  **Breaking Change**: Task Master instructions for Claude Code are now stored in `.taskmaster/CLAUDE.md` and imported into the main CLAUDE.md file. Users who previously had Task Master content directly in their CLAUDE.md will need to run `task-master rules remove claude` followed by `task-master rules add claude` to migrate to the new structure.
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`fd005c4`](https://github.com/eyaltoledano/claude-task-master/commit/fd005c4c5481ffac58b11f01a448fa5b29056b8d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Implement Boundary-First Tag Resolution to ensure consistent and deterministic tag handling across CLI and MCP, resolving potential race conditions.
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`444aa5a`](https://github.com/eyaltoledano/claude-task-master/commit/444aa5ae1943ba72d012b3f01b1cc9362a328248) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix `task-master lang --setup` breaking when no language is defined, now defaults to English
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`624922c`](https://github.com/eyaltoledano/claude-task-master/commit/624922ca598c4ce8afe9a5646ebb375d4616db63) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix: show command no longer requires complexity report file to exist
+
+  The `tm show` command was incorrectly requiring the complexity report file to exist even when not needed. Now it only validates the complexity report path when a custom report file is explicitly provided via the -r/--report option.
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`858d4a1`](https://github.com/eyaltoledano/claude-task-master/commit/858d4a1c5486d20e7e3a8e37e3329d7fb8200310) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Update VS Code profile with MCP config transformation
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`0451ebc`](https://github.com/eyaltoledano/claude-task-master/commit/0451ebcc32cd7e9d395b015aaa8602c4734157e1) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix MCP server error when retrieving tools and resources
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`0a70ab6`](https://github.com/eyaltoledano/claude-task-master/commit/0a70ab6179cb2b5b4b2d9dc256a7a3b69a0e5dd6) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add MCP configuration support to Claude Code rules
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`4629128`](https://github.com/eyaltoledano/claude-task-master/commit/4629128943f6283385f4762c09cf2752f855cc33) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fixed the comprehensive taskmaster system integration via custom slash commands with proper syntax
+  - Provide claude clode with a complete set of of commands that can trigger task master events directly within Claude Code
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`0886c83`](https://github.com/eyaltoledano/claude-task-master/commit/0886c83d0c678417c0313256a6dd96f7ee2c9ac6) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Correct MCP server name and use 'Add to Cursor' button with updated placeholder keys.
+
+- [#1009](https://github.com/eyaltoledano/claude-task-master/pull/1009) [`88c434a`](https://github.com/eyaltoledano/claude-task-master/commit/88c434a9393e429d9277f59b3e20f1005076bbe0) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add missing API keys to .env.example and README.md
+
+## 0.21.0-rc.0
+
+### Minor Changes
+
+- [#1001](https://github.com/eyaltoledano/claude-task-master/pull/1001) [`75a36ea`](https://github.com/eyaltoledano/claude-task-master/commit/75a36ea99a1c738a555bdd4fe7c763d0c5925e37) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Kiro editor rule profile support
+  - Add support for Kiro IDE with custom rule files and MCP configuration
+  - Generate rule files in `.kiro/steering/` directory with markdown format
+  - Include MCP server configuration with enhanced file inclusion patterns
+
+- [#1011](https://github.com/eyaltoledano/claude-task-master/pull/1011) [`3eb050a`](https://github.com/eyaltoledano/claude-task-master/commit/3eb050aaddb90fca1a04517e2ee24f73934323be) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Created a comprehensive documentation site for Task Master AI. Visit https://docs.task-master.dev to explore guides, API references, and examples.
+
+- [#978](https://github.com/eyaltoledano/claude-task-master/pull/978) [`fedfd6a`](https://github.com/eyaltoledano/claude-task-master/commit/fedfd6a0f41a78094f7ee7f69be689b699475a79) Thanks [@ben-vargas](https://github.com/ben-vargas)! - Complete Groq provider integration and add MoonshotAI Kimi K2 model support
+  - Fixed Groq provider registration
+  - Added Groq API key validation
+  - Added GROQ_API_KEY to .env.example
+  - Added moonshotai/kimi-k2-instruct model with $1/$3 per 1M token pricing and 16k max output
+
+- [#974](https://github.com/eyaltoledano/claude-task-master/pull/974) [`5b0eda0`](https://github.com/eyaltoledano/claude-task-master/commit/5b0eda07f20a365aa2ec1736eed102bca81763a9) Thanks [@joedanz](https://github.com/joedanz)! - feat: Add Zed editor rule profile with agent rules and MCP config
+  - Resolves #637
+
+- [#973](https://github.com/eyaltoledano/claude-task-master/pull/973) [`6d05e86`](https://github.com/eyaltoledano/claude-task-master/commit/6d05e8622c1d761acef10414940ff9a766b3b57d) Thanks [@joedanz](https://github.com/joedanz)! - Add Amp rule profile with AGENT.md and MCP config
+
+- [#1011](https://github.com/eyaltoledano/claude-task-master/pull/1011) [`3eb050a`](https://github.com/eyaltoledano/claude-task-master/commit/3eb050aaddb90fca1a04517e2ee24f73934323be) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve project root detection
+  - No longer creates an infinite loop when unable to detect your code workspace
+
+- [#970](https://github.com/eyaltoledano/claude-task-master/pull/970) [`b87499b`](https://github.com/eyaltoledano/claude-task-master/commit/b87499b56e626001371a87ed56ffc72675d829f3) Thanks [@joedanz](https://github.com/joedanz)! - Add OpenCode profile with AGENTS.md and MCP config
+  - Resolves #965
+
+### Patch Changes
+
+- [#1011](https://github.com/eyaltoledano/claude-task-master/pull/1011) [`3eb050a`](https://github.com/eyaltoledano/claude-task-master/commit/3eb050aaddb90fca1a04517e2ee24f73934323be) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Make `task-master update` more reliable with AI responses
+
+  The `update` command now handles AI responses more robustly. If the AI forgets to include certain task fields, the command will automatically fill in the missing data from your original tasks instead of failing. This means smoother bulk task updates without losing important information like IDs, dependencies, or completed subtasks.
+
+- [#1011](https://github.com/eyaltoledano/claude-task-master/pull/1011) [`3eb050a`](https://github.com/eyaltoledano/claude-task-master/commit/3eb050aaddb90fca1a04517e2ee24f73934323be) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix subtask dependency validation when expanding tasks
+
+  When using `task-master expand` to break down tasks into subtasks, dependencies between subtasks are now properly validated. Previously, subtasks with dependencies would fail validation. Now subtasks can correctly depend on their siblings within the same parent task.
+
+- [#949](https://github.com/eyaltoledano/claude-task-master/pull/949) [`f662654`](https://github.com/eyaltoledano/claude-task-master/commit/f662654afb8e7a230448655265d6f41adf6df62c) Thanks [@ben-vargas](https://github.com/ben-vargas)! - Prevent CLAUDE.md overwrite by using Claude Code's import feature
+  - Task Master now creates its instructions in `.taskmaster/CLAUDE.md` instead of overwriting the user's `CLAUDE.md`
+  - Adds an import section to the user's CLAUDE.md that references the Task Master instructions
+  - Preserves existing user content in CLAUDE.md files
+  - Provides clean uninstall that only removes Task Master's additions
+
+  **Breaking Change**: Task Master instructions for Claude Code are now stored in `.taskmaster/CLAUDE.md` and imported into the main CLAUDE.md file. Users who previously had Task Master content directly in their CLAUDE.md will need to run `task-master rules remove claude` followed by `task-master rules add claude` to migrate to the new structure.
+
+- [#943](https://github.com/eyaltoledano/claude-task-master/pull/943) [`f98df5c`](https://github.com/eyaltoledano/claude-task-master/commit/f98df5c0fdb253b2b55d4278c11d626529c4dba4) Thanks [@mm-parthy](https://github.com/mm-parthy)! - Implement Boundary-First Tag Resolution to ensure consistent and deterministic tag handling across CLI and MCP, resolving potential race conditions.
+
+- [#1011](https://github.com/eyaltoledano/claude-task-master/pull/1011) [`3eb050a`](https://github.com/eyaltoledano/claude-task-master/commit/3eb050aaddb90fca1a04517e2ee24f73934323be) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix `task-master lang --setup` breaking when no language is defined, now defaults to English
+
+- [#979](https://github.com/eyaltoledano/claude-task-master/pull/979) [`ab2e946`](https://github.com/eyaltoledano/claude-task-master/commit/ab2e94608749a2f148118daa0443bd32bca6e7a1) Thanks [@ben-vargas](https://github.com/ben-vargas)! - Fix: show command no longer requires complexity report file to exist
+
+  The `tm show` command was incorrectly requiring the complexity report file to exist even when not needed. Now it only validates the complexity report path when a custom report file is explicitly provided via the -r/--report option.
+
+- [#971](https://github.com/eyaltoledano/claude-task-master/pull/971) [`5544222`](https://github.com/eyaltoledano/claude-task-master/commit/55442226d0aa4870470d2a9897f5538d6a0e329e) Thanks [@joedanz](https://github.com/joedanz)! - Update VS Code profile with MCP config transformation
+
+- [#1002](https://github.com/eyaltoledano/claude-task-master/pull/1002) [`6d0654c`](https://github.com/eyaltoledano/claude-task-master/commit/6d0654cb4191cee794e1c8cbf2b92dc33d4fb410) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix MCP server error when retrieving tools and resources
+
+- [#980](https://github.com/eyaltoledano/claude-task-master/pull/980) [`cc4fe20`](https://github.com/eyaltoledano/claude-task-master/commit/cc4fe205fb468e7144c650acc92486df30731560) Thanks [@joedanz](https://github.com/joedanz)! - Add MCP configuration support to Claude Code rules
+
+- [#968](https://github.com/eyaltoledano/claude-task-master/pull/968) [`7b4803a`](https://github.com/eyaltoledano/claude-task-master/commit/7b4803a479105691c7ed032fd878fe3d48d82724) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fixed the comprehensive taskmaster system integration via custom slash commands with proper syntax
+  - Provide claude clode with a complete set of of commands that can trigger task master events directly within Claude Code
+
+- [#995](https://github.com/eyaltoledano/claude-task-master/pull/995) [`b78de8d`](https://github.com/eyaltoledano/claude-task-master/commit/b78de8dbb4d6dc93b48e2f81c32960ef069736ed) Thanks [@joedanz](https://github.com/joedanz)! - Correct MCP server name and use 'Add to Cursor' button with updated placeholder keys.
+
+- [#972](https://github.com/eyaltoledano/claude-task-master/pull/972) [`1c7badf`](https://github.com/eyaltoledano/claude-task-master/commit/1c7badff2f5c548bfa90a3b2634e63087a382a84) Thanks [@joedanz](https://github.com/joedanz)! - Add missing API keys to .env.example and README.md
+
 ## 0.20.0
 
 ### Minor Changes

README.md

@@ -14,7 +14,13 @@ A task management system for AI-driven development with Claude, designed to work
 
 ## Documentation
 
-For more detailed information, check out the documentation in the `docs` directory:
+📚 **[View Full Documentation](https://docs.task-master.dev)**
+
+For detailed guides, API references, and comprehensive examples, visit our documentation site.
+
+### Quick Reference
+
+The following documentation is also available in the `docs` directory:
 
 - [Configuration Guide](docs/configuration.md) - Set up environment variables and customize Task Master
 - [Tutorial](docs/tutorial.md) - Step-by-step guide to getting started with Task Master

apps/extension/package.json

@@ -1,5 +1,6 @@
 {
 	"name": "extension",
+	"private": true,
 	"version": "0.20.0",
 	"main": "index.js",
 	"scripts": {

docs/models.md

@@ -1,4 +1,4 @@
-# Available Models as of July 16, 2025
+# Available Models as of July 19, 2025
 
 ## Main Models
 

jest.config.js

@@ -48,8 +48,5 @@ export default {
 	verbose: true,
 
 	// Setup file
-	setupFilesAfterEnv: ['<rootDir>/tests/setup.js'],
-
-	// Ignore e2e tests from default Jest runs
-	testPathIgnorePatterns: ['<rootDir>/tests/e2e/']
+	setupFilesAfterEnv: ['<rootDir>/tests/setup.js']
 };

jest.e2e.config.js

@@ -1,82 +0,0 @@
-/**
- * Jest configuration for E2E tests
- * Separate from unit tests to allow different settings
- */
-
-export default {
-	displayName: 'E2E Tests',
-	testMatch: ['<rootDir>/tests/e2e/**/*.test.js'],
-	testPathIgnorePatterns: [
-		'/node_modules/',
-		'/tests/e2e/utils/',
-		'/tests/e2e/config/',
-		'/tests/e2e/runners/',
-		'/tests/e2e/e2e_helpers.sh',
-		'/tests/e2e/test_llm_analysis.sh',
-		'/tests/e2e/run_e2e.sh',
-		'/tests/e2e/run_fallback_verification.sh'
-	],
-	testEnvironment: 'node',
-	testTimeout: 600000, // 10 minutes default (AI operations can be slow)
-	maxWorkers: 10, // Run tests in parallel workers to avoid rate limits
-	maxConcurrency: 10, // Limit concurrent test execution
-	testSequencer: '<rootDir>/tests/e2e/setup/rate-limit-sequencer.cjs', // Custom sequencer for rate limiting
-	verbose: true,
-	// Suppress console output for cleaner test results
-	silent: false,
-	setupFilesAfterEnv: ['<rootDir>/tests/e2e/setup/jest-setup.js'],
-	globalSetup: '<rootDir>/tests/e2e/setup/global-setup.js',
-	globalTeardown: '<rootDir>/tests/e2e/setup/global-teardown.js',
-	collectCoverageFrom: [
-		'src/**/*.js',
-		'!src/**/*.test.js',
-		'!src/**/__tests__/**'
-	],
-	coverageDirectory: '<rootDir>/coverage-e2e',
-	// Custom reporters for better E2E test output
-	// Transform configuration to match unit tests
-	transform: {},
-	transformIgnorePatterns: ['/node_modules/'],
-	// Module configuration
-	moduleNameMapper: {
-		'^@/(.*)$': '<rootDir>/$1'
-	},
-	moduleDirectories: ['node_modules', '<rootDir>'],
-	// Reporters configuration
-	reporters: [
-		'default',
-		'jest-junit',
-		[
-			'jest-html-reporters',
-			{
-				publicPath: './test-results',
-				filename: 'index.html',
-				pageTitle: 'Task Master E2E Test Report',
-				expand: true,
-				openReport: false,
-				hideIcon: false,
-				includeFailureMsg: true,
-				enableMergeData: true,
-				dataMergeLevel: 1,
-				inlineSource: false,
-				customInfos: [
-					{
-						title: 'Environment',
-						value: 'E2E Testing'
-					},
-					{
-						title: 'Test Type',
-						value: 'CLI Commands'
-					}
-				]
-			}
-		]
-	],
-	// Environment variables for E2E tests
-	testEnvironmentOptions: {
-		env: {
-			NODE_ENV: 'test',
-			E2E_TEST: 'true'
-		}
-	}
-};

jest.e2e.projects.config.js

@@ -1,116 +0,0 @@
-/**
- * Jest configuration using projects feature to separate AI and non-AI tests
- * This allows different concurrency settings for each type
- */
-
-const baseConfig = {
-	testEnvironment: 'node',
-	testTimeout: 600000,
-	verbose: true,
-	silent: false,
-	setupFilesAfterEnv: ['<rootDir>/tests/e2e/setup/jest-setup.js'],
-	globalSetup: '<rootDir>/tests/e2e/setup/global-setup.js',
-	globalTeardown: '<rootDir>/tests/e2e/setup/global-teardown.js',
-	transform: {},
-	transformIgnorePatterns: ['/node_modules/'],
-	moduleNameMapper: {
-		'^@/(.*)$': '<rootDir>/$1'
-	},
-	moduleDirectories: ['node_modules', '<rootDir>'],
-	reporters: [
-		'default',
-		'jest-junit',
-		[
-			'jest-html-reporters',
-			{
-				publicPath: './test-results',
-				filename: 'index.html',
-				pageTitle: 'Task Master E2E Test Report',
-				expand: true,
-				openReport: false,
-				hideIcon: false,
-				includeFailureMsg: true,
-				enableMergeData: true,
-				dataMergeLevel: 1,
-				inlineSource: false
-			}
-		]
-	]
-};
-
-export default {
-	projects: [
-		{
-			...baseConfig,
-			displayName: 'Non-AI E2E Tests',
-			testMatch: [
-				'<rootDir>/tests/e2e/**/add-dependency.test.js',
-				'<rootDir>/tests/e2e/**/remove-dependency.test.js',
-				'<rootDir>/tests/e2e/**/validate-dependencies.test.js',
-				'<rootDir>/tests/e2e/**/fix-dependencies.test.js',
-				'<rootDir>/tests/e2e/**/add-subtask.test.js',
-				'<rootDir>/tests/e2e/**/remove-subtask.test.js',
-				'<rootDir>/tests/e2e/**/clear-subtasks.test.js',
-				'<rootDir>/tests/e2e/**/set-status.test.js',
-				'<rootDir>/tests/e2e/**/show.test.js',
-				'<rootDir>/tests/e2e/**/list.test.js',
-				'<rootDir>/tests/e2e/**/next.test.js',
-				'<rootDir>/tests/e2e/**/tags.test.js',
-				'<rootDir>/tests/e2e/**/add-tag.test.js',
-				'<rootDir>/tests/e2e/**/delete-tag.test.js',
-				'<rootDir>/tests/e2e/**/rename-tag.test.js',
-				'<rootDir>/tests/e2e/**/copy-tag.test.js',
-				'<rootDir>/tests/e2e/**/use-tag.test.js',
-				'<rootDir>/tests/e2e/**/init.test.js',
-				'<rootDir>/tests/e2e/**/models.test.js',
-				'<rootDir>/tests/e2e/**/move.test.js',
-				'<rootDir>/tests/e2e/**/remove-task.test.js',
-				'<rootDir>/tests/e2e/**/sync-readme.test.js',
-				'<rootDir>/tests/e2e/**/rules.test.js',
-				'<rootDir>/tests/e2e/**/lang.test.js',
-				'<rootDir>/tests/e2e/**/migrate.test.js'
-			],
-			// Non-AI tests can run with more parallelism
-			maxWorkers: 4,
-			maxConcurrency: 5
-		},
-		{
-			...baseConfig,
-			displayName: 'Light AI E2E Tests',
-			testMatch: [
-				'<rootDir>/tests/e2e/**/add-task.test.js',
-				'<rootDir>/tests/e2e/**/update-subtask.test.js',
-				'<rootDir>/tests/e2e/**/complexity-report.test.js'
-			],
-			// Light AI tests with moderate parallelism
-			maxWorkers: 3,
-			maxConcurrency: 3
-		},
-		{
-			...baseConfig,
-			displayName: 'Heavy AI E2E Tests',
-			testMatch: [
-				'<rootDir>/tests/e2e/**/update-task.test.js',
-				'<rootDir>/tests/e2e/**/expand-task.test.js',
-				'<rootDir>/tests/e2e/**/research.test.js',
-				'<rootDir>/tests/e2e/**/research-save.test.js',
-				'<rootDir>/tests/e2e/**/parse-prd.test.js',
-				'<rootDir>/tests/e2e/**/generate.test.js',
-				'<rootDir>/tests/e2e/**/analyze-complexity.test.js',
-				'<rootDir>/tests/e2e/**/update.test.js'
-			],
-			// Heavy AI tests run sequentially to avoid rate limits
-			maxWorkers: 1,
-			maxConcurrency: 1,
-			// Even longer timeout for AI operations
-			testTimeout: 900000 // 15 minutes
-		}
-	],
-	// Global settings
-	coverageDirectory: '<rootDir>/coverage-e2e',
-	collectCoverageFrom: [
-		'src/**/*.js',
-		'!src/**/*.test.js',
-		'!src/**/__tests__/**'
-	]
-};

package-lock.json

@@ -69,9 +69,6 @@
 				"ink": "^5.0.1",
 				"jest": "^29.7.0",
 				"jest-environment-node": "^29.7.0",
-				"jest-html-reporters": "^3.1.7",
-				"jest-junit": "^16.0.0",
-				"mcp-jest": "^1.0.10",
 				"mock-fs": "^5.5.0",
 				"prettier": "^3.5.3",
 				"react": "^18.3.1",
@@ -3460,9 +3457,9 @@
 			}
 		},
 		"node_modules/@modelcontextprotocol/sdk": {
-			"version": "1.15.1",
-			"resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.15.1.tgz",
-			"integrity": "sha512-W/XlN9c528yYn+9MQkVjxiTPgPxoxt+oczfjHBDsJx0+59+O7B75Zhsp0B16Xbwbz8ANISDajh6+V7nIcPMc5w==",
+			"version": "1.15.0",
+			"resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.15.0.tgz",
+			"integrity": "sha512-67hnl/ROKdb03Vuu0YOr+baKTvf1/5YBHBm9KnZdjdAh8hjt4FRCPD5ucwxGB237sBpzlqQsLy1PFu7z/ekZ9Q==",
 			"license": "MIT",
 			"dependencies": {
 				"ajv": "^6.12.6",
@@ -9700,138 +9697,6 @@
 				"fsevents": "^2.3.2"
 			}
 		},
-		"node_modules/jest-html-reporters": {
-			"version": "3.1.7",
-			"resolved": "https://registry.npmjs.org/jest-html-reporters/-/jest-html-reporters-3.1.7.tgz",
-			"integrity": "sha512-GTmjqK6muQ0S0Mnksf9QkL9X9z2FGIpNSxC52E0PHDzjPQ1XDu2+XTI3B3FS43ZiUzD1f354/5FfwbNIBzT7ew==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"fs-extra": "^10.0.0",
-				"open": "^8.0.3"
-			}
-		},
-		"node_modules/jest-html-reporters/node_modules/define-lazy-prop": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
-			"integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/jest-html-reporters/node_modules/fs-extra": {
-			"version": "10.1.0",
-			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
-			"integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"graceful-fs": "^4.2.0",
-				"jsonfile": "^6.0.1",
-				"universalify": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/jest-html-reporters/node_modules/is-docker": {
-			"version": "2.2.1",
-			"resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
-			"integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
-			"dev": true,
-			"license": "MIT",
-			"bin": {
-				"is-docker": "cli.js"
-			},
-			"engines": {
-				"node": ">=8"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/jest-html-reporters/node_modules/is-wsl": {
-			"version": "2.2.0",
-			"resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
-			"integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"is-docker": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/jest-html-reporters/node_modules/jsonfile": {
-			"version": "6.1.0",
-			"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
-			"integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"universalify": "^2.0.0"
-			},
-			"optionalDependencies": {
-				"graceful-fs": "^4.1.6"
-			}
-		},
-		"node_modules/jest-html-reporters/node_modules/open": {
-			"version": "8.4.2",
-			"resolved": "https://registry.npmjs.org/open/-/open-8.4.2.tgz",
-			"integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"define-lazy-prop": "^2.0.0",
-				"is-docker": "^2.1.1",
-				"is-wsl": "^2.2.0"
-			},
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/jest-html-reporters/node_modules/universalify": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
-			"integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 10.0.0"
-			}
-		},
-		"node_modules/jest-junit": {
-			"version": "16.0.0",
-			"resolved": "https://registry.npmjs.org/jest-junit/-/jest-junit-16.0.0.tgz",
-			"integrity": "sha512-A94mmw6NfJab4Fg/BlvVOUXzXgF0XIH6EmTgJ5NDPp4xoKq0Kr7sErb+4Xs9nZvu58pJojz5RFGpqnZYJTrRfQ==",
-			"dev": true,
-			"license": "Apache-2.0",
-			"dependencies": {
-				"mkdirp": "^1.0.4",
-				"strip-ansi": "^6.0.1",
-				"uuid": "^8.3.2",
-				"xml": "^1.0.1"
-			},
-			"engines": {
-				"node": ">=10.12.0"
-			}
-		},
-		"node_modules/jest-junit/node_modules/uuid": {
-			"version": "8.3.2",
-			"resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-			"integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
-			"dev": true,
-			"license": "MIT",
-			"bin": {
-				"uuid": "dist/bin/uuid"
-			}
-		},
 		"node_modules/jest-leak-detector": {
 			"version": "29.7.0",
 			"resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.7.0.tgz",
@@ -10861,27 +10726,6 @@
 				"node": ">= 0.4"
 			}
 		},
-		"node_modules/mcp-jest": {
-			"version": "1.0.10",
-			"resolved": "https://registry.npmjs.org/mcp-jest/-/mcp-jest-1.0.10.tgz",
-			"integrity": "sha512-gmvWzgj+p789Hofeuej60qBDfHTFn98aNfpgb+Q7a69vLSLvXBXDv2pcjYOLEuBvss/AGe26xq0WHbbX01X5AA==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@modelcontextprotocol/sdk": "^1.12.1",
-				"zod": "^3.22.0"
-			},
-			"bin": {
-				"mcp-jest": "dist/cli.js"
-			},
-			"engines": {
-				"node": ">=18"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/josharsh"
-			}
-		},
 		"node_modules/mcp-proxy": {
 			"version": "5.3.0",
 			"resolved": "https://registry.npmjs.org/mcp-proxy/-/mcp-proxy-5.3.0.tgz",
@@ -11131,19 +10975,6 @@
 				"node": ">=16 || 14 >=14.17"
 			}
 		},
-		"node_modules/mkdirp": {
-			"version": "1.0.4",
-			"resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
-			"integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
-			"dev": true,
-			"license": "MIT",
-			"bin": {
-				"mkdirp": "bin/cmd.js"
-			},
-			"engines": {
-				"node": ">=10"
-			}
-		},
 		"node_modules/mock-fs": {
 			"version": "5.5.0",
 			"resolved": "https://registry.npmjs.org/mock-fs/-/mock-fs-5.5.0.tgz",
@@ -13791,13 +13622,6 @@
 				}
 			}
 		},
-		"node_modules/xml": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/xml/-/xml-1.0.1.tgz",
-			"integrity": "sha512-huCv9IH9Tcf95zuYCsQraZtWnJvBtLVE0QHMOs8bWyZAFZNDcYjsPq1nEx8jKA9y+Beo9v+7OBPRisQTjinQMw==",
-			"dev": true,
-			"license": "MIT"
-		},
 		"node_modules/xsschema": {
 			"version": "0.3.0-beta.8",
 			"resolved": "https://registry.npmjs.org/xsschema/-/xsschema-0.3.0-beta.8.tgz",

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "task-master-ai",
-	"version": "0.20.0",
+	"version": "0.21.0",
 	"description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
 	"main": "index.js",
 	"type": "module",
@@ -15,22 +15,18 @@
 	],
 	"scripts": {
 		"test": "node --experimental-vm-modules node_modules/.bin/jest",
+		"test:fails": "node --experimental-vm-modules node_modules/.bin/jest --onlyFailures",
 		"test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
 		"test:coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
-		"test:e2e:bash": "./tests/e2e/run_e2e.sh",
-		"test:e2e:bash:analyze": "./tests/e2e/run_e2e.sh --analyze-log",
-		"e2e": "node --experimental-vm-modules node_modules/.bin/jest --config jest.e2e.config.js",
-		"e2e:watch": "node --experimental-vm-modules node_modules/.bin/jest --config jest.e2e.config.js --watch",
-		"e2e:ai": "node --experimental-vm-modules node_modules/.bin/jest --config jest.e2e.projects.config.js --selectProjects='Heavy AI E2E Tests'",
-		"e2e:non-ai": "node --experimental-vm-modules node_modules/.bin/jest --config jest.e2e.projects.config.js --selectProjects='Non-AI E2E Tests'",
-		"e2e:report": "open test-results/index.html",
+		"test:e2e": "./tests/e2e/run_e2e.sh",
+		"test:e2e-report": "./tests/e2e/run_e2e.sh --analyze-log",
 		"prepare": "chmod +x bin/task-master.js mcp-server/server.js",
 		"changeset": "changeset",
 		"release": "changeset publish",
 		"inspector": "npx @modelcontextprotocol/inspector node mcp-server/server.js",
 		"mcp-server": "node mcp-server/server.js",
-		"format": "biome format . --write",
-		"format:check": "biome format ."
+		"format-check": "biome format .",
+		"format": "biome format . --write"
 	},
 	"keywords": [
 		"claude",
@@ -91,8 +87,8 @@
 	},
 	"optionalDependencies": {
 		"@anthropic-ai/claude-code": "^1.0.25",
-		"@biomejs/cli-linux-x64": "^1.9.4",
-		"ai-sdk-provider-gemini-cli": "^0.0.4"
+		"ai-sdk-provider-gemini-cli": "^0.0.4",
+		"@biomejs/cli-linux-x64": "^1.9.4"
 	},
 	"engines": {
 		"node": ">=18.0.0"
@@ -128,9 +124,6 @@
 		"ink": "^5.0.1",
 		"jest": "^29.7.0",
 		"jest-environment-node": "^29.7.0",
-		"jest-html-reporters": "^3.1.7",
-		"jest-junit": "^16.0.0",
-		"mcp-jest": "^1.0.10",
 		"mock-fs": "^5.5.0",
 		"prettier": "^3.5.3",
 		"react": "^18.3.1",

scripts/modules/commands.js

@@ -3727,10 +3727,7 @@ Examples:
 			const taskMaster = initTaskMaster({});
 			const projectRoot = taskMaster.getProjectRoot(); // Find project root for context
 			const { response, setup } = options;
-			console.log(
-				chalk.blue('Response language set to:', JSON.stringify(options))
-			);
-			let responseLanguage = response || 'English';
+			let responseLanguage = response !== undefined ? response : 'English';
 			if (setup) {
 				console.log(
 					chalk.blue('Starting interactive response language setup...')
@@ -3772,6 +3769,7 @@ Examples:
 						`❌ Error setting response language: ${result.error.message}`
 					)
 				);
+				process.exit(1);
 			}
 		});
 

scripts/modules/supported-models.json

@@ -303,7 +303,7 @@
 				"output": 3.0
 			},
 			"allowed_roles": ["main", "fallback"],
-			"max_tokens": 16384
+			"max_tokens": 131072
 		},
 		{
 			"id": "llama-3.3-70b-versatile",

scripts/modules/task-manager/expand-task.js

@@ -40,8 +40,10 @@ const subtaskSchema = z
 			.min(10)
 			.describe('Detailed description of the subtask'),
 		dependencies: z
-			.array(z.number().int())
-			.describe('IDs of prerequisite subtasks within this expansion'),
+			.array(z.string())
+			.describe(
+				'Array of subtask dependencies within the same parent task. Use format ["parentTaskId.1", "parentTaskId.2"]. Subtasks can only depend on siblings, not external tasks.'
+			),
 		details: z.string().min(20).describe('Implementation details and guidance'),
 		status: z
 			.string()
@@ -235,12 +237,10 @@ function parseSubtasksFromText(
 			...rawSubtask,
 			id: currentId,
 			dependencies: Array.isArray(rawSubtask.dependencies)
-				? rawSubtask.dependencies
-						.map((dep) => (typeof dep === 'string' ? parseInt(dep, 10) : dep))
-						.filter(
-							(depId) =>
-								!Number.isNaN(depId) && depId >= startId && depId < currentId
-						)
+				? rawSubtask.dependencies.filter(
+						(dep) =>
+							typeof dep === 'string' && dep.startsWith(`${parentTaskId}.`)
+					)
 				: [],
 			status: 'pending'
 		};

scripts/modules/task-manager/models.js

@@ -25,6 +25,10 @@ import { findConfigPath } from '../../../src/utils/path-utils.js';
 import { log } from '../utils.js';
 import { CUSTOM_PROVIDERS } from '../../../src/constants/providers.js';
 
+// Constants
+const CONFIG_MISSING_ERROR =
+	'The configuration file is missing. Run "task-master init" to create it.';
+
 /**
  * Fetches the list of models from OpenRouter API.
  * @returns {Promise<Array|null>} A promise that resolves with the list of model IDs or null if fetch fails.
@@ -168,9 +172,7 @@ async function getModelConfiguration(options = {}) {
 	);
 
 	if (!configExists) {
-		throw new Error(
-			'The configuration file is missing. Run "task-master models --setup" to create it.'
-		);
+		throw new Error(CONFIG_MISSING_ERROR);
 	}
 
 	try {
@@ -298,9 +300,7 @@ async function getAvailableModelsList(options = {}) {
 	);
 
 	if (!configExists) {
-		throw new Error(
-			'The configuration file is missing. Run "task-master models --setup" to create it.'
-		);
+		throw new Error(CONFIG_MISSING_ERROR);
 	}
 
 	try {
@@ -391,9 +391,7 @@ async function setModel(role, modelId, options = {}) {
 	);
 
 	if (!configExists) {
-		throw new Error(
-			'The configuration file is missing. Run "task-master models --setup" to create it.'
-		);
+		throw new Error(CONFIG_MISSING_ERROR);
 	}
 
 	// Validate role

scripts/modules/task-manager/parse-prd.js

@@ -19,7 +19,6 @@ import {
 import { generateObjectService } from '../ai-services-unified.js';
 import { getDebugFlag } from '../config-manager.js';
 import { getPromptManager } from '../prompt-manager.js';
-import generateTaskFiles from './generate-task-files.js';
 import { displayAiUsageSummary } from '../ui.js';
 
 // Define the Zod schema for a SINGLE task object

scripts/modules/task-manager/response-language.js

@@ -34,7 +34,7 @@ function setResponseLanguage(lang, options = {}) {
 			error: {
 				code: 'CONFIG_MISSING',
 				message:
-					'The configuration file is missing. Run "task-master models --setup" to create it.'
+					'The configuration file is missing. Run "task-master init" to create it.'
 			}
 		};
 	}

scripts/modules/task-manager/update-tasks.js

@@ -42,7 +42,39 @@ const updatedTaskSchema = z
 		subtasks: z.array(z.any()).nullable() // Keep subtasks flexible for now
 	})
 	.strip(); // Allow potential extra fields during parsing if needed, then validate structure
+
+// Preprocessing schema that adds defaults before validation
+const preprocessTaskSchema = z.preprocess((task) => {
+	// Ensure task is an object
+	if (typeof task !== 'object' || task === null) {
+		return {};
+	}
+
+	// Return task with defaults for missing fields
+	return {
+		...task,
+		// Add defaults for required fields if missing
+		id: task.id ?? 0,
+		title: task.title ?? 'Untitled Task',
+		description: task.description ?? '',
+		status: task.status ?? 'pending',
+		dependencies: Array.isArray(task.dependencies) ? task.dependencies : [],
+		// Optional fields - preserve undefined/null distinction
+		priority: task.hasOwnProperty('priority') ? task.priority : null,
+		details: task.hasOwnProperty('details') ? task.details : null,
+		testStrategy: task.hasOwnProperty('testStrategy')
+			? task.testStrategy
+			: null,
+		subtasks: Array.isArray(task.subtasks)
+			? task.subtasks
+			: task.subtasks === null
+				? null
+				: []
+	};
+}, updatedTaskSchema);
+
 const updatedTaskArraySchema = z.array(updatedTaskSchema);
+const preprocessedTaskArraySchema = z.array(preprocessTaskSchema);
 
 /**
  * Parses an array of task objects from AI's text response.
@@ -195,32 +227,50 @@ function parseUpdatedTasksFromText(text, expectedCount, logFn, isMCP) {
 		);
 	}
 
-	// Preprocess tasks to ensure required fields have proper defaults
-	const preprocessedTasks = parsedTasks.map((task) => ({
-		...task,
-		// Ensure subtasks is always an array (not null or undefined)
-		subtasks: Array.isArray(task.subtasks) ? task.subtasks : [],
-		// Ensure status has a default value if missing
-		status: task.status || 'pending',
-		// Ensure dependencies is always an array
-		dependencies: Array.isArray(task.dependencies) ? task.dependencies : []
-	}));
+	// Log missing fields for debugging before preprocessing
+	let hasWarnings = false;
+	parsedTasks.forEach((task, index) => {
+		const missingFields = [];
+		if (!task.hasOwnProperty('id')) missingFields.push('id');
+		if (!task.hasOwnProperty('status')) missingFields.push('status');
+		if (!task.hasOwnProperty('dependencies'))
+			missingFields.push('dependencies');
 
-	const validationResult = updatedTaskArraySchema.safeParse(preprocessedTasks);
-	if (!validationResult.success) {
-		report('error', 'Parsed task array failed Zod validation.');
-		validationResult.error.errors.forEach((err) => {
-			report('error', `  - Path '${err.path.join('.')}': ${err.message}`);
-		});
-		throw new Error(
-			`AI response failed task structure validation: ${validationResult.error.message}`
+		if (missingFields.length > 0) {
+			hasWarnings = true;
+			report(
+				'warn',
+				`Task ${index} is missing fields: ${missingFields.join(', ')} - will use defaults`
+			);
+		}
+	});
+
+	if (hasWarnings) {
+		report(
+			'warn',
+			'Some tasks were missing required fields. Applying defaults...'
 		);
 	}
 
-	report('info', 'Successfully validated task structure.');
-	return validationResult.data.slice(
+	// Use the preprocessing schema to add defaults and validate
+	const preprocessResult = preprocessedTaskArraySchema.safeParse(parsedTasks);
+
+	if (!preprocessResult.success) {
+		// This should rarely happen now since preprocessing adds defaults
+		report('error', 'Failed to validate task array even after preprocessing.');
+		preprocessResult.error.errors.forEach((err) => {
+			report('error', `  - Path '${err.path.join('.')}': ${err.message}`);
+		});
+
+		throw new Error(
+			`AI response failed validation: ${preprocessResult.error.message}`
+		);
+	}
+
+	report('info', 'Successfully validated and transformed task structure.');
+	return preprocessResult.data.slice(
 		0,
-		expectedCount || validationResult.data.length
+		expectedCount || preprocessResult.data.length
 	);
 }
 

src/prompts/expand-task.json

@@ -56,17 +56,17 @@
 	"prompts": {
 		"complexity-report": {
 			"condition": "expansionPrompt",
-			"system": "You are an AI assistant helping with task breakdown. Generate {{#if (gt subtaskCount 0)}}exactly {{subtaskCount}}{{else}}an appropriate number of{{/if}} subtasks based on the provided prompt and context.\nRespond ONLY with a valid JSON object containing a single key \"subtasks\" whose value is an array of the generated subtask objects.\nEach subtask object in the array must have keys: \"id\", \"title\", \"description\", \"dependencies\", \"details\", \"status\".\nEnsure the 'id' starts from {{nextSubtaskId}} and is sequential.\nEnsure 'dependencies' only reference valid prior subtask IDs generated in this response (starting from {{nextSubtaskId}}).\nEnsure 'status' is 'pending'.\nDo not include any other text or explanation.",
+			"system": "You are an AI assistant helping with task breakdown. Generate {{#if (gt subtaskCount 0)}}exactly {{subtaskCount}}{{else}}an appropriate number of{{/if}} subtasks based on the provided prompt and context.\nRespond ONLY with a valid JSON object containing a single key \"subtasks\" whose value is an array of the generated subtask objects.\nEach subtask object in the array must have keys: \"id\", \"title\", \"description\", \"dependencies\", \"details\", \"status\".\nEnsure the 'id' starts from {{nextSubtaskId}} and is sequential.\nFor 'dependencies', use the full subtask ID format: \"{{task.id}}.1\", \"{{task.id}}.2\", etc. Only reference subtasks within this same task.\nEnsure 'status' is 'pending'.\nDo not include any other text or explanation.",
 			"user": "{{expansionPrompt}}{{#if additionalContext}}\n\n{{additionalContext}}{{/if}}{{#if complexityReasoningContext}}\n\n{{complexityReasoningContext}}{{/if}}{{#if gatheredContext}}\n\n# Project Context\n\n{{gatheredContext}}{{/if}}"
 		},
 		"research": {
 			"condition": "useResearch === true && !expansionPrompt",
 			"system": "You are an AI assistant that responds ONLY with valid JSON objects as requested. The object should contain a 'subtasks' array.",
-			"user": "Analyze the following task and break it down into {{#if (gt subtaskCount 0)}}exactly {{subtaskCount}}{{else}}an appropriate number of{{/if}} specific subtasks using your research capabilities. Assign sequential IDs starting from {{nextSubtaskId}}.\n\nParent Task:\nID: {{task.id}}\nTitle: {{task.title}}\nDescription: {{task.description}}\nCurrent details: {{#if task.details}}{{task.details}}{{else}}None{{/if}}{{#if additionalContext}}\nConsider this context: {{additionalContext}}{{/if}}{{#if complexityReasoningContext}}\nComplexity Analysis Reasoning: {{complexityReasoningContext}}{{/if}}{{#if gatheredContext}}\n\n# Project Context\n\n{{gatheredContext}}{{/if}}\n\nCRITICAL: Respond ONLY with a valid JSON object containing a single key \"subtasks\". The value must be an array of the generated subtasks, strictly matching this structure:\n\n{\n  \"subtasks\": [\n    {\n      \"id\": <number>, // Sequential ID starting from {{nextSubtaskId}}\n      \"title\": \"<string>\",\n      \"description\": \"<string>\",\n      \"dependencies\": [<number>], // e.g., [{{nextSubtaskId}} + 1]. If no dependencies, use an empty array [].\n      \"details\": \"<string>\",\n      \"testStrategy\": \"<string>\" // Optional\n    },\n    // ... (repeat for {{#if (gt subtaskCount 0)}}{{subtaskCount}}{{else}}appropriate number of{{/if}} subtasks)\n  ]\n}\n\nImportant: For the 'dependencies' field, if a subtask has no dependencies, you MUST use an empty array, for example: \"dependencies\": []. Do not use null or omit the field.\n\nDo not include ANY explanatory text, markdown, or code block markers. Just the JSON object."
+			"user": "Analyze the following task and break it down into {{#if (gt subtaskCount 0)}}exactly {{subtaskCount}}{{else}}an appropriate number of{{/if}} specific subtasks using your research capabilities. Assign sequential IDs starting from {{nextSubtaskId}}.\n\nParent Task:\nID: {{task.id}}\nTitle: {{task.title}}\nDescription: {{task.description}}\nCurrent details: {{#if task.details}}{{task.details}}{{else}}None{{/if}}{{#if additionalContext}}\nConsider this context: {{additionalContext}}{{/if}}{{#if complexityReasoningContext}}\nComplexity Analysis Reasoning: {{complexityReasoningContext}}{{/if}}{{#if gatheredContext}}\n\n# Project Context\n\n{{gatheredContext}}{{/if}}\n\nCRITICAL: Respond ONLY with a valid JSON object containing a single key \"subtasks\". The value must be an array of the generated subtasks, strictly matching this structure:\n\n{\n  \"subtasks\": [\n    {\n      \"id\": <number>, // Sequential ID starting from {{nextSubtaskId}}\n      \"title\": \"<string>\",\n      \"description\": \"<string>\",\n      \"dependencies\": [\"<string>\"], // Use full subtask IDs like [\"{{task.id}}.1\", \"{{task.id}}.2\"]. If no dependencies, use an empty array [].\n      \"details\": \"<string>\",\n      \"testStrategy\": \"<string>\" // Optional\n    },\n    // ... (repeat for {{#if (gt subtaskCount 0)}}{{subtaskCount}}{{else}}appropriate number of{{/if}} subtasks)\n  ]\n}\n\nImportant: For the 'dependencies' field, if a subtask has no dependencies, you MUST use an empty array, for example: \"dependencies\": []. Do not use null or omit the field.\n\nDo not include ANY explanatory text, markdown, or code block markers. Just the JSON object."
 		},
 		"default": {
-			"system": "You are an AI assistant helping with task breakdown for software development.\nYou need to break down a high-level task into {{#if (gt subtaskCount 0)}}{{subtaskCount}}{{else}}an appropriate number of{{/if}} specific subtasks that can be implemented one by one.\n\nSubtasks should:\n1. Be specific and actionable implementation steps\n2. Follow a logical sequence\n3. Each handle a distinct part of the parent task\n4. Include clear guidance on implementation approach\n5. Have appropriate dependency chains between subtasks (using the new sequential IDs)\n6. Collectively cover all aspects of the parent task\n\nFor each subtask, provide:\n- id: Sequential integer starting from the provided nextSubtaskId\n- title: Clear, specific title\n- description: Detailed description\n- dependencies: Array of prerequisite subtask IDs (use the new sequential IDs)\n- details: Implementation details, the output should be in string\n- testStrategy: Optional testing approach\n\nRespond ONLY with a valid JSON object containing a single key \"subtasks\" whose value is an array matching the structure described. Do not include any explanatory text, markdown formatting, or code block markers.",
-			"user": "Break down this task into {{#if (gt subtaskCount 0)}}exactly {{subtaskCount}}{{else}}an appropriate number of{{/if}} specific subtasks:\n\nTask ID: {{task.id}}\nTitle: {{task.title}}\nDescription: {{task.description}}\nCurrent details: {{#if task.details}}{{task.details}}{{else}}None{{/if}}{{#if additionalContext}}\nAdditional context: {{additionalContext}}{{/if}}{{#if complexityReasoningContext}}\nComplexity Analysis Reasoning: {{complexityReasoningContext}}{{/if}}{{#if gatheredContext}}\n\n# Project Context\n\n{{gatheredContext}}{{/if}}\n\nReturn ONLY the JSON object containing the \"subtasks\" array, matching this structure:\n\n{\n  \"subtasks\": [\n    {\n      \"id\": {{nextSubtaskId}}, // First subtask ID\n      \"title\": \"Specific subtask title\",\n      \"description\": \"Detailed description\",\n      \"dependencies\": [], // e.g., [{{nextSubtaskId}} + 1] if it depends on the next\n      \"details\": \"Implementation guidance\",\n      \"testStrategy\": \"Optional testing approach\"\n    },\n    // ... (repeat for {{#if (gt subtaskCount 0)}}a total of {{subtaskCount}}{{else}}an appropriate number of{{/if}} subtasks with sequential IDs)\n  ]\n}"
+			"system": "You are an AI assistant helping with task breakdown for software development.\nYou need to break down a high-level task into {{#if (gt subtaskCount 0)}}{{subtaskCount}}{{else}}an appropriate number of{{/if}} specific subtasks that can be implemented one by one.\n\nSubtasks should:\n1. Be specific and actionable implementation steps\n2. Follow a logical sequence\n3. Each handle a distinct part of the parent task\n4. Include clear guidance on implementation approach\n5. Have appropriate dependency chains between subtasks (using full subtask IDs)\n6. Collectively cover all aspects of the parent task\n\nFor each subtask, provide:\n- id: Sequential integer starting from the provided nextSubtaskId\n- title: Clear, specific title\n- description: Detailed description\n- dependencies: Array of prerequisite subtask IDs using full format like [\"{{task.id}}.1\", \"{{task.id}}.2\"]\n- details: Implementation details, the output should be in string\n- testStrategy: Optional testing approach\n\nRespond ONLY with a valid JSON object containing a single key \"subtasks\" whose value is an array matching the structure described. Do not include any explanatory text, markdown formatting, or code block markers.",
+			"user": "Break down this task into {{#if (gt subtaskCount 0)}}exactly {{subtaskCount}}{{else}}an appropriate number of{{/if}} specific subtasks:\n\nTask ID: {{task.id}}\nTitle: {{task.title}}\nDescription: {{task.description}}\nCurrent details: {{#if task.details}}{{task.details}}{{else}}None{{/if}}{{#if additionalContext}}\nAdditional context: {{additionalContext}}{{/if}}{{#if complexityReasoningContext}}\nComplexity Analysis Reasoning: {{complexityReasoningContext}}{{/if}}{{#if gatheredContext}}\n\n# Project Context\n\n{{gatheredContext}}{{/if}}\n\nReturn ONLY the JSON object containing the \"subtasks\" array, matching this structure:\n\n{\n  \"subtasks\": [\n    {\n      \"id\": {{nextSubtaskId}}, // First subtask ID\n      \"title\": \"Specific subtask title\",\n      \"description\": \"Detailed description\",\n      \"dependencies\": [], // e.g., [\"{{task.id}}.1\", \"{{task.id}}.2\"] for dependencies. Use empty array [] if no dependencies\n      \"details\": \"Implementation guidance\",\n      \"testStrategy\": \"Optional testing approach\"\n    },\n    // ... (repeat for {{#if (gt subtaskCount 0)}}a total of {{subtaskCount}}{{else}}an appropriate number of{{/if}} subtasks with sequential IDs)\n  ]\n}"
 		}
 	}
 }

src/prompts/update-tasks.json

@@ -31,8 +31,8 @@
 	},
 	"prompts": {
 		"default": {
-			"system": "You are an AI assistant helping to update software development tasks based on new context.\nYou will be given a set of tasks and a prompt describing changes or new implementation details.\nYour job is to update the tasks to reflect these changes, while preserving their basic structure.\n\nGuidelines:\n1. Maintain the same IDs, statuses, and dependencies unless specifically mentioned in the prompt\n2. Update titles, descriptions, details, and test strategies to reflect the new information\n3. Do not change anything unnecessarily - just adapt what needs to change based on the prompt\n4. You should return ALL the tasks in order, not just the modified ones\n5. Return a complete valid JSON object with the updated tasks array\n6. VERY IMPORTANT: Preserve all subtasks marked as \"done\" or \"completed\" - do not modify their content\n7. For tasks with completed subtasks, build upon what has already been done rather than rewriting everything\n8. If an existing completed subtask needs to be changed/undone based on the new context, DO NOT modify it directly\n9. Instead, add a new subtask that clearly indicates what needs to be changed or replaced\n10. Use the existence of completed subtasks as an opportunity to make new subtasks more specific and targeted\n\nThe changes described in the prompt should be applied to ALL tasks in the list.",
-			"user": "Here are the tasks to update:\n{{{json tasks}}}\n\nPlease update these tasks based on the following new context:\n{{updatePrompt}}\n\nIMPORTANT: In the tasks JSON above, any subtasks with \"status\": \"done\" or \"status\": \"completed\" should be preserved exactly as is. Build your changes around these completed items.{{#if projectContext}}\n\n# Project Context\n\n{{projectContext}}{{/if}}\n\nReturn only the updated tasks as a valid JSON array."
+			"system": "You are an AI assistant helping to update software development tasks based on new context.\nYou will be given a set of tasks and a prompt describing changes or new implementation details.\nYour job is to update the tasks to reflect these changes, while preserving their basic structure.\n\nCRITICAL RULES:\n1. Return ONLY a JSON array - no explanations, no markdown, no additional text before or after\n2. Each task MUST have ALL fields from the original (do not omit any fields)\n3. Maintain the same IDs, statuses, and dependencies unless specifically mentioned in the prompt\n4. Update titles, descriptions, details, and test strategies to reflect the new information\n5. Do not change anything unnecessarily - just adapt what needs to change based on the prompt\n6. You should return ALL the tasks in order, not just the modified ones\n7. Return a complete valid JSON array with all tasks\n8. VERY IMPORTANT: Preserve all subtasks marked as \"done\" or \"completed\" - do not modify their content\n9. For tasks with completed subtasks, build upon what has already been done rather than rewriting everything\n10. If an existing completed subtask needs to be changed/undone based on the new context, DO NOT modify it directly\n11. Instead, add a new subtask that clearly indicates what needs to be changed or replaced\n12. Use the existence of completed subtasks as an opportunity to make new subtasks more specific and targeted\n\nThe changes described in the prompt should be applied to ALL tasks in the list.",
+			"user": "Here are the tasks to update:\n{{{json tasks}}}\n\nPlease update these tasks based on the following new context:\n{{updatePrompt}}\n\nIMPORTANT: In the tasks JSON above, any subtasks with \"status\": \"done\" or \"status\": \"completed\" should be preserved exactly as is. Build your changes around these completed items.{{#if projectContext}}\n\n# Project Context\n\n{{projectContext}}{{/if}}\n\nRequired JSON structure for EACH task (ALL fields MUST be present):\n{\n  \"id\": <number>,\n  \"title\": <string>,\n  \"description\": <string>,\n  \"status\": <string>,\n  \"dependencies\": <array>,\n  \"priority\": <string or null>,\n  \"details\": <string or null>,\n  \"testStrategy\": <string or null>,\n  \"subtasks\": <array or null>\n}\n\nReturn a valid JSON array containing ALL the tasks with ALL their fields:\n- id (number) - preserve existing value\n- title (string)\n- description (string)\n- status (string) - preserve existing value unless explicitly changing\n- dependencies (array) - preserve existing value unless explicitly changing\n- priority (string or null)\n- details (string or null)\n- testStrategy (string or null)\n- subtasks (array or null)\n\nReturn ONLY the JSON array now:"
 		}
 	}
 }

src/task-master.js

@@ -17,6 +17,7 @@ import {
 	LEGACY_CONFIG_FILE,
 	COMPLEXITY_REPORT_FILE
 } from './constants/paths.js';
+import { findProjectRoot } from './utils/path-utils.js';
 
 /**
  * TaskMaster class manages all the paths for the application.
@@ -159,22 +160,6 @@ export class TaskMaster {
  * @returns {TaskMaster} An initialized TaskMaster instance.
  */
 export function initTaskMaster(overrides = {}) {
-	const findProjectRoot = (startDir = process.cwd()) => {
-		const projectMarkers = [TASKMASTER_DIR, LEGACY_CONFIG_FILE];
-		let currentDir = path.resolve(startDir);
-		const rootDir = path.parse(currentDir).root;
-		while (currentDir !== rootDir) {
-			for (const marker of projectMarkers) {
-				const markerPath = path.join(currentDir, marker);
-				if (fs.existsSync(markerPath)) {
-					return currentDir;
-				}
-			}
-			currentDir = path.dirname(currentDir);
-		}
-		return null;
-	};
-
 	const resolvePath = (
 		pathType,
 		override,
@@ -264,13 +249,8 @@ export function initTaskMaster(overrides = {}) {
 
 		paths.projectRoot = resolvedOverride;
 	} else {
-		const foundRoot = findProjectRoot();
-		if (!foundRoot) {
-			throw new Error(
-				'Unable to find project root. No project markers found. Run "init" command first.'
-			);
-		}
-		paths.projectRoot = foundRoot;
+		// findProjectRoot now always returns a value (fallback to cwd)
+		paths.projectRoot = findProjectRoot();
 	}
 
 	// TaskMaster Directory

src/utils/path-utils.js

@@ -66,8 +66,10 @@ export function findProjectRoot(startDir = process.cwd()) {
 
 	let currentDir = path.resolve(startDir);
 	const rootDir = path.parse(currentDir).root;
+	const maxDepth = 50; // Reasonable limit to prevent infinite loops
+	let depth = 0;
 
-	while (currentDir !== rootDir) {
+	while (currentDir !== rootDir && depth < maxDepth) {
 		// Check if current directory contains any project markers
 		for (const marker of projectMarkers) {
 			const markerPath = path.join(currentDir, marker);
@@ -76,9 +78,11 @@ export function findProjectRoot(startDir = process.cwd()) {
 			}
 		}
 		currentDir = path.dirname(currentDir);
+		depth++;
 	}
 
-	return null;
+	// Fallback to current working directory if no project root found
+	return process.cwd();
 }
 
 /**

tests/e2e/README.md

@@ -1,204 +0,0 @@
-# Task Master E2E Tests
-
-This directory contains the modern end-to-end test suite for Task Master AI. The JavaScript implementation provides parallel execution, better error handling, and improved maintainability compared to the legacy bash script.
-
-## Features
-
-- **Parallel Execution**: Run test groups concurrently for faster test completion
-- **Modular Architecture**: Tests are organized into logical groups (setup, core, providers, advanced)
-- **Comprehensive Logging**: Detailed logs with timestamps, cost tracking, and color-coded output
-- **LLM Analysis**: Automatic analysis of test results using AI
-- **Error Handling**: Robust error handling with categorization and recommendations
-- **Flexible Configuration**: Easy to configure test settings and provider configurations
-
-## Structure
-
-```
-tests/e2e/
-├── config/
-│   └── test-config.js      # Test configuration and settings
-├── utils/
-│   ├── logger.js           # Test logging utilities
-│   ├── test-helpers.js     # Common test helper functions
-│   ├── llm-analyzer.js     # LLM-based log analysis
-│   └── error-handler.js    # Error handling and reporting
-├── tests/
-│   ├── setup.test.js       # Setup and initialization tests
-│   ├── core.test.js        # Core task management tests
-│   ├── providers.test.js   # Multi-provider tests
-│   └── advanced.test.js    # Advanced feature tests
-├── runners/
-│   ├── parallel-runner.js  # Parallel test execution
-│   └── test-worker.js      # Worker thread for parallel execution
-├── run-e2e-tests.js        # Main test runner
-├── run_e2e.sh              # Legacy bash implementation
-└── e2e_helpers.sh          # Legacy bash helpers
-```
-
-## Usage
-
-### Run All Tests (Recommended)
-
-```bash
-# Runs all test groups in the correct order
-npm run test:e2e
-```
-
-### Run Tests Sequentially
-
-```bash
-# Runs all test groups sequentially instead of in parallel
-npm run test:e2e:sequential
-```
-
-### Run Individual Test Groups
-
-Each test command automatically handles setup if needed, creating a fresh test directory:
-
-```bash
-# Each command creates its own test environment automatically
-npm run test:e2e:setup      # Setup only (initialize, parse PRD, analyze complexity)
-npm run test:e2e:core       # Auto-runs setup + core tests (task CRUD, dependencies, status)
-npm run test:e2e:providers  # Auto-runs setup + provider tests (multi-provider testing)
-npm run test:e2e:advanced   # Auto-runs setup + advanced tests (tags, subtasks, expand)
-```
-
-**Note**: Each command creates a fresh test directory, so running individual tests will not share state. This ensures test isolation but means each run will parse the PRD and set up from scratch.
-
-### Run Multiple Groups
-
-```bash
-# Specify multiple groups to run together
-node tests/e2e/run-e2e-tests.js --groups core,providers
-
-# This automatically runs setup first if needed
-node tests/e2e/run-e2e-tests.js --groups providers,advanced
-```
-
-### Run Tests Against Existing Directory
-
-If you want to reuse a test directory from a previous run:
-
-```bash
-# First, find your test directory from a previous run:
-ls tests/e2e/_runs/
-
-# Then run specific tests against that directory:
-node tests/e2e/run-e2e-tests.js --groups core --test-dir tests/e2e/_runs/run_2025-07-03_094800611
-```
-
-### Analyze Existing Log
-```bash
-npm run test:e2e:analyze
-
-# Or analyze specific log file
-node tests/e2e/run-e2e-tests.js --analyze-log path/to/log.log
-```
-
-### Skip Verification Tests
-```bash
-node tests/e2e/run-e2e-tests.js --skip-verification
-```
-
-### Run Legacy Bash Tests
-```bash
-npm run test:e2e:bash
-```
-
-## Test Groups
-
-### Setup (`setup`)
-- NPM global linking
-- Project initialization
-- PRD parsing
-- Complexity analysis
-
-### Core (`core`)
-- Task CRUD operations
-- Dependency management
-- Status management
-- Subtask operations
-
-### Providers (`providers`)
-- Multi-provider add-task testing
-- Provider comparison
-- Model switching
-- Error handling per provider
-
-### Advanced (`advanced`)
-- Tag management
-- Model configuration
-- Task expansion
-- File generation
-
-## Configuration
-
-Edit `config/test-config.js` to customize:
-
-- Test paths and directories
-- Provider configurations
-- Test prompts
-- Parallel execution settings
-- LLM analysis settings
-
-## Output
-
-- **Log Files**: Saved to `tests/e2e/log/` with timestamp
-- **Test Artifacts**: Created in `tests/e2e/_runs/run_TIMESTAMP/`
-- **Console Output**: Color-coded with progress indicators
-- **Cost Tracking**: Automatic tracking of AI API costs
-
-## Requirements
-
-- Node.js >= 18.0.0
-- Dependencies: chalk, boxen, dotenv, node-fetch
-- System utilities: jq, bc
-- Valid API keys in `.env` file
-
-## Comparison with Bash Tests
-
-| Feature | Bash Script | JavaScript |
-|---------|------------|------------|
-| Parallel Execution | ❌ | ✅ |
-| Error Categorization | Basic | Advanced |
-| Test Isolation | Limited | Full |
-| Performance | Slower | Faster |
-| Debugging | Harder | Easier |
-| Cross-platform | Limited | Better |
-
-## Troubleshooting
-
-1. **Missing Dependencies**: Install system utilities with `brew install jq bc` (macOS) or `apt-get install jq bc` (Linux)
-2. **API Errors**: Check `.env` file for valid API keys
-3. **Permission Errors**: Ensure proper file permissions
-4. **Timeout Issues**: Adjust timeout in config file
-
-## Development
-
-To add new tests:
-
-1. Create a new test file in `tests/` directory
-2. Export a default async function that accepts (logger, helpers, context)
-3. Return a results object with status and errors
-4. Add the test to appropriate group in `test-config.js`
-
-Example test structure:
-```javascript
-export default async function myTest(logger, helpers, context) {
-  const results = {
-    status: 'passed',
-    errors: []
-  };
-
-  try {
-    logger.step('Running my test');
-    // Test implementation
-    logger.success('Test passed');
-  } catch (error) {
-    results.status = 'failed';
-    results.errors.push(error.message);
-  }
-
-  return results;
-}
-```

tests/e2e/TEST-REPORTS.md

@@ -1,81 +0,0 @@
-# E2E Test Reports
-
-Task Master's E2E tests now generate comprehensive test reports using Jest Stare, providing an interactive and visually appealing test report similar to Playwright's reporting capabilities.
-
-## Test Report Formats
-
-When you run `npm run test:e2e:jest`, the following reports are generated:
-
-### 1. Jest Stare HTML Report
-- **Location**: `test-results/index.html`
-- **Features**:
-  - Interactive dashboard with charts and graphs
-  - Test execution timeline and performance metrics
-  - Detailed failure messages with stack traces
-  - Console output for each test
-  - Search and filter capabilities
-  - Pass/Fail/Skip statistics with visual charts
-  - Test duration analysis
-  - Collapsible test suites
-  - Coverage link integration
-  - Summary statistics
-
-### 2. JSON Results
-- **Location**: `test-results/jest-results.json`
-- **Use Cases**:
-  - Programmatic access to test results
-  - Custom reporting tools
-  - Test result analysis
-
-### 3. JUnit XML Report
-- **Location**: `test-results/e2e-junit.xml`
-- **Use Cases**:
-  - CI/CD integration
-  - Test result parsing
-  - Historical tracking
-
-### 4. Console Output
-- Standard Jest terminal output with verbose mode enabled
-
-## Running Tests with Reports
-
-```bash
-# Run all E2E tests and generate reports
-npm run test:e2e:jest
-
-# View the HTML report
-npm run test:e2e:jest:report
-
-# Run specific tests
-npm run test:e2e:jest:command "add-task"
-```
-
-## Report Configuration
-
-The report configuration is defined in `jest.e2e.config.js`:
-
-- **HTML Reporter**: Includes failure messages, console logs, and execution warnings
-- **JUnit Reporter**: Includes console output and suite errors
-- **Coverage**: Separate coverage directory at `coverage-e2e/`
-
-## CI/CD Integration
-
-The JUnit XML report can be consumed by CI tools like:
-- Jenkins (JUnit plugin)
-- GitHub Actions (test-reporter action)
-- GitLab CI (artifact reports)
-- CircleCI (test results)
-
-## Ignored Files
-
-The following are automatically ignored by git:
-- `test-results/` directory
-- `coverage-e2e/` directory
-- Individual report files
-
-## Viewing Historical Results
-
-To keep historical test results:
-1. Copy the `test-results` directory before running new tests
-2. Use a timestamp suffix: `test-results-2024-01-15/`
-3. Compare HTML reports side by side

tests/e2e/config/test-config.js

@@ -1,72 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { config as dotenvConfig } from 'dotenv';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Load environment variables
-const projectRoot = join(__dirname, '../../..');
-dotenvConfig({ path: join(projectRoot, '.env') });
-
-export const testConfig = {
-	// Paths
-	paths: {
-		projectRoot,
-		sourceDir: projectRoot,
-		baseTestDir: join(projectRoot, 'tests/e2e/_runs'),
-		logDir: join(projectRoot, 'tests/e2e/log'),
-		samplePrdSource: join(projectRoot, 'tests/fixtures/sample-prd.txt'),
-		mainEnvFile: join(projectRoot, '.env'),
-		supportedModelsFile: join(
-			projectRoot,
-			'scripts/modules/supported-models.json'
-		)
-	},
-
-	// Test settings
-	settings: {
-		runVerificationTest: true,
-		parallelTestGroups: 4, // Number of parallel test groups
-		timeout: 600000, // 10 minutes default timeout
-		retryAttempts: 2
-	},
-
-	// Provider test configuration
-	providers: [
-		{ name: 'anthropic', model: 'claude-3-7-sonnet-20250219', flags: [] },
-		{ name: 'openai', model: 'gpt-4o', flags: [] },
-		{ name: 'google', model: 'gemini-2.5-pro-preview-05-06', flags: [] },
-		{ name: 'perplexity', model: 'sonar-pro', flags: [] },
-		{ name: 'xai', model: 'grok-3', flags: [] },
-		{ name: 'openrouter', model: 'anthropic/claude-3.7-sonnet', flags: [] }
-	],
-
-	// Test prompts
-	prompts: {
-		addTask:
-			'Create a task to implement user authentication using OAuth 2.0 with Google as the provider. Include steps for registering the app, handling the callback, and storing user sessions.',
-		updateTask:
-			'Update backend server setup: Ensure CORS is configured to allow requests from the frontend origin.',
-		updateFromTask:
-			'Refactor the backend storage module to use a simple JSON file (storage.json) instead of an in-memory object for persistence. Update relevant tasks.',
-		updateSubtask:
-			'Implementation note: Remember to handle potential API errors and display a user-friendly message.'
-	},
-
-	// LLM Analysis settings
-	llmAnalysis: {
-		enabled: true,
-		model: 'claude-3-7-sonnet-20250219',
-		provider: 'anthropic',
-		maxTokens: 3072
-	}
-};
-
-// Export test groups for parallel execution
-export const testGroups = {
-	setup: ['setup'],
-	core: ['core'],
-	providers: ['providers'],
-	advanced: ['advanced']
-};

tests/e2e/runners/parallel-runner.js

@@ -1,225 +0,0 @@
-import { Worker } from 'worker_threads';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { EventEmitter } from 'events';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export class ParallelTestRunner extends EventEmitter {
-	constructor(logger) {
-		super();
-		this.logger = logger;
-		this.workers = [];
-		this.results = {};
-	}
-
-	/**
-	 * Run test groups in parallel
-	 * @param {Object} testGroups - Groups of tests to run
-	 * @param {Object} sharedContext - Shared context for all tests
-	 * @returns {Promise<Object>} Combined results from all test groups
-	 */
-	async runTestGroups(testGroups, sharedContext) {
-		const groupNames = Object.keys(testGroups);
-		const workerPromises = [];
-
-		this.logger.info(
-			`Starting parallel execution of ${groupNames.length} test groups`
-		);
-
-		for (const groupName of groupNames) {
-			const workerPromise = this.runTestGroup(
-				groupName,
-				testGroups[groupName],
-				sharedContext
-			);
-			workerPromises.push(workerPromise);
-		}
-
-		// Wait for all workers to complete
-		const results = await Promise.allSettled(workerPromises);
-
-		// Process results
-		const combinedResults = {
-			overall: 'passed',
-			groups: {},
-			summary: {
-				totalGroups: groupNames.length,
-				passedGroups: 0,
-				failedGroups: 0,
-				errors: []
-			}
-		};
-
-		results.forEach((result, index) => {
-			const groupName = groupNames[index];
-
-			if (result.status === 'fulfilled') {
-				combinedResults.groups[groupName] = result.value;
-				if (result.value.status === 'passed') {
-					combinedResults.summary.passedGroups++;
-				} else {
-					combinedResults.summary.failedGroups++;
-					combinedResults.overall = 'failed';
-				}
-			} else {
-				combinedResults.groups[groupName] = {
-					status: 'failed',
-					error: result.reason.message || 'Unknown error'
-				};
-				combinedResults.summary.failedGroups++;
-				combinedResults.summary.errors.push({
-					group: groupName,
-					error: result.reason.message
-				});
-				combinedResults.overall = 'failed';
-			}
-		});
-
-		return combinedResults;
-	}
-
-	/**
-	 * Run a single test group in a worker thread
-	 */
-	async runTestGroup(groupName, testModules, sharedContext) {
-		return new Promise((resolve, reject) => {
-			const workerPath = join(__dirname, 'test-worker.js');
-
-			const worker = new Worker(workerPath, {
-				workerData: {
-					groupName,
-					testModules,
-					sharedContext,
-					logDir: this.logger.logDir,
-					testRunId: this.logger.testRunId
-				}
-			});
-
-			this.workers.push(worker);
-
-			// Handle messages from worker
-			worker.on('message', (message) => {
-				if (message.type === 'log') {
-					const level = message.level.toLowerCase();
-					if (typeof this.logger[level] === 'function') {
-						this.logger[level](message.message);
-					} else {
-						// Fallback to info if the level doesn't exist
-						this.logger.info(message.message);
-					}
-				} else if (message.type === 'step') {
-					this.logger.step(message.message);
-				} else if (message.type === 'cost') {
-					this.logger.addCost(message.cost);
-				} else if (message.type === 'results') {
-					this.results[groupName] = message.results;
-				}
-			});
-
-			// Handle worker completion
-			worker.on('exit', (code) => {
-				this.workers = this.workers.filter((w) => w !== worker);
-
-				if (code === 0) {
-					resolve(
-						this.results[groupName] || { status: 'passed', group: groupName }
-					);
-				} else {
-					reject(
-						new Error(`Worker for group ${groupName} exited with code ${code}`)
-					);
-				}
-			});
-
-			// Handle worker errors
-			worker.on('error', (error) => {
-				this.workers = this.workers.filter((w) => w !== worker);
-				reject(error);
-			});
-		});
-	}
-
-	/**
-	 * Terminate all running workers
-	 */
-	async terminate() {
-		const terminationPromises = this.workers.map((worker) =>
-			worker
-				.terminate()
-				.catch((err) =>
-					this.logger.warning(`Failed to terminate worker: ${err.message}`)
-				)
-		);
-
-		await Promise.all(terminationPromises);
-		this.workers = [];
-	}
-}
-
-/**
- * Sequential test runner for comparison or fallback
- */
-export class SequentialTestRunner {
-	constructor(logger, helpers) {
-		this.logger = logger;
-		this.helpers = helpers;
-	}
-
-	/**
-	 * Run tests sequentially
-	 */
-	async runTests(testModules, context) {
-		const results = {
-			overall: 'passed',
-			tests: {},
-			summary: {
-				totalTests: testModules.length,
-				passedTests: 0,
-				failedTests: 0,
-				errors: []
-			}
-		};
-
-		for (const testModule of testModules) {
-			try {
-				this.logger.step(`Running ${testModule} tests`);
-
-				// Dynamic import of test module
-				const testPath = join(
-					dirname(__dirname),
-					'tests',
-					`${testModule}.test.js`
-				);
-				const { default: testFn } = await import(testPath);
-
-				// Run the test
-				const testResults = await testFn(this.logger, this.helpers, context);
-
-				results.tests[testModule] = testResults;
-
-				if (testResults.status === 'passed') {
-					results.summary.passedTests++;
-				} else {
-					results.summary.failedTests++;
-					results.overall = 'failed';
-				}
-			} catch (error) {
-				this.logger.error(`Failed to run ${testModule}: ${error.message}`);
-				results.tests[testModule] = {
-					status: 'failed',
-					error: error.message
-				};
-				results.summary.failedTests++;
-				results.summary.errors.push({
-					test: testModule,
-					error: error.message
-				});
-				results.overall = 'failed';
-			}
-		}
-
-		return results;
-	}
-}

tests/e2e/runners/test-worker.js

@@ -1,135 +0,0 @@
-import { parentPort, workerData } from 'worker_threads';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { TestLogger } from '../utils/logger.js';
-import { TestHelpers } from '../utils/test-helpers.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Worker logger that sends messages to parent
-class WorkerLogger extends TestLogger {
-	constructor(logDir, testRunId, groupName) {
-		super(logDir, `${testRunId}_${groupName}`);
-		this.groupName = groupName;
-	}
-
-	log(level, message, options = {}) {
-		super.log(level, message, options);
-
-		// Send log to parent
-		parentPort.postMessage({
-			type: 'log',
-			level: level.toLowerCase(),
-			message: `[${this.groupName}] ${message}`
-		});
-	}
-
-	step(message) {
-		super.step(message);
-
-		parentPort.postMessage({
-			type: 'step',
-			message: `[${this.groupName}] ${message}`
-		});
-	}
-
-	addCost(cost) {
-		super.addCost(cost);
-
-		parentPort.postMessage({
-			type: 'cost',
-			cost
-		});
-	}
-}
-
-// Main worker execution
-async function runTestGroup() {
-	const { groupName, testModules, sharedContext, logDir, testRunId } =
-		workerData;
-
-	const logger = new WorkerLogger(logDir, testRunId, groupName);
-	const helpers = new TestHelpers(logger);
-
-	logger.info(`Worker started for test group: ${groupName}`);
-
-	const results = {
-		group: groupName,
-		status: 'passed',
-		tests: {},
-		errors: [],
-		startTime: Date.now()
-	};
-
-	try {
-		// Run each test module in the group
-		for (const testModule of testModules) {
-			try {
-				logger.info(`Running test: ${testModule}`);
-
-				// Dynamic import of test module
-				const testPath = join(
-					dirname(__dirname),
-					'tests',
-					`${testModule}.test.js`
-				);
-				const { default: testFn } = await import(testPath);
-
-				// Run the test with shared context
-				const testResults = await testFn(logger, helpers, sharedContext);
-
-				results.tests[testModule] = testResults;
-
-				if (testResults.status !== 'passed') {
-					results.status = 'failed';
-					if (testResults.errors) {
-						results.errors.push(...testResults.errors);
-					}
-				}
-			} catch (error) {
-				logger.error(`Test ${testModule} failed: ${error.message}`);
-				results.tests[testModule] = {
-					status: 'failed',
-					error: error.message,
-					stack: error.stack
-				};
-				results.status = 'failed';
-				results.errors.push({
-					test: testModule,
-					error: error.message
-				});
-			}
-		}
-	} catch (error) {
-		logger.error(`Worker error: ${error.message}`);
-		results.status = 'failed';
-		results.errors.push({
-			group: groupName,
-			error: error.message,
-			stack: error.stack
-		});
-	}
-
-	results.endTime = Date.now();
-	results.duration = results.endTime - results.startTime;
-
-	// Flush logs and get summary
-	logger.flush();
-	const summary = logger.getSummary();
-	results.summary = summary;
-
-	// Send results to parent
-	parentPort.postMessage({
-		type: 'results',
-		results
-	});
-
-	logger.info(`Worker completed for test group: ${groupName}`);
-}
-
-// Run the test group
-runTestGroup().catch((error) => {
-	console.error('Worker fatal error:', error);
-	process.exit(1);
-});

tests/e2e/setup/global-setup.js

@@ -1,59 +0,0 @@
-/**
- * Global setup for E2E tests
- * Runs once before all test suites
- */
-
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export default async () => {
-	// Silent mode for cleaner output
-	if (!process.env.JEST_SILENT_REPORTER) {
-		console.log('\n🚀 Setting up E2E test environment...\n');
-	}
-
-	try {
-		// Ensure task-master is linked globally
-		const projectRoot = join(__dirname, '../../..');
-		if (!process.env.JEST_SILENT_REPORTER) {
-			console.log('📦 Linking task-master globally...');
-		}
-		execSync('npm link', {
-			cwd: projectRoot,
-			stdio: 'inherit'
-		});
-
-		// Verify .env file exists
-		const envPath = join(projectRoot, '.env');
-		if (!existsSync(envPath)) {
-			console.warn(
-				'⚠️  Warning: .env file not found. Some tests may fail without API keys.'
-			);
-		} else {
-			if (!process.env.JEST_SILENT_REPORTER) {
-				console.log('✅ .env file found');
-			}
-		}
-
-		// Verify task-master command is available
-		try {
-			execSync('task-master --version', { stdio: 'pipe' });
-			if (!process.env.JEST_SILENT_REPORTER) {
-				console.log('✅ task-master command is available\n');
-			}
-		} catch (error) {
-			throw new Error(
-				'task-master command not found. Please ensure npm link succeeded.'
-			);
-		}
-	} catch (error) {
-		console.error('❌ Global setup failed:', error.message);
-		throw error;
-	}
-};

tests/e2e/setup/global-teardown.js

@@ -1,14 +0,0 @@
-/**
- * Global teardown for E2E tests
- * Runs once after all test suites
- */
-
-export default async () => {
-	// Silent mode for cleaner output
-	if (!process.env.JEST_SILENT_REPORTER) {
-		console.log('\n🧹 Cleaning up E2E test environment...\n');
-	}
-
-	// Any global cleanup needed
-	// Note: Individual test directories are cleaned up in afterEach hooks
-};

tests/e2e/setup/jest-setup.js

@@ -1,91 +0,0 @@
-/**
- * Jest setup file for E2E tests
- * Runs before each test file
- */
-
-import { jest, expect, afterAll } from '@jest/globals';
-import { TestHelpers } from '../utils/test-helpers.js';
-import { TestLogger } from '../utils/logger.js';
-
-// Increase timeout for all E2E tests (can be overridden per test)
-jest.setTimeout(600000);
-
-// Add custom matchers for CLI testing
-expect.extend({
-	toContainTaskId(received) {
-		const taskIdRegex = /#?\d+/;
-		const pass = taskIdRegex.test(received);
-
-		if (pass) {
-			return {
-				message: () => `expected ${received} not to contain a task ID`,
-				pass: true
-			};
-		} else {
-			return {
-				message: () => `expected ${received} to contain a task ID (e.g., #123)`,
-				pass: false
-			};
-		}
-	},
-
-	toHaveExitCode(received, expected) {
-		const pass = received.exitCode === expected;
-
-		if (pass) {
-			return {
-				message: () => `expected exit code not to be ${expected}`,
-				pass: true
-			};
-		} else {
-			return {
-				message: () =>
-					`expected exit code ${expected} but got ${received.exitCode}\nstderr: ${received.stderr}`,
-				pass: false
-			};
-		}
-	},
-
-	toContainInOutput(received, expected) {
-		const output = (received.stdout || '') + (received.stderr || '');
-		const pass = output.includes(expected);
-
-		if (pass) {
-			return {
-				message: () => `expected output not to contain "${expected}"`,
-				pass: true
-			};
-		} else {
-			return {
-				message: () =>
-					`expected output to contain "${expected}"\nstdout: ${received.stdout}\nstderr: ${received.stderr}`,
-				pass: false
-			};
-		}
-	}
-});
-
-// Global test helpers
-global.TestHelpers = TestHelpers;
-global.TestLogger = TestLogger;
-
-// Helper to create test context
-import { mkdtempSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-global.createTestContext = (testName) => {
-	// Create a proper log directory in temp for tests
-	const testLogDir = mkdtempSync(join(tmpdir(), `task-master-test-logs-${testName}-`));
-	const testRunId = Date.now().toString();
-	
-	const logger = new TestLogger(testLogDir, testRunId);
-	const helpers = new TestHelpers(logger);
-	return { logger, helpers };
-};
-
-// Clean up any hanging processes
-afterAll(async () => {
-	// Give time for any async operations to complete
-	await new Promise((resolve) => setTimeout(resolve, 100));
-});

tests/e2e/setup/rate-limit-sequencer.cjs

@@ -1,73 +0,0 @@
-/**
- * Custom Jest test sequencer to manage parallel execution
- * and avoid hitting AI rate limits
- */
-
-const Sequencer = require('@jest/test-sequencer').default;
-
-class RateLimitSequencer extends Sequencer {
-	/**
-	 * Sort tests to optimize execution and avoid rate limits
-	 */
-	sort(tests) {
-		// Categorize tests by their AI usage
-		const aiHeavyTests = [];
-		const aiLightTests = [];
-		const nonAiTests = [];
-
-		tests.forEach((test) => {
-			const testPath = test.path.toLowerCase();
-			
-			// Tests that make heavy use of AI APIs
-			if (
-				testPath.includes('update-task') ||
-				testPath.includes('expand-task') ||
-				testPath.includes('research') ||
-				testPath.includes('parse-prd') ||
-				testPath.includes('generate') ||
-				testPath.includes('analyze-complexity')
-			) {
-				aiHeavyTests.push(test);
-			}
-			// Tests that make light use of AI APIs
-			else if (
-				testPath.includes('add-task') ||
-				testPath.includes('update-subtask')
-			) {
-				aiLightTests.push(test);
-			}
-			// Tests that don't use AI APIs
-			else {
-				nonAiTests.push(test);
-			}
-		});
-
-		// Sort each category by duration (fastest first)
-		const sortByDuration = (a, b) => {
-			const aTime = a.duration || 0;
-			const bTime = b.duration || 0;
-			return aTime - bTime;
-		};
-
-		aiHeavyTests.sort(sortByDuration);
-		aiLightTests.sort(sortByDuration);
-		nonAiTests.sort(sortByDuration);
-
-		// Return tests in order: non-AI first, then light AI, then heavy AI
-		// This allows non-AI tests to run quickly while AI tests are distributed
-		return [...nonAiTests, ...aiLightTests, ...aiHeavyTests];
-	}
-
-	/**
-	 * Shard tests across workers to balance AI load
-	 */
-	shard(tests, { shardIndex, shardCount }) {
-		const shardSize = Math.ceil(tests.length / shardCount);
-		const start = shardSize * shardIndex;
-		const end = shardSize * (shardIndex + 1);
-
-		return tests.slice(start, end);
-	}
-}
-
-module.exports = RateLimitSequencer;

tests/e2e/tests/commands/add-dependency.test.js

@@ -1,501 +0,0 @@
-/**
- * E2E tests for add-dependency command
- * Tests dependency management functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('task-master add-dependency', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-add-dep-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('add-dependency');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic dependency creation', () => {
-		it('should add a single dependency to a task', async () => {
-			// Create tasks
-			const dep = await helpers.taskMaster('add-task', ['--title', 'Dependency task', '--description', 'A dependency'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Main task', '--description', 'Main task description'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Add dependency
-			const result = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully added dependency');
-
-			// Verify dependency was added
-			const showResult = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			expect(showResult.stdout).toContain('Dependencies:');
-			expect(showResult.stdout).toContain(depId);
-		});
-
-		it('should add multiple dependencies one by one', async () => {
-			// Create dependency tasks
-			const dep1 = await helpers.taskMaster('add-task', ['--title', 'First dependency', '--description', 'First dep'], { cwd: testDir });
-			const depId1 = helpers.extractTaskId(dep1.stdout);
-
-			const dep2 = await helpers.taskMaster('add-task', ['--title', 'Second dependency', '--description', 'Second dep'], { cwd: testDir });
-			const depId2 = helpers.extractTaskId(dep2.stdout);
-
-			const dep3 = await helpers.taskMaster('add-task', ['--title', 'Third dependency', '--description', 'Third dep'], { cwd: testDir });
-			const depId3 = helpers.extractTaskId(dep3.stdout);
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Main task', '--description', 'Main task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Add dependencies one by one
-			const result1 = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId1], { cwd: testDir });
-			expect(result1).toHaveExitCode(0);
-
-			const result2 = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId2], { cwd: testDir });
-			expect(result2).toHaveExitCode(0);
-
-			const result3 = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId3], { cwd: testDir });
-			expect(result3).toHaveExitCode(0);
-
-			// Verify all dependencies were added
-			const showResult = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			expect(showResult.stdout).toContain(depId1);
-			expect(showResult.stdout).toContain(depId2);
-			expect(showResult.stdout).toContain(depId3);
-		});
-	});
-
-	describe('Dependency validation', () => {
-		it('should prevent circular dependencies', async () => {
-			// Create circular dependency chain
-			const task1 = await helpers.taskMaster('add-task', ['--title', 'Task 1', '--description', 'First task'], { cwd: testDir });
-			const id1 = helpers.extractTaskId(task1.stdout);
-
-			const task2 = await helpers.taskMaster('add-task', ['--title', 'Task 2', '--description', 'Second task'], { cwd: testDir });
-			const id2 = helpers.extractTaskId(task2.stdout);
-
-			// Add first dependency
-			await helpers.taskMaster('add-dependency', ['--id', id2, '--depends-on', id1], { cwd: testDir });
-
-			// Try to create circular dependency
-			const result = await helpers.taskMaster('add-dependency', ['--id', id1, '--depends-on', id2], {
-				cwd: testDir,
-				allowFailure: true
-			});
-			expect(result.exitCode).not.toBe(0);
-			// The command exits with code 1 but doesn't output to stderr
-		});
-
-		it('should prevent self-dependencies', async () => {
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task', '--description', 'A task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			const result = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', taskId], {
-				cwd: testDir,
-				allowFailure: true
-			});
-			expect(result.exitCode).not.toBe(0);
-			// The command exits with code 1 but doesn't output to stderr
-		});
-
-		it('should detect transitive circular dependencies', async () => {
-			// Create chain: A -> B -> C, then try C -> A
-			const taskA = await helpers.taskMaster('add-task', ['--title', 'Task A', '--description', 'Task A'], { cwd: testDir });
-			const idA = helpers.extractTaskId(taskA.stdout);
-
-			const taskB = await helpers.taskMaster('add-task', ['--title', 'Task B', '--description', 'Task B'], { cwd: testDir });
-			const idB = helpers.extractTaskId(taskB.stdout);
-
-			const taskC = await helpers.taskMaster('add-task', ['--title', 'Task C', '--description', 'Task C'], { cwd: testDir });
-			const idC = helpers.extractTaskId(taskC.stdout);
-
-			// Create chain
-			await helpers.taskMaster('add-dependency', ['--id', idB, '--depends-on', idA], { cwd: testDir });
-			await helpers.taskMaster('add-dependency', ['--id', idC, '--depends-on', idB], { cwd: testDir });
-
-			// Try to create circular dependency
-			const result = await helpers.taskMaster('add-dependency', ['--id', idA, '--depends-on', idC], {
-				cwd: testDir,
-				allowFailure: true
-			});
-			expect(result.exitCode).not.toBe(0);
-			// The command exits with code 1 but doesn't output to stderr
-		});
-
-		it('should prevent duplicate dependencies', async () => {
-			const dep = await helpers.taskMaster('add-task', ['--title', 'Dependency', '--description', 'A dependency'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task', '--description', 'A task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Add dependency first time
-			await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId], { cwd: testDir });
-
-			// Try to add same dependency again
-			const result = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('already exists');
-		});
-	});
-
-	describe('Status updates', () => {
-		it('should update task status to blocked when adding dependencies', async () => {
-			const dep = await helpers.taskMaster('add-task', [
-				'--title',
-				'Incomplete dependency',
-				'--description',
-				'Not done yet'
-			], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task', '--description', 'A task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Start the task
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-
-			// Add dependency (does not automatically change status to blocked)
-			const result = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			// The add-dependency command doesn't automatically change task status
-
-			// Verify status remains in-progress
-			const showResult = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			expect(showResult.stdout).toContain('► in-progress');
-		});
-
-		it('should not change status if all dependencies are complete', async () => {
-			const dep = await helpers.taskMaster('add-task', ['--title', 'Complete dependency', '--description', 'Done'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-			await helpers.taskMaster('set-status', ['--id', depId, '--status', 'done'], { cwd: testDir });
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task', '--description', 'A task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-
-			// Add completed dependency
-			const result = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', depId], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).not.toContain('Status changed');
-
-			// Status should remain in-progress
-			const showResult = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			expect(showResult.stdout).toContain('► in-progress');
-		});
-	});
-
-	describe('Subtask dependencies', () => {
-		it('should add dependency to a subtask', async () => {
-			// Create parent and dependency
-			const parent = await helpers.taskMaster('add-task', ['--title', 'Parent task', '--description', 'Parent'], { cwd: testDir });
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			const dep = await helpers.taskMaster('add-task', ['--title', 'Dependency', '--description', 'A dependency'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			// Expand parent
-			const expandResult = await helpers.taskMaster('expand', ['--id', parentId, '--num', '2'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-			
-			// Verify expand succeeded
-			expect(expandResult).toHaveExitCode(0);
-
-			// Add dependency to subtask
-			const subtaskId = `${parentId}.1`;
-			const result = await helpers.taskMaster('add-dependency', ['--id', subtaskId, '--depends-on', depId], { cwd: testDir, allowFailure: true });
-			
-			// Debug output
-			if (result.exitCode !== 0) {
-				console.log('STDERR:', result.stderr);
-				console.log('STDOUT:', result.stdout);
-			}
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully added dependency');
-		});
-
-		it('should allow subtask to depend on another subtask', async () => {
-			// Create parent task
-			const parent = await helpers.taskMaster('add-task', ['--title', 'Parent', '--description', 'Parent task'], { cwd: testDir });
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Expand to create subtasks
-			const expandResult = await helpers.taskMaster('expand', ['--id', parentId, '--num', '3'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-			expect(expandResult).toHaveExitCode(0);
-
-			// Make subtask 2 depend on subtask 1
-			const result = await helpers.taskMaster('add-dependency', [
-				'--id', `${parentId}.2`,
-				'--depends-on', `${parentId}.1`
-			], { cwd: testDir, allowFailure: true });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully added dependency');
-		});
-
-		it('should allow parent to depend on its own subtask', async () => {
-			// Note: Current implementation allows parent-subtask dependencies
-			const parent = await helpers.taskMaster('add-task', ['--title', 'Parent', '--description', 'Parent task'], { cwd: testDir });
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			const expandResult = await helpers.taskMaster('expand', ['--id', parentId, '--num', '2'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-			expect(expandResult).toHaveExitCode(0);
-
-			const result = await helpers.taskMaster(
-				'add-dependency',
-				['--id', parentId, '--depends-on', `${parentId}.1`],
-				{ cwd: testDir, allowFailure: true }
-			);
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully added dependency');
-		});
-	});
-
-	// Note: The add-dependency command only supports single task/dependency operations
-	// Bulk operations are not implemented in the current version
-
-	describe('Complex dependency graphs', () => {
-		it('should handle diamond dependency pattern', async () => {
-			// Create diamond: A depends on B and C, both B and C depend on D
-			const taskD = await helpers.taskMaster('add-task', ['--title', 'Task D - base', '--description', 'Base task'], { cwd: testDir });
-			const idD = helpers.extractTaskId(taskD.stdout);
-
-			const taskB = await helpers.taskMaster('add-task', ['--title', 'Task B', '--description', 'Middle task B'], { cwd: testDir });
-			const idB = helpers.extractTaskId(taskB.stdout);
-			await helpers.taskMaster('add-dependency', ['--id', idB, '--depends-on', idD], { cwd: testDir });
-
-			const taskC = await helpers.taskMaster('add-task', ['--title', 'Task C', '--description', 'Middle task C'], { cwd: testDir });
-			const idC = helpers.extractTaskId(taskC.stdout);
-			await helpers.taskMaster('add-dependency', ['--id', idC, '--depends-on', idD], { cwd: testDir });
-
-			const taskA = await helpers.taskMaster('add-task', ['--title', 'Task A - top', '--description', 'Top task'], { cwd: testDir });
-			const idA = helpers.extractTaskId(taskA.stdout);
-
-			// Add both dependencies to create diamond (one by one)
-			const result1 = await helpers.taskMaster('add-dependency', ['--id', idA, '--depends-on', idB], { cwd: testDir });
-			expect(result1).toHaveExitCode(0);
-			expect(result1.stdout).toContain('Successfully added dependency');
-
-			const result2 = await helpers.taskMaster('add-dependency', ['--id', idA, '--depends-on', idC], { cwd: testDir });
-			expect(result2).toHaveExitCode(0);
-			expect(result2.stdout).toContain('Successfully added dependency');
-
-			// Verify the structure
-			const showResult = await helpers.taskMaster('show', [idA], { cwd: testDir });
-			expect(showResult.stdout).toContain(idB);
-			expect(showResult.stdout).toContain(idC);
-		});
-
-		it('should show transitive dependencies', async () => {
-			// Create chain A -> B -> C -> D
-			const taskD = await helpers.taskMaster('add-task', ['--title', 'Task D', '--description', 'End task'], { cwd: testDir });
-			const idD = helpers.extractTaskId(taskD.stdout);
-
-			const taskC = await helpers.taskMaster('add-task', ['--title', 'Task C', '--description', 'Middle task'], { cwd: testDir });
-			const idC = helpers.extractTaskId(taskC.stdout);
-			await helpers.taskMaster('add-dependency', ['--id', idC, '--depends-on', idD], { cwd: testDir });
-
-			const taskB = await helpers.taskMaster('add-task', ['--title', 'Task B', '--description', 'Middle task'], { cwd: testDir });
-			const idB = helpers.extractTaskId(taskB.stdout);
-			await helpers.taskMaster('add-dependency', ['--id', idB, '--depends-on', idC], { cwd: testDir });
-
-			const taskA = await helpers.taskMaster('add-task', ['--title', 'Task A', '--description', 'Start task'], { cwd: testDir });
-			const idA = helpers.extractTaskId(taskA.stdout);
-			await helpers.taskMaster('add-dependency', ['--id', idA, '--depends-on', idB], { cwd: testDir });
-
-			// Show should indicate full dependency chain
-			const result = await helpers.taskMaster('show', [idA], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Dependencies:');
-			expect(result.stdout).toContain(idB);
-			// May also show transitive dependencies in some views
-		});
-	});
-
-	describe('Tag context', () => {
-		it('should add dependencies within a tag', async () => {
-			// Create tag
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-
-			// Create tasks in feature tag
-			const dep = await helpers.taskMaster('add-task', ['--title', 'Feature dependency', '--description', 'Dep in feature'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Feature task', '--description', 'Task in feature'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Add dependency with tag context
-			const result = await helpers.taskMaster('add-dependency', [
-				'--id', taskId,
-				'--depends-on', depId,
-				'--tag',
-				'feature'
-			], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			// Tag context is shown in the emoji header
-			expect(result.stdout).toContain('🏷️ tag: feature');
-		});
-
-		it('should prevent cross-tag dependencies by default', async () => {
-			// Create tasks in different tags
-			const masterTask = await helpers.taskMaster('add-task', ['--title', 'Master task', '--description', 'In master tag'], { cwd: testDir });
-			const masterId = helpers.extractTaskId(masterTask.stdout);
-
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-			const featureTask = await helpers.taskMaster('add-task', [
-				'--title',
-				'Feature task',
-				'--description',
-				'In feature tag'
-			], { cwd: testDir });
-			const featureId = helpers.extractTaskId(featureTask.stdout);
-
-			// Try to add cross-tag dependency
-			const result = await helpers.taskMaster(
-				'add-dependency',
-				['--id', featureId, '--depends-on', masterId, '--tag', 'feature'],
-				{ cwd: testDir, allowFailure: true }
-			);
-			// Depending on implementation, this might warn or fail
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should handle non-existent task IDs', async () => {
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task', '--description', 'A task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			const result = await helpers.taskMaster('add-dependency', ['--id', taskId, '--depends-on', '999'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-			expect(result.exitCode).not.toBe(0);
-			// The command exits with code 1 but doesn't output to stderr
-		});
-
-		it('should handle invalid task ID format', async () => {
-			const result = await helpers.taskMaster('add-dependency', ['--id', 'invalid-id', '--depends-on', '1'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-			expect(result.exitCode).not.toBe(0);
-			// The command exits with code 1 but doesn't output to stderr
-		});
-
-		it('should require both task and dependency IDs', async () => {
-			const result = await helpers.taskMaster('add-dependency', ['--id', '1'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('required');
-		});
-	});
-
-	describe('Output options', () => {
-		it.skip('should support quiet mode (not implemented)', async () => {
-			// The -q flag is not supported by add-dependency command
-			const dep = await helpers.taskMaster('add-task', ['--title', 'Dep', '--description', 'A dep'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task', '--description', 'A task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			const result = await helpers.taskMaster('add-dependency', [
-				'--id', taskId,
-				'--depends-on', depId
-			], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully added dependency');
-		});
-
-		it.skip('should support JSON output (not implemented)', async () => {
-			// The --json flag is not supported by add-dependency command
-			const dep = await helpers.taskMaster('add-task', ['--title', 'Dep', '--description', 'A dep'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task', '--description', 'A task'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			const result = await helpers.taskMaster('add-dependency', [
-				'--id', taskId,
-				'--depends-on', depId,
-				'--json'
-			], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-
-			const json = JSON.parse(result.stdout);
-			expect(json.task.id).toBe(parseInt(taskId));
-			expect(json.task.dependencies).toContain(parseInt(depId));
-			expect(json.added).toBe(1);
-		});
-	});
-
-	describe('Visualization', () => {
-		it('should show dependency graph after adding', async () => {
-			// Create simple dependency chain
-			const task1 = await helpers.taskMaster('add-task', ['--title', 'Base task', '--description', 'Base'], { cwd: testDir });
-			const id1 = helpers.extractTaskId(task1.stdout);
-
-			const task2 = await helpers.taskMaster('add-task', ['--title', 'Middle task', '--description', 'Middle'], { cwd: testDir });
-			const id2 = helpers.extractTaskId(task2.stdout);
-
-			const task3 = await helpers.taskMaster('add-task', ['--title', 'Top task', '--description', 'Top'], { cwd: testDir });
-			const id3 = helpers.extractTaskId(task3.stdout);
-
-			// Build chain
-			await helpers.taskMaster('add-dependency', ['--id', id2, '--depends-on', id1], { cwd: testDir });
-			const result = await helpers.taskMaster('add-dependency', ['--id', id3, '--depends-on', id2], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			// Check for dependency added message
-			expect(result.stdout).toContain('Successfully added dependency');
-		});
-	});
-});

tests/e2e/tests/commands/add-subtask.test.js

@@ -1,405 +0,0 @@
-/**
- * E2E tests for add-subtask command
- * Tests subtask creation and conversion functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('task-master add-subtask', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-add-subtask-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('add-subtask');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic subtask creation', () => {
-		it('should add a new subtask to a parent task', async () => {
-			// Create parent task
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Add subtask
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentId,
-					'--title',
-					'New subtask',
-					'--description',
-					'This is a new subtask',
-					'--skip-generate'
-				],
-				{ cwd: testDir }
-			);
-
-			// Verify success
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Creating new subtask');
-			expect(result.stdout).toContain('successfully created');
-			expect(result.stdout).toContain(`${parentId}.1`); // subtask ID
-
-			// Verify subtask was added
-			const showResult = await helpers.taskMaster('show', [parentId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('New'); // Truncated in table
-			expect(showResult.stdout).toContain('Subtasks'); // Section header
-		});
-
-		it('should add a subtask with custom status and details', async () => {
-			// Create parent task
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Add subtask with custom options
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentId,
-					'--title',
-					'Advanced subtask',
-					'--description',
-					'Subtask with details',
-					'--details',
-					'Implementation details here',
-					'--status',
-					'in-progress',
-					'--skip-generate'
-				],
-				{ cwd: testDir }
-			);
-
-			// Verify success
-			expect(result).toHaveExitCode(0);
-
-			// Verify subtask properties
-			const showResult = await helpers.taskMaster('show', [`${parentId}.1`], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Advanced'); // Truncated in table
-			expect(showResult.stdout).toContain('Subtask'); // Part of description
-			expect(showResult.stdout).toContain('Implementation'); // Part of details
-			expect(showResult.stdout).toContain('in-progress');
-		});
-
-		it('should add a subtask with dependencies', async () => {
-			// Create dependency task
-			const dep = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Dependency task', '--description', 'A dependency'],
-				{ cwd: testDir }
-			);
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			// Create parent task and subtask
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Add first subtask
-			await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentId, '--title', 'First subtask', '--skip-generate'],
-				{ cwd: testDir }
-			);
-
-			// Add second subtask with dependencies
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentId,
-					'--title',
-					'Subtask with deps',
-					'--dependencies',
-					`${parentId}.1,${depId}`,
-					'--skip-generate'
-				],
-				{ cwd: testDir }
-			);
-
-			// Verify success
-			expect(result).toHaveExitCode(0);
-
-			// Verify subtask was created (dependencies may not show in standard show output)
-			const showResult = await helpers.taskMaster('show', [`${parentId}.2`], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Subtask'); // Part of title
-		});
-	});
-
-	describe('Task conversion', () => {
-		it('should convert an existing task to a subtask', async () => {
-			// Create tasks
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			const taskToConvert = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Task to be converted',
-					'--description',
-					'This will become a subtask'
-				],
-				{ cwd: testDir }
-			);
-			const convertId = helpers.extractTaskId(taskToConvert.stdout);
-
-			// Convert task to subtask
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentId, '--task-id', convertId, '--skip-generate'],
-				{ cwd: testDir }
-			);
-
-			// Verify success
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(`Converting task ${convertId}`);
-			expect(result.stdout).toContain('successfully converted');
-
-			// Verify task was converted
-			const showParent = await helpers.taskMaster('show', [parentId], {
-				cwd: testDir
-			});
-			expect(showParent.stdout).toContain('Task'); // Truncated title in table
-
-			// Verify original task no longer exists as top-level
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(listResult.stdout).not.toContain(`${convertId}:`);
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail when parent ID is not provided', async () => {
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				['--title', 'Orphan subtask'],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('--parent parameter is required');
-		});
-
-		it('should fail when neither task-id nor title is provided', async () => {
-			// Create parent task first
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentId],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain(
-				'Either --task-id or --title must be provided'
-			);
-		});
-
-		it('should handle non-existent parent task', async () => {
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				['--parent', '999', '--title', 'Lost subtask'],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Error');
-		});
-
-		it('should handle non-existent task ID for conversion', async () => {
-			// Create parent task first
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentId, '--task-id', '999'],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Error');
-		});
-	});
-
-	describe('Tag context', () => {
-		it('should work with tag option', async () => {
-			// Create tag and switch to it
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-
-			// Create parent task in feature tag
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Feature task', '--description', 'A feature task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Add subtask to feature tag
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentId,
-					'--title',
-					'Feature subtask',
-					'--tag',
-					'feature',
-					'--skip-generate'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify subtask is in feature tag
-			const showResult = await helpers.taskMaster(
-				'show',
-				[parentId, '--tag', 'feature'],
-				{ cwd: testDir }
-			);
-			expect(showResult.stdout).toContain('Feature'); // Truncated title
-
-			// Verify master tag is unaffected
-			await helpers.taskMaster('use-tag', ['master'], { cwd: testDir });
-			const masterList = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(masterList.stdout).not.toContain('Feature subtask');
-		});
-	});
-
-	describe('Output format', () => {
-		it('should create subtask successfully with standard output', async () => {
-			// Create parent task
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentId,
-					'--title',
-					'Standard subtask',
-					'--skip-generate'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Creating new subtask');
-			expect(result.stdout).toContain('successfully created');
-		});
-
-		it('should display success box with next steps', async () => {
-			// Create parent task
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'A parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			const result = await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentId, '--title', 'Success subtask', '--skip-generate'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Next Steps:');
-			expect(result.stdout).toContain('task-master show');
-			expect(result.stdout).toContain('task-master set-status');
-		});
-	});
-});

tests/e2e/tests/commands/add-tag.test.js

@@ -1,433 +0,0 @@
-/**
- * E2E tests for add-tag command
- * Tests tag creation functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('task-master add-tag', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-add-tag-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('add-tag');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic tag creation', () => {
-		it('should create a new tag successfully', async () => {
-			const result = await helpers.taskMaster('add-tag', ['feature-x'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully created tag "feature-x"');
-
-			// Verify tag was created in tasks.json
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = JSON.parse(readFileSync(tasksJsonPath, 'utf8'));
-			expect(tasksContent).toHaveProperty('feature-x');
-			expect(tasksContent['feature-x']).toHaveProperty('tasks');
-			expect(Array.isArray(tasksContent['feature-x'].tasks)).toBe(true);
-		});
-
-		it('should create tag with description', async () => {
-			const result = await helpers.taskMaster(
-				'add-tag',
-				['release-v1', '--description', '"First major release"'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully created tag "release-v1"');
-
-			// Verify tag has description
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = JSON.parse(readFileSync(tasksJsonPath, 'utf8'));
-			expect(tasksContent['release-v1']).toHaveProperty('metadata');
-			expect(tasksContent['release-v1'].metadata).toHaveProperty(
-				'description',
-				'First major release'
-			);
-		});
-
-		it('should handle tag name with hyphens and underscores', async () => {
-			const result = await helpers.taskMaster(
-				'add-tag',
-				['feature_auth-system'],
-				{
-					cwd: testDir
-				}
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'Successfully created tag "feature_auth-system"'
-			);
-		});
-	});
-
-	describe('Duplicate tag handling', () => {
-		it('should fail when creating a tag that already exists', async () => {
-			// Create initial tag
-			const firstResult = await helpers.taskMaster('add-tag', ['duplicate'], {
-				cwd: testDir
-			});
-			expect(firstResult).toHaveExitCode(0);
-
-			// Try to create same tag again
-			const secondResult = await helpers.taskMaster('add-tag', ['duplicate'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(secondResult.exitCode).not.toBe(0);
-			expect(secondResult.stderr).toContain('already exists');
-		});
-
-		it('should not allow creating master tag', async () => {
-			const result = await helpers.taskMaster('add-tag', ['master'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('reserved tag name');
-		});
-	});
-
-	describe('Special characters handling', () => {
-		it('should handle tag names with numbers', async () => {
-			const result = await helpers.taskMaster('add-tag', ['sprint-123'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully created tag "sprint-123"');
-		});
-
-		it('should reject tag names with spaces', async () => {
-			// When passed through shell, 'my tag' becomes two arguments: 'my' and 'tag'
-			// The command receives 'my' as the tag name (which is valid) and 'tag' is ignored
-			// This test actually creates a tag named 'my' successfully
-			// To properly test space rejection, we would need to quote the argument
-			const result = await helpers.taskMaster('add-tag', ['"my tag"'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('can only contain letters, numbers, hyphens, and underscores');
-		});
-
-		it('should reject tag names with special characters', async () => {
-			// Test each special character individually to avoid shell interpretation issues
-			const testCases = [
-				{ name: 'tag@name', quoted: '"tag@name"' },
-				{ name: 'tag#name', quoted: '"tag#name"' },
-				{ name: 'tag\\$name', quoted: '"tag\\$name"' }, // Escape $ to prevent shell variable expansion
-				{ name: 'tag%name', quoted: '"tag%name"' }
-			];
-
-			for (const { name, quoted } of testCases) {
-				const result = await helpers.taskMaster('add-tag', [quoted], {
-					cwd: testDir,
-					allowFailure: true
-				});
-
-				expect(result.exitCode).not.toBe(0);
-				expect(result.stderr).toMatch(/can only contain letters, numbers, hyphens, and underscores/i);
-			}
-		});
-
-		it('should handle very long tag names', async () => {
-			const longName = 'a'.repeat(100);
-			const result = await helpers.taskMaster('add-tag', [longName], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			// Should either succeed or fail with appropriate error
-			if (result.exitCode !== 0) {
-				expect(result.stderr).toMatch(/too long|Invalid/i);
-			} else {
-				expect(result.stdout).toContain('Successfully created tag');
-			}
-		});
-	});
-
-	describe('Multiple tag creation', () => {
-		it('should create multiple tags sequentially', async () => {
-			const tags = ['dev', 'staging', 'production'];
-
-			for (const tag of tags) {
-				const result = await helpers.taskMaster('add-tag', [tag], {
-					cwd: testDir
-				});
-				expect(result).toHaveExitCode(0);
-				expect(result.stdout).toContain(`Successfully created tag "${tag}"`);
-			}
-
-			// Verify all tags exist
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = JSON.parse(readFileSync(tasksJsonPath, 'utf8'));
-
-			for (const tag of tags) {
-				expect(tasksContent).toHaveProperty(tag);
-			}
-		});
-
-		it('should handle concurrent tag creation', async () => {
-			const tags = ['concurrent-1', 'concurrent-2', 'concurrent-3'];
-			const promises = tags.map((tag) =>
-				helpers.taskMaster('add-tag', [tag], { cwd: testDir })
-			);
-
-			const results = await Promise.all(promises);
-
-			// All should succeed
-			results.forEach((result, index) => {
-				expect(result).toHaveExitCode(0);
-				expect(result.stdout).toContain(
-					`Successfully created tag "${tags[index]}"`
-				);
-			});
-		});
-	});
-
-	describe('Tag creation with copy options', () => {
-		it('should create tag with copy-from-current option', async () => {
-			// Create new tag with copy option (even if no tasks to copy)
-			const result = await helpers.taskMaster(
-				'add-tag',
-				['feature-copy', '--copy-from-current'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'Successfully created tag "feature-copy"'
-			);
-
-			// Verify tag was created
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = JSON.parse(readFileSync(tasksJsonPath, 'utf8'));
-			expect(tasksContent).toHaveProperty('feature-copy');
-		});
-	});
-
-	describe('Git branch integration', () => {
-		it.skip('should create tag from current git branch', async () => {
-			// Initialize git repo
-			await helpers.executeCommand('git', ['init'], { cwd: testDir });
-			await helpers.executeCommand(
-				'git',
-				['config', 'user.email', 'test@example.com'],
-				{ cwd: testDir }
-			);
-			await helpers.executeCommand(
-				'git',
-				['config', 'user.name', 'Test User'],
-				{ cwd: testDir }
-			);
-
-			// Create and checkout a feature branch
-			await helpers.executeCommand('git', ['checkout', '-b', 'feature/auth'], {
-				cwd: testDir
-			});
-
-			// Create tag from branch
-			const result = await helpers.taskMaster('add-tag', ['--from-branch'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully created tag');
-			expect(result.stdout).toContain('feature/auth');
-
-			// Verify tag was created with branch-based name
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = JSON.parse(readFileSync(tasksJsonPath, 'utf8'));
-			const tagNames = Object.keys(tasksContent);
-			const branchTag = tagNames.find((tag) => tag.includes('auth'));
-			expect(branchTag).toBeTruthy();
-		});
-
-		it.skip('should fail when not in a git repository', async () => {
-			const result = await helpers.taskMaster('add-tag', ['--from-branch'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Not in a git repository');
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail without tag name argument', async () => {
-			const result = await helpers.taskMaster('add-tag', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Either tagName argument or --from-branch option is required');
-		});
-
-		it('should handle empty tag name', async () => {
-			const result = await helpers.taskMaster('add-tag', [''], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Either tagName argument or --from-branch option is required');
-		});
-
-		it.skip('should handle file system errors gracefully', async () => {
-			// Make tasks.json read-only
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			await helpers.executeCommand('chmod', ['444', tasksJsonPath], {
-				cwd: testDir
-			});
-
-			const result = await helpers.taskMaster('add-tag', ['readonly-test'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toBeTruthy();
-
-			// Restore permissions for cleanup
-			await helpers.executeCommand('chmod', ['644', tasksJsonPath], {
-				cwd: testDir
-			});
-		});
-	});
-
-	describe('Tag aliases', () => {
-		it('should work with add-tag alias', async () => {
-			const result = await helpers.taskMaster('add-tag', ['alias-test'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully created tag "alias-test"');
-		});
-	});
-
-	describe('Integration with other commands', () => {
-		it('should allow switching to newly created tag', async () => {
-			// Create tag
-			const createResult = await helpers.taskMaster('add-tag', ['switchable'], {
-				cwd: testDir
-			});
-			expect(createResult).toHaveExitCode(0);
-
-			// Switch to new tag
-			const switchResult = await helpers.taskMaster('use-tag', ['switchable'], {
-				cwd: testDir
-			});
-			expect(switchResult).toHaveExitCode(0);
-			expect(switchResult.stdout).toContain('Successfully switched to tag "switchable"');
-		});
-
-		it('should allow adding tasks to newly created tag', async () => {
-			// Create tag
-			await helpers.taskMaster('add-tag', ['task-container'], {
-				cwd: testDir
-			});
-
-			// Add task to specific tag
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Task in new tag',
-					'--description',
-					'Testing',
-					'--tag',
-					'task-container'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify task is in the correct tag
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = JSON.parse(readFileSync(tasksJsonPath, 'utf8'));
-			expect(tasksContent['task-container'].tasks).toHaveLength(1);
-		});
-	});
-
-	describe('Tag metadata', () => {
-		it('should store tag creation timestamp', async () => {
-			const beforeTime = Date.now();
-
-			const result = await helpers.taskMaster('add-tag', ['timestamped'], {
-				cwd: testDir
-			});
-
-			const afterTime = Date.now();
-			expect(result).toHaveExitCode(0);
-
-			// Check if tag has creation metadata
-			const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = JSON.parse(readFileSync(tasksJsonPath, 'utf8'));
-
-			// If implementation includes timestamps, verify them
-			if (tasksContent.timestamped?.createdAt) {
-				const createdAt = new Date(
-					tasksContent.timestamped.createdAt
-				).getTime();
-				expect(createdAt).toBeGreaterThanOrEqual(beforeTime);
-				expect(createdAt).toBeLessThanOrEqual(afterTime);
-			}
-		});
-	});
-});

tests/e2e/tests/commands/add-task.test.js

@@ -1,600 +0,0 @@
-/**
- * Comprehensive E2E tests for add-task command
- * Tests all aspects of task creation including AI and manual modes
- */
-
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-describe('add-task command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-add-task-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('add-task');
-		helpers = context.helpers;
-
-		copyConfigFiles(testDir);
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('AI-powered task creation', () => {
-		it('should create task with AI prompt', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Create a user authentication system with JWT tokens'],
-				{ cwd: testDir, timeout: 30000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContainTaskId();
-
-			const taskId = helpers.extractTaskId(result.stdout);
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-
-			// AI generated task should contain a title and description
-			expect(showResult.stdout).toContain('Title:');
-			expect(showResult.stdout).toContain('Description:');
-			expect(showResult.stdout).toContain('Implementation Details:');
-		}, 45000); // 45 second timeout for this test
-
-		it('should handle very long prompts', async () => {
-			const longPrompt =
-				'Create a comprehensive system that ' +
-				'handles many features '.repeat(50);
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', longPrompt],
-				{ cwd: testDir, timeout: 30000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContainTaskId();
-		}, 45000);
-
-		it('should handle special characters in prompt', async () => {
-			const specialPrompt =
-				'Implement feature: User data and settings with special chars';
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', specialPrompt],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContainTaskId();
-		});
-
-		it('should verify AI generates reasonable output', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--prompt',
-					'Build a responsive navigation menu with dropdown support'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			const taskId = helpers.extractTaskId(result.stdout);
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			// Verify AI generated task has proper structure
-			expect(showResult.stdout).toContain('Title:');
-			expect(showResult.stdout).toContain('Status:');
-			expect(showResult.stdout).toContain('Priority:');
-			expect(showResult.stdout).toContain('Description:');
-		});
-	});
-
-	describe('Manual task creation', () => {
-		it('should create task with title and description', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Setup database connection',
-					'--description',
-					'Configure PostgreSQL connection with connection pooling'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContainTaskId();
-
-			const taskId = helpers.extractTaskId(result.stdout);
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-
-			// Check that at least part of our title and description are shown
-			expect(showResult.stdout).toContain('Setup');
-			expect(showResult.stdout).toContain('Configure');
-		});
-
-		it('should create task with manual details', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Implement caching layer',
-					'--description',
-					'Add Redis caching to improve performance',
-					'--details',
-					'Use Redis for session storage and API response caching'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContainTaskId();
-		});
-	});
-
-	describe('Task creation with options', () => {
-		it('should create task with priority', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--prompt',
-					'Fix critical security vulnerability',
-					'--priority',
-					'high'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			const taskId = helpers.extractTaskId(result.stdout);
-
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout.toLowerCase()).toContain('high');
-		});
-
-		it('should create task with dependencies', async () => {
-			// Create dependency task first
-			const depResult = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Setup environment',
-					'--description',
-					'Initial environment setup'
-				],
-				{ cwd: testDir }
-			);
-			const depTaskId = helpers.extractTaskId(depResult.stdout);
-
-			// Create task with dependency
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Deploy application', '--dependencies', depTaskId],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			const taskId = helpers.extractTaskId(result.stdout);
-
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain(depTaskId);
-		});
-
-		it('should handle multiple dependencies', async () => {
-			// Create multiple dependency tasks
-			const dep1 = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Setup environment'],
-				{ cwd: testDir }
-			);
-			const depId1 = helpers.extractTaskId(dep1.stdout);
-
-			const dep2 = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Configure database'],
-				{ cwd: testDir }
-			);
-			const depId2 = helpers.extractTaskId(dep2.stdout);
-
-			// Create task with multiple dependencies
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--prompt',
-					'Deploy application',
-					'--dependencies',
-					`${depId1},${depId2}`
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			const taskId = helpers.extractTaskId(result.stdout);
-
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain(depId1);
-			expect(showResult.stdout).toContain(depId2);
-		});
-
-		it('should create task with all options combined', async () => {
-			// Setup
-			const depResult = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Prerequisite task',
-					'--description',
-					'Task that must be completed first'
-				],
-				{ cwd: testDir }
-			);
-			const depTaskId = helpers.extractTaskId(depResult.stdout);
-
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-complete', '--description', 'Complete feature test'],
-				{ cwd: testDir }
-			);
-
-			// Create task with all options
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--prompt',
-					'Comprehensive task with all features',
-					'--priority',
-					'medium',
-					'--dependencies',
-					depTaskId
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			const taskId = helpers.extractTaskId(result.stdout);
-
-			// Verify all options
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout.toLowerCase()).toContain('medium');
-			expect(showResult.stdout).toContain(depTaskId);
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail without prompt or title+description', async () => {
-			const result = await helpers.taskMaster('add-task', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain(
-				'Either --prompt or both --title and --description must be provided'
-			);
-		});
-
-		it('should fail with only title (missing description)', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Incomplete task'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-		});
-
-		it('should handle invalid priority by defaulting to medium', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Test task', '--priority', 'invalid'],
-				{ cwd: testDir }
-			);
-
-			// Should succeed but use default priority and show warning
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Invalid priority "invalid"');
-			expect(result.stdout).toContain('Using default priority "medium"');
-
-			const taskId = helpers.extractTaskId(result.stdout);
-
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Priority:');
-			expect(showResult.stdout).toContain('medium');
-		});
-
-		it('should warn and continue with non-existent dependency', async () => {
-			// Based on the implementation, invalid dependencies are filtered out with a warning
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Test task', '--dependencies', '99999'],
-				{ cwd: testDir }
-			);
-
-			// Should succeed but with warning
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('do not exist');
-		});
-	});
-
-	describe('Concurrent operations', () => {
-		it('should handle multiple tasks created in parallel', async () => {
-			const promises = [];
-			for (let i = 0; i < 3; i++) {
-				promises.push(
-					helpers.taskMaster(
-						'add-task',
-						['--prompt', `Parallel task ${i + 1}`],
-						{ cwd: testDir }
-					)
-				);
-			}
-
-			const results = await Promise.all(promises);
-
-			results.forEach((result) => {
-				expect(result).toHaveExitCode(0);
-				expect(result.stdout).toContainTaskId();
-			});
-		});
-	});
-
-	describe('Research mode', () => {
-		it('should create task using research mode', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--prompt',
-					'Research best practices for implementing OAuth2 authentication',
-					'--research'
-				],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContainTaskId();
-
-			// Verify task was created
-			const taskId = helpers.extractTaskId(result.stdout);
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			// Verify task was created with research mode (should have more detailed output)
-			expect(showResult.stdout).toContain('Title:');
-			expect(showResult.stdout).toContain('Implementation Details:');
-		}, 60000);
-	});
-
-	describe('File path handling', () => {
-		it('should use custom tasks file path', async () => {
-			// Create custom tasks file
-			const customPath = join(testDir, 'custom-tasks.json');
-			writeFileSync(customPath, JSON.stringify({ master: { tasks: [] } }));
-
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--file', customPath, '--prompt', 'Task in custom file'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify task was added to custom file
-			const customContent = JSON.parse(readFileSync(customPath, 'utf8'));
-			expect(customContent.master.tasks.length).toBe(1);
-		});
-	});
-
-	describe('Priority validation', () => {
-		it('should accept all valid priority values', async () => {
-			const priorities = ['high', 'medium', 'low'];
-
-			for (const priority of priorities) {
-				const result = await helpers.taskMaster(
-					'add-task',
-					[
-						'--prompt',
-						`Task with ${priority} priority`,
-						'--priority',
-						priority
-					],
-					{ cwd: testDir }
-				);
-
-				expect(result).toHaveExitCode(0);
-				const taskId = helpers.extractTaskId(result.stdout);
-
-				const showResult = await helpers.taskMaster('show', [taskId], {
-					cwd: testDir
-				});
-				expect(showResult.stdout.toLowerCase()).toContain(priority);
-			}
-		});
-
-		it('should accept priority values case-insensitively', async () => {
-			const priorities = ['HIGH', 'Medium', 'LoW'];
-			const expected = ['high', 'medium', 'low'];
-
-			for (let i = 0; i < priorities.length; i++) {
-				const result = await helpers.taskMaster(
-					'add-task',
-					[
-						'--prompt',
-						`Task with ${priorities[i]} priority`,
-						'--priority',
-						priorities[i]
-					],
-					{ cwd: testDir }
-				);
-
-				expect(result).toHaveExitCode(0);
-				const taskId = helpers.extractTaskId(result.stdout);
-
-				const showResult = await helpers.taskMaster('show', [taskId], {
-					cwd: testDir
-				});
-				expect(showResult.stdout).toContain('Priority:');
-				expect(showResult.stdout).toContain(expected[i]);
-			}
-		});
-
-		it('should default to medium priority when not specified', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Task without explicit priority'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			const taskId = helpers.extractTaskId(result.stdout);
-
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout.toLowerCase()).toContain('medium');
-		});
-	});
-
-	describe('AI dependency suggestions', () => {
-		it('should let AI suggest dependencies based on context', async () => {
-			// Create some existing tasks that AI might reference
-			// Create an existing task that AI might reference
-			await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Setup authentication system'],
-				{ cwd: testDir }
-			);
-
-			// Create a task that should logically depend on auth
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Implement user profile page with authentication checks'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Check if AI suggested dependencies
-			if (result.stdout.includes('AI suggested')) {
-				expect(result.stdout).toContain('Dependencies');
-			}
-		}, 60000);
-	});
-
-	describe('Tag support', () => {
-		it('should add task to specific tag', async () => {
-			// Create a new tag
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-branch', '--description', 'Feature branch tag'],
-				{ cwd: testDir }
-			);
-
-			// Add task to specific tag
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Task for feature branch', '--tag', 'feature-branch'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContainTaskId();
-
-			// Verify task is in the correct tag
-			const taskId = helpers.extractTaskId(result.stdout);
-			const showResult = await helpers.taskMaster(
-				'show',
-				[taskId, '--tag', 'feature-branch'],
-				{ cwd: testDir }
-			);
-			expect(showResult).toHaveExitCode(0);
-		});
-
-		it('should add to master tag by default', async () => {
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Task for master tag'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify task is in master tag
-			const tasksContent = JSON.parse(
-				readFileSync(join(testDir, '.taskmaster/tasks/tasks.json'), 'utf8')
-			);
-			expect(tasksContent.master.tasks.length).toBeGreaterThan(0);
-		});
-	});
-
-	describe('AI fallback behavior', () => {
-		it('should handle invalid model gracefully', async () => {
-			// Set an invalid model
-			await helpers.taskMaster('models', ['--set-main', 'invalid-model-xyz'], {
-				cwd: testDir
-			});
-
-			const result = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Test fallback behavior'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			// Should either use fallback or fail gracefully
-			if (result.exitCode === 0) {
-				expect(result.stdout).toContainTaskId();
-			} else {
-				expect(result.stderr).toBeTruthy();
-			}
-
-			// Reset to valid model for other tests
-			await helpers.taskMaster('models', ['--set-main', 'gpt-3.5-turbo'], {
-				cwd: testDir
-			});
-		});
-	});
-});

tests/e2e/tests/commands/analyze-complexity.test.js

@@ -1,377 +0,0 @@
-/**
- * Comprehensive E2E tests for analyze-complexity command
- * Tests all aspects of complexity analysis including research mode and output formats
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { execSync } from 'child_process';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-describe('analyze-complexity command', () => {
-	let testDir;
-	let helpers;
-	let taskIds;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-analyze-complexity-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('analyze-complexity');
-		helpers = context.helpers;
-
-		copyConfigFiles(testDir);
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-
-		// Setup test tasks for analysis
-		taskIds = [];
-
-		// Create simple task
-		const simple = await helpers.taskMaster(
-			'add-task',
-			['--title', 'Simple task', '--description', 'A very simple task'],
-			{ cwd: testDir }
-		);
-		taskIds.push(helpers.extractTaskId(simple.stdout));
-
-		// Create complex task with subtasks
-		const complex = await helpers.taskMaster(
-			'add-task',
-			[
-				'--prompt',
-				'Build a complete e-commerce platform with payment processing'
-			],
-			{ cwd: testDir }
-		);
-		const complexId = helpers.extractTaskId(complex.stdout);
-		taskIds.push(complexId);
-
-		// Expand complex task to add subtasks
-		await helpers.taskMaster('expand', ['-i', complexId, '-n', '3'], { cwd: testDir, timeout: 60000 });
-
-		// Create task with dependencies
-		const withDeps = await helpers.taskMaster(
-			'add-task',
-			['--title', 'Deployment task', '--description', 'Deploy the application'],
-			{ cwd: testDir }
-		);
-		const withDepsId = helpers.extractTaskId(withDeps.stdout);
-		taskIds.push(withDepsId);
-		
-		// Add dependency
-		await helpers.taskMaster('add-dependency', ['--id', withDepsId, '--depends-on', taskIds[0]], { cwd: testDir });
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic complexity analysis', () => {
-		it('should analyze complexity without flags', async () => {
-			const result = await helpers.taskMaster('analyze-complexity', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toContain('complexity');
-		});
-
-		it.skip('should analyze with research flag', async () => {
-			// Skip this test - research mode takes too long for CI
-			// Research flag requires internet access and can timeout
-		});
-	});
-
-	describe('Output options', () => {
-		it('should save to custom output file', async () => {
-			// Create reports directory first
-			const reportsDir = join(testDir, '.taskmaster/reports');
-			mkdirSync(reportsDir, { recursive: true });
-			
-			// Create the output file first (the command expects it to exist)
-			const outputPath = '.taskmaster/reports/custom-complexity.json';
-			const fullPath = join(testDir, outputPath);
-			writeFileSync(fullPath, '{}');
-			
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				['--output', outputPath],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(existsSync(fullPath)).toBe(true);
-
-			// Verify it's valid JSON
-			const report = JSON.parse(readFileSync(fullPath, 'utf8'));
-			expect(report).toBeDefined();
-			expect(typeof report).toBe('object');
-		});
-
-		it('should save analysis to default location', async () => {
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				[],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Check if report was saved
-			const defaultPath = join(testDir, '.taskmaster/reports/task-complexity-report.json');
-			expect(existsSync(defaultPath)).toBe(true);
-		});
-
-		it('should show task analysis in output', async () => {
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				[],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Check for basic analysis output
-			const output = result.stdout.toLowerCase();
-			expect(output).toContain('analyzing');
-			
-			// Check if tasks are mentioned
-			taskIds.forEach(id => {
-				expect(result.stdout).toContain(id.toString());
-			});
-		});
-	});
-
-	describe('Filtering options', () => {
-		it('should analyze specific tasks', async () => {
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				['--id', taskIds.join(',')],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Should analyze only specified tasks
-			taskIds.forEach((taskId) => {
-				expect(result.stdout).toContain(taskId.toString());
-			});
-		});
-
-		it('should filter by tag', async () => {
-			// Create tag
-			await helpers.taskMaster('add-tag', ['complex-tag'], { cwd: testDir });
-			
-			// Switch to the tag context
-			await helpers.taskMaster('use-tag', ['complex-tag'], { cwd: testDir });
-			
-			// Create task in that tag
-			const taggedResult = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Tagged complex task', '--description', 'Task in complex-tag'],
-				{ cwd: testDir }
-			);
-			const taggedId = helpers.extractTaskId(taggedResult.stdout);
-
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				['--tag', 'complex-tag'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(taggedId);
-		});
-
-		it.skip('should filter by status', async () => {
-			// Skip this test - status filtering is not implemented
-			// The analyze-complexity command doesn't support --status flag
-		});
-	});
-
-	describe('Threshold configuration', () => {
-		it('should use custom threshold', async () => {
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				['--threshold', '7'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			
-			// Check that the analysis completed
-			const output = result.stdout;
-			expect(output).toContain('Task complexity analysis complete');
-		});
-
-		it('should accept threshold values between 1-10', async () => {
-			// Test valid threshold
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				['--threshold', '10'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Task complexity analysis complete');
-		});
-	});
-
-	describe('Edge cases', () => {
-		it('should handle empty project', async () => {
-			// Create a new temp directory
-			const emptyDir = mkdtempSync(join(tmpdir(), 'task-master-empty-'));
-
-			try {
-				await helpers.taskMaster('init', ['-y'], { cwd: emptyDir });
-				
-				// Ensure tasks.json exists (bug workaround)
-				const tasksJsonPath = join(emptyDir, '.taskmaster/tasks/tasks.json');
-				if (!existsSync(tasksJsonPath)) {
-					mkdirSync(join(emptyDir, '.taskmaster/tasks'), { recursive: true });
-					writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-				}
-
-				const result = await helpers.taskMaster('analyze-complexity', [], {
-					cwd: emptyDir
-				});
-
-				expect(result.exitCode).not.toBe(0);
-				expect(result.stderr).toContain('No tasks found');
-			} finally {
-				rmSync(emptyDir, { recursive: true, force: true });
-			}
-		});
-
-		it('should handle invalid output path', async () => {
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				['--output', '/invalid/path/report.json'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-		});
-	});
-
-	describe('Performance', () => {
-		it('should analyze many tasks efficiently', async () => {
-			// Create 20 more tasks
-			const promises = [];
-			for (let i = 0; i < 20; i++) {
-				promises.push(
-					helpers.taskMaster(
-						'add-task',
-						['--title', `Performance test task ${i}`, '--description', `Test task ${i} for performance testing`],
-						{ cwd: testDir }
-					)
-				);
-			}
-			await Promise.all(promises);
-
-			const startTime = Date.now();
-			const result = await helpers.taskMaster('analyze-complexity', [], {
-				cwd: testDir
-			});
-			const duration = Date.now() - startTime;
-
-			expect(result).toHaveExitCode(0);
-			expect(duration).toBeLessThan(60000); // Should complete in less than 60 seconds
-		});
-	});
-
-	describe('Complexity scoring', () => {
-		it.skip('should score complex tasks higher than simple ones', async () => {
-			// Skip this test as it requires AI API access
-			const result = await helpers.taskMaster(
-				'analyze-complexity',
-				[],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Read the saved report
-			const reportPath = join(testDir, '.taskmaster/reports/task-complexity-report.json');
-			
-			// Check if report exists
-			expect(existsSync(reportPath)).toBe(true);
-			
-			const analysis = JSON.parse(readFileSync(reportPath, 'utf8'));
-			
-			// The report structure might have tasks or complexityAnalysis array
-			const tasks = analysis.tasks || analysis.complexityAnalysis || analysis.results || [];
-			
-			// If no tasks found, check if analysis itself is an array
-			const taskArray = Array.isArray(analysis) ? analysis : tasks;
-			
-			// Convert taskIds to numbers if they're strings
-			const simpleTaskId = parseInt(taskIds[0], 10);
-			const complexTaskId = parseInt(taskIds[1], 10);
-			
-			// Try to find tasks by different possible ID fields
-			const simpleTask = taskArray.find((t) => 
-				t.id === simpleTaskId || 
-				t.id === taskIds[0] || 
-				t.taskId === simpleTaskId || 
-				t.taskId === taskIds[0]
-			);
-			const complexTask = taskArray.find((t) => 
-				t.id === complexTaskId || 
-				t.id === taskIds[1] || 
-				t.taskId === complexTaskId || 
-				t.taskId === taskIds[1]
-			);
-
-			expect(simpleTask).toBeDefined();
-			expect(complexTask).toBeDefined();
-			
-			// Get the complexity score from whichever property is used
-			const simpleScore = simpleTask.complexityScore || simpleTask.complexity?.score || 0;
-			const complexScore = complexTask.complexityScore || complexTask.complexity?.score || 0;
-			expect(complexScore).toBeGreaterThan(simpleScore);
-		});
-	});
-
-	describe('Report generation', () => {
-		it('should generate complexity report', async () => {
-			// First run analyze-complexity to generate the default report
-			await helpers.taskMaster('analyze-complexity', [], { cwd: testDir });
-
-			// Then run complexity-report to display it
-			const result = await helpers.taskMaster('complexity-report', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toMatch(
-				/complexity.*report|analysis/
-			);
-		});
-	});
-});

tests/e2e/tests/commands/clear-subtasks.test.js

@@ -1,240 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master clear-subtasks command', () => {
-	let testDir;
-	let helpers;
-	let tasksPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-clear-subtasks-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('clear-subtasks command');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-
-		// Set up tasks path
-		tasksPath = join(testDir, '.taskmaster', 'tasks', 'tasks.json');
-
-		// Create test tasks with subtasks
-		const testTasks = {
-			tasks: [
-					{
-						id: 1,
-						description: 'Task with subtasks',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: [
-							{
-								id: 1.1,
-								description: 'Subtask 1',
-								status: 'pending',
-								priority: 'medium'
-							},
-							{
-								id: 1.2,
-								description: 'Subtask 2',
-								status: 'pending',
-								priority: 'medium'
-							}
-						]
-					},
-					{
-						id: 2,
-						description: 'Another task with subtasks',
-						status: 'in_progress',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: [
-							{
-								id: 2.1,
-								description: 'Subtask 2.1',
-								status: 'pending',
-								priority: 'low'
-							}
-						]
-					},
-					{
-						id: 3,
-						description: 'Task without subtasks',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-		};
-
-		// Ensure .taskmaster directory exists
-		mkdirSync(dirname(tasksPath), { recursive: true });
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should clear subtasks from a specific task', async () => {
-		// Run clear-subtasks command for task 1
-		const result = await helpers.taskMaster('clear-subtasks', ['-f', tasksPath, '-i', '1'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Clearing Subtasks');
-		expect(result.stdout).toContain('Cleared 2 subtasks from task 1');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		// Handle both formats: direct tasks array or master.tasks
-		const tasks = updatedTasks.master ? updatedTasks.master.tasks : updatedTasks.tasks;
-		const task1 = tasks.find(t => t.id === 1);
-		const task2 = tasks.find(t => t.id === 2);
-
-		// Verify task 1 has no subtasks
-		expect(task1.subtasks).toHaveLength(0);
-
-		// Verify task 2 still has subtasks
-		expect(task2.subtasks).toHaveLength(1);
-	});
-
-	it('should clear subtasks from multiple tasks', async () => {
-		// Run clear-subtasks command for tasks 1 and 2
-		const result = await helpers.taskMaster('clear-subtasks', ['-f', tasksPath, '-i', '1,2'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Clearing Subtasks');
-		// The success message appears in a decorative box with chalk formatting and ANSI codes
-		// Using a more flexible pattern to account for ANSI escape codes and formatting
-		expect(result.stdout).toMatch(/Successfully\s+cleared\s+subtasks\s+from\s+.*2.*\s+task\(s\)/i);
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		// Handle both formats: direct tasks array or master.tasks
-		const tasks = updatedTasks.master ? updatedTasks.master.tasks : updatedTasks.tasks;
-		const task1 = tasks.find(t => t.id === 1);
-		const task2 = tasks.find(t => t.id === 2);
-
-		// Verify both tasks have no subtasks
-		expect(task1.subtasks).toHaveLength(0);
-		expect(task2.subtasks).toHaveLength(0);
-	});
-
-	it('should clear subtasks from all tasks with --all flag', async () => {
-		// Run clear-subtasks command with --all
-		const result = await helpers.taskMaster('clear-subtasks', ['-f', tasksPath, '--all'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Clearing Subtasks');
-		// The success message appears in a decorative box with extra spaces
-		expect(result.stdout).toMatch(/Successfully\s+cleared\s+subtasks\s+from/i);
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		
-		// Verify all tasks have no subtasks
-		const tasks = updatedTasks.master ? updatedTasks.master.tasks : updatedTasks.tasks;
-		tasks.forEach(task => {
-			expect(task.subtasks).toHaveLength(0);
-		});
-	});
-
-	it('should handle task without subtasks gracefully', async () => {
-		// Run clear-subtasks command for task 3 (which has no subtasks)
-		const result = await helpers.taskMaster('clear-subtasks', ['-f', tasksPath, '-i', '3'], { cwd: testDir });
-
-		// Should succeed without error
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Clearing Subtasks');
-
-		// Task should remain unchanged
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const tasks = updatedTasks.master ? updatedTasks.master.tasks : updatedTasks.tasks;
-		const task3 = tasks.find(t => t.id === 3);
-		expect(task3.subtasks).toHaveLength(0);
-	});
-
-	it('should fail when neither --id nor --all is specified', async () => {
-		// Run clear-subtasks command without specifying tasks
-		const result = await helpers.taskMaster('clear-subtasks', ['-f', tasksPath], { cwd: testDir });
-
-		// Should fail with error
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-		expect(result.stderr).toContain('Please specify task IDs');
-	});
-
-	it('should handle non-existent task ID', async () => {
-		// Run clear-subtasks command with non-existent task ID
-		const result = await helpers.taskMaster('clear-subtasks', ['-f', tasksPath, '-i', '999'], { cwd: testDir });
-
-		// Should handle gracefully
-		expect(result).toHaveExitCode(0);
-		// Original tasks should remain unchanged
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		// Check if master tag was created (which happens with readJSON/writeJSON)
-		const tasks = updatedTasks.master ? updatedTasks.master.tasks : updatedTasks.tasks;
-		expect(tasks).toHaveLength(3);
-	});
-
-	it.skip('should work with tag option', async () => {
-		// Skip this test as tag support might not be implemented yet
-		// Create tasks with different tags
-		const multiTagTasks = {
-			master: {
-				tasks: [{
-					id: 1,
-					description: 'Master task',
-					subtasks: [{ id: 1.1, description: 'Master subtask' }]
-				}]
-			},
-			feature: {
-				tasks: [{
-					id: 1,
-					description: 'Feature task',
-					subtasks: [{ id: 1.1, description: 'Feature subtask' }]
-				}]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(multiTagTasks, null, 2));
-
-		// Clear subtasks from feature tag
-		const result = await helpers.taskMaster('clear-subtasks', ['-f', tasksPath, '-i', '1', '--tag', 'feature'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-
-		// Verify only feature tag was affected
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		expect(updatedTasks.master.tasks[0].subtasks).toHaveLength(1);
-		expect(updatedTasks.feature.tasks[0].subtasks).toHaveLength(0);
-	});
-});

tests/e2e/tests/commands/command-coverage.md

@@ -1,128 +0,0 @@
-# Command Test Coverage
-
-## Commands Found in commands.js
-
-1. **parse-prd** ✅ (has test: parse-prd.test.js)
-2. **update** ✅ (has test: update.test.js)
-3. **update-task** ✅ (has test: update-task.test.js)
-4. **update-subtask** ✅ (has test: update-subtask.test.js)
-5. **generate** ✅ (has test: generate.test.js)
-6. **set-status** (aliases: mark, set) ✅ (has test: set-status.test.js)
-7. **list** ✅ (has test: list.test.js)
-8. **expand** ✅ (has test: expand-task.test.js)
-9. **analyze-complexity** ✅ (has test: analyze-complexity.test.js)
-10. **research** ✅ (has test: research.test.js, research-save.test.js)
-11. **clear-subtasks** ✅ (has test: clear-subtasks.test.js)
-12. **add-task** ✅ (has test: add-task.test.js)
-13. **next** ✅ (has test: next.test.js)
-14. **show** ✅ (has test: show.test.js)
-15. **add-dependency** ✅ (has test: add-dependency.test.js)
-16. **remove-dependency** ✅ (has test: remove-dependency.test.js)
-17. **validate-dependencies** ✅ (has test: validate-dependencies.test.js)
-18. **fix-dependencies** ✅ (has test: fix-dependencies.test.js)
-19. **complexity-report** ✅ (has test: complexity-report.test.js)
-20. **add-subtask** ✅ (has test: add-subtask.test.js)
-21. **remove-subtask** ✅ (has test: remove-subtask.test.js)
-22. **remove-task** ✅ (has test: remove-task.test.js)
-23. **init** ✅ (has test: init.test.js)
-24. **models** ✅ (has test: models.test.js)
-25. **lang** ✅ (has test: lang.test.js)
-26. **move** ✅ (has test: move.test.js)
-27. **rules** ✅ (has test: rules.test.js)
-28. **migrate** ✅ (has test: migrate.test.js)
-29. **sync-readme** ✅ (has test: sync-readme.test.js)
-30. **add-tag** ✅ (has test: add-tag.test.js)
-31. **delete-tag** ✅ (has test: delete-tag.test.js)
-32. **tags** ✅ (has test: tags.test.js)
-33. **use-tag** ✅ (has test: use-tag.test.js)
-34. **rename-tag** ✅ (has test: rename-tag.test.js)
-35. **copy-tag** ✅ (has test: copy-tag.test.js)
-
-## Summary
-
-- **Total Commands**: 35
-- **Commands with Tests**: 35 (100%)
-- **Commands without Tests**: 0 (0%)
-
-## Missing Tests (Priority)
-
-### Lower Priority (Additional features)
-1. **lang** - Manages response language settings
-2. **move** - Moves task/subtask to new position
-3. **rules** - Manages task rules/profiles
-4. **migrate** - Migrates project structure
-5. **sync-readme** - Syncs task list to README
-
-### Tag Management (Complete set)
-6. **add-tag** - Creates new tag
-7. **delete-tag** - Deletes existing tag
-8. **tags** - Lists all tags
-9. **use-tag** - Switches tag context
-10. **rename-tag** - Renames existing tag
-11. **copy-tag** - Copies tag with tasks
-
-## Test Execution Status (Updated: 2025-07-17)
-
-### ✅ Fully Passing (All tests pass)
-1. **add-dependency** - 19/21 tests pass (2 skipped as not implemented)
-2. **add-subtask** - 11/11 tests pass (100%)
-3. **add-task** - 24/24 tests pass (100%)
-4. **clear-subtasks** - 6/7 tests pass (1 skipped for tag option)
-5. **copy-tag** - 14/14 tests pass (100%)
-6. **delete-tag** - 15/16 tests pass (1 skipped as aliases not fully supported)
-7. **complexity-report** - 8/8 tests pass (100%)
-8. **fix-dependencies** - 8/8 tests pass (100%)
-9. **generate** - 4/4 tests pass (100%)
-10. **init** - 7/7 tests pass (100%)
-11. **models** - 13/13 tests pass (100%)
-12. **next** - 8/8 tests pass (100%)
-13. **remove-dependency** - 9/9 tests pass (100%)
-14. **remove-subtask** - 9/9 tests pass (100%)
-15. **rename-tag** - 14/14 tests pass (100%)
-16. **show** - 8+/18 tests pass (core functionality working, some multi-word titles still need quoting)
-17. **rules** - 21/21 tests pass (100%)
-18. **set-status** - 17/17 tests pass (100%)
-19. **tags** - 14/14 tests pass (100%)
-20. **update-subtask** - Core functionality working (test file includes tests for unimplemented options)
-21. **update** - Fixed: test file renamed from update-tasks.test.js to update.test.js, uses correct --from parameter instead of non-existent --ids/--status/--priority
-22. **use-tag** - 6/6 tests pass (100%)
-23. **validate-dependencies** - 8/8 tests pass (100%)
-
-### ⚠️ Mostly Passing (Some tests fail/skip)
-22. **add-tag** - 18/21 tests pass (3 skipped: 2 git integration bugs, 1 file system test)
-23. **analyze-complexity** - 12/15 tests pass (3 skipped: 1 research mode timeout, 1 status filtering not implemented, 1 empty project edge case)
-24. **lang** - 16/20 tests pass (4 failing: error handling behaviors changed)
-25. **parse-prd** - 5/18 tests pass (13 timeout due to AI API calls taking 80+ seconds, but core functionality works)
-26. **sync-readme** - 11/20 tests pass (9 fail due to task title truncation in README export, but core functionality works)
-
-### ❌ Failing/Timeout Issues  
-27. **update-task** - ~15/18 tests pass after rewrite (completely rewritten to match actual AI-powered command interface, some tests timeout due to AI calls)
-28. **expand-task** - Tests consistently timeout (AI API calls take 30+ seconds, causing Jest timeout)
-29. **list** - Tests consistently timeout (fixed invalid "blocked" status in tests, command works manually)
-30. **move** - Tests fail with "Task with ID 1 already exists" error, even for basic error handling tests
-31. **remove-task** - Tests consistently timeout during setup or execution
-32. **research-save** - Uses legacy test format, likely timeout due to AI research calls (120s timeout configured)
-32. **research** - 2/24 tests pass (22 timeout due to AI research calls, but fixed command interface issues)
-
-### ❓ Not Yet Tested
-- All other commands...
-
-## Recently Added Tests (2024)
-
-The following tests were just created:
-- generate.test.js
-- init.test.js
-- clear-subtasks.test.js
-- add-subtask.test.js
-- remove-subtask.test.js
-- next.test.js
-- remove-dependency.test.js
-- validate-dependencies.test.js
-- fix-dependencies.test.js
-- complexity-report.test.js
-- models.test.js (fixed 2025-07-17)
-- parse-prd.test.js (fixed 2025-07-17: 5/18 tests pass, core functionality working but some AI calls timeout)
-- set-status.test.js (fixed 2025-07-17: 17/17 tests pass)
-- sync-readme.test.js (fixed 2025-07-17: 11/20 tests pass, core functionality working)
-- use-tag.test.js (verified 2025-07-17: 6/6 tests pass, no fixes needed!)
-- list.test.js (invalid "blocked" status fixed to "review" 2025-07-17, but tests timeout)

tests/e2e/tests/commands/complexity-report.test.js

@@ -1,327 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master complexity-report command', () => {
-	let testDir;
-	let helpers;
-	let reportPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-complexity-report-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('complexity-report command');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-
-		// Initialize report path
-		reportPath = join(testDir, '.taskmaster/task-complexity-report.json');
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should display complexity report', async () => {
-		// Create a sample complexity report matching actual structure
-		const complexityReport = {
-			meta: {
-				generatedAt: new Date().toISOString(),
-				tasksAnalyzed: 3,
-				totalTasks: 3,
-				analysisCount: 3,
-				thresholdScore: 5,
-				projectName: 'test-project',
-				usedResearch: false
-			},
-			complexityAnalysis: [
-				{
-					taskId: 1,
-					taskTitle: 'Simple task',
-					complexityScore: 3,
-					recommendedSubtasks: 2,
-					expansionPrompt: 'Break down this simple task',
-					reasoning: 'This is a simple task with low complexity'
-				},
-				{
-					taskId: 2,
-					taskTitle: 'Medium complexity task',
-					complexityScore: 5,
-					recommendedSubtasks: 4,
-					expansionPrompt: 'Break down this medium complexity task',
-					reasoning: 'This task has moderate complexity'
-				},
-				{
-					taskId: 3,
-					taskTitle: 'Complex task',
-					complexityScore: 8,
-					recommendedSubtasks: 6,
-					expansionPrompt: 'Break down this complex task',
-					reasoning: 'This is a complex task requiring careful decomposition'
-				}
-			]
-		};
-
-		// Ensure .taskmaster directory exists
-		mkdirSync(dirname(reportPath), { recursive: true });
-		writeFileSync(reportPath, JSON.stringify(complexityReport, null, 2));
-
-		// Run complexity-report command
-		const result = await helpers.taskMaster('complexity-report', ['-f', reportPath], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Task Complexity Analysis Report');
-		expect(result.stdout).toContain('Tasks Analyzed:');
-		expect(result.stdout).toContain('3'); // number of tasks
-		expect(result.stdout).toContain('Simple task');
-		expect(result.stdout).toContain('Medium complexity task');
-		expect(result.stdout).toContain('Complex task');
-		// Check for complexity distribution
-		expect(result.stdout).toContain('Complexity Distribution');
-		expect(result.stdout).toContain('Low');
-		expect(result.stdout).toContain('Medium');
-		expect(result.stdout).toContain('High')
-	});
-
-	it('should display detailed task complexity', async () => {
-		// Create a report with detailed task info matching actual structure
-		const detailedReport = {
-			meta: {
-				generatedAt: new Date().toISOString(),
-				tasksAnalyzed: 1,
-				totalTasks: 1,
-				analysisCount: 1,
-				thresholdScore: 5,
-				projectName: 'test-project',
-				usedResearch: false
-			},
-			complexityAnalysis: [
-				{
-					taskId: 1,
-					taskTitle: 'Implement authentication system',
-					complexityScore: 7,
-					recommendedSubtasks: 5,
-					expansionPrompt: 'Break down authentication system implementation with focus on security',
-					reasoning: 'Requires integration with multiple services, security considerations'
-				}
-			]
-		};
-
-		writeFileSync(reportPath, JSON.stringify(detailedReport, null, 2));
-
-		// Run complexity-report command
-		const result = await helpers.taskMaster('complexity-report', ['-f', reportPath], { cwd: testDir });
-
-		// Verify detailed output
-		expect(result).toHaveExitCode(0);
-		// Title might be truncated in display
-		expect(result.stdout).toContain('Implement authentic'); // partial match
-		expect(result.stdout).toContain('7'); // complexity score
-		expect(result.stdout).toContain('5'); // recommended subtasks
-		// Check for expansion prompt text (visible in the expansion command)
-		expect(result.stdout).toContain('authentication');
-		expect(result.stdout).toContain('system');
-		expect(result.stdout).toContain('implementation');
-	});
-
-	it('should handle missing report file', async () => {
-		const nonExistentPath = join(testDir, '.taskmaster', 'non-existent-report.json');
-
-		// Run complexity-report command with non-existent file
-		const result = await helpers.taskMaster('complexity-report', ['-f', nonExistentPath], { cwd: testDir, allowFailure: true });
-
-		// Should fail gracefully
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-		expect(result.stderr).toContain('does not exist');
-		// The error message doesn't contain 'analyze-complexity' but does show path not found
-		expect(result.stderr).toContain('does not exist');
-	});
-
-	it('should handle empty report', async () => {
-		// Create an empty report matching actual structure
-		const emptyReport = {
-			meta: {
-				generatedAt: new Date().toISOString(),
-				tasksAnalyzed: 0,
-				totalTasks: 0,
-				analysisCount: 0,
-				thresholdScore: 5,
-				projectName: 'test-project',
-				usedResearch: false
-			},
-			complexityAnalysis: []
-		};
-
-		writeFileSync(reportPath, JSON.stringify(emptyReport, null, 2));
-
-		// Run complexity-report command
-		const result = await helpers.taskMaster('complexity-report', ['-f', reportPath], { cwd: testDir });
-
-		// Should handle gracefully
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Tasks Analyzed:');
-		expect(result.stdout).toContain('0');
-		// Empty report still shows the table structure
-		expect(result.stdout).toContain('Complexity Distribution');
-	});
-
-	it('should work with tag option for tag-specific reports', async () => {
-		// Create tag-specific report
-		const reportsDir = join(testDir, '.taskmaster/reports');
-		mkdirSync(reportsDir, { recursive: true });
-		// For tags, the path includes the tag name
-		const featureReportPath = join(testDir, '.taskmaster/reports/task-complexity-report_feature.json');
-		const featureReport = {
-			meta: {
-				generatedAt: new Date().toISOString(),
-				tasksAnalyzed: 2,
-				totalTasks: 2,
-				analysisCount: 2,
-				thresholdScore: 5,
-				projectName: 'test-project',
-				usedResearch: false
-			},
-			complexityAnalysis: [
-				{
-					taskId: 1,
-					taskTitle: 'Feature task 1',
-					complexityScore: 3,
-					recommendedSubtasks: 2,
-					expansionPrompt: 'Break down feature task 1',
-					reasoning: 'Low complexity feature task'
-				},
-				{
-					taskId: 2,
-					taskTitle: 'Feature task 2',
-					complexityScore: 5,
-					recommendedSubtasks: 3,
-					expansionPrompt: 'Break down feature task 2',
-					reasoning: 'Medium complexity feature task'
-				}
-			]
-		};
-
-		writeFileSync(featureReportPath, JSON.stringify(featureReport, null, 2));
-
-		// Run complexity-report command with specific file path (not tag)
-		const result = await helpers.taskMaster('complexity-report', ['-f', featureReportPath], { cwd: testDir });
-
-		// Should display feature-specific report
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Feature task 1');
-		expect(result.stdout).toContain('Feature task 2');
-		expect(result.stdout).toContain('Tasks Analyzed:');
-		expect(result.stdout).toContain('2');
-	});
-
-	it('should display complexity distribution chart', async () => {
-		// Create report with various complexity levels
-		const distributionReport = {
-			meta: {
-				generatedAt: new Date().toISOString(),
-				tasksAnalyzed: 10,
-				totalTasks: 10,
-				analysisCount: 10,
-				thresholdScore: 5,
-				projectName: 'test-project',
-				usedResearch: false
-			},
-			complexityAnalysis: Array.from({ length: 10 }, (_, i) => ({
-				taskId: i + 1,
-				taskTitle: `Task ${i + 1}`,
-				complexityScore: i < 3 ? 2 : i < 8 ? 5 : 8,
-				recommendedSubtasks: i < 3 ? 2 : i < 8 ? 3 : 5,
-				expansionPrompt: `Break down task ${i + 1}`,
-				reasoning: `Task ${i + 1} complexity reasoning`
-			}))
-		};
-
-		writeFileSync(reportPath, JSON.stringify(distributionReport, null, 2));
-
-		// Run complexity-report command
-		const result = await helpers.taskMaster('complexity-report', ['-f', reportPath], { cwd: testDir });
-
-		// Should show distribution
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Complexity Distribution');
-		// The distribution text appears with percentages in a decorative box
-		expect(result.stdout).toMatch(/Low \(1-4\): 3 tasks \(\d+%\)/);
-		expect(result.stdout).toMatch(/Medium \(5-7\): 5 tasks \(\d+%\)/);
-		expect(result.stdout).toMatch(/High \(8-10\): 2 tasks \(\d+%\)/);
-	});
-
-	it('should handle malformed report gracefully', async () => {
-		// Create malformed report
-		writeFileSync(reportPath, '{ invalid json }');
-
-		// Run complexity-report command
-		const result = await helpers.taskMaster('complexity-report', ['-f', reportPath], { cwd: testDir });
-
-		// The command exits silently when JSON parsing fails
-		expect(result).toHaveExitCode(0);
-		// Output shows error message and tag footer
-		expect(result.stdout).toContain('🏷️ tag: master');
-		expect(result.stdout).toContain('[ERROR]');
-		expect(result.stdout).toContain('Error reading complexity report');
-	});
-
-	it('should display report generation time', async () => {
-		const generatedAt = '2024-03-15T10:30:00Z';
-		const timedReport = {
-			meta: {
-				generatedAt,
-				tasksAnalyzed: 1,
-				totalTasks: 1,
-				analysisCount: 1,
-				thresholdScore: 5,
-				projectName: 'test-project',
-				usedResearch: false
-			},
-			complexityAnalysis: [{
-				taskId: 1,
-				taskTitle: 'Test task',
-				complexityScore: 5,
-				recommendedSubtasks: 3,
-				expansionPrompt: 'Break down test task',
-				reasoning: 'Medium complexity test task'
-			}]
-		};
-
-		writeFileSync(reportPath, JSON.stringify(timedReport, null, 2));
-
-		// Run complexity-report command
-		const result = await helpers.taskMaster('complexity-report', ['-f', reportPath], { cwd: testDir });
-
-		// Should show generation time
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Generated');
-		expect(result.stdout).toMatch(/2024|Mar|15/); // Date formatting may vary
-	});
-});

tests/e2e/tests/commands/copy-tag.test.js

@@ -1,487 +0,0 @@
-/**
- * E2E tests for copy-tag command
- * Tests tag copying functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-describe('task-master copy-tag', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-copy-tag-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('copy-tag');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Copy configuration files
-		copyConfigFiles(testDir);
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic copying', () => {
-		it('should copy an existing tag with all its tasks', async () => {
-			// Create a tag with tasks
-			await helpers.taskMaster(
-				'add-tag',
-				['feature', '--description', 'Feature branch'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-
-			// Add tasks to feature tag
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Feature task 1', '--description', 'First task in feature'],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Feature task 2',
-					'--description',
-					'Second task in feature'
-				],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-
-			// Switch to master and add a task
-			await helpers.taskMaster('use-tag', ['master'], { cwd: testDir });
-			const task3 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task', '--description', 'Task only in master'],
-				{ cwd: testDir }
-			);
-			const taskId3 = helpers.extractTaskId(task3.stdout);
-
-			// Copy the feature tag
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['feature', 'feature-backup'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully copied tag');
-			expect(result.stdout).toContain('feature');
-			expect(result.stdout).toContain('feature-backup');
-			// The output has a single space after the colon in the formatted box
-			expect(result.stdout).toMatch(/Tasks Copied:\s*2/);
-
-			// Verify the new tag exists
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('feature');
-			expect(tagsResult.stdout).toContain('feature-backup');
-
-			// Verify tasks are in the new tag
-			await helpers.taskMaster('use-tag', ['feature-backup'], { cwd: testDir });
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			// Just verify we have 2 tasks copied
-			expect(listResult.stdout).toContain('Pending: 2');
-			// Verify we're showing tasks (the table has task IDs)
-			expect(listResult.stdout).toContain('│ 1  │');
-			expect(listResult.stdout).toContain('│ 2  │');
-		});
-
-		it('should copy tag with custom description', async () => {
-			await helpers.taskMaster(
-				'add-tag',
-				['original', '--description', 'Original description'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['original', 'copy', '--description', 'Custom copy description'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify description in metadata
-			const tagsResult = await helpers.taskMaster('tags', ['--show-metadata'], {
-				cwd: testDir
-			});
-			expect(tagsResult.stdout).toContain('copy');
-			// The table truncates descriptions, so just check for 'Custom'
-			expect(tagsResult.stdout).toContain('Custom');
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail when copying non-existent tag', async () => {
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['nonexistent', 'new-tag'],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('not exist');
-		});
-
-		it('should fail when target tag already exists', async () => {
-			await helpers.taskMaster('add-tag', ['existing'], { cwd: testDir });
-
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['master', 'existing'],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('already exists');
-		});
-
-		it('should validate tag name format', async () => {
-			await helpers.taskMaster('add-tag', ['source'], { cwd: testDir });
-
-			// Try invalid tag names
-			const invalidNames = [
-				'tag with spaces',
-				'tag/with/slashes',
-				'tag@with@special'
-			];
-
-			for (const invalidName of invalidNames) {
-				const result = await helpers.taskMaster(
-					'copy-tag',
-					['source', `"${invalidName}"`],
-					{
-						cwd: testDir,
-						allowFailure: true
-					}
-				);
-				expect(result.exitCode).not.toBe(0);
-				// The error should mention valid characters
-				expect(result.stderr).toContain(
-					'letters, numbers, hyphens, and underscores'
-				);
-			}
-		});
-	});
-
-	describe('Special cases', () => {
-		it('should copy master tag successfully', async () => {
-			// Add tasks to master
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task 1', '--description', 'First task'],
-				{ cwd: testDir }
-			);
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task 2', '--description', 'Second task'],
-				{ cwd: testDir }
-			);
-
-			// Copy master tag
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['master', 'master-backup'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully copied tag');
-			// The output has a single space after the colon in the formatted box
-			expect(result.stdout).toMatch(/Tasks Copied:\s*2/);
-
-			// Verify both tags exist
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('master');
-			expect(tagsResult.stdout).toContain('master-backup');
-		});
-
-		it('should handle tag with no tasks', async () => {
-			// Create empty tag
-			await helpers.taskMaster(
-				'add-tag',
-				['empty', '--description', 'Empty tag'],
-				{ cwd: testDir }
-			);
-
-			// Copy the empty tag
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['empty', 'empty-copy'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully copied tag');
-			// The output has a single space after the colon in the formatted box
-			expect(result.stdout).toMatch(/Tasks Copied:\s*0/);
-
-			// Verify copy exists
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('empty');
-			expect(tagsResult.stdout).toContain('empty-copy');
-		});
-
-		it('should create tag with same name but different case', async () => {
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['feature', 'FEATURE'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully copied tag');
-
-			// Verify both tags exist
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('feature');
-			expect(tagsResult.stdout).toContain('FEATURE');
-		});
-	});
-
-	describe('Tasks with subtasks', () => {
-		it('should preserve subtasks when copying', async () => {
-			// Create tag with task that has subtasks
-			await helpers.taskMaster('add-tag', ['sprint'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['sprint'], { cwd: testDir });
-
-			// Add task and expand it
-			const task = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Epic task', '--description', 'Task with subtasks'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Expand to create subtasks
-			const expandResult = await helpers.taskMaster('expand', ['-i', taskId, '-n', '3'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-			expect(expandResult).toHaveExitCode(0);
-			
-			// Verify subtasks were created in the source tag
-			const verifyResult = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			if (!verifyResult.stdout.includes('Subtasks')) {
-				// If expand didn't create subtasks, add them manually
-				await helpers.taskMaster('add-subtask', ['--parent', taskId, '--title', 'Subtask 1', '--description', 'First subtask'], { cwd: testDir });
-				await helpers.taskMaster('add-subtask', ['--parent', taskId, '--title', 'Subtask 2', '--description', 'Second subtask'], { cwd: testDir });
-				await helpers.taskMaster('add-subtask', ['--parent', taskId, '--title', 'Subtask 3', '--description', 'Third subtask'], { cwd: testDir });
-			}
-
-			// Copy the tag
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['sprint', 'sprint-backup'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully copied tag');
-
-			// Verify subtasks are preserved
-			await helpers.taskMaster('use-tag', ['sprint-backup'], { cwd: testDir });
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Epic');
-			
-			// Check if subtasks were preserved
-			if (showResult.stdout.includes('Subtasks')) {
-				// If subtasks are shown, verify they exist
-				expect(showResult.stdout).toContain('Subtasks');
-				// The subtask IDs might be numeric (1, 2, 3) instead of dot notation
-				expect(showResult.stdout).toMatch(/[1-3]/);
-			} else {
-				// If copy-tag doesn't preserve subtasks, this is a known limitation
-				console.log('Note: copy-tag command may not preserve subtasks - this could be expected behavior');
-				expect(showResult.stdout).toContain('No subtasks found');
-			}
-		});
-	});
-
-	describe('Tag metadata', () => {
-		it('should preserve original tag description by default', async () => {
-			const description = 'This is the original feature branch';
-			await helpers.taskMaster(
-				'add-tag',
-				['feature', '--description', `"${description}"`],
-				{ cwd: testDir }
-			);
-
-			// Copy without custom description
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['feature', 'feature-copy'],
-				{ cwd: testDir }
-			);
-			expect(result).toHaveExitCode(0);
-
-			// Check the copy has a default description mentioning it's a copy
-			const tagsResult = await helpers.taskMaster('tags', ['--show-metadata'], {
-				cwd: testDir
-			});
-			expect(tagsResult.stdout).toContain('feature-copy');
-			// The default behavior is to create a description like "Copy of 'feature' created on ..."
-			expect(tagsResult.stdout).toContain('Copy of');
-			expect(tagsResult.stdout).toContain('feature');
-		});
-
-		it('should set creation date for new tag', async () => {
-			await helpers.taskMaster('add-tag', ['source'], { cwd: testDir });
-
-			// Copy the tag
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['source', 'destination'],
-				{ cwd: testDir }
-			);
-			expect(result).toHaveExitCode(0);
-
-			// Check metadata shows creation date
-			const tagsResult = await helpers.taskMaster('tags', ['--show-metadata'], {
-				cwd: testDir
-			});
-			expect(tagsResult.stdout).toContain('destination');
-			// Should show date in format like MM/DD/YYYY or YYYY-MM-DD
-			const datePattern = /\d{1,2}\/\d{1,2}\/\d{4}|\d{4}-\d{2}-\d{2}/;
-			expect(tagsResult.stdout).toMatch(datePattern);
-		});
-	});
-
-	describe('Cross-tag operations', () => {
-		it('should handle tasks that belong to multiple tags', async () => {
-			// Create two tags
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['bugfix'], { cwd: testDir });
-
-			// Add task to feature
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Shared task', '--description', 'Task in multiple tags'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task1.stdout);
-
-			// Also add it to bugfix (by switching and creating another task, then we'll test the copy behavior)
-			await helpers.taskMaster('use-tag', ['bugfix'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Bugfix only', '--description', 'Only in bugfix'],
-				{ cwd: testDir }
-			);
-
-			// Copy feature tag
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['feature', 'feature-v2'],
-				{ cwd: testDir }
-			);
-			expect(result).toHaveExitCode(0);
-
-			// Verify task is in new tag
-			await helpers.taskMaster('use-tag', ['feature-v2'], { cwd: testDir });
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			// Just verify the task is there (title may be truncated)
-			expect(listResult.stdout).toContain('Shared');
-			// Check for the pending count in the Project Dashboard - it appears after other counts
-			expect(listResult.stdout).toMatch(/Pending:\s*1/);
-		});
-	});
-
-	describe('Output format', () => {
-		it('should provide clear success message', async () => {
-			await helpers.taskMaster('add-tag', ['dev'], { cwd: testDir });
-
-			// Add some tasks
-			await helpers.taskMaster('use-tag', ['dev'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 1', '--description', 'First'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 2', '--description', 'Second'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['dev', 'dev-backup'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully copied tag');
-			expect(result.stdout).toContain('dev');
-			expect(result.stdout).toContain('dev-backup');
-			// The output has a single space after the colon in the formatted box
-			expect(result.stdout).toMatch(/Tasks Copied:\s*2/);
-		});
-
-		it('should handle verbose output if supported', async () => {
-			await helpers.taskMaster('add-tag', ['test'], { cwd: testDir });
-
-			// Try with potential verbose flag (if supported)
-			const result = await helpers.taskMaster(
-				'copy-tag',
-				['test', 'test-copy'],
-				{ cwd: testDir }
-			);
-
-			// Basic success is enough
-			expect(result).toHaveExitCode(0);
-		});
-	});
-});

tests/e2e/tests/commands/delete-tag.test.js

@@ -1,529 +0,0 @@
-/**
- * Comprehensive E2E tests for delete-tag command
- * Tests all aspects of tag deletion including safeguards and edge cases
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('delete-tag command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-delete-tag-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('delete-tag');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic tag deletion', () => {
-		it('should delete an existing tag with confirmation bypass', async () => {
-			// Create a new tag
-			const addTagResult = await helpers.taskMaster(
-				'add-tag',
-				['feature-xyz', '--description', 'Feature branch for XYZ'],
-				{ cwd: testDir }
-			);
-			expect(addTagResult).toHaveExitCode(0);
-
-			// Delete the tag with --yes flag
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['feature-xyz', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully deleted tag "feature-xyz"');
-			expect(result.stdout).toContain('✓ Tag Deleted Successfully');
-
-			// Verify tag is deleted by listing tags
-			const listResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(listResult.stdout).not.toContain('feature-xyz');
-		});
-
-		it('should delete a tag with tasks', async () => {
-			// Create a new tag
-			await helpers.taskMaster(
-				'add-tag',
-				['temp-feature', '--description', 'Temporary feature'],
-				{ cwd: testDir }
-			);
-
-			// Switch to the new tag
-			await helpers.taskMaster('use-tag', ['temp-feature'], { cwd: testDir });
-
-			// Add some tasks to the tag
-			const task1Result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Task 1"',
-					'--description',
-					'"First task in temp-feature"'
-				],
-				{ cwd: testDir }
-			);
-			expect(task1Result).toHaveExitCode(0);
-
-			const task2Result = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Task 2"',
-					'--description',
-					'"Second task in temp-feature"'
-				],
-				{ cwd: testDir }
-			);
-			expect(task2Result).toHaveExitCode(0);
-
-			// Verify tasks were created by listing them
-			const listResult = await helpers.taskMaster(
-				'list',
-				['--tag', 'temp-feature'],
-				{ cwd: testDir }
-			);
-			expect(listResult.stdout).toContain('Task 1');
-			expect(listResult.stdout).toContain('Task 2');
-
-			// Delete the tag while it's current
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['temp-feature', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toMatch(/Tasks Deleted:\s*2/);
-			expect(result.stdout).toContain('Switched current tag to "master"');
-
-			// Verify we're on master tag
-			const showResult = await helpers.taskMaster('show', [], { cwd: testDir });
-			expect(showResult.stdout).toContain('🏷️ tag: master');
-		});
-	});
-
-	describe('Error cases', () => {
-		it('should fail when deleting non-existent tag', async () => {
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['non-existent-tag', '--yes'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Tag "non-existent-tag" does not exist');
-		});
-
-		it('should fail when trying to delete master tag', async () => {
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['master', '--yes'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Cannot delete the "master" tag');
-		});
-
-		it('should fail with invalid tag name', async () => {
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['invalid/tag/name', '--yes'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			// The error might come from not finding the tag or invalid name
-			expect(result.stderr).toMatch(/does not exist|invalid/i);
-		});
-
-		it('should fail when no tag name is provided', async () => {
-			const result = await helpers.taskMaster('delete-tag', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('required');
-		});
-	});
-
-	describe('Interactive confirmation flow', () => {
-		it('should require confirmation without --yes flag', async () => {
-			// Create a tag
-			await helpers.taskMaster('add-tag', ['interactive-test'], {
-				cwd: testDir
-			});
-
-			// Try to delete without --yes flag
-			// Since this would require interactive input, we expect it to fail or timeout
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['interactive-test'],
-				{ cwd: testDir, allowFailure: true, timeout: 2000 }
-			);
-
-			// Check what happened
-			if (result.stdout.includes('Successfully deleted')) {
-				// If delete succeeded without confirmation, skip the test
-				// as the feature may not be implemented
-				console.log(
-					'Interactive confirmation may not be implemented - tag was deleted without --yes flag'
-				);
-				expect(true).toBe(true); // Pass the test with a note
-			} else {
-				// If the command failed or timed out, tag should still exist
-				expect(result.exitCode).not.toBe(0);
-				const tagsResult = await helpers.taskMaster('tags', [], {
-					cwd: testDir
-				});
-				expect(tagsResult.stdout).toContain('interactive-test');
-			}
-		});
-	});
-
-	describe('Current tag handling', () => {
-		it('should switch to master when deleting the current tag', async () => {
-			// Create and switch to a new tag
-			await helpers.taskMaster('add-tag', ['current-feature'], {
-				cwd: testDir
-			});
-			await helpers.taskMaster('use-tag', ['current-feature'], {
-				cwd: testDir
-			});
-
-			// Add a task to verify we're on the current tag
-			await helpers.taskMaster(
-				'add-task',
-				['--title', '"Task in current feature"'],
-				{ cwd: testDir }
-			);
-
-			// Delete the current tag
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['current-feature', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Switched current tag to "master"');
-
-			// Verify we're on master tag
-			const currentTagResult = await helpers.taskMaster('tags', [], {
-				cwd: testDir
-			});
-			expect(currentTagResult.stdout).toMatch(/●\s*master\s*\(current\)/);
-		});
-
-		it('should not switch tags when deleting a non-current tag', async () => {
-			// Create two tags
-			await helpers.taskMaster('add-tag', ['feature-a'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['feature-b'], { cwd: testDir });
-
-			// Switch to feature-a
-			await helpers.taskMaster('use-tag', ['feature-a'], { cwd: testDir });
-
-			// Delete feature-b (not current)
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['feature-b', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).not.toContain('Switched current tag');
-
-			// Verify we're still on feature-a
-			const currentTagResult = await helpers.taskMaster('tags', [], {
-				cwd: testDir
-			});
-			expect(currentTagResult.stdout).toMatch(/●\s*feature-a\s*\(current\)/);
-		});
-	});
-
-	describe('Tag with complex data', () => {
-		it('should delete tag with subtasks and dependencies', async () => {
-			// Create a tag with complex task structure
-			await helpers.taskMaster('add-tag', ['complex-feature'], {
-				cwd: testDir
-			});
-			await helpers.taskMaster('use-tag', ['complex-feature'], {
-				cwd: testDir
-			});
-
-			// Add parent task
-			const parentResult = await helpers.taskMaster(
-				'add-task',
-				['--title', '"Parent task"', '--description', '"Has subtasks"'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parentResult.stdout);
-
-			// Add subtasks
-			await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentId, '--title', '"Subtask 1"'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentId, '--title', '"Subtask 2"'],
-				{ cwd: testDir }
-			);
-
-			// Add task with dependencies
-			const depResult = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Dependent task"',
-					'--description',
-					'"Task that depends on parent"',
-					'--dependencies',
-					parentId
-				],
-				{ cwd: testDir }
-			);
-			expect(depResult).toHaveExitCode(0);
-
-			// Delete the tag
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['complex-feature', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Check that tasks were deleted - actual count may vary depending on implementation
-			expect(result.stdout).toMatch(/Tasks Deleted:\s*\d+/);
-			expect(result.stdout).toContain(
-				'Successfully deleted tag "complex-feature"'
-			);
-		});
-
-		it('should handle tag with many tasks efficiently', async () => {
-			// Create a tag
-			await helpers.taskMaster('add-tag', ['bulk-feature'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['bulk-feature'], { cwd: testDir });
-
-			// Add many tasks
-			const taskCount = 10;
-			for (let i = 1; i <= taskCount; i++) {
-				await helpers.taskMaster(
-					'add-task',
-					[
-						'--title',
-						`Task ${i}`,
-						'--description',
-						`Description for task ${i}`
-					],
-					{ cwd: testDir }
-				);
-			}
-
-			// Delete the tag
-			const startTime = Date.now();
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['bulk-feature', '--yes'],
-				{ cwd: testDir }
-			);
-			const endTime = Date.now();
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toMatch(new RegExp(`Tasks Deleted:\\s*${taskCount}`));
-
-			// Should complete within reasonable time (5 seconds)
-			expect(endTime - startTime).toBeLessThan(5000);
-		});
-	});
-
-	describe('File path handling', () => {
-		it('should work with custom tasks file path', async () => {
-			// Create custom tasks file with a tag
-			const customPath = join(testDir, 'custom-tasks.json');
-			writeFileSync(
-				customPath,
-				JSON.stringify({
-					master: { tasks: [] },
-					'custom-tag': {
-						tasks: [
-							{
-								id: 1,
-								title: 'Task in custom tag',
-								status: 'pending'
-							}
-						],
-						metadata: {
-							created: new Date().toISOString(),
-							description: 'Custom tag'
-						}
-					}
-				})
-			);
-
-			// Delete tag from custom file
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['custom-tag', '--yes', '--file', customPath],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully deleted tag "custom-tag"');
-
-			// Verify tag is deleted from custom file
-			const fileContent = JSON.parse(readFileSync(customPath, 'utf8'));
-			expect(fileContent['custom-tag']).toBeUndefined();
-			expect(fileContent.master).toBeDefined();
-		});
-	});
-
-	describe('Edge cases', () => {
-		it('should handle empty tag gracefully', async () => {
-			// Create an empty tag
-			await helpers.taskMaster('add-tag', ['empty-tag'], { cwd: testDir });
-
-			// Delete the empty tag
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['empty-tag', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toMatch(/Tasks Deleted:\s*0/);
-		});
-
-		it('should handle special characters in tag names', async () => {
-			// Create tag with hyphens and numbers
-			const tagName = 'feature-123-test';
-			await helpers.taskMaster('add-tag', [tagName], { cwd: testDir });
-
-			// Delete it
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				[tagName, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(`Successfully deleted tag "${tagName}"`);
-		});
-
-		it('should preserve other tags when deleting one', async () => {
-			// Create multiple tags
-			await helpers.taskMaster('add-tag', ['keep-me-1'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['delete-me'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['keep-me-2'], { cwd: testDir });
-
-			// Add tasks to each
-			await helpers.taskMaster('use-tag', ['keep-me-1'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Task in keep-me-1"',
-					'--description',
-					'"Description for keep-me-1"'
-				],
-				{ cwd: testDir }
-			);
-
-			await helpers.taskMaster('use-tag', ['delete-me'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Task in delete-me"',
-					'--description',
-					'"Description for delete-me"'
-				],
-				{ cwd: testDir }
-			);
-
-			await helpers.taskMaster('use-tag', ['keep-me-2'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Task in keep-me-2"',
-					'--description',
-					'"Description for keep-me-2"'
-				],
-				{ cwd: testDir }
-			);
-
-			// Delete middle tag
-			const result = await helpers.taskMaster(
-				'delete-tag',
-				['delete-me', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify other tags still exist with their tasks
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('keep-me-1');
-			expect(tagsResult.stdout).toContain('keep-me-2');
-			expect(tagsResult.stdout).not.toContain('delete-me');
-
-			// Verify tasks in other tags are preserved
-			await helpers.taskMaster('use-tag', ['keep-me-1'], { cwd: testDir });
-			const list1 = await helpers.taskMaster('list', ['--tag', 'keep-me-1'], {
-				cwd: testDir
-			});
-			expect(list1.stdout).toContain('Task in keep-me-1');
-
-			await helpers.taskMaster('use-tag', ['keep-me-2'], { cwd: testDir });
-			const list2 = await helpers.taskMaster('list', ['--tag', 'keep-me-2'], {
-				cwd: testDir
-			});
-			expect(list2.stdout).toContain('Task in keep-me-2');
-		});
-	});
-});

tests/e2e/tests/commands/expand-task.test.js

@@ -1,380 +0,0 @@
-/**
- * Comprehensive E2E tests for expand-task command
- * Tests all aspects of task expansion including single, multiple, and recursive expansion
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-describe('expand-task command', () => {
-	let testDir;
-	let helpers;
-	let simpleTaskId;
-	// Removed complexTaskId to reduce AI calls in tests
-	let manualTaskId;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-expand-task-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('expand-task');
-		helpers = context.helpers;
-
-		copyConfigFiles(testDir);
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-
-		// Create simple task for expansion
-		const simpleResult = await helpers.taskMaster(
-			'add-task',
-			['--prompt', 'Create a user authentication system'],
-			{ cwd: testDir }
-		);
-		simpleTaskId = helpers.extractTaskId(simpleResult.stdout);
-
-		// Create manual task (no AI prompt) - removed complex task to reduce AI calls
-		const manualResult = await helpers.taskMaster(
-			'add-task',
-			[
-				'--title',
-				'Manual task for expansion',
-				'--description',
-				'This is a manually created task'
-			],
-			{ cwd: testDir }
-		);
-		manualTaskId = helpers.extractTaskId(manualResult.stdout);
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Single task expansion', () => {
-		it('should expand a single task', async () => {
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', simpleTaskId],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully parsed');
-
-			// Verify subtasks were created
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const expandedTask = tasks.master.tasks.find(t => t.id === parseInt(simpleTaskId));
-			
-			expect(expandedTask.subtasks).toBeDefined();
-			expect(expandedTask.subtasks.length).toBeGreaterThan(0);
-		}, 60000);
-
-		it('should expand with custom number of subtasks', async () => {
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', simpleTaskId, '--num', '3'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Check that we got approximately 3 subtasks (AI might create more)
-			const showResult = await helpers.taskMaster('show', [simpleTaskId], {
-				cwd: testDir
-			});
-			const subtaskMatches = showResult.stdout.match(/\d+\.\d+/g);
-			expect(subtaskMatches).toBeTruthy();
-			expect(subtaskMatches.length).toBeGreaterThanOrEqual(2);
-			expect(subtaskMatches.length).toBeLessThanOrEqual(10); // AI might create more subtasks
-		}, 60000);
-
-		it('should expand with research mode', async () => {
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', simpleTaskId, '--research'],
-				{ cwd: testDir, timeout: 60000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('research');
-		}, 90000);
-
-		it('should expand with additional context', async () => {
-			const result = await helpers.taskMaster(
-				'expand',
-				[
-					'--id',
-					manualTaskId,
-					'--prompt',
-					'Focus on security best practices and testing'
-				],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify context was used
-			const showResult = await helpers.taskMaster('show', [manualTaskId], {
-				cwd: testDir
-			});
-			const outputLower = showResult.stdout.toLowerCase();
-			expect(outputLower).toMatch(/security|test/);
-		}, 60000);
-	});
-
-	describe('Bulk expansion', () => {
-		it('should expand all tasks', async () => {
-			const result = await helpers.taskMaster('expand', ['--all'], {
-				cwd: testDir,
-				timeout: 90000 // Reduced timeout since we have fewer tasks
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Expanding all');
-
-			// Verify at least one task has subtasks (reduced expectation)
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksData = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const tasks = tasksData.master.tasks;
-
-			const tasksWithSubtasks = tasks.filter(
-				(t) => t.subtasks && t.subtasks.length > 0
-			);
-			expect(tasksWithSubtasks.length).toBeGreaterThanOrEqual(1); // Reduced from 2 to 1
-		}, 120000); // Reduced timeout from 150000 to 120000
-
-		it('should expand all with force flag', async () => {
-			// First expand one task
-			await helpers.taskMaster('expand', ['--id', simpleTaskId], {
-				cwd: testDir
-			});
-
-			// Then expand all with force
-			const result = await helpers.taskMaster('expand', ['--all', '--force'], {
-				cwd: testDir,
-				timeout: 90000 // Reduced timeout
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toContain('force');
-		}, 120000); // Reduced timeout from 150000 to 120000
-	});
-
-	describe('Specific task ranges', () => {
-		it.skip('should expand tasks by ID range', async () => {
-			// Create more tasks
-			await helpers.taskMaster('add-task', ['--prompt', 'Additional task 1'], {
-				cwd: testDir
-			});
-			await helpers.taskMaster('add-task', ['--prompt', 'Additional task 2'], {
-				cwd: testDir
-			});
-
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', '2,3,4'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify tasks 2-4 were expanded by checking the tasks file
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			
-			const task2 = tasks.master.tasks.find(t => t.id === 2);
-			const task3 = tasks.master.tasks.find(t => t.id === 3);
-			const task4 = tasks.master.tasks.find(t => t.id === 4);
-			
-			// Check that subtasks were created
-			expect(task2.subtasks).toBeDefined();
-			expect(task2.subtasks.length).toBeGreaterThan(0);
-			expect(task3.subtasks).toBeDefined();
-			expect(task3.subtasks.length).toBeGreaterThan(0);
-			expect(task4.subtasks).toBeDefined();
-			expect(task4.subtasks.length).toBeGreaterThan(0);
-		}, 120000);
-
-		it.skip('should expand specific task IDs', async () => {
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', `${simpleTaskId},${complexTaskId}`],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Both tasks should have subtasks
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			
-			const simpleTask = tasks.master.tasks.find(t => t.id === parseInt(simpleTaskId));
-			const complexTask = tasks.master.tasks.find(t => t.id === parseInt(complexTaskId));
-			
-			// Check that subtasks were created
-			expect(simpleTask.subtasks).toBeDefined();
-			expect(simpleTask.subtasks.length).toBeGreaterThan(0);
-			expect(complexTask.subtasks).toBeDefined();
-			expect(complexTask.subtasks.length).toBeGreaterThan(0);
-		}, 120000);
-	});
-
-	describe('Error handling', () => {
-		it('should fail for non-existent task ID', async () => {
-			const result = await helpers.taskMaster('expand', ['--id', '99999'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('not found');
-		});
-
-		it('should skip already expanded tasks without force', async () => {
-			// First expansion
-			await helpers.taskMaster('expand', ['--id', simpleTaskId], {
-				cwd: testDir
-			});
-
-			// Second expansion without force
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', simpleTaskId],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toMatch(/already|skip/);
-		});
-
-		it('should handle invalid number of subtasks', async () => {
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', simpleTaskId, '--num', '-1'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			// The command should either fail or use default number
-			if (result.exitCode !== 0) {
-				expect(result.stderr || result.stdout).toContain('Invalid');
-			} else {
-				// If it succeeds, it should use default number of subtasks
-				expect(result.stdout).toContain('Using default number of subtasks');
-			}
-		});
-	});
-
-	describe('Tag support', () => {
-		it('should expand tasks in specific tag', async () => {
-			// Create tag and tagged task
-			await helpers.taskMaster('add-tag', ['feature-tag'], { cwd: testDir });
-
-			const taggedResult = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Tagged task for expansion', '--tag', 'feature-tag'],
-				{ cwd: testDir }
-			);
-			const taggedId = helpers.extractTaskId(taggedResult.stdout);
-
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', taggedId, '--tag', 'feature-tag'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify expansion in correct tag
-			const showResult = await helpers.taskMaster(
-				'show',
-				[taggedId, '--tag', 'feature-tag'],
-				{ cwd: testDir }
-			);
-			expect(showResult.stdout).toContain('Subtasks');
-		}, 60000);
-	});
-
-	describe('Model configuration', () => {
-		it('should use specified model for expansion', async () => {
-			const result = await helpers.taskMaster(
-				'expand',
-				['--id', simpleTaskId],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-		}, 60000);
-	});
-
-	describe('Output validation', () => {
-		it('should create valid subtask structure', async () => {
-			await helpers.taskMaster('expand', ['--id', simpleTaskId], {
-				cwd: testDir
-			});
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksData = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const task = tasksData.master.tasks.find(
-				(t) => t.id === parseInt(simpleTaskId)
-			);
-
-			expect(task.subtasks).toBeDefined();
-			expect(Array.isArray(task.subtasks)).toBe(true);
-			expect(task.subtasks.length).toBeGreaterThan(0);
-
-			// Validate subtask structure
-			task.subtasks.forEach((subtask, index) => {
-				expect(subtask.id).toBe(index + 1);
-				expect(subtask.title).toBeTruthy();
-				expect(subtask.description).toBeTruthy();
-				expect(subtask.status).toBe('pending');
-			});
-		});
-
-		it('should maintain task dependencies after expansion', async () => {
-			// Create task with dependency
-			const depResult = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Dependent task', '--dependencies', simpleTaskId],
-				{ cwd: testDir }
-			);
-			const depTaskId = helpers.extractTaskId(depResult.stdout);
-
-			// Expand the task
-			await helpers.taskMaster('expand', ['--id', depTaskId], { cwd: testDir });
-
-			// Check dependencies are preserved
-			const showResult = await helpers.taskMaster('show', [depTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Dependencies:');
-			expect(showResult.stdout).toContain(simpleTaskId);
-		});
-	});
-});

tests/e2e/tests/commands/fix-dependencies.test.js

@@ -1,425 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master fix-dependencies command', () => {
-	let testDir;
-	let helpers;
-	let tasksPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-fix-dependencies-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('fix-dependencies command');
-		helpers = context.helpers;
-
-		// Set up tasks path
-		tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		if (!existsSync(tasksPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should fix missing dependencies by removing them', async () => {
-		// Create test tasks with missing dependencies
-		const tasksWithMissingDeps = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [999, 888], // Non-existent tasks
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1, 777], // Mix of valid and invalid
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(tasksWithMissingDeps, null, 2));
-
-		// Run fix-dependencies command
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Checking for and fixing invalid dependencies');
-		expect(result.stdout).toContain('Fixed dependency issues');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task1 = updatedTasks.master.tasks.find(t => t.id === 1);
-		const task2 = updatedTasks.master.tasks.find(t => t.id === 2);
-
-		// Verify missing dependencies were removed
-		expect(task1.dependencies).toEqual([]);
-		expect(task2.dependencies).toEqual([1]); // Only valid dependency remains
-	});
-
-	it('should fix circular dependencies', async () => {
-		// Create test tasks with circular dependencies
-		const circularTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [3], // Circular: 1 -> 3 -> 2 -> 1
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1],
-						subtasks: []
-					},
-					{
-						id: 3,
-						description: 'Task 3',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [2],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(circularTasks, null, 2));
-
-		// Run fix-dependencies command
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		
-		// Check if circular dependencies were detected and fixed
-		if (result.stdout.includes('No dependency issues found')) {
-			// If no issues were found, it might be that the implementation doesn't detect this type of circular dependency
-			// In this case, we'll just verify that dependencies are still intact
-			const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const dependencies = [
-				updatedTasks.master.tasks.find(t => t.id === 1).dependencies,
-				updatedTasks.master.tasks.find(t => t.id === 2).dependencies,
-				updatedTasks.master.tasks.find(t => t.id === 3).dependencies
-			];
-			
-			// If no circular dependency detection is implemented, tasks should remain unchanged
-			expect(dependencies).toEqual([[3], [1], [2]]);
-		} else {
-			// Circular dependencies were detected and should be fixed
-			expect(result.stdout).toContain('Fixed dependency issues');
-			
-			// Read updated tasks
-			const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			
-			// At least one dependency in the circle should be removed
-			const dependencies = [
-				updatedTasks.master.tasks.find(t => t.id === 1).dependencies,
-				updatedTasks.master.tasks.find(t => t.id === 2).dependencies,
-				updatedTasks.master.tasks.find(t => t.id === 3).dependencies
-			];
-
-			// Verify circular dependency was broken
-			const totalDeps = dependencies.reduce((sum, deps) => sum + deps.length, 0);
-			expect(totalDeps).toBeLessThan(3); // At least one dependency removed
-		}
-	});
-
-	it('should fix self-dependencies', async () => {
-		// Create test tasks with self-dependencies
-		const selfDepTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [1, 2], // Self-dependency + valid dependency
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(selfDepTasks, null, 2));
-
-		// Run fix-dependencies command
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		
-		// Check if self-dependencies were detected and fixed
-		if (result.stdout.includes('No dependency issues found')) {
-			// If no issues were found, self-dependency detection might not be implemented
-			// In this case, we'll just verify that dependencies remain unchanged
-			const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const task1 = updatedTasks.master.tasks.find(t => t.id === 1);
-			
-			// If no self-dependency detection is implemented, task should remain unchanged
-			expect(task1.dependencies).toEqual([1, 2]);
-		} else {
-			// Self-dependencies were detected and should be fixed
-			expect(result.stdout).toContain('Fixed dependency issues');
-			
-			// Read updated tasks
-			const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const task1 = updatedTasks.master.tasks.find(t => t.id === 1);
-
-			// Verify self-dependency was removed
-			expect(task1.dependencies).toEqual([2]);
-		}
-	});
-
-	it('should fix subtask dependencies', async () => {
-		// Create test tasks with invalid subtask dependencies
-		const subtaskDepTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: [
-							{
-								id: 1,
-								description: 'Subtask 1.1',
-								status: 'pending',
-								priority: 'medium',
-								dependencies: ['999', '1.1'] // Invalid + self-dependency
-							},
-							{
-								id: 2,
-								description: 'Subtask 1.2',
-								status: 'pending',
-								priority: 'low',
-								dependencies: ['1.1'] // Valid
-							}
-						]
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(subtaskDepTasks, null, 2));
-
-		// Run fix-dependencies command
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Fixed');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task1 = updatedTasks.master.tasks.find(t => t.id === 1);
-		const subtask1 = task1.subtasks.find(s => s.id === 1);
-		const subtask2 = task1.subtasks.find(s => s.id === 2);
-
-		// Verify invalid dependencies were removed
-		expect(subtask1.dependencies).toEqual([]);
-		expect(subtask2.dependencies).toEqual(['1.1']); // Valid dependency remains
-	});
-
-	it('should handle tasks with no dependency issues', async () => {
-		// Create test tasks with valid dependencies
-		const validTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(validTasks, null, 2));
-
-		// Run fix-dependencies command
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should succeed with no changes
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('No dependency issues found');
-
-		// Verify tasks remain unchanged
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		expect(updatedTasks).toEqual(validTasks);
-	});
-
-	it('should work with tag option', async () => {
-		// Create tasks with different tags
-		const multiTagTasks = {
-			master: {
-				tasks: [{
-					id: 1,
-					description: 'Master task',
-					dependencies: [999] // Invalid
-				}]
-			},
-			feature: {
-				tasks: [{
-					id: 1,
-					description: 'Feature task',
-					dependencies: [888] // Invalid
-				}]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(multiTagTasks, null, 2));
-
-		// Fix dependencies in feature tag only
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath, '--tag', 'feature'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Fixed');
-
-		// Verify only feature tag was fixed
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		expect(updatedTasks.master.tasks[0].dependencies).toEqual([999]); // Unchanged
-		expect(updatedTasks.feature.tasks[0].dependencies).toEqual([]); // Fixed
-	});
-
-	it('should handle complex dependency chains', async () => {
-		// Create test tasks with complex invalid dependencies
-		const complexTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [2, 999], // Valid + invalid
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [3, 4], // All valid
-						subtasks: []
-					},
-					{
-						id: 3,
-						description: 'Task 3',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [1], // Creates indirect cycle
-						subtasks: []
-					},
-					{
-						id: 4,
-						description: 'Task 4',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [888, 777], // All invalid
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(complexTasks, null, 2));
-
-		// Run fix-dependencies command
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Fixed');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task1 = updatedTasks.master.tasks.find(t => t.id === 1);
-		const task4 = updatedTasks.master.tasks.find(t => t.id === 4);
-
-		// Verify invalid dependencies were removed
-		expect(task1.dependencies).not.toContain(999);
-		expect(task4.dependencies).toEqual([]);
-	});
-
-	it('should handle empty task list', async () => {
-		// Create empty tasks file
-		const emptyTasks = {
-			master: {
-				tasks: []
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(emptyTasks, null, 2));
-
-		// Run fix-dependencies command
-		const result = await helpers.taskMaster('fix-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should handle gracefully
-		expect(result).toHaveExitCode(0);
-		// The output includes this in a formatted box
-		expect(result.stdout).toContain('Tasks checked: 0');
-	});
-});

tests/e2e/tests/commands/generate.test.js

@@ -1,275 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master generate command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-generate-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('generate command');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should generate task files from tasks.json', async () => {
-		// Create a test tasks.json file
-		const outputDir = join(testDir, 'generated-tasks');
-		
-		// Create test tasks
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Implement user authentication',
-						description: 'Set up authentication system',
-						details: 'Implementation details for auth system',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						testStrategy: 'Unit and integration tests',
-						subtasks: [
-							{
-								id: 1,
-								title: 'Set up JWT tokens',
-								description: 'Implement JWT token handling',
-								details: 'Create JWT token generation and validation',
-								status: 'pending',
-								dependencies: []
-							}
-						]
-					},
-					{
-						id: 2,
-						title: 'Create database schema',
-						description: 'Design and implement database schema',
-						details: 'Create tables and relationships',
-						status: 'in_progress',
-						priority: 'medium',
-						dependencies: [],
-						testStrategy: 'Database migration tests',
-						subtasks: []
-					}
-				],
-				metadata: {
-					created: new Date().toISOString(),
-					updated: new Date().toISOString(),
-					description: 'Tasks for master context'
-				}
-			}
-		};
-
-		// Write test tasks to tasks.json
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		writeFileSync(tasksJsonPath, JSON.stringify(testTasks, null, 2));
-
-		// Run generate command
-		const result = await helpers.taskMaster('generate', ['-o', outputDir], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('SUCCESS');
-
-		// Check that output directory was created
-		expect(existsSync(outputDir)).toBe(true);
-
-		// Check that task files were generated
-		const generatedFiles = readdirSync(outputDir);
-		expect(generatedFiles).toContain('task_001.txt');
-		expect(generatedFiles).toContain('task_002.txt');
-
-		// Verify content of generated files
-		const task1Content = readFileSync(join(outputDir, 'task_001.txt'), 'utf8');
-		expect(task1Content).toContain('Implement user authentication');
-		expect(task1Content).toContain('Set up JWT tokens');
-		expect(task1Content).toContain('pending');
-		expect(task1Content).toContain('high');
-
-		const task2Content = readFileSync(join(outputDir, 'task_002.txt'), 'utf8');
-		expect(task2Content).toContain('Create database schema');
-		expect(task2Content).toContain('in_progress');
-		expect(task2Content).toContain('medium');
-	});
-
-	it('should use default output directory when not specified', async () => {
-		// Create a test tasks.json file
-		const defaultOutputDir = join(testDir, '.taskmaster');
-		
-		// Create test tasks
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 3,
-						title: 'Simple task',
-						description: 'A simple task for testing',
-						details: 'Implementation details',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [],
-						testStrategy: 'Basic testing',
-						subtasks: []
-					}
-				],
-				metadata: {
-					created: new Date().toISOString(),
-					updated: new Date().toISOString(),
-					description: 'Tasks for master context'
-				}
-			}
-		};
-
-		// Write test tasks to tasks.json
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		writeFileSync(tasksJsonPath, JSON.stringify(testTasks, null, 2));
-
-		// Run generate command without output directory
-		const result = await helpers.taskMaster('generate', [], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Output directory:');
-		expect(result.stdout).toContain('.taskmaster');
-
-		// Check that task file was generated in default location
-		// The files are generated in a subdirectory, so let's check if the expected structure exists
-		const expectedDir = existsSync(join(defaultOutputDir, 'task_files')) ? 
-			join(defaultOutputDir, 'task_files') : 
-			existsSync(join(defaultOutputDir, 'tasks')) ? 
-				join(defaultOutputDir, 'tasks') : 
-				defaultOutputDir;
-		
-		if (existsSync(expectedDir) && expectedDir !== defaultOutputDir) {
-			const generatedFiles = readdirSync(expectedDir);
-			expect(generatedFiles).toContain('task_003.txt');
-		} else {
-			// Check if the file exists anywhere in the default directory tree
-			const searchForFile = (dir, fileName) => {
-				const items = readdirSync(dir, { withFileTypes: true });
-				for (const item of items) {
-					if (item.isDirectory()) {
-						const fullPath = join(dir, item.name);
-						if (searchForFile(fullPath, fileName)) return true;
-					} else if (item.name === fileName) {
-						return true;
-					}
-				}
-				return false;
-			};
-			expect(searchForFile(defaultOutputDir, 'task_003.txt')).toBe(true);
-		}
-	});
-
-	it('should handle tag option correctly', async () => {
-		// Create a test tasks.json file with multiple tags
-		const outputDir = join(testDir, 'generated-tags');
-		
-		// Create test tasks with different tags
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Master tag task',
-						description: 'A task for the master tag',
-						details: 'Implementation details',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						testStrategy: 'Master testing',
-						subtasks: []
-					}
-				],
-				metadata: {
-					created: new Date().toISOString(),
-					updated: new Date().toISOString(),
-					description: 'Tasks for master context'
-				}
-			},
-			feature: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Feature tag task',
-						description: 'A task for the feature tag',
-						details: 'Feature implementation details',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						testStrategy: 'Feature testing',
-						subtasks: []
-					}
-				],
-				metadata: {
-					created: new Date().toISOString(),
-					updated: new Date().toISOString(),
-					description: 'Tasks for feature context'
-				}
-			}
-		};
-
-		// Write test tasks to tasks.json
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		writeFileSync(tasksJsonPath, JSON.stringify(testTasks, null, 2));
-
-		// Run generate command with tag option
-		const result = await helpers.taskMaster('generate', ['-o', outputDir, '--tag', 'feature'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('SUCCESS');
-
-		// Check that only feature tag task was generated
-		const generatedFiles = readdirSync(outputDir);
-		expect(generatedFiles).toHaveLength(1);
-		expect(generatedFiles).toContain('task_001_feature.txt');
-
-		// Verify it's the feature tag task
-		const taskContent = readFileSync(join(outputDir, 'task_001_feature.txt'), 'utf8');
-		expect(taskContent).toContain('Feature tag task');
-		expect(taskContent).not.toContain('Master tag task');
-	});
-
-	it('should handle missing tasks file gracefully', async () => {
-		const nonExistentPath = join(testDir, 'non-existent-tasks.json');
-		
-		// Run generate command with non-existent file
-		const result = await helpers.taskMaster('generate', ['-f', nonExistentPath], { cwd: testDir });
-
-		// Should fail with appropriate error
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-	});
-});

tests/e2e/tests/commands/init.test.js

@@ -1,219 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-describe('task-master init command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-init-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('init command');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Note: Don't run init here, let individual tests do it
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should initialize a new project with default values', async () => {
-		// Run init command with --yes flag to skip prompts
-		const result = await helpers.taskMaster('init', ['--yes', '--skip-install', '--no-aliases', '--no-git'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Initializing project');
-
-		// Check that .taskmaster directory was created
-		const taskMasterDir = join(testDir, '.taskmaster');
-		expect(existsSync(taskMasterDir)).toBe(true);
-
-		// Check that config.json was created
-		const configPath = join(taskMasterDir, 'config.json');
-		expect(existsSync(configPath)).toBe(true);
-
-		// Verify config content
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config).toHaveProperty('global');
-		expect(config).toHaveProperty('models');
-		expect(config.global.projectName).toBeTruthy();
-
-		// Check that templates directory was created
-		const templatesDir = join(taskMasterDir, 'templates');
-		expect(existsSync(templatesDir)).toBe(true);
-
-		// Check that docs directory was created
-		const docsDir = join(taskMasterDir, 'docs');
-		expect(existsSync(docsDir)).toBe(true);
-	});
-
-	it('should initialize with custom project name and description', async () => {
-		const customName = 'MyTestProject';
-		const customDescription = 'A test project for task-master';
-		const customAuthor = 'Test Author';
-
-		// Run init command with custom values
-		const result = await helpers.taskMaster('init', ['--yes',
-				'--name', customName,
-				'--description', customDescription,
-				'--author', customAuthor,
-				'--skip-install',
-				'--no-aliases',
-				'--no-git'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-
-		// Check config was created
-		const configPath = join(testDir, '.taskmaster', 'config.json');
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		
-		// Check that config exists and has a projectName (may be default if --name doesn't work)
-		expect(config.global.projectName).toBeTruthy();
-		
-		// Check if package.json was created with custom values
-		const packagePath = join(testDir, 'package.json');
-		if (existsSync(packagePath)) {
-			const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
-			// Custom name might be in package.json instead
-			if (packageJson.name) {
-				expect(packageJson.name).toBe(customName);
-			}
-			if (packageJson.description) {
-				expect(packageJson.description).toBe(customDescription);
-			}
-			if (packageJson.author) {
-				expect(packageJson.author).toBe(customAuthor);
-			}
-		}
-	});
-
-	it('should initialize with specific rules', async () => {
-		// Run init command with specific rules
-		const result = await helpers.taskMaster('init', ['--yes',
-				'--rules', 'cursor,windsurf',
-				'--skip-install',
-				'--no-aliases',
-				'--no-git'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Initializing project');
-
-		// Check that rules were created in various possible locations
-		const rulesFiles = readdirSync(testDir);
-		const ruleFiles = rulesFiles.filter(f => f.includes('rules') || f.includes('.cursorrules') || f.includes('.windsurfrules'));
-		
-		// Also check in .taskmaster directory if it exists
-		const taskMasterDir = join(testDir, '.taskmaster');
-		if (existsSync(taskMasterDir)) {
-			const taskMasterFiles = readdirSync(taskMasterDir);
-			const taskMasterRuleFiles = taskMasterFiles.filter(f => f.includes('rules') || f.includes('.cursorrules') || f.includes('.windsurfrules'));
-			ruleFiles.push(...taskMasterRuleFiles);
-		}
-		
-		// If no rule files found, just check that init succeeded (rules feature may not be implemented)
-		if (ruleFiles.length === 0) {
-			// Rules feature might not be implemented, just verify basic init worked
-			expect(existsSync(join(testDir, '.taskmaster'))).toBe(true);
-		} else {
-			expect(ruleFiles.length).toBeGreaterThan(0);
-		}
-	});
-
-	it('should handle dry-run option', async () => {
-		// Run init command with dry-run
-		const result = await helpers.taskMaster('init', ['--yes', '--dry-run'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('DRY RUN');
-
-		// Check that no actual files were created
-		const taskMasterDir = join(testDir, '.taskmaster');
-		expect(existsSync(taskMasterDir)).toBe(false);
-	});
-
-	it('should fail when initializing in already initialized project', async () => {
-		// First initialization
-		const first = await helpers.taskMaster('init', ['--yes', '--skip-install', '--no-aliases', '--no-git'], { cwd: testDir });
-		expect(first).toHaveExitCode(0);
-
-		// Second initialization should fail or warn
-		const result = await helpers.taskMaster('init', ['--yes', '--skip-install', '--no-aliases', '--no-git'], { cwd: testDir, allowFailure: true });
-
-		// Check if it fails with appropriate message or succeeds with warning
-		if (result.exitCode !== 0) {
-			// Expected behavior: command fails
-			expect(result.stderr).toMatch(/already exists|already initialized/i);
-		} else {
-			// Alternative behavior: command succeeds but shows warning
-			expect(result.stdout).toMatch(/already exists|already initialized|skipping/i);
-		}
-	});
-
-	it('should initialize with version option', async () => {
-		const customVersion = '1.2.3';
-
-		// Run init command with custom version
-		const result = await helpers.taskMaster('init', ['--yes',
-				'--version', customVersion,
-				'--skip-install',
-				'--no-aliases',
-				'--no-git'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-
-		// If package.json is created, check version
-		const packagePath = join(testDir, 'package.json');
-		if (existsSync(packagePath)) {
-			const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
-			expect(packageJson.version).toBe(customVersion);
-		}
-	});
-
-	it('should handle git options correctly', async () => {
-		// Run init command with git option
-		const result = await helpers.taskMaster('init', ['--yes',
-				'--git',
-				'--git-tasks',
-				'--skip-install',
-				'--no-aliases'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-
-		// Check if .git directory was created
-		const gitDir = join(testDir, '.git');
-		expect(existsSync(gitDir)).toBe(true);
-
-		// Check if .gitignore was created
-		const gitignorePath = join(testDir, '.gitignore');
-		if (existsSync(gitignorePath)) {
-			const gitignoreContent = readFileSync(gitignorePath, 'utf8');
-			// .gitignore should contain some common patterns
-			expect(gitignoreContent).toContain('node_modules/');
-			expect(gitignoreContent).toContain('.env');
-			
-			// For git functionality, just verify gitignore has basic content
-			expect(gitignoreContent.length).toBeGreaterThan(50);
-		}
-	});
-});

tests/e2e/tests/commands/lang.test.js

@@ -1,427 +0,0 @@
-/**
- * Comprehensive E2E tests for lang command
- * Tests response language management functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import fs, {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync,
-	chmodSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-// TODO: fix config spam issue with lang
-describe.skip('lang command', () => {
-	let testDir;
-	let helpers;
-	let configPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-lang-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('lang');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Set config path
-		configPath = join(testDir, '.taskmaster/config.json');
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Setting response language', () => {
-		it('should set response language using --response flag', async () => {
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Spanish'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: Spanish'
-			);
-
-			// Verify config was updated
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('Spanish');
-		});
-
-		it('should set response language to custom language', async () => {
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Français'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: Français'
-			);
-
-			// Verify config was updated
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('Français');
-		});
-
-		it('should handle multi-word language names', async () => {
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', '"Traditional Chinese"'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: Traditional Chinese'
-			);
-
-			// Verify config was updated
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('Traditional Chinese');
-		});
-
-		it('should preserve other config settings when updating language', async () => {
-			// Read original config
-			const originalConfig = helpers.readJson(configPath);
-			const originalLogLevel = originalConfig.global.logLevel;
-			const originalProjectName = originalConfig.global.projectName;
-
-			// Set language
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'German'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify other settings are preserved
-			const updatedConfig = helpers.readJson(configPath);
-			expect(updatedConfig.global.responseLanguage).toBe('German');
-			expect(updatedConfig.global.logLevel).toBe(originalLogLevel);
-			expect(updatedConfig.global.projectName).toBe(originalProjectName);
-			expect(updatedConfig.models).toEqual(originalConfig.models);
-		});
-	});
-
-	describe('Interactive setup', () => {
-		it('should handle --setup flag (requires manual testing)', async () => {
-			// Note: Interactive prompts are difficult to test in automated tests
-			// This test verifies the command accepts the flag but doesn't test interaction
-			const result = await helpers.taskMaster('lang', ['--setup'], {
-				cwd: testDir,
-				timeout: 5000,
-				allowFailure: true
-			});
-
-			// Command should start but timeout waiting for input
-			expect(result.stdout).toContain(
-				'Starting interactive response language setup...'
-			);
-		});
-	});
-
-	describe('Default behavior', () => {
-		it('should default to English when no language specified', async () => {
-			// Remove response language from config
-			const config = helpers.readJson(configPath);
-			delete config.global.responseLanguage;
-			writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-			// Run lang command without parameters
-			const result = await helpers.taskMaster('lang', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Response language set to:');
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: English'
-			);
-
-			// Verify config was updated
-			const updatedConfig = helpers.readJson(configPath);
-			expect(updatedConfig.global.responseLanguage).toBe('English');
-		});
-
-		it('should maintain current language when command run without flags', async () => {
-			// First set to Spanish
-			await helpers.taskMaster('lang', ['--response', 'Spanish'], {
-				cwd: testDir
-			});
-
-			// Run without flags
-			const result = await helpers.taskMaster('lang', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			// Default behavior sets to English
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: English'
-			);
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should handle missing config file', async () => {
-			// Remove config file
-			rmSync(configPath, { force: true });
-
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Spanish'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stdout).toContain('❌ Error setting response language');
-			expect(result.stdout).toContain('The configuration file is missing');
-			expect(result.stdout).toContain(
-				'Run "task-master models --setup" to create it'
-			);
-		});
-
-		it('should handle empty language string', async () => {
-			const result = await helpers.taskMaster('lang', ['--response', ''], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stdout).toContain('❌ Error setting response language');
-			expect(result.stdout).toContain('Invalid response language');
-			expect(result.stdout).toContain('Must be a non-empty string');
-		});
-
-		it('should handle config write errors gracefully', async () => {
-			// Make config file read-only (simulate write error)
-			chmodSync(configPath, 0o444);
-
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Italian'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			// Restore write permissions for cleanup
-			fs.chmodSync(configPath, 0o644);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stdout).toContain('❌ Error setting response language');
-		});
-	});
-
-	describe('Integration with other commands', () => {
-		it('should persist language setting across multiple commands', async () => {
-			// Set language
-			await helpers.taskMaster('lang', ['--response', 'Japanese'], {
-				cwd: testDir
-			});
-
-			// Run another command (add-task)
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Test task',
-					'--description',
-					'Testing language persistence'
-				],
-				{ cwd: testDir }
-			);
-
-			// Verify language is still set
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('Japanese');
-		});
-
-		it('should work correctly when project root is different', async () => {
-			// Create a subdirectory
-			const subDir = join(testDir, 'subproject');
-			mkdirSync(subDir, { recursive: true });
-
-			// Run lang command from subdirectory
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Korean'],
-				{ cwd: subDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: Korean'
-			);
-
-			// Verify config in parent directory was updated
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('Korean');
-		});
-	});
-
-	describe('Special characters and edge cases', () => {
-		it('should handle languages with special characters', async () => {
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Português'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: Português'
-			);
-
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('Português');
-		});
-
-		it('should handle very long language names', async () => {
-			const longLanguage = 'Ancient Mesopotamian Cuneiform Script Translation';
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', `"${longLanguage}"`],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				`✅ Successfully set response language to: ${longLanguage}`
-			);
-
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe(longLanguage);
-		});
-
-		it('should handle language with numbers', async () => {
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', '"English 2.0"'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'✅ Successfully set response language to: English 2.0'
-			);
-
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('English 2.0');
-		});
-
-		it('should trim whitespace from language input', async () => {
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', '  Spanish  '],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// The trim happens in validation
-			expect(result.stdout).toContain('Successfully set response language to:');
-
-			const config = helpers.readJson(configPath);
-			// Verify the exact value stored (implementation may or may not trim)
-			expect(config.global.responseLanguage).toBeDefined();
-		});
-	});
-
-	describe('Performance', () => {
-		it('should update language quickly', async () => {
-			const startTime = Date.now();
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Russian'],
-				{ cwd: testDir }
-			);
-			const endTime = Date.now();
-
-			expect(result).toHaveExitCode(0);
-			// Should complete within 2 seconds
-			expect(endTime - startTime).toBeLessThan(2000);
-		});
-
-		it('should handle multiple rapid language changes', async () => {
-			const languages = [
-				'Spanish',
-				'French',
-				'German',
-				'Italian',
-				'Portuguese'
-			];
-
-			for (const lang of languages) {
-				const result = await helpers.taskMaster('lang', ['--response', lang], {
-					cwd: testDir
-				});
-				expect(result).toHaveExitCode(0);
-			}
-
-			// Verify final language is set
-			const config = helpers.readJson(configPath);
-			expect(config.global.responseLanguage).toBe('Portuguese');
-		});
-	});
-
-	describe('Display output', () => {
-		it('should show clear success message', async () => {
-			const result = await helpers.taskMaster('lang', ['--response', 'Dutch'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			// Check for colored output indicators
-			expect(result.stdout).toContain('Response language set to:');
-			expect(result.stdout).toContain('✅');
-			expect(result.stdout).toContain(
-				'Successfully set response language to: Dutch'
-			);
-		});
-
-		it('should show clear error message on failure', async () => {
-			// Remove config to trigger error
-			rmSync(configPath, { force: true });
-
-			const result = await helpers.taskMaster(
-				'lang',
-				['--response', 'Swedish'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			// Check for colored error indicators
-			expect(result.stdout).toContain('❌');
-			expect(result.stdout).toContain('Error setting response language');
-		});
-	});
-});

tests/e2e/tests/commands/list.test.js

@@ -1,814 +0,0 @@
-/**
- * Comprehensive E2E tests for list command
- * Tests all aspects of task listing including filtering and display options
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('list command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-list-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('list');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic listing', () => {
-		it('should list all tasks', async () => {
-			// Create some test tasks
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 1', '--description', 'First task'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 2', '--description', 'Second task'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1  │ Task');
-			expect(result.stdout).toContain('│ 2  │ Task');
-			expect(result.stdout).toContain('Project Dashboard');
-			expect(result.stdout).toContain('ID');
-			expect(result.stdout).toContain('Title');
-			expect(result.stdout).toContain('Status');
-			expect(result.stdout).toContain('Priority');
-			expect(result.stdout).toContain('Dependencies');
-		});
-
-		it('should show empty list message when no tasks exist', async () => {
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('No tasks found');
-		});
-
-		it('should display task progress dashboard', async () => {
-			// Create tasks with different statuses
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Completed task', '--description', 'Done'],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId1, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'In progress task', '--description', 'Working on it'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Project Dashboard');
-			expect(result.stdout).toContain('Tasks Progress:');
-			expect(result.stdout).toContain('Done:');
-			expect(result.stdout).toContain('In Progress:');
-			expect(result.stdout).toContain('Pending:');
-		});
-	});
-
-	describe('Status filtering', () => {
-		beforeEach(async () => {
-			// Create tasks with different statuses
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Pending task', '--description', 'Not started'],
-				{ cwd: testDir }
-			);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'In progress task', '--description', 'Working on it'],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId2, '--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			const task3 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Done task', '--description', 'Completed'],
-				{ cwd: testDir }
-			);
-			const taskId3 = helpers.extractTaskId(task3.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId3, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			const task4 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Review task', '--description', 'Needs review'],
-				{ cwd: testDir }
-			);
-			const taskId4 = helpers.extractTaskId(task4.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId4, '--status', 'review'],
-				{ cwd: testDir }
-			);
-
-			const task5 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Deferred task', '--description', 'Postponed'],
-				{ cwd: testDir }
-			);
-			const taskId5 = helpers.extractTaskId(task5.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId5, '--status', 'deferred'],
-				{ cwd: testDir }
-			);
-
-			const task6 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Cancelled task', '--description', 'No longer needed'],
-				{ cwd: testDir }
-			);
-			const taskId6 = helpers.extractTaskId(task6.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId6, '--status', 'cancelled'],
-				{ cwd: testDir }
-			);
-		});
-
-		it('should filter by pending status', async () => {
-			const result = await helpers.taskMaster('list', ['--status', 'pending'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1  │ Pending');
-			expect(result.stdout).not.toContain('In progress task');
-			expect(result.stdout).not.toContain('Done task');
-			expect(result.stdout).toContain('Filtered by status: pending');
-		});
-
-		it('should filter by in-progress status', async () => {
-			const result = await helpers.taskMaster(
-				'list',
-				['--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 2  │ In');
-			// Check that the main table doesn't contain other status tasks
-			expect(result.stdout).not.toContain('│ 1  │ Pending');
-			expect(result.stdout).not.toContain('│ 3  │ Done');
-		});
-
-		it('should filter by done status', async () => {
-			const result = await helpers.taskMaster('list', ['--status', 'done'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 3  │ Done');
-			// Check that the main table doesn't contain other status tasks
-			expect(result.stdout).not.toContain('│ 1  │ Pending');
-			expect(result.stdout).not.toContain('│ 2  │ In');
-		});
-
-		it('should filter by review status', async () => {
-			const result = await helpers.taskMaster('list', ['--status', 'review'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 4  │ Review');
-			// Check that the main table doesn't contain other status tasks
-			expect(result.stdout).not.toContain('│ 1  │ Pending');
-		});
-
-		it('should filter by deferred status', async () => {
-			const result = await helpers.taskMaster(
-				'list',
-				['--status', 'deferred'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 5  │ Deferred');
-			// Check that the main table doesn't contain other status tasks
-			expect(result.stdout).not.toContain('│ 1  │ Pending');
-		});
-
-		it('should filter by cancelled status', async () => {
-			const result = await helpers.taskMaster(
-				'list',
-				['--status', 'cancelled'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 6  │ Cancelled');
-			// Check that the main table doesn't contain other status tasks
-			expect(result.stdout).not.toContain('│ 1  │ Pending');
-		});
-
-		it('should handle multiple statuses with comma separation', async () => {
-			const result = await helpers.taskMaster(
-				'list',
-				['--status', 'pending,in-progress'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1  │ Pending');
-			expect(result.stdout).toContain('│ 2  │ In');
-			expect(result.stdout).not.toContain('Done task');
-			expect(result.stdout).not.toContain('Review task');
-		});
-
-		it('should show empty message for non-existent status filter', async () => {
-			const result = await helpers.taskMaster(
-				'list',
-				['--status', 'invalid-status'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				"No tasks with status 'invalid-status' found"
-			);
-		});
-	});
-
-	describe('Priority display', () => {
-		it('should display task priorities correctly', async () => {
-			// Create tasks with different priorities
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'High priority task',
-					'--description',
-					'Urgent',
-					'--priority',
-					'high'
-				],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Medium priority task',
-					'--description',
-					'Normal',
-					'--priority',
-					'medium'
-				],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Low priority task',
-					'--description',
-					'Can wait',
-					'--priority',
-					'low'
-				],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toMatch(/high/i);
-			expect(result.stdout).toMatch(/medium/i);
-			expect(result.stdout).toMatch(/low/i);
-
-			// Check priority breakdown
-			expect(result.stdout).toContain('Priority Breakdown:');
-			expect(result.stdout).toContain('High priority:');
-			expect(result.stdout).toContain('Medium priority:');
-			expect(result.stdout).toContain('Low priority:');
-		});
-	});
-
-	describe('Subtasks display', () => {
-		let parentTaskId;
-
-		beforeEach(async () => {
-			// Create a parent task with subtasks
-			const parentResult = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'Has subtasks'],
-				{ cwd: testDir }
-			);
-			parentTaskId = helpers.extractTaskId(parentResult.stdout);
-
-			// Add subtasks
-			await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentTaskId,
-					'--title',
-					'Subtask 1',
-					'--description',
-					'First subtask'
-				],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentTaskId,
-					'--title',
-					'Subtask 2',
-					'--description',
-					'Second subtask'
-				],
-				{ cwd: testDir }
-			);
-		});
-
-		it('should not show subtasks by default', async () => {
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1  │ Parent');
-			// Check that subtasks are not in the main table (they may appear in the recommended next task section)
-			expect(result.stdout).not.toMatch(/│\s*1\.1\s*│.*Subtask 1/);
-			expect(result.stdout).not.toMatch(/│\s*1\.2\s*│.*Subtask 2/);
-		});
-
-		it('should show subtasks with --with-subtasks flag', async () => {
-			const result = await helpers.taskMaster('list', ['--with-subtasks'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1     │ Parent');
-			// Check for subtask rows in the table
-			expect(result.stdout).toContain('│ 1.1   │ └─ Subtask');
-			expect(result.stdout).toContain('│ 1.2   │ └─ Subtask');
-			expect(result.stdout).toContain(`${parentTaskId}.1`);
-			expect(result.stdout).toContain(`${parentTaskId}.2`);
-			expect(result.stdout).toContain('└─');
-		});
-
-		it('should include subtasks in progress calculation', async () => {
-			const result = await helpers.taskMaster('list', ['--with-subtasks'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Subtasks Progress:');
-			// Check for completion count in subtasks progress
-			expect(result.stdout).toContain('Completed: 0/2');
-		});
-	});
-
-	describe('Tag filtering', () => {
-		beforeEach(async () => {
-			// Create a new tag
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-branch', '--description', 'Feature branch tasks'],
-				{ cwd: testDir }
-			);
-
-			// Add tasks to master tag
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task 1', '--description', 'In master tag'],
-				{ cwd: testDir }
-			);
-
-			// Switch to feature tag and add tasks
-			await helpers.taskMaster('use-tag', ['feature-branch'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Feature task 1',
-					'--description',
-					'In feature tag',
-					'--tag',
-					'feature-branch'
-				],
-				{ cwd: testDir }
-			);
-		});
-
-		it('should list tasks from specific tag', async () => {
-			const result = await helpers.taskMaster(
-				'list',
-				['--tag', 'feature-branch'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1  │ Feature');
-			expect(result.stdout).not.toContain('Master task 1');
-			// Check for tag in the output
-			expect(result.stdout).toContain('🏷️ tag: feature-branch');
-		});
-
-		it('should list tasks from master tag by default', async () => {
-			// Switch back to master tag
-			await helpers.taskMaster('use-tag', ['master'], { cwd: testDir });
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1  │ Master');
-			expect(result.stdout).not.toContain('Feature task 1');
-		});
-	});
-
-	describe('Dependencies display', () => {
-		it('should show task dependencies correctly', async () => {
-			// Create dependency tasks
-			const dep1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Dependency 1', '--description', 'First dependency'],
-				{ cwd: testDir }
-			);
-			const depId1 = helpers.extractTaskId(dep1.stdout);
-
-			const dep2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Dependency 2', '--description', 'Second dependency'],
-				{ cwd: testDir }
-			);
-			const depId2 = helpers.extractTaskId(dep2.stdout);
-
-			// Create task with dependencies
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Task with dependencies',
-					'--description',
-					'Depends on other tasks',
-					'--dependencies',
-					`${depId1},${depId2}`
-				],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(depId1);
-			expect(result.stdout).toContain(depId2);
-		});
-
-		it('should show dependency status with colors', async () => {
-			// Create dependency task
-			const dep = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Completed dependency', '--description', 'Done'],
-				{ cwd: testDir }
-			);
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			// Mark dependency as done
-			await helpers.taskMaster(
-				'set-status',
-				['--id', depId, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			// Create task with dependency
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Task with completed dependency',
-					'--description',
-					'Has satisfied dependency',
-					'--dependencies',
-					depId
-				],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			// The done dependency should be shown (implementation uses color coding)
-			expect(result.stdout).toContain(depId);
-		});
-
-		it('should show dependency dashboard', async () => {
-			// Create some tasks with dependencies
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Independent task', '--description', 'No dependencies'],
-				{ cwd: testDir }
-			);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Dependency task', '--description', 'Will be depended on'],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Dependent task',
-					'--description',
-					'Depends on task 2',
-					'--dependencies',
-					taskId2
-				],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Dependency Status & Next Task');
-			expect(result.stdout).toContain('Tasks with no dependencies:');
-			expect(result.stdout).toContain('Tasks ready to work on:');
-			expect(result.stdout).toContain('Tasks blocked by dependencies:');
-		});
-	});
-
-	describe('Complexity display', () => {
-		it('should show complexity scores when available', async () => {
-			// Create tasks
-			await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Build a complex authentication system'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Create a simple hello world endpoint'],
-				{ cwd: testDir }
-			);
-
-			// Run complexity analysis
-			const analyzeResult = await helpers.taskMaster('analyze-complexity', [], {
-				cwd: testDir,
-				timeout: 60000
-			});
-
-			if (analyzeResult.exitCode === 0) {
-				const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-				expect(result).toHaveExitCode(0);
-				expect(result.stdout).toContain('Complexity');
-			}
-		});
-	});
-
-	describe('Next task recommendation', () => {
-		it('should show next task recommendation', async () => {
-			// Create tasks with different priorities and dependencies
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'High priority task',
-					'--description',
-					'Should be done first',
-					'--priority',
-					'high'
-				],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Next Task to Work On');
-			expect(result.stdout).toContain('Start working:');
-			expect(result.stdout).toContain('task-master set-status');
-			expect(result.stdout).toContain('View details:');
-			expect(result.stdout).toContain('task-master show');
-		});
-
-		it('should show next eligible task when dependencies are resolved', async () => {
-			// Create prerequisite task
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Prerequisite', '--description', 'Must be done first'],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-
-			// Create task depending on it
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Dependent task',
-					'--description',
-					'Waiting for prerequisite',
-					'--dependencies',
-					taskId1
-				],
-				{ cwd: testDir }
-			);
-
-			// Mark first task as done
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId1, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			// Should recommend the ready task
-			expect(result.stdout).toContain('Next Task to Work On');
-			// Check for next task recommendation
-			expect(result.stdout).toContain('ID: 2 - Dependent task');
-		});
-	});
-
-	describe('File path handling', () => {
-		it('should use custom tasks file path', async () => {
-			// Create custom tasks file
-			const customPath = join(testDir, 'custom-tasks.json');
-			writeFileSync(
-				customPath,
-				JSON.stringify({
-					master: {
-						tasks: [
-							{
-								id: 1,
-								title: 'Custom file task',
-								description: 'Task in custom file',
-								status: 'pending',
-								priority: 'medium',
-								dependencies: []
-							}
-						]
-					}
-				})
-			);
-
-			const result = await helpers.taskMaster('list', ['--file', customPath], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Custom file task');
-			expect(result.stdout).toContain(`Listing tasks from: ${customPath}`);
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should handle missing tasks file gracefully', async () => {
-			const nonExistentPath = join(testDir, 'non-existent.json');
-			const result = await helpers.taskMaster(
-				'list',
-				['--file', nonExistentPath],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Error');
-		});
-
-		it('should handle invalid JSON in tasks file', async () => {
-			const invalidPath = join(testDir, 'invalid.json');
-			writeFileSync(invalidPath, '{ invalid json }');
-
-			const result = await helpers.taskMaster('list', ['--file', invalidPath], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-		});
-	});
-
-	describe('Performance with many tasks', () => {
-		it('should handle listing 50+ tasks efficiently', async () => {
-			// Create many tasks
-			const promises = [];
-			for (let i = 1; i <= 50; i++) {
-				promises.push(
-					helpers.taskMaster(
-						'add-task',
-						['--title', `Task ${i}`, '--description', `Description ${i}`],
-						{ cwd: testDir }
-					)
-				);
-			}
-
-			await Promise.all(promises);
-
-			const startTime = Date.now();
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-			const endTime = Date.now();
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('│ 1  │ Task');
-			expect(result.stdout).toContain('Tasks Progress:');
-
-			// Should complete within reasonable time (5 seconds)
-			expect(endTime - startTime).toBeLessThan(5000);
-		});
-	});
-
-	describe('Display formatting', () => {
-		it('should truncate long titles appropriately', async () => {
-			const longTitle =
-				'This is a very long task title that should be truncated in the display to fit within the table column width constraints';
-			await helpers.taskMaster(
-				'add-task',
-				['--title', longTitle, '--description', 'Task with long title'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			// Should contain at least part of the title
-			expect(result.stdout).toContain('│ 1  │ This');
-		});
-
-		it('should show suggested next steps', async () => {
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Sample task', '--description', 'For testing'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Suggested Next Steps:');
-			expect(result.stdout).toContain('task-master next');
-			expect(result.stdout).toContain('task-master expand');
-			expect(result.stdout).toContain('task-master set-status');
-		});
-	});
-});

tests/e2e/tests/commands/models.test.js

@@ -1,281 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master models command', () => {
-	let testDir;
-	let helpers;
-	let configPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-models-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('models command');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		configPath = join(testDir, '.taskmaster', 'config.json');
-		
-		// Create initial config with models
-		const initialConfig = {
-			models: {
-				main: {
-					provider: 'anthropic',
-					modelId: 'claude-3-5-sonnet-20241022',
-					maxTokens: 100000,
-					temperature: 0.2
-				},
-				research: {
-					provider: 'perplexity',
-					modelId: 'sonar',
-					maxTokens: 4096,
-					temperature: 0.1
-				},
-				fallback: {
-					provider: 'openai',
-					modelId: 'gpt-4o',
-					maxTokens: 128000,
-					temperature: 0.2
-				}
-			},
-			global: {
-				projectName: 'Test Project',
-				defaultTag: 'master'
-			}
-		};
-
-		mkdirSync(dirname(configPath), { recursive: true });
-		writeFileSync(configPath, JSON.stringify(initialConfig, null, 2));
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should display current model configuration', async () => {
-		// Run models command without options
-		const result = await helpers.taskMaster('models', [], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Active Model Configuration');
-		expect(result.stdout).toContain('Main');
-		expect(result.stdout).toContain('claude-3-5-sonnet-20241022');
-		expect(result.stdout).toContain('Research');
-		expect(result.stdout).toContain('sonar');
-		expect(result.stdout).toContain('Fallback');
-		expect(result.stdout).toContain('gpt-4o');
-	});
-
-	it('should set main model', async () => {
-		// Run models command to set main model
-		const result = await helpers.taskMaster('models', ['--set-main', 'gpt-4o-mini'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('✅');
-		expect(result.stdout).toContain('main model');
-
-		// Verify config was updated
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config.models.main.modelId).toBe('gpt-4o-mini');
-		expect(config.models.main.provider).toBe('openai');
-	});
-
-	it('should set research model', async () => {
-		// Run models command to set research model
-		const result = await helpers.taskMaster('models', ['--set-research', 'sonar-pro'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('✅');
-		expect(result.stdout).toContain('research model');
-
-		// Verify config was updated
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config.models.research.modelId).toBe('sonar-pro');
-		expect(config.models.research.provider).toBe('perplexity');
-	});
-
-	it('should set fallback model', async () => {
-		// Run models command to set fallback model
-		const result = await helpers.taskMaster('models', ['--set-fallback', 'claude-3-7-sonnet-20250219'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('✅');
-		expect(result.stdout).toContain('fallback model');
-
-		// Verify config was updated
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config.models.fallback.modelId).toBe('claude-3-7-sonnet-20250219');
-		expect(config.models.fallback.provider).toBe('anthropic');
-	});
-
-	it('should set custom Ollama model', async () => {
-		// Run models command with Ollama flag
-		const result = await helpers.taskMaster('models', ['--set-main', 'llama3.3:70b', '--ollama'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		
-		// Check if Ollama setup worked or if it failed gracefully
-		if (result.stdout.includes('✅')) {
-			// Ollama worked - verify config was updated
-			const config = JSON.parse(readFileSync(configPath, 'utf8'));
-			expect(config.models.main.modelId).toBe('llama3.3:70b');
-			expect(config.models.main.provider).toBe('ollama');
-		} else {
-			// Ollama might not be available in test environment - just verify command completed
-			expect(result.stdout).toContain('No model configuration changes were made');
-		}
-	});
-
-	it('should set custom OpenRouter model', async () => {
-		// Run models command with OpenRouter flag
-		const result = await helpers.taskMaster('models', ['--set-main', 'anthropic/claude-3.5-sonnet', '--openrouter'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('✅');
-
-		// Verify config was updated
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config.models.main.modelId).toBe('anthropic/claude-3.5-sonnet');
-		expect(config.models.main.provider).toBe('openrouter');
-	});
-
-	it('should set custom Bedrock model', async () => {
-		// Run models command with Bedrock flag
-		const result = await helpers.taskMaster('models', ['--set-main', 'anthropic.claude-3-sonnet-20240229-v1:0', '--bedrock'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('✅');
-
-		// Verify config was updated
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config.models.main.modelId).toBe('anthropic.claude-3-sonnet-20240229-v1:0');
-		expect(config.models.main.provider).toBe('bedrock');
-	});
-
-	it('should set Claude Code model', async () => {
-		// Run models command with Claude Code flag
-		const result = await helpers.taskMaster('models', ['--set-main', 'sonnet', '--claude-code'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('✅');
-
-		// Verify config was updated
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config.models.main.modelId).toBe('sonnet');
-		expect(config.models.main.provider).toBe('claude-code');
-	});
-
-	it('should fail with multiple provider flags', async () => {
-		// Run models command with multiple provider flags
-		const result = await helpers.taskMaster('models', ['--set-main', 'some-model', '--ollama', '--openrouter'], { 
-			cwd: testDir, 
-			allowFailure: true 
-		});
-
-		// Should fail
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-		expect(result.stderr).toContain('multiple provider flags');
-	});
-
-	it('should handle invalid model ID', async () => {
-		// Run models command with non-existent model
-		const result = await helpers.taskMaster('models', ['--set-main', 'non-existent-model-12345'], { 
-			cwd: testDir,
-			allowFailure: true 
-		});
-
-		// Command should complete successfully
-		expect(result).toHaveExitCode(0);
-		
-		// Check what actually happened
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		
-		if (config.models.main.modelId === 'non-existent-model-12345') {
-			// Model was set (some systems allow any model ID)
-			expect(config.models.main.modelId).toBe('non-existent-model-12345');
-		} else {
-			// Model was rejected and original kept - verify original is still there
-			expect(config.models.main.modelId).toBe('claude-3-5-sonnet-20241022');
-			// Should have some indication that the model wasn't changed
-			expect(result.stdout).toMatch(/No model configuration changes|invalid|not found|error/i);
-		}
-	});
-
-	it('should set multiple models at once', async () => {
-		// Run models command to set multiple models
-		const result = await helpers.taskMaster('models', ['--set-main', 'gpt-4o',
-				'--set-research', 'sonar',
-				'--set-fallback', 'claude-3-5-sonnet-20241022'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toMatch(/✅.*main model/);
-		expect(result.stdout).toMatch(/✅.*research model/);
-		expect(result.stdout).toMatch(/✅.*fallback model/);
-
-		// Verify all were updated
-		const config = JSON.parse(readFileSync(configPath, 'utf8'));
-		expect(config.models.main.modelId).toBe('gpt-4o');
-		expect(config.models.research.modelId).toBe('sonar');
-		expect(config.models.fallback.modelId).toBe('claude-3-5-sonnet-20241022');
-	});
-
-	it('should handle setup flag', async () => {
-		// Run models command with setup flag
-		// This will try to run interactive setup, so we need to handle it differently
-		const result = await helpers.taskMaster('models', ['--setup'], { 
-			cwd: testDir, 
-			timeout: 2000, // Short timeout since it will wait for input
-			allowFailure: true 
-		});
-
-		// Should start setup process or fail gracefully in non-interactive environment
-		if (result.exitCode === 0) {
-			expect(result.stdout).toContain('interactive model setup');
-		} else {
-			// In non-interactive environment, it might fail or show help
-			expect(result.stderr || result.stdout).toBeTruthy();
-		}
-	});
-
-	it('should display available models list', async () => {
-		// Run models command with a flag that triggers model list display
-		const result = await helpers.taskMaster('models', [], { cwd: testDir });
-
-		// Should show current configuration
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Model');
-		
-		// Could also have available models section
-		if (result.stdout.includes('Available Models')) {
-			expect(result.stdout).toMatch(/claude|gpt|sonar/i);
-		}
-	});
-});

tests/e2e/tests/commands/next.test.js

@@ -1,379 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master next command', () => {
-	let testDir;
-	let helpers;
-	let tasksPath;
-	let complexityReportPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-next-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('next command');
-		helpers = context.helpers;
-
-		// Initialize paths
-		tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		complexityReportPath = join(testDir, '.taskmaster/task-complexity-report.json');
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		if (!existsSync(tasksPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should show the next available task', async () => {
-		// Create test tasks
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Completed task',
-						description: 'A completed task',
-						status: 'done',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						title: 'Next available task',
-						description: 'The next available task',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 3,
-						title: 'Blocked task',
-						description: 'A blocked task',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [2],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		// Ensure .taskmaster directory exists
-		mkdirSync(dirname(tasksPath), { recursive: true });
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-
-		// Run next command
-		const result = await helpers.taskMaster('next', ['-f', tasksPath], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Next Task: #2');
-		expect(result.stdout).toContain('Next available task');
-		expect(result.stdout).toContain('The next available task');
-		expect(result.stdout).toContain('Priority:');
-		expect(result.stdout).toContain('high');
-	});
-
-	it('should prioritize tasks based on complexity report', async () => {
-		// Create test tasks
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Low complexity task',
-						description: 'A simple task with low complexity',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						title: 'High complexity task',
-						description: 'A complex task with high complexity',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		// Create complexity report
-		const complexityReport = {
-			tasks: [
-				{
-					id: 1,
-					complexity: {
-						score: 3,
-						factors: {
-							technical: 'low',
-							scope: 'small'
-						}
-					}
-				},
-				{
-					id: 2,
-					complexity: {
-						score: 8,
-						factors: {
-							technical: 'high',
-							scope: 'large'
-						}
-					}
-				}
-			]
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-		writeFileSync(complexityReportPath, JSON.stringify(complexityReport, null, 2));
-
-		// Run next command with complexity report
-		const result = await helpers.taskMaster('next', ['-f', tasksPath, '-r', complexityReportPath], { cwd: testDir });
-
-		// Should prioritize lower complexity task
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Next Task: #1');
-		expect(result.stdout).toContain('Low complexity task');
-	});
-
-	it('should handle dependencies correctly', async () => {
-		// Create test tasks with dependencies
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Prerequisite task',
-						description: 'A task that others depend on',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						title: 'Dependent task',
-						description: 'A task that depends on task 1',
-						status: 'pending',
-						priority: 'critical',
-						dependencies: [1],
-						subtasks: []
-					},
-					{
-						id: 3,
-						title: 'Independent task',
-						description: 'A task with no dependencies',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-
-		// Run next command
-		const result = await helpers.taskMaster('next', ['-f', tasksPath], { cwd: testDir });
-
-		// Should show task 1 (prerequisite) even though task 2 has higher priority
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Next Task: #1');
-		expect(result.stdout).toContain('Prerequisite task');
-	});
-
-	it('should skip in-progress tasks', async () => {
-		// Create test tasks
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'In progress task',
-						description: 'A task currently in progress',
-						status: 'in_progress',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						title: 'Available pending task',
-						description: 'A task available for starting',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-
-		// Run next command
-		const result = await helpers.taskMaster('next', ['-f', tasksPath], { cwd: testDir });
-
-		// Should show pending task, not in-progress
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Next Task: #2');
-		expect(result.stdout).toContain('Available pending task');
-	});
-
-	it('should handle all tasks completed', async () => {
-		// Create test tasks - all done
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Completed task 1',
-						status: 'done',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Completed task 2',
-						status: 'done',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-
-		// Run next command
-		const result = await helpers.taskMaster('next', ['-f', tasksPath], { cwd: testDir });
-
-		// Should indicate no tasks available
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('No eligible tasks found');
-	});
-
-	it('should handle blocked tasks', async () => {
-		// Create test tasks - all blocked
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Blocked task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [2],
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Blocked task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-
-		// Run next command
-		const result = await helpers.taskMaster('next', ['-f', tasksPath], { cwd: testDir });
-
-		// Should indicate circular dependency or all blocked
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout.toLowerCase()).toMatch(/circular|blocked|no.*eligible/);
-	});
-
-	it('should work with tag option', async () => {
-		// Create tasks with different tags
-		const multiTagTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Master task',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			},
-			feature: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Feature task',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(multiTagTasks, null, 2));
-
-		// Run next command with feature tag
-		const result = await helpers.taskMaster('next', ['-f', tasksPath, '--tag', 'feature'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Feature task');
-		expect(result.stdout).not.toContain('Master task');
-	});
-
-	it('should handle empty task list', async () => {
-		// Create empty tasks file
-		const emptyTasks = {
-			master: {
-				tasks: []
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(emptyTasks, null, 2));
-
-		// Run next command
-		const result = await helpers.taskMaster('next', ['-f', tasksPath], { cwd: testDir });
-
-		// Should handle gracefully
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('No eligible tasks found');
-	});
-});

tests/e2e/tests/commands/parse-prd.test.js

@@ -1,487 +0,0 @@
-/**
- * Comprehensive E2E tests for parse-prd command
- * Tests all aspects of PRD parsing including task generation, research mode, and various formats
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-// Skip these tests if Perplexity API key is not available
-const shouldSkip = !process.env.PERPLEXITY_API_KEY;
-
-describe.skip('parse-prd command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-parse-prd-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('parse-prd');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Copy configuration files
-		copyConfigFiles(testDir);
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic PRD parsing', () => {
-		it('should parse PRD from file', async () => {
-			// Create a simple PRD file
-			const prdContent = `# Project Requirements
-			
-			Build a user authentication system with the following features:
-			- User registration with email verification
-			- Login with JWT tokens
-			- Password reset functionality
-			- User profile management`;
-
-			const prdPath = join(testDir, 'test-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			const result = await helpers.taskMaster('parse-prd', [prdPath], {
-				cwd: testDir,
-				timeout: 150000
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully generated');
-
-			// Verify tasks.json was created
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			expect(existsSync(tasksPath)).toBe(true);
-
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			expect(tasks.master.tasks.length).toBeGreaterThan(0);
-		}, 180000);
-
-		it('should use default PRD file when none specified', async () => {
-			// Create default prd.txt in docs directory (first location checked)
-			const prdContent = 'Build a simple todo application';
-			const defaultPrdPath = join(testDir, '.taskmaster/docs/prd.txt');
-			mkdirSync(join(testDir, '.taskmaster/docs'), { recursive: true });
-			writeFileSync(defaultPrdPath, prdContent);
-
-			const result = await helpers.taskMaster('parse-prd', [], {
-				cwd: testDir,
-				timeout: 150000
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully generated');
-		}, 180000);
-
-		it('should parse PRD using --input option', async () => {
-			const prdContent = 'Create a REST API for blog management';
-			const prdPath = join(testDir, 'api-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				['--input', prdPath],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully generated');
-		}, 180000);
-	});
-
-	describe('Task generation options', () => {
-		it('should generate custom number of tasks', async () => {
-			const prdContent =
-				'Build a comprehensive e-commerce platform with all features';
-			const prdPath = join(testDir, 'ecommerce-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				[prdPath, '--num-tasks', '5'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			// AI might generate slightly more or less, but should be close to 5
-			expect(tasks.master.tasks.length).toBeGreaterThanOrEqual(3);
-			expect(tasks.master.tasks.length).toBeLessThanOrEqual(7);
-		}, 180000);
-
-		it('should handle custom output path', async () => {
-			const prdContent = 'Build a chat application';
-			const prdPath = join(testDir, 'chat-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			const customOutput = join(testDir, 'custom-tasks.json');
-
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				[prdPath, '--output', customOutput],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(existsSync(customOutput)).toBe(true);
-
-			const tasks = JSON.parse(readFileSync(customOutput, 'utf8'));
-			expect(tasks.master.tasks.length).toBeGreaterThan(0);
-		}, 180000);
-	});
-
-	describe('Force and append modes', () => {
-		it('should overwrite with --force flag', async () => {
-			// Create initial tasks
-			const initialPrd = 'Build feature A';
-			const prdPath1 = join(testDir, 'initial.txt');
-			writeFileSync(prdPath1, initialPrd);
-
-			await helpers.taskMaster('parse-prd', [prdPath1], { cwd: testDir });
-
-			// Create new PRD
-			const newPrd = 'Build feature B';
-			const prdPath2 = join(testDir, 'new.txt');
-			writeFileSync(prdPath2, newPrd);
-
-			// Parse with force flag
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				[prdPath2, '--force'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).not.toContain('overwrite existing tasks?');
-		}, 180000);
-
-		it('should append tasks with --append flag', async () => {
-			// Create initial tasks
-			const initialPrd = 'Build authentication system';
-			const prdPath1 = join(testDir, 'auth-prd.txt');
-			writeFileSync(prdPath1, initialPrd);
-
-			await helpers.taskMaster('parse-prd', [prdPath1], { cwd: testDir });
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const initialTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const initialCount = initialTasks.master.tasks.length;
-
-			// Create additional PRD
-			const additionalPrd = 'Build user profile features';
-			const prdPath2 = join(testDir, 'profile-prd.txt');
-			writeFileSync(prdPath2, additionalPrd);
-
-			// Parse with append flag
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				[prdPath2, '--append'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Appending to existing tasks');
-
-			const finalTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			expect(finalTasks.master.tasks.length).toBeGreaterThan(initialCount);
-
-			// Verify IDs are sequential
-			const maxId = Math.max(...finalTasks.master.tasks.map((t) => t.id));
-			expect(maxId).toBe(finalTasks.master.tasks.length);
-		}, 180000);
-	});
-
-	describe('Research mode', () => {
-		it('should use research mode with --research flag', async () => {
-			const prdContent =
-				'Build a machine learning pipeline for recommendation system';
-			const prdPath = join(testDir, 'ml-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				[prdPath, '--research'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(
-				'Using Perplexity AI for research-backed task generation'
-			);
-
-			// Research mode should produce more detailed tasks
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-
-			// Check that tasks have detailed implementation details
-			const hasDetailedTasks = tasks.master.tasks.some(
-				(t) => t.details && t.details.length > 200
-			);
-			expect(hasDetailedTasks).toBe(true);
-		}, 180000);
-	});
-
-	describe('Tag support', () => {
-		it('should parse PRD to specific tag', async () => {
-			// Create a new tag
-			await helpers.taskMaster('add-tag', ['feature-x'], { cwd: testDir });
-
-			const prdContent = 'Build feature X components';
-			const prdPath = join(testDir, 'feature-x-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				[prdPath, '--tag', 'feature-x'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-
-			expect(tasks['feature-x']).toBeDefined();
-			expect(tasks['feature-x'].tasks.length).toBeGreaterThan(0);
-		}, 180000);
-	});
-
-	describe('File format handling', () => {
-		it('should parse markdown format PRD', async () => {
-			const prdContent = `# Project: Task Management System
-
-## Overview
-Build a task management system with the following features:
-
-### Core Features
-- **Task Creation**: Users can create tasks with title and description
-- **Task Lists**: Organize tasks in different lists
-- **Due Dates**: Set and track due dates
-
-### Technical Requirements
-- REST API backend
-- React frontend
-- PostgreSQL database`;
-
-			const prdPath = join(testDir, 'markdown-prd.md');
-			writeFileSync(prdPath, prdContent);
-
-			const result = await helpers.taskMaster('parse-prd', [prdPath], {
-				cwd: testDir,
-				timeout: 150000
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-
-			// Should parse technical requirements into tasks
-			const hasApiTask = tasks.master.tasks.some(
-				(t) =>
-					t.title.toLowerCase().includes('api') ||
-					t.description.toLowerCase().includes('api')
-			);
-			expect(hasApiTask).toBe(true);
-		}, 180000);
-
-		it('should handle PRD with code blocks', async () => {
-			const prdContent = `# API Requirements
-
-Create REST endpoints:
-
-\`\`\`
-POST /api/users - Create user
-GET /api/users/:id - Get user by ID
-PUT /api/users/:id - Update user
-DELETE /api/users/:id - Delete user
-\`\`\`
-
-Each endpoint should have proper error handling and validation.`;
-
-			const prdPath = join(testDir, 'api-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			const result = await helpers.taskMaster('parse-prd', [prdPath], {
-				cwd: testDir,
-				timeout: 150000
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-
-			// Should create tasks for API endpoints
-			const hasEndpointTasks = tasks.master.tasks.some(
-				(t) =>
-					t.title.includes('endpoint') ||
-					t.description.includes('endpoint') ||
-					t.details.includes('/api/')
-			);
-			expect(hasEndpointTasks).toBe(true);
-		}, 180000);
-	});
-
-	describe('Error handling', () => {
-		it('should fail with non-existent file', async () => {
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				['non-existent-file.txt'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('does not exist');
-		});
-
-		it('should fail with empty PRD file', async () => {
-			const emptyPrdPath = join(testDir, 'empty.txt');
-			writeFileSync(emptyPrdPath, '');
-
-			const result = await helpers.taskMaster('parse-prd', [emptyPrdPath], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-		});
-
-		it('should show help when no PRD specified and no default exists', async () => {
-			const result = await helpers.taskMaster('parse-prd', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stdout).toContain('Parse PRD Help');
-			expect(result.stderr).toContain('PRD file not found');
-		});
-	});
-
-	describe('Performance and edge cases', () => {
-		it('should handle large PRD files', async () => {
-			// Create a large PRD with many requirements
-			let largePrd = '# Large Project Requirements\n\n';
-			for (let i = 1; i <= 50; i++) {
-				largePrd += `## Feature ${i}\n`;
-				largePrd += `Build feature ${i} with the following requirements:\n`;
-				largePrd += `- Requirement A for feature ${i}\n`;
-				largePrd += `- Requirement B for feature ${i}\n`;
-				largePrd += `- Integration with feature ${i - 1}\n\n`;
-			}
-
-			const prdPath = join(testDir, 'large-prd.txt');
-			writeFileSync(prdPath, largePrd);
-
-			const startTime = Date.now();
-			const result = await helpers.taskMaster(
-				'parse-prd',
-				[prdPath, '--num-tasks', '20'],
-				{ cwd: testDir, timeout: 150000 }
-			);
-			const duration = Date.now() - startTime;
-
-			expect(result).toHaveExitCode(0);
-			expect(duration).toBeLessThan(120000); // Should complete within 2 minutes
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			expect(tasks.master.tasks.length).toBeGreaterThan(10);
-		}, 180000);
-
-		it('should handle PRD with special characters', async () => {
-			const prdContent = `# Project: Système de Gestion 管理システム
-
-Build a system with:
-- UTF-8 support: ñáéíóú αβγδε 中文字符
-- Special symbols: @#$%^&*()_+{}[]|\\:;"'<>,.?/
-- Emoji support: 🚀 📊 💻 ✅`;
-
-			const prdPath = join(testDir, 'special-chars-prd.txt');
-			writeFileSync(prdPath, prdContent, 'utf8');
-
-			const result = await helpers.taskMaster('parse-prd', [prdPath], {
-				cwd: testDir,
-				timeout: 150000
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasksContent = readFileSync(tasksPath, 'utf8');
-			const tasks = JSON.parse(tasksContent);
-
-			// Verify special characters are preserved
-			expect(tasksContent).toContain('UTF-8');
-		}, 180000);
-	});
-
-	describe('Integration with other commands', () => {
-		it('should work with list command after parsing', async () => {
-			const prdContent = 'Build a simple blog system';
-			const prdPath = join(testDir, 'blog-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			// Parse PRD
-			await helpers.taskMaster('parse-prd', [prdPath], { cwd: testDir });
-
-			// List tasks
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-
-			expect(listResult).toHaveExitCode(0);
-			expect(listResult.stdout).toContain('ID');
-			expect(listResult.stdout).toContain('Title');
-			expect(listResult.stdout).toContain('pending');
-		});
-
-		it('should work with expand command on generated tasks', async () => {
-			const prdContent = 'Build user authentication';
-			const prdPath = join(testDir, 'auth-prd.txt');
-			writeFileSync(prdPath, prdContent);
-
-			// Parse PRD
-			await helpers.taskMaster('parse-prd', [prdPath], { cwd: testDir });
-
-			// Expand first task
-			const expandResult = await helpers.taskMaster('expand', ['--id', '1'], {
-				cwd: testDir,
-				timeout: 150000
-			});
-
-			expect(expandResult).toHaveExitCode(0);
-			expect(expandResult.stdout).toContain('Expanded task');
-		}, 180000);
-	});
-});

tests/e2e/tests/commands/remove-dependency.test.js

@@ -1,259 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master remove-dependency command', () => {
-	let testDir;
-	let helpers;
-	let tasksPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-remove-dependency-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('remove-dependency command');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Set up tasks path
-		tasksPath = join(testDir, '.taskmaster', 'tasks', 'tasks.json');
-
-		// Create test tasks with dependencies
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1 - Independent',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2 - Depends on 1',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1],
-						subtasks: []
-					},
-					{
-						id: 3,
-						description: 'Task 3 - Depends on 1 and 2',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [1, 2],
-						subtasks: [
-							{
-								id: 1,
-								description: 'Subtask 3.1',
-								status: 'pending',
-								priority: 'medium',
-								dependencies: ['1', '2']
-							}
-						]
-					},
-					{
-						id: 4,
-						description: 'Task 4 - Complex dependencies',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [1, 2, 3],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		// Ensure .taskmaster directory exists
-		mkdirSync(dirname(tasksPath), { recursive: true });
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should remove a dependency from a task', async () => {
-		// Run remove-dependency command
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '2', '-d', '1'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Removing dependency');
-		expect(result.stdout).toContain('from task 2');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task2 = updatedTasks.master.tasks.find(t => t.id === 2);
-
-		// Verify dependency was removed
-		expect(task2.dependencies).toEqual([]);
-	});
-
-	it('should remove one dependency while keeping others', async () => {
-		// Run remove-dependency command to remove dependency 1 from task 3
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '3', '-d', '1'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task3 = updatedTasks.master.tasks.find(t => t.id === 3);
-
-		// Verify only dependency 1 was removed, dependency 2 remains
-		expect(task3.dependencies).toEqual([2]);
-	});
-
-	it('should handle removing all dependencies from a task', async () => {
-		// Remove all dependencies from task 4 one by one
-		await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '4', '-d', '1'], { cwd: testDir });
-
-		await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '4', '-d', '2'], { cwd: testDir });
-
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '4', '-d', '3'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task4 = updatedTasks.master.tasks.find(t => t.id === 4);
-
-		// Verify all dependencies were removed
-		expect(task4.dependencies).toEqual([]);
-	});
-
-	it('should handle subtask dependencies', async () => {
-		// Run remove-dependency command for subtask
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '3.1', '-d', '1'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task3 = updatedTasks.master.tasks.find(t => t.id === 3);
-		const subtask = task3.subtasks.find(s => s.id === 1);
-
-		// Verify subtask dependency was removed
-		expect(subtask.dependencies).toEqual(['2']);
-	});
-
-	it('should fail when required parameters are missing', async () => {
-		// Run without --id
-		const result1 = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-d', '1'], { cwd: testDir, allowFailure: true });
-
-		expect(result1.exitCode).not.toBe(0);
-		expect(result1.stderr).toContain('Error');
-		expect(result1.stderr).toContain('Both --id and --depends-on are required');
-
-		// Run without --depends-on
-		const result2 = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '2'], { cwd: testDir, allowFailure: true });
-
-		expect(result2.exitCode).not.toBe(0);
-		expect(result2.stderr).toContain('Error');
-		expect(result2.stderr).toContain('Both --id and --depends-on are required');
-	});
-
-	it('should handle removing non-existent dependency', async () => {
-		// Try to remove a dependency that doesn't exist
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '1', '-d', '999'], { cwd: testDir });
-
-		// Should succeed (no-op)
-		expect(result).toHaveExitCode(0);
-
-		// Task should remain unchanged
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task1 = updatedTasks.master.tasks.find(t => t.id === 1);
-		expect(task1.dependencies).toEqual([]);
-	});
-
-	it('should handle non-existent task', async () => {
-		// Try to remove dependency from non-existent task
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '999', '-d', '1'], { cwd: testDir, allowFailure: true });
-
-		// Should fail gracefully
-		expect(result.exitCode).not.toBe(0);
-		// The command might succeed gracefully or show error - let's just check it doesn't crash
-		if (result.stderr) {
-			expect(result.stderr.length).toBeGreaterThan(0);
-		}
-	});
-
-	it('should work with tag option', async () => {
-		// Create tasks with different tags
-		const multiTagTasks = {
-			master: {
-				tasks: [{
-					id: 1,
-					description: 'Master task',
-					dependencies: [2]
-				}]
-			},
-			feature: {
-				tasks: [{
-					id: 1,
-					description: 'Feature task',
-					dependencies: [2, 3]
-				}]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(multiTagTasks, null, 2));
-
-		// Remove dependency from feature tag
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '1', '-d', '2', '--tag', 'feature'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-
-		// Verify only feature tag was affected
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		expect(updatedTasks.master.tasks[0].dependencies).toEqual([2]);
-		expect(updatedTasks.feature.tasks[0].dependencies).toEqual([3]);
-	});
-
-	it('should handle mixed dependency types', async () => {
-		// Create task with mixed dependency types (numbers and strings)
-		const mixedTasks = {
-			master: {
-				tasks: [{
-					id: 5,
-					description: 'Task with mixed deps',
-					dependencies: [1, '2', 3, '4.1'],
-					subtasks: []
-				}]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(mixedTasks, null, 2));
-
-		// Remove string dependency
-		const result = await helpers.taskMaster('remove-dependency', ['-f', tasksPath, '-i', '5', '-d', '4.1'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-
-		// Verify correct dependency was removed
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const task5 = updatedTasks.master.tasks.find(t => t.id === 5);
-		expect(task5.dependencies).toEqual([1, '2', 3]);
-	});
-});

tests/e2e/tests/commands/remove-subtask.test.js

@@ -1,285 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master remove-subtask command', () => {
-	let testDir;
-	let helpers;
-	let tasksPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-remove-subtask-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('remove-subtask command');
-		helpers = context.helpers;
-
-		// Initialize paths
-		tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		if (!existsSync(tasksPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	beforeEach(() => {
-		// Create test tasks with subtasks
-		const testTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Parent task 1',
-						description: 'Parent task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: [
-							{
-								id: 1,
-								title: 'Subtask 1.1',
-								description: 'First subtask',
-								status: 'pending',
-								priority: 'medium',
-								dependencies: []
-							},
-							{
-								id: 2,
-								title: 'Subtask 1.2',
-								description: 'Second subtask',
-								status: 'in_progress',
-								priority: 'high',
-								dependencies: ['1.1']
-							}
-						]
-					},
-					{
-						id: 2,
-						title: 'Parent task 2',
-						description: 'Parent task 2',
-						status: 'in_progress',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: [
-							{
-								id: 1,
-								title: 'Subtask 2.1',
-								description: 'Another subtask',
-								status: 'pending',
-								priority: 'low',
-								dependencies: []
-							}
-						]
-					},
-					{
-						id: 3,
-						title: 'Task without subtasks',
-						description: 'Task without subtasks',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		// Ensure .taskmaster directory exists
-		mkdirSync(dirname(tasksPath), { recursive: true });
-		writeFileSync(tasksPath, JSON.stringify(testTasks, null, 2));
-	});
-
-	it('should remove a subtask from its parent', async () => {
-		// Run remove-subtask command
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '1.1', '--skip-generate'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Removing subtask 1.1');
-		expect(result.stdout).toContain('successfully deleted');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const parentTask = updatedTasks.master.tasks.find(t => t.id === 1);
-
-		// Verify subtask was removed
-		expect(parentTask.subtasks).toHaveLength(1);
-		expect(parentTask.subtasks[0].id).toBe(2);
-		expect(parentTask.subtasks[0].title).toBe('Subtask 1.2');
-	});
-
-	it('should remove multiple subtasks', async () => {
-		// Run remove-subtask command with multiple IDs
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '1.1,1.2', '--skip-generate'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Removing subtask 1.1');
-		expect(result.stdout).toContain('Removing subtask 1.2');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const parentTask = updatedTasks.master.tasks.find(t => t.id === 1);
-
-		// Verify both subtasks were removed (property may be empty array or undefined)
-		expect(parentTask).toBeDefined();
-		expect(parentTask.subtasks || []).toHaveLength(0);
-	});
-
-	it('should convert subtask to standalone task with --convert flag', async () => {
-		// Run remove-subtask command with convert flag
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '2.1', '--convert', '--skip-generate'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('converted to a standalone task');
-		expect(result.stdout).toContain('Converted to Task');
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const parentTask = updatedTasks.master.tasks.find(t => t.id === 2);
-		
-		// Verify subtask was removed from parent
-		expect(parentTask.subtasks || []).toHaveLength(0);
-
-		// Verify new standalone task was created
-		const newTask = updatedTasks.master.tasks.find(t => t.title === 'Subtask 2.1');
-		expect(newTask).toBeDefined();
-		expect(newTask.description).toBe('Another subtask');
-		expect(newTask.status).toBe('pending');
-		expect(newTask.priority).toBe('medium');
-	});
-
-	it('should handle dependencies when converting subtask', async () => {
-		// Run remove-subtask command to convert subtask with dependencies
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '1.2', '--convert', '--skip-generate'], { cwd: testDir });
-
-		// Verify success
-		expect(result).toHaveExitCode(0);
-
-		// Read updated tasks
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		const newTask = updatedTasks.master.tasks.find(t => t.title === 'Subtask 1.2');
-		
-		// Verify dependencies were preserved and updated
-		expect(newTask).toBeDefined();
-		expect(newTask.dependencies).toBeDefined();
-		// Dependencies should be updated from '1.1' to appropriate format
-	});
-
-	it('should fail when ID is not provided', async () => {
-		// Run remove-subtask command without ID
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath], { cwd: testDir });
-
-		// Should fail
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-		expect(result.stderr).toContain('--id parameter is required');
-	});
-
-	it('should fail with invalid subtask ID format', async () => {
-		// Run remove-subtask command with invalid ID format
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '1'], { cwd: testDir });
-
-		// Should fail
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-		expect(result.stderr).toContain('must be in format "parentId.subtaskId"');
-	});
-
-	it('should handle non-existent subtask ID', async () => {
-		// Run remove-subtask command with non-existent subtask
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '1.999'], { cwd: testDir });
-
-		// Should fail gracefully
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-	});
-
-	it('should handle removing from non-existent parent', async () => {
-		// Run remove-subtask command with non-existent parent
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '999.1'], { cwd: testDir });
-
-		// Should fail gracefully
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stderr).toContain('Error');
-	});
-
-	it('should work with tag option', async () => {
-		// Create tasks with different tags
-		const multiTagTasks = {
-			master: {
-				tasks: [{
-					id: 1,
-					title: 'Master task',
-					description: 'Master task',
-					status: 'pending',
-					priority: 'medium',
-					dependencies: [],
-					subtasks: [{
-						id: 1,
-						title: 'Master subtask',
-						description: 'To be removed',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: []
-					}]
-				}]
-			},
-			feature: {
-				tasks: [{
-					id: 1,
-					title: 'Feature task',
-					description: 'Feature task',
-					status: 'pending',
-					priority: 'medium',
-					dependencies: [],
-					subtasks: [{
-						id: 1,
-						title: 'Feature subtask',
-						description: 'To be removed',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: []
-					}]
-				}]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(multiTagTasks, null, 2));
-
-		// Remove subtask from feature tag
-		const result = await helpers.taskMaster('remove-subtask', ['-f', tasksPath, '-i', '1.1', '--tag', 'feature', '--skip-generate'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-
-		// Verify only feature tag was affected
-		const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-		expect(updatedTasks.master.tasks[0].subtasks).toHaveLength(1);
-		expect(updatedTasks.feature.tasks[0].subtasks || []).toHaveLength(0);
-	});
-});

tests/e2e/tests/commands/remove-task.test.js

@@ -1,582 +0,0 @@
-/**
- * E2E tests for remove-task command
- * Tests task removal functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-describe('task-master remove-task', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-remove-task-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('remove-task');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Copy configuration files
-		copyConfigFiles(testDir);
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic task removal', () => {
-		it('should remove a single task', async () => {
-			// Create a task
-			const task = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task to remove', '--description', 'This will be removed'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Remove the task with --yes to skip confirmation
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', taskId, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully removed task');
-			expect(result.stdout).toContain(taskId);
-
-			// Verify task is gone
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(listResult.stdout).not.toContain('Task to remove');
-		});
-
-		it('should remove task with confirmation prompt bypassed', async () => {
-			// Create a task
-			const task = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Task to force remove',
-					'--description',
-					'Will be removed with force'
-				],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Remove with yes flag to skip confirmation
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', taskId, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully removed task');
-		});
-
-		it('should remove multiple tasks', async () => {
-			// Create multiple tasks
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'First task', '--description', 'To be removed'],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Second task', '--description', 'Also to be removed'],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-
-			const task3 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Third task', '--description', 'Will remain'],
-				{ cwd: testDir }
-			);
-			const taskId3 = helpers.extractTaskId(task3.stdout);
-
-			// Remove first two tasks
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', `${taskId1},${taskId2}`, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully removed');
-
-			// Verify correct tasks were removed
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(listResult.stdout).not.toContain('First task');
-			expect(listResult.stdout).not.toContain('Second task');
-			expect(listResult.stdout).toContain('Third task');
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail when removing non-existent task', async () => {
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', '999', '--yes'],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			// The command might succeed but show a warning, or fail
-			if (result.exitCode === 0) {
-				// If it succeeds, it should show that no task was removed
-				expect(result.stdout).toMatch(
-					/not found|no.*task.*999|does not exist|No existing tasks found to remove/i
-				);
-			} else {
-				expect(result.stderr).toContain('not found');
-			}
-		});
-
-		it('should fail when task ID is not provided', async () => {
-			const result = await helpers.taskMaster('remove-task', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('required');
-		});
-
-		it('should handle invalid task ID format', async () => {
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', 'invalid-id', '--yes'],
-				{
-					cwd: testDir,
-					allowFailure: true
-				}
-			);
-
-			// The command might succeed but show a warning, or fail
-			if (result.exitCode === 0) {
-				// If it succeeds, it should show that the ID is invalid or not found
-				expect(result.stdout).toMatch(
-					/invalid|not found|does not exist|No existing tasks found to remove/i
-				);
-			} else {
-				expect(result.exitCode).not.toBe(0);
-			}
-		});
-	});
-
-	describe('Task with dependencies', () => {
-		it('should warn when removing task that others depend on', async () => {
-			// Create dependent tasks
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Base task', '--description', 'Others depend on this'],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Dependent task', '--description', 'Depends on base'],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-
-			// Add dependency
-			await helpers.taskMaster(
-				'add-dependency',
-				['--id', taskId2, '--depends-on', taskId1],
-				{ cwd: testDir }
-			);
-
-			// Try to remove base task
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', taskId1, '--yes'],
-				{ cwd: testDir }
-			);
-
-			// Should either warn or update dependent tasks
-			expect(result).toHaveExitCode(0);
-		});
-
-		it('should handle removing task with dependencies', async () => {
-			// Create tasks with dependency chain
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Dependency 1', '--description', 'First dep'],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Main task', '--description', 'Has dependencies'],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-
-			// Add dependency
-			await helpers.taskMaster(
-				'add-dependency',
-				['--id', taskId2, '--depends-on', taskId1],
-				{ cwd: testDir }
-			);
-
-			// Remove the main task (with dependencies)
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', taskId2, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully removed task');
-
-			// Dependency task should still exist
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(listResult.stdout).toContain('Dependency 1');
-			expect(listResult.stdout).not.toContain('Main task');
-		});
-	});
-
-	describe('Task with subtasks', () => {
-		it('should remove task and all its subtasks', async () => {
-			// Create parent task
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent task', '--description', 'Has subtasks'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Expand to create subtasks
-			await helpers.taskMaster('expand', ['-i', parentId, '-n', '3'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-
-			// Remove parent task
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', parentId, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully removed task');
-
-			// Verify parent and subtasks are gone
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(listResult.stdout).not.toContain('Parent task');
-			expect(listResult.stdout).not.toContain(`${parentId}.1`);
-			expect(listResult.stdout).not.toContain(`${parentId}.2`);
-			expect(listResult.stdout).not.toContain(`${parentId}.3`);
-		});
-
-		it('should remove only subtask when specified', async () => {
-			// Create parent task with subtasks
-			const parent = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Parent with subtasks', '--description', 'Parent task'],
-				{ cwd: testDir }
-			);
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Try to expand to create subtasks
-			const expandResult = await helpers.taskMaster(
-				'expand',
-				['-i', parentId, '-n', '3'],
-				{
-					cwd: testDir,
-					timeout: 60000
-				}
-			);
-
-			// Check if subtasks were created
-			const verifyResult = await helpers.taskMaster('show', [parentId], {
-				cwd: testDir
-			});
-			if (!verifyResult.stdout.includes('Subtasks')) {
-				// If expand didn't create subtasks, create them manually
-				await helpers.taskMaster(
-					'add-subtask',
-					[
-						'--parent',
-						parentId,
-						'--title',
-						'Subtask 1',
-						'--description',
-						'First subtask'
-					],
-					{ cwd: testDir }
-				);
-				await helpers.taskMaster(
-					'add-subtask',
-					[
-						'--parent',
-						parentId,
-						'--title',
-						'Subtask 2',
-						'--description',
-						'Second subtask'
-					],
-					{ cwd: testDir }
-				);
-				await helpers.taskMaster(
-					'add-subtask',
-					[
-						'--parent',
-						parentId,
-						'--title',
-						'Subtask 3',
-						'--description',
-						'Third subtask'
-					],
-					{ cwd: testDir }
-				);
-			}
-
-			// Remove only one subtask
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', `${parentId}.2`, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify parent task still exists
-			const showResult = await helpers.taskMaster('show', [parentId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Parent with subtasks');
-
-			// Check if subtasks are displayed - the behavior may vary
-			if (showResult.stdout.includes('Subtasks')) {
-				// If subtasks are shown, verify the correct ones exist
-				expect(showResult.stdout).toContain(`${parentId}.1`);
-				expect(showResult.stdout).not.toContain(`${parentId}.2`);
-				expect(showResult.stdout).toContain(`${parentId}.3`);
-			} else {
-				// If subtasks aren't shown, verify via list command
-				const listResult = await helpers.taskMaster(
-					'list',
-					['--with-subtasks'],
-					{ cwd: testDir }
-				);
-				expect(listResult.stdout).toContain('Parent with subtasks');
-				// The subtask should be removed from the list
-				expect(listResult.stdout).not.toContain(`${parentId}.2`);
-			}
-		});
-	});
-
-	describe('Tag context', () => {
-		it('should remove task from specific tag', async () => {
-			// Create tag and add tasks
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-
-			// Add task to master
-			const masterTask = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task', '--description', 'In master'],
-				{ cwd: testDir }
-			);
-			const masterId = helpers.extractTaskId(masterTask.stdout);
-
-			// Add task to feature tag
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-			const featureTask = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Feature task', '--description', 'In feature'],
-				{ cwd: testDir }
-			);
-			const featureId = helpers.extractTaskId(featureTask.stdout);
-
-			// Remove task from feature tag
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', featureId, '--tag', 'feature', '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify only feature task was removed
-			await helpers.taskMaster('use-tag', ['master'], { cwd: testDir });
-			const masterList = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(masterList.stdout).toContain('Master task');
-
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-			const featureList = await helpers.taskMaster('list', [], {
-				cwd: testDir
-			});
-			expect(featureList.stdout).not.toContain('Feature task');
-		});
-	});
-
-	describe('Status considerations', () => {
-		it('should remove tasks in different statuses', async () => {
-			// Create tasks with different statuses
-			const pendingTask = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Pending task', '--description', 'Status: pending'],
-				{ cwd: testDir }
-			);
-			const pendingId = helpers.extractTaskId(pendingTask.stdout);
-
-			const inProgressTask = await helpers.taskMaster(
-				'add-task',
-				['--title', 'In progress task', '--description', 'Status: in-progress'],
-				{ cwd: testDir }
-			);
-			const inProgressId = helpers.extractTaskId(inProgressTask.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', inProgressId, '--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			const doneTask = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Done task', '--description', 'Status: done'],
-				{ cwd: testDir }
-			);
-			const doneId = helpers.extractTaskId(doneTask.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', doneId, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			// Remove all tasks
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', `${pendingId},${inProgressId},${doneId}`, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify all are removed
-			const listResult = await helpers.taskMaster('list', ['--all'], {
-				cwd: testDir
-			});
-			expect(listResult.stdout).not.toContain('Pending task');
-			expect(listResult.stdout).not.toContain('In progress task');
-			expect(listResult.stdout).not.toContain('Done task');
-		});
-
-		it('should warn when removing in-progress task', async () => {
-			// Create in-progress task
-			const task = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Active task',
-					'--description',
-					'Currently being worked on'
-				],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId, '--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			// Remove without force (if interactive prompt is supported)
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', taskId, '--yes'],
-				{ cwd: testDir }
-			);
-
-			// Should succeed with force flag
-			expect(result).toHaveExitCode(0);
-		});
-	});
-
-	describe('Output options', () => {
-		it('should support quiet mode', async () => {
-			const task = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Quiet removal', '--description', 'Remove quietly'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Remove without quiet flag since -q is not supported
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', taskId, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Task should be removed
-		});
-
-		it('should show detailed output in verbose mode', async () => {
-			const task = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Verbose removal', '--description', 'Remove with details'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Remove with verbose flag if supported
-			const result = await helpers.taskMaster(
-				'remove-task',
-				['--id', taskId, '--yes'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully removed task');
-		});
-	});
-});

tests/e2e/tests/commands/rename-tag.test.js

@@ -1,302 +0,0 @@
-/**
- * E2E tests for rename-tag command
- * Tests tag renaming functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('task-master rename-tag', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-rename-tag-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('rename-tag');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic renaming', () => {
-		it('should rename an existing tag', async () => {
-			// Create a tag
-			await helpers.taskMaster('add-tag', ['feature', '--description', 'Feature branch'], { cwd: testDir });
-
-			// Add some tasks to the tag
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-			const task1 = await helpers.taskMaster('add-task', ['--title', '"Task in feature"', '--description', '"First task"'], { cwd: testDir });
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-
-			// Switch back to master and add another task
-			await helpers.taskMaster('use-tag', ['master'], { cwd: testDir });
-			const task2 = await helpers.taskMaster('add-task', ['--title', '"Task in master"', '--description', '"Second task"'], { cwd: testDir });
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-
-			// Rename the tag
-			const result = await helpers.taskMaster('rename-tag', ['feature', 'feature-v2'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully renamed tag');
-			expect(result.stdout).toContain('feature');
-			expect(result.stdout).toContain('feature-v2');
-
-			// Verify the tag was renamed in the tags list
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('feature-v2');
-			expect(tagsResult.stdout).not.toMatch(/^\s*feature\s+/m);
-
-			// Verify tasks are still accessible in renamed tag
-			await helpers.taskMaster('use-tag', ['feature-v2'], { cwd: testDir });
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(listResult.stdout).toContain('Task in feature');
-		});
-
-		it('should update active tag when renaming current tag', async () => {
-			// Create and switch to a tag
-			await helpers.taskMaster('add-tag', ['develop'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['develop'], { cwd: testDir });
-
-			// Rename the active tag
-			const result = await helpers.taskMaster('rename-tag', ['develop', 'development'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-
-			// Verify we're now on the renamed tag
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			// Match the table format where bullet and (current) are in the same cell
-			expect(tagsResult.stdout).toMatch(/●\s*development\s*\(current\)/);
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail when renaming non-existent tag', async () => {
-			const result = await helpers.taskMaster('rename-tag', ['nonexistent', 'new-name'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('not exist');
-		});
-
-		it('should fail when new tag name already exists', async () => {
-			// Create a tag
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['hotfix'], { cwd: testDir });
-
-			// Try to rename to existing tag name
-			const result = await helpers.taskMaster('rename-tag', ['feature', 'hotfix'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('already exists');
-		});
-
-		it('should not rename master tag', async () => {
-			const result = await helpers.taskMaster('rename-tag', ['master', 'main'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Cannot rename');
-			expect(result.stderr).toContain('master');
-		});
-
-		it('should validate tag name format', async () => {
-			await helpers.taskMaster('add-tag', ['valid-tag'], { cwd: testDir });
-
-			// Test that most tag names are actually accepted
-			const validNames = ['tag-with-dashes', 'tag_with_underscores', 'tagwithletters123'];
-			
-			for (const validName of validNames) {
-				const result = await helpers.taskMaster('rename-tag', ['valid-tag', validName], {
-					cwd: testDir,
-					allowFailure: true
-				});
-				expect(result.exitCode).toBe(0);
-				
-				// Rename back for next test
-				await helpers.taskMaster('rename-tag', [validName, 'valid-tag'], { cwd: testDir });
-			}
-		});
-	});
-
-	describe('Tag with tasks', () => {
-		it('should rename tag with multiple tasks', async () => {
-			// Create tag and add tasks
-			await helpers.taskMaster('add-tag', ['sprint-1'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['sprint-1'], { cwd: testDir });
-
-			// Add multiple tasks
-			for (let i = 1; i <= 3; i++) {
-				await helpers.taskMaster('add-task', [
-					'--title', `"Sprint task ${i}"`,
-					'--description', `"Task ${i} for sprint"`
-				], { cwd: testDir });
-			}
-
-			// Rename the tag
-			const result = await helpers.taskMaster('rename-tag', ['sprint-1', 'sprint-1-renamed'], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-
-			// Verify tasks are still in renamed tag
-			await helpers.taskMaster('use-tag', ['sprint-1-renamed'], { cwd: testDir });
-			const listResult = await helpers.taskMaster('list', [], { cwd: testDir });
-			expect(listResult.stdout).toContain('Sprint task 1');
-			expect(listResult.stdout).toContain('Sprint task 2');
-			expect(listResult.stdout).toContain('Sprint task 3');
-		});
-
-		it('should handle tag with no tasks', async () => {
-			// Create empty tag
-			await helpers.taskMaster('add-tag', ['empty-tag', '--description', 'Tag with no tasks'], { cwd: testDir });
-
-			// Rename it
-			const result = await helpers.taskMaster('rename-tag', ['empty-tag', 'not-empty'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully renamed tag');
-
-			// Verify renamed tag exists
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('not-empty');
-			expect(tagsResult.stdout).not.toContain('empty-tag');
-		});
-	});
-
-	describe('Tag metadata', () => {
-		it('should preserve tag description when renaming', async () => {
-			const description = 'This is a feature branch for authentication';
-			await helpers.taskMaster('add-tag', ['auth-feature', '--description', description], { cwd: testDir });
-
-			// Rename the tag
-			await helpers.taskMaster('rename-tag', ['auth-feature', 'authentication'], { cwd: testDir });
-
-			// Check description is preserved (at least the beginning due to table width limits)
-			const tagsResult = await helpers.taskMaster('tags', ['--show-metadata'], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('authentication');
-			expect(tagsResult.stdout).toContain('This');
-		});
-
-		it('should update tag timestamps', async () => {
-			await helpers.taskMaster('add-tag', ['temp-feature'], { cwd: testDir });
-
-			// Wait a bit to ensure timestamp difference
-			await new Promise(resolve => setTimeout(resolve, 100));
-
-			// Rename the tag
-			const result = await helpers.taskMaster('rename-tag', ['temp-feature', 'permanent-feature'], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-
-			// Verify tag exists with new name
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('permanent-feature');
-		});
-	});
-
-	describe('Integration with other commands', () => {
-		it('should work with tag switching after rename', async () => {
-			// Create tags
-			await helpers.taskMaster('add-tag', ['dev'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['staging'], { cwd: testDir });
-
-			// Add task to dev
-			await helpers.taskMaster('use-tag', ['dev'], { cwd: testDir });
-			await helpers.taskMaster('add-task', ['--title', 'Dev task', '--description', 'Task in dev'], { cwd: testDir });
-
-			// Rename dev to development
-			await helpers.taskMaster('rename-tag', ['dev', 'development'], { cwd: testDir });
-
-			// Should be able to switch to renamed tag
-			const switchResult = await helpers.taskMaster('use-tag', ['development'], { cwd: testDir });
-			expect(switchResult).toHaveExitCode(0);
-
-			// Verify we're on the right tag
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			// Match the table format where bullet and (current) are in the same cell
-			expect(tagsResult.stdout).toMatch(/●\s*development\s*\(current\)/);
-		});
-
-		it('should fail gracefully when renaming during operations', async () => {
-			await helpers.taskMaster('add-tag', ['feature-x'], { cwd: testDir });
-
-			// Try to rename to itself
-			const result = await helpers.taskMaster('rename-tag', ['feature-x', 'feature-x'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			// Should either succeed with no-op or fail gracefully
-			if (result.exitCode !== 0) {
-				expect(result.stderr).toBeTruthy();
-			}
-		});
-	});
-
-	describe('Edge cases', () => {
-		it('should handle special characters in tag names', async () => {
-			// Create tag with valid special chars
-			await helpers.taskMaster('add-tag', ['feature-123'], { cwd: testDir });
-
-			// Rename to another valid format
-			const result = await helpers.taskMaster('rename-tag', ['feature-123', 'feature_456'], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-
-			// Verify rename worked
-			const tagsResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(tagsResult.stdout).toContain('feature_456');
-			expect(tagsResult.stdout).not.toContain('feature-123');
-		});
-
-		it('should handle very long tag names', async () => {
-			const longName = 'feature-' + 'a'.repeat(50);
-			await helpers.taskMaster('add-tag', ['short'], { cwd: testDir });
-
-			// Try to rename to very long name
-			const result = await helpers.taskMaster('rename-tag', ['short', longName], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			// Should either succeed or fail with appropriate message
-			if (result.exitCode !== 0) {
-				expect(result.stderr).toBeTruthy();
-			}
-		});
-	});
-});

tests/e2e/tests/commands/research-save.test.js

@@ -1,578 +0,0 @@
-/**
- * Comprehensive E2E tests for research-save command
- * Tests all aspects of saving research results to files and knowledge base
- */
-
-export default async function testResearchSave(logger, helpers, context) {
-	const { testDir } = context;
-	const results = {
-		status: 'passed',
-		errors: [],
-		tests: []
-	};
-
-	async function runTest(name, testFn) {
-		try {
-			logger.info(`\nRunning: ${name}`);
-			await testFn();
-			results.tests.push({ name, status: 'passed' });
-			logger.success(`✓ ${name}`);
-		} catch (error) {
-			results.tests.push({ name, status: 'failed', error: error.message });
-			results.errors.push({ test: name, error: error.message });
-			logger.error(`✗ ${name}: ${error.message}`);
-		}
-	}
-
-	try {
-		logger.info('Starting comprehensive research-save tests...');
-
-		// Test 1: Basic research and save
-		await runTest('Basic research and save', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				['How to implement OAuth 2.0 in Node.js', '--output', 'oauth-guide.md'],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Verify file was created
-			const outputPath = `${testDir}/oauth-guide.md`;
-			if (!helpers.fileExists(outputPath)) {
-				throw new Error('Research output file was not created');
-			}
-
-			// Check file content
-			const content = helpers.readFile(outputPath);
-			if (!content.includes('OAuth') || !content.includes('Node.js')) {
-				throw new Error('Saved research does not contain expected content');
-			}
-		});
-
-		// Test 2: Research save with task context
-		await runTest('Research save with task context', async () => {
-			// Create a task
-			const taskResult = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Implement secure API authentication'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(taskResult.stdout);
-
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'--task',
-					taskId,
-					'JWT vs OAuth comparison for REST APIs',
-					'--output',
-					'auth-research.md'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check saved content includes task context
-			const content = helpers.readFile(`${testDir}/auth-research.md`);
-			if (!content.includes('JWT') || !content.includes('OAuth')) {
-				throw new Error('Research does not cover requested topics');
-			}
-
-			// Should reference the task
-			if (!content.includes(taskId) && !content.includes('Task #')) {
-				throw new Error('Saved research does not reference the task context');
-			}
-		});
-
-		// Test 3: Research save to knowledge base
-		await runTest('Save to knowledge base', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'Database indexing strategies',
-					'--knowledge-base',
-					'--category',
-					'database'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check knowledge base directory
-			const kbPath = `${testDir}/.taskmaster/knowledge-base/database`;
-			if (!helpers.fileExists(kbPath)) {
-				throw new Error('Knowledge base category directory not created');
-			}
-
-			// Should create a file with timestamp or ID
-			const files = helpers.listFiles(kbPath);
-			if (files.length === 0) {
-				throw new Error('No files created in knowledge base');
-			}
-
-			// Verify content
-			const savedFile = files[0];
-			const content = helpers.readFile(`${kbPath}/${savedFile}`);
-			if (!content.includes('index') || !content.includes('database')) {
-				throw new Error('Knowledge base entry lacks expected content');
-			}
-		});
-
-		// Test 4: Research save with custom format
-		await runTest('Save with custom format', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'React performance optimization',
-					'--output',
-					'react-perf.json',
-					'--format',
-					'json'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Verify JSON format
-			const content = helpers.readFile(`${testDir}/react-perf.json`);
-			let parsed;
-			try {
-				parsed = JSON.parse(content);
-			} catch (e) {
-				throw new Error('Output is not valid JSON');
-			}
-
-			// Check JSON structure
-			if (!parsed.topic || !parsed.content || !parsed.timestamp) {
-				throw new Error('JSON output missing expected fields');
-			}
-
-			if (
-				!parsed.content.toLowerCase().includes('react') ||
-				!parsed.content.toLowerCase().includes('performance')
-			) {
-				throw new Error('JSON content not relevant to query');
-			}
-		});
-
-		// Test 5: Research save with metadata
-		await runTest('Save with metadata', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'Microservices communication patterns',
-					'--output',
-					'microservices.md',
-					'--metadata',
-					'author=TaskMaster',
-					'--metadata',
-					'tags=architecture,microservices',
-					'--metadata',
-					'version=1.0'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check file content for metadata
-			const content = helpers.readFile(`${testDir}/microservices.md`);
-
-			// Should include metadata in frontmatter or header
-			if (!content.includes('author') && !content.includes('Author')) {
-				throw new Error('Metadata not included in saved file');
-			}
-
-			if (
-				!content.includes('microservice') ||
-				!content.includes('communication')
-			) {
-				throw new Error('Research content not relevant');
-			}
-		});
-
-		// Test 6: Append to existing file
-		await runTest('Append to existing research file', async () => {
-			// Create initial file
-			const initialContent =
-				'# API Research\n\n## Previous Research\n\nInitial content here.\n\n';
-			helpers.writeFile(`${testDir}/api-research.md`, initialContent);
-
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'GraphQL schema design best practices',
-					'--output',
-					'api-research.md',
-					'--append'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check file was appended
-			const content = helpers.readFile(`${testDir}/api-research.md`);
-			if (!content.includes('Previous Research')) {
-				throw new Error('Original content was overwritten instead of appended');
-			}
-			if (!content.includes('GraphQL') || !content.includes('schema')) {
-				throw new Error('New research not appended');
-			}
-		});
-
-		// Test 7: Research save with references
-		await runTest('Save with source references', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'TypeScript decorators guide',
-					'--output',
-					'decorators.md',
-					'--include-references'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check for references section
-			const content = helpers.readFile(`${testDir}/decorators.md`);
-			if (!content.includes('TypeScript') || !content.includes('decorator')) {
-				throw new Error('Research content not relevant');
-			}
-
-			// Should include references or sources
-			const hasReferences =
-				content.includes('Reference') ||
-				content.includes('Source') ||
-				content.includes('Further reading') ||
-				content.includes('Links');
-			if (!hasReferences) {
-				throw new Error('No references section included');
-			}
-		});
-
-		// Test 8: Batch research and save
-		await runTest('Batch research topics', async () => {
-			const topics = [
-				'Docker best practices',
-				'Kubernetes deployment strategies',
-				'CI/CD pipeline setup'
-			];
-
-			const result = await helpers.taskMaster(
-				'research-save',
-				['--batch', '--output-dir', 'devops-research', ...topics],
-				{ cwd: testDir, timeout: 180000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check directory was created
-			const outputDir = `${testDir}/devops-research`;
-			if (!helpers.fileExists(outputDir)) {
-				throw new Error('Output directory not created');
-			}
-
-			// Should have files for each topic
-			const files = helpers.listFiles(outputDir);
-			if (files.length < topics.length) {
-				throw new Error(
-					`Expected ${topics.length} files, found ${files.length}`
-				);
-			}
-
-			// Verify each file has relevant content
-			let foundDocker = false,
-				foundK8s = false,
-				foundCICD = false;
-			files.forEach((file) => {
-				const content = helpers.readFile(`${outputDir}/${file}`).toLowerCase();
-				if (content.includes('docker')) foundDocker = true;
-				if (content.includes('kubernetes')) foundK8s = true;
-				if (
-					content.includes('ci') ||
-					content.includes('cd') ||
-					content.includes('pipeline')
-				)
-					foundCICD = true;
-			});
-
-			if (!foundDocker || !foundK8s || !foundCICD) {
-				throw new Error('Not all topics were researched and saved');
-			}
-		});
-
-		// Test 9: Research save with template
-		await runTest('Save with custom template', async () => {
-			// Create template file
-			const template = `# {{TOPIC}}
-
-Date: {{DATE}}
-Category: {{CATEGORY}}
-
-## Summary
-{{SUMMARY}}
-
-## Detailed Research
-{{CONTENT}}
-
-## Key Takeaways
-{{TAKEAWAYS}}
-
-## Implementation Notes
-{{NOTES}}
-`;
-			helpers.writeFile(`${testDir}/research-template.md`, template);
-
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'Redis caching strategies',
-					'--output',
-					'redis-research.md',
-					'--template',
-					'research-template.md',
-					'--category',
-					'performance'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check template was used
-			const content = helpers.readFile(`${testDir}/redis-research.md`);
-			if (!content.includes('Redis caching strategies')) {
-				throw new Error('Template topic not filled');
-			}
-			if (!content.includes('Category: performance')) {
-				throw new Error('Template category not filled');
-			}
-			if (
-				!content.includes('Key Takeaways') ||
-				!content.includes('Implementation Notes')
-			) {
-				throw new Error('Template structure not preserved');
-			}
-		});
-
-		// Test 10: Error handling - invalid output path
-		await runTest('Error handling - invalid output path', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				['Test topic', '--output', '/invalid/path/file.md'],
-				{ cwd: testDir, allowFailure: true }
-			);
-			if (result.exitCode === 0) {
-				throw new Error('Should have failed with invalid output path');
-			}
-		});
-
-		// Test 11: Research save with task integration
-		await runTest('Save and link to task', async () => {
-			// Create task
-			const taskResult = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Implement caching layer'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(taskResult.stdout);
-
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'--task',
-					taskId,
-					'Caching strategies comparison',
-					'--output',
-					'caching-research.md',
-					'--link-to-task'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check task was updated with research link
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			if (
-				!showResult.stdout.includes('caching-research.md') &&
-				!showResult.stdout.includes('Research')
-			) {
-				throw new Error('Task not updated with research link');
-			}
-		});
-
-		// Test 12: Research save with compression
-		await runTest('Save with compression for large research', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'Comprehensive guide to distributed systems',
-					'--output',
-					'dist-systems.md.gz',
-					'--compress'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check compressed file exists
-			const compressedPath = `${testDir}/dist-systems.md.gz`;
-			if (!helpers.fileExists(compressedPath)) {
-				throw new Error('Compressed file not created');
-			}
-		});
-
-		// Test 13: Research save with versioning
-		await runTest('Save with version control', async () => {
-			// Save initial version
-			await helpers.taskMaster(
-				'research-save',
-				['API design patterns', '--output', 'api-patterns.md', '--version'],
-				{ cwd: testDir, timeout: 120000 }
-			);
-
-			// Save updated version
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'API design patterns - updated',
-					'--output',
-					'api-patterns.md',
-					'--version'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check for version files
-			const files = helpers.listFiles(testDir);
-			const versionFiles = files.filter(
-				(f) => f.includes('api-patterns') && f.includes('.v')
-			);
-
-			if (versionFiles.length === 0) {
-				throw new Error('No version files created');
-			}
-		});
-
-		// Test 14: Research save with export formats
-		await runTest('Export to multiple formats', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'Testing strategies overview',
-					'--output',
-					'testing',
-					'--formats',
-					'md,json,txt'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check all format files exist
-			const formats = ['md', 'json', 'txt'];
-			formats.forEach((format) => {
-				const filePath = `${testDir}/testing.${format}`;
-				if (!helpers.fileExists(filePath)) {
-					throw new Error(`${format} format file not created`);
-				}
-			});
-		});
-
-		// Test 15: Research save with summary generation
-		await runTest('Save with auto-generated summary', async () => {
-			const result = await helpers.taskMaster(
-				'research-save',
-				[
-					'Machine learning deployment strategies',
-					'--output',
-					'ml-deployment.md',
-					'--include-summary',
-					'--summary-length',
-					'200'
-				],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			if (result.exitCode !== 0) {
-				throw new Error(`Command failed: ${result.stderr}`);
-			}
-
-			// Check for summary section
-			const content = helpers.readFile(`${testDir}/ml-deployment.md`);
-			if (
-				!content.includes('Summary') &&
-				!content.includes('TL;DR') &&
-				!content.includes('Overview')
-			) {
-				throw new Error('No summary section found');
-			}
-
-			// Content should be about ML deployment
-			if (
-				!content.includes('machine learning') &&
-				!content.includes('ML') &&
-				!content.includes('deployment')
-			) {
-				throw new Error('Research content not relevant to query');
-			}
-		});
-
-		// Calculate summary
-		const totalTests = results.tests.length;
-		const passedTests = results.tests.filter(
-			(t) => t.status === 'passed'
-		).length;
-		const failedTests = results.tests.filter(
-			(t) => t.status === 'failed'
-		).length;
-
-		logger.info('\n=== Research-Save Test Summary ===');
-		logger.info(`Total tests: ${totalTests}`);
-		logger.info(`Passed: ${passedTests}`);
-		logger.info(`Failed: ${failedTests}`);
-
-		if (failedTests > 0) {
-			results.status = 'failed';
-			logger.error(`\n${failedTests} tests failed`);
-		} else {
-			logger.success('\n✅ All research-save tests passed!');
-		}
-	} catch (error) {
-		results.status = 'failed';
-		results.errors.push({
-			test: 'research-save test suite',
-			error: error.message,
-			stack: error.stack
-		});
-		logger.error(`Research-save test suite failed: ${error.message}`);
-	}
-
-	return results;
-}

tests/e2e/tests/commands/research.test.js

@@ -1,527 +0,0 @@
-/**
- * Comprehensive E2E tests for research command
- * Tests all aspects of AI-powered research functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('research command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-research-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('research');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic research functionality', () => {
-		it('should perform research on a topic', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				[
-					'What are the best practices for implementing OAuth 2.0 authentication?'
-				],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research Results');
-
-			// Should contain relevant OAuth information
-			const hasOAuthInfo =
-				result.stdout.toLowerCase().includes('oauth') ||
-				result.stdout.toLowerCase().includes('authentication');
-			expect(hasOAuthInfo).toBe(true);
-		}, 120000);
-
-		it('should research using topic as argument', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['React performance optimization techniques'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research Results');
-
-			// Should contain React-related information
-			const hasReactInfo =
-				result.stdout.toLowerCase().includes('react') ||
-				result.stdout.toLowerCase().includes('performance');
-			expect(hasReactInfo).toBe(true);
-		}, 120000);
-
-		it('should handle technical research queries', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['Compare PostgreSQL vs MongoDB for a real-time analytics application'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Should contain database comparison
-			const hasDatabaseInfo =
-				result.stdout.toLowerCase().includes('postgresql') ||
-				result.stdout.toLowerCase().includes('mongodb');
-			expect(hasDatabaseInfo).toBe(true);
-		}, 120000);
-	});
-
-	describe('Research depth control', () => {
-		it('should perform quick research with --quick flag', async () => {
-			const startTime = Date.now();
-			const result = await helpers.taskMaster(
-				'research',
-				['REST API design', '--quick'],
-				{ cwd: testDir, timeout: 60000 }
-			);
-			const duration = Date.now() - startTime;
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research Results');
-
-			// Quick research should be faster
-			expect(duration).toBeLessThan(60000);
-		}, 90000);
-
-		it('should perform detailed research with --detailed flag', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['Microservices architecture patterns', '--detailed'],
-				{ cwd: testDir, timeout: 120000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research Results');
-
-			// Detailed research should have more content
-			expect(result.stdout.length).toBeGreaterThan(500);
-
-			// Should contain comprehensive information
-			const hasPatterns =
-				result.stdout.toLowerCase().includes('pattern') ||
-				result.stdout.toLowerCase().includes('architecture');
-			expect(hasPatterns).toBe(true);
-		}, 150000);
-	});
-
-	describe('Research with citations', () => {
-		it('should include sources with --sources flag', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['GraphQL best practices', '--sources'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research Results');
-
-			// Should include source references
-			const hasSources =
-				result.stdout.includes('Source:') ||
-				result.stdout.includes('Reference:') ||
-				result.stdout.includes('http');
-			expect(hasSources).toBe(true);
-		}, 120000);
-	});
-
-	describe('Research output options', () => {
-		it('should save research to file with --save flag', async () => {
-			const outputPath = join(testDir, 'research-output.md');
-
-			const result = await helpers.taskMaster(
-				'research',
-				['Docker container security', '--save', outputPath],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research saved to');
-
-			// Verify file was created
-			expect(existsSync(outputPath)).toBe(true);
-
-			// Verify file contains research content
-			const content = readFileSync(outputPath, 'utf8');
-			expect(content).toContain('Docker');
-			expect(content.length).toBeGreaterThan(100);
-		}, 120000);
-
-		it('should output in JSON format', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['WebSocket implementation', '--output', 'json'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Output should be valid JSON
-			const jsonOutput = JSON.parse(result.stdout);
-			expect(jsonOutput.topic).toBeDefined();
-			expect(jsonOutput.research).toBeDefined();
-			expect(jsonOutput.timestamp).toBeDefined();
-		}, 120000);
-
-		it('should output in markdown format by default', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['CI/CD pipeline best practices'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Should contain markdown formatting
-			const hasMarkdown =
-				result.stdout.includes('#') ||
-				result.stdout.includes('*') ||
-				result.stdout.includes('-');
-			expect(hasMarkdown).toBe(true);
-		}, 120000);
-	});
-
-	describe('Research categories', () => {
-		it('should research coding patterns', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				[
-					'--topic',
-					'Singleton pattern in JavaScript',
-					'--category',
-					'patterns'
-				],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toContain('singleton');
-			expect(result.stdout.toLowerCase()).toContain('pattern');
-		}, 120000);
-
-		it('should research security topics', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['OWASP Top 10 vulnerabilities', '--category', 'security'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toContain('security');
-			expect(result.stdout.toUpperCase()).toContain('OWASP');
-		}, 120000);
-
-		it('should research performance topics', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['Database query optimization', '--category', 'performance'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toContain('optimization');
-			expect(result.stdout.toLowerCase()).toContain('performance');
-		}, 120000);
-	});
-
-	describe('Research integration with tasks', () => {
-		it('should research for specific task context', async () => {
-			// Create a task first
-			const addResult = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Implement real-time chat feature'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(addResult.stdout);
-
-			// Research for the task
-			const result = await helpers.taskMaster(
-				'research',
-				['--id', taskId, '--topic', 'WebSocket vs Server-Sent Events'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research Results');
-			expect(result.stdout.toLowerCase()).toContain('websocket');
-		}, 120000);
-
-		it('should append research to task notes', async () => {
-			// Create a task
-			const addResult = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Setup monitoring system'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(addResult.stdout);
-
-			// Research and append to task
-			const result = await helpers.taskMaster(
-				'research',
-				[
-					'--id',
-					taskId,
-					'--topic',
-					'Prometheus vs ELK stack',
-					'--append-to-task'
-				],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research appended to task');
-
-			// Verify task has research notes
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout.toLowerCase()).toContain('prometheus');
-		}, 120000);
-	});
-
-	describe('Research history', () => {
-		it('should save research history', async () => {
-			// Perform multiple researches
-			await helpers.taskMaster(
-				'research',
-				['GraphQL subscriptions'],
-				{ cwd: testDir, timeout: 60000 }
-			);
-
-			await helpers.taskMaster('research', ['Redis pub/sub'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-
-			// Check research history
-			const historyPath = join(testDir, '.taskmaster/research-history.json');
-			if (existsSync(historyPath)) {
-				const history = JSON.parse(readFileSync(historyPath, 'utf8'));
-				expect(history.length).toBeGreaterThanOrEqual(2);
-			}
-		}, 150000);
-
-		it('should list recent research with --history flag', async () => {
-			// Perform a research first
-			await helpers.taskMaster(
-				'research',
-				['Kubernetes deployment strategies'],
-				{ cwd: testDir, timeout: 60000 }
-			);
-
-			// List history
-			const result = await helpers.taskMaster('research', ['--history'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Research History');
-		}, 90000);
-	});
-
-	describe('Error handling', () => {
-		it('should fail without topic', async () => {
-			const result = await helpers.taskMaster('research', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('topic');
-		});
-
-		it('should handle invalid output format', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['Test topic', '--output', 'invalid-format'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Invalid output format');
-		});
-
-		it('should handle network errors gracefully', async () => {
-			// This test might pass if network is available
-			// It's mainly to ensure the command handles errors gracefully
-			const result = await helpers.taskMaster(
-				'research',
-				['Test with potential network issues'],
-				{ cwd: testDir, timeout: 30000, allowFailure: true }
-			);
-
-			// Should either succeed or fail gracefully
-			if (result.exitCode !== 0) {
-				expect(result.stderr).toBeTruthy();
-			} else {
-				expect(result.stdout).toContain('Research Results');
-			}
-		}, 45000);
-	});
-
-	describe('Research focus areas', () => {
-		it('should research implementation details', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				[
-					'--topic',
-					'JWT implementation in Node.js',
-					'--focus',
-					'implementation'
-				],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toContain('implementation');
-			expect(result.stdout.toLowerCase()).toContain('code');
-		}, 120000);
-
-		it('should research best practices', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['REST API versioning', '--focus', 'best-practices'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout.toLowerCase()).toContain('best practice');
-		}, 120000);
-
-		it('should research comparisons', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['Vue vs React vs Angular', '--focus', 'comparison'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			const output = result.stdout.toLowerCase();
-			expect(output).toContain('vue');
-			expect(output).toContain('react');
-			expect(output).toContain('angular');
-		}, 120000);
-	});
-
-	describe('Research with constraints', () => {
-		it('should limit research length with --max-length', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['Machine learning basics', '--max-length', '500'],
-				{ cwd: testDir, timeout: 60000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Research output should be concise
-			expect(result.stdout.length).toBeLessThan(2000); // Accounting for formatting
-		}, 90000);
-
-		it('should research with specific year constraint', async () => {
-			const result = await helpers.taskMaster(
-				'research',
-				['Latest JavaScript features', '--year', '2024'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Should focus on recent content
-			const hasRecentInfo =
-				result.stdout.includes('2024') ||
-				result.stdout.toLowerCase().includes('latest') ||
-				result.stdout.toLowerCase().includes('recent');
-			expect(hasRecentInfo).toBe(true);
-		}, 120000);
-	});
-
-	describe('Research caching', () => {
-		it('should cache and reuse research results', async () => {
-			const topic = 'Redis caching strategies';
-
-			// First research
-			const startTime1 = Date.now();
-			const result1 = await helpers.taskMaster('research', [topic], {
-				cwd: testDir,
-				timeout: 90000
-			});
-			const duration1 = Date.now() - startTime1;
-			expect(result1).toHaveExitCode(0);
-
-			// Second research (should be cached)
-			const startTime2 = Date.now();
-			const result2 = await helpers.taskMaster('research', [topic], {
-				cwd: testDir,
-				timeout: 30000
-			});
-			const duration2 = Date.now() - startTime2;
-			expect(result2).toHaveExitCode(0);
-
-			// Cached result should be much faster
-			if (result2.stdout.includes('(cached)')) {
-				expect(duration2).toBeLessThan(duration1 / 2);
-			}
-		}, 150000);
-
-		it('should bypass cache with --no-cache flag', async () => {
-			const topic = 'Docker best practices';
-
-			// First research
-			await helpers.taskMaster('research', [topic], {
-				cwd: testDir,
-				timeout: 60000
-			});
-
-			// Second research without cache
-			const result = await helpers.taskMaster(
-				'research',
-				[topic, '--no-cache'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).not.toContain('(cached)');
-		}, 180000);
-	});
-});

tests/e2e/tests/commands/rules.test.js

@@ -1,412 +0,0 @@
-/**
- * Comprehensive E2E tests for rules command
- * Tests adding, removing, and managing task rules/profiles
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync,
-	readdirSync,
-	statSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('rules command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-rules-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('rules');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project without rules
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic rules operations', () => {
-		it('should add a single rule profile', async () => {
-			const result = await helpers.taskMaster('rules', ['add', 'windsurf'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Adding rules for profile: windsurf');
-			expect(result.stdout).toContain('Completed adding rules for profile: windsurf');
-			expect(result.stdout).toContain('Summary for windsurf');
-
-			// Check that windsurf rules directory was created
-			const windsurfDir = join(testDir, '.windsurf');
-			expect(existsSync(windsurfDir)).toBe(true);
-		});
-
-		it('should add multiple rule profiles', async () => {
-			const result = await helpers.taskMaster(
-				'rules',
-				['add', 'windsurf', 'roo'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Adding rules for profile: windsurf');
-			expect(result.stdout).toContain('Adding rules for profile: roo');
-			expect(result.stdout).toContain('Summary for windsurf');
-			expect(result.stdout).toContain('Summary for roo');
-
-			// Check that both directories were created
-			expect(existsSync(join(testDir, '.windsurf'))).toBe(true);
-			expect(existsSync(join(testDir, '.roo'))).toBe(true);
-		});
-
-		it('should add multiple rule profiles with comma separation', async () => {
-			const result = await helpers.taskMaster(
-				'rules',
-				['add', 'windsurf,roo,cursor'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Adding rules for profile: windsurf');
-			expect(result.stdout).toContain('Adding rules for profile: roo');
-			expect(result.stdout).toContain('Adding rules for profile: cursor');
-
-			// Check directories
-			expect(existsSync(join(testDir, '.windsurf'))).toBe(true);
-			expect(existsSync(join(testDir, '.roo'))).toBe(true);
-			expect(existsSync(join(testDir, '.cursor'))).toBe(true);
-		});
-
-		it('should remove a rule profile', async () => {
-			// First add the profile
-			await helpers.taskMaster('rules', ['add', 'windsurf'], { cwd: testDir });
-
-			// Then remove it with force flag to skip confirmation
-			const result = await helpers.taskMaster(
-				'rules',
-				['remove', 'windsurf', '--force'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Removing rules for profile: windsurf');
-			expect(result.stdout).toContain('Summary for windsurf');
-			expect(result.stdout).toContain('Rule profile removed');
-		});
-
-		it('should handle removing multiple profiles', async () => {
-			// Add multiple profiles
-			await helpers.taskMaster('rules', ['add', 'windsurf', 'roo', 'cursor'], {
-				cwd: testDir
-			});
-
-			// Remove two of them
-			const result = await helpers.taskMaster(
-				'rules',
-				['remove', 'windsurf', 'roo', '--force'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Removing rules for profile: windsurf');
-			expect(result.stdout).toContain('Removing rules for profile: roo');
-			expect(result.stdout).toContain('Total: 2 profile(s) processed - 2 removed');
-
-			// Cursor should still exist
-			expect(existsSync(join(testDir, '.cursor'))).toBe(true);
-			// Others should be gone
-			expect(existsSync(join(testDir, '.windsurf'))).toBe(false);
-			expect(existsSync(join(testDir, '.roo'))).toBe(false);
-		});
-	});
-
-	describe('Interactive setup', () => {
-		it('should launch interactive setup with --setup flag', async () => {
-			// Since interactive setup requires user input, we'll just check that it starts
-			const result = await helpers.taskMaster('rules', ['--setup'], {
-				cwd: testDir,
-				timeout: 1000, // Short timeout since we can't provide input
-				allowFailure: true
-			});
-
-			// The command should start but timeout waiting for input
-			expect(result.stdout).toContain('Rule Profiles Setup');
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should error on invalid action', async () => {
-			const result = await helpers.taskMaster(
-				'rules',
-				['invalid-action', 'windsurf'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain("Invalid or missing action 'invalid-action'");
-			expect(result.stderr).toContain('Valid actions are: add, remove');
-		});
-
-		it('should error when no action provided', async () => {
-			const result = await helpers.taskMaster('rules', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain("Invalid or missing action 'none'");
-		});
-
-		it('should error when no profiles specified for add/remove', async () => {
-			const result = await helpers.taskMaster('rules', ['add'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain(
-				'Please specify at least one rule profile'
-			);
-		});
-
-		it('should warn about invalid profile names', async () => {
-			const result = await helpers.taskMaster(
-				'rules',
-				['add', 'windsurf', 'invalid-profile', 'roo'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully processed profiles: windsurf, roo');
-
-			// Should still add the valid profiles
-			expect(result.stdout).toContain('Adding rules for profile: windsurf');
-			expect(result.stdout).toContain('Adding rules for profile: roo');
-		});
-
-		it('should handle project not initialized', async () => {
-			// Create a new directory without initializing task-master
-			const uninitDir = mkdtempSync(join(tmpdir(), 'task-master-uninit-'));
-
-			const result = await helpers.taskMaster('rules', ['add', 'windsurf'], {
-				cwd: uninitDir,
-				allowFailure: true
-			});
-
-			// The rules command currently succeeds even in uninitialized directories
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Adding rules for profile: windsurf');
-			expect(result.stdout).toContain('Successfully processed profiles: windsurf');
-
-			// Cleanup
-			rmSync(uninitDir, { recursive: true, force: true });
-		});
-	});
-
-	describe('Rule file generation', () => {
-		it('should create correct rule files for windsurf profile', async () => {
-			await helpers.taskMaster('rules', ['add', 'windsurf'], { cwd: testDir });
-
-			const rulesDir = join(testDir, '.windsurf/rules');
-			expect(existsSync(rulesDir)).toBe(true);
-
-			// Check for expected rule files
-			const expectedFiles = ['windsurf_rules.md', 'taskmaster.md'];
-			const actualFiles = readdirSync(rulesDir);
-
-			expectedFiles.forEach((file) => {
-				expect(actualFiles).toContain(file);
-			});
-
-			// Check that rules contain windsurf-specific content
-			const rulesPath = join(rulesDir, 'windsurf_rules.md');
-			const rulesContent = readFileSync(rulesPath, 'utf8');
-			expect(rulesContent).toContain('Windsurf');
-		});
-
-		it('should create correct rule files for roo profile', async () => {
-			await helpers.taskMaster('rules', ['add', 'roo'], { cwd: testDir });
-
-			const rulesDir = join(testDir, '.roo/rules');
-			expect(existsSync(rulesDir)).toBe(true);
-
-			// Check for roo-specific files
-			const files = readdirSync(rulesDir);
-			expect(files.length).toBeGreaterThan(0);
-
-			// Check that rules contain roo-specific content
-			const instructionsPath = join(rulesDir, 'instructions.md');
-			if (existsSync(instructionsPath)) {
-				const content = readFileSync(instructionsPath, 'utf8');
-				expect(content).toContain('Roo');
-			}
-		});
-
-		it('should create MCP configuration for claude profile', async () => {
-			const result = await helpers.taskMaster('rules', ['add', 'claude'], { cwd: testDir });
-
-			// Check that the claude profile was processed successfully
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Completed adding rules for profile: claude');
-			expect(result.stdout).toContain('Summary for claude');
-		});
-	});
-
-	describe('Profile combinations', () => {
-		it('should handle adding all available profiles', async () => {
-			const allProfiles = [
-				'claude',
-				'cline',
-				'codex',
-				'cursor',
-				'gemini',
-				'roo',
-				'trae',
-				'vscode',
-				'windsurf'
-			];
-
-			const result = await helpers.taskMaster(
-				'rules',
-				['add', ...allProfiles],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Total: 27 files processed');
-
-			// Check that directories were created for profiles that use them
-			const profileDirs = ['.windsurf', '.roo', '.cursor', '.cline'];
-			profileDirs.forEach((dir) => {
-				const dirPath = join(testDir, dir);
-				if (existsSync(dirPath)) {
-					expect(statSync(dirPath).isDirectory()).toBe(true);
-				}
-			});
-		});
-
-		it('should not duplicate rules when adding same profile twice', async () => {
-			// Add windsurf profile
-			await helpers.taskMaster('rules', ['add', 'windsurf'], { cwd: testDir });
-
-			// Add it again
-			const result = await helpers.taskMaster('rules', ['add', 'windsurf'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			// Should still complete successfully but may indicate files already exist
-			expect(result.stdout).toContain('Adding rules for profile: windsurf');
-		});
-	});
-
-	describe('Removing rules edge cases', () => {
-		it('should handle removing non-existent profile gracefully', async () => {
-			const result = await helpers.taskMaster(
-				'rules',
-				['remove', 'windsurf', '--force'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Removing rules for profile: windsurf');
-			// Should indicate it was skipped or already removed
-		});
-
-		it('should preserve non-task-master files in profile directories', async () => {
-			// Add windsurf profile
-			await helpers.taskMaster('rules', ['add', 'windsurf'], { cwd: testDir });
-
-			// Add a custom file to the windsurf directory
-			const customFilePath = join(testDir, '.windsurf/custom-file.txt');
-			writeFileSync(customFilePath, 'This should not be deleted');
-
-			// Remove windsurf profile
-			await helpers.taskMaster('rules', ['remove', 'windsurf', '--force'], {
-				cwd: testDir
-			});
-
-			// The custom file should still exist if the directory wasn't removed
-			// (This behavior depends on the implementation)
-			if (existsSync(join(testDir, '.windsurf'))) {
-				expect(existsSync(customFilePath)).toBe(true);
-			}
-		});
-	});
-
-	describe('Summary outputs', () => {
-		it('should show detailed summary after adding profiles', async () => {
-			const result = await helpers.taskMaster(
-				'rules',
-				['add', 'windsurf', 'roo'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Total: 8 files processed');
-			expect(result.stdout).toContain('Successfully processed profiles: windsurf, roo');
-		});
-
-		it('should show removal summary', async () => {
-			// Add profiles first
-			await helpers.taskMaster('rules', ['add', 'windsurf', 'roo'], {
-				cwd: testDir
-			});
-
-			// Remove them
-			const result = await helpers.taskMaster(
-				'rules',
-				['remove', 'windsurf', 'roo', '--force'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Total: 2 profile(s) processed - 2 removed');
-		});
-	});
-
-	describe('Mixed operations', () => {
-		it('should handle mix of valid and invalid profiles', async () => {
-			const result = await helpers.taskMaster(
-				'rules',
-				['add', 'windsurf', 'not-a-profile', 'roo', 'another-invalid'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Adding rules for profile: windsurf');
-			expect(result.stdout).toContain('Adding rules for profile: roo');
-			expect(result.stdout).toContain('Successfully processed profiles: windsurf, roo');
-
-			// Should still successfully add the valid ones
-			expect(existsSync(join(testDir, '.windsurf'))).toBe(true);
-			expect(existsSync(join(testDir, '.roo'))).toBe(true);
-		});
-	});
-});

tests/e2e/tests/commands/set-status.test.js

@@ -1,316 +0,0 @@
-/**
- * E2E tests for set-status command
- * Tests task status management functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('task-master set-status', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-set-status-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('set-status');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic status changes', () => {
-		it('should change task status to in-progress', async () => {
-			// Create a task
-			const task = await helpers.taskMaster('add-task', ['--title', 'Test task', '--description', 'A task to test status'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Set status to in-progress
-			const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-			expect(result.stdout).toContain('in-progress');
-
-			// Verify status change
-			const showResult = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			expect(showResult.stdout).toContain('► in-progress');
-		});
-
-		it('should change task status to done', async () => {
-			// Create a task
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task to complete', '--description', 'Will be marked as done'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Set status to done
-			const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'done'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-			expect(result.stdout).toContain('done');
-
-			// Verify in completed list
-			const listResult = await helpers.taskMaster('list', ['--status', 'done'], { cwd: testDir });
-			expect(listResult.stdout).toContain('✓ done');
-		});
-
-		it('should change task status to review', async () => {
-			// Create a task
-			const task = await helpers.taskMaster('add-task', ['--title', 'Blocked task', '--description', 'Will be review'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Set status to review
-			const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'review'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-			expect(result.stdout).toContain('review');
-		});
-
-		it('should revert task status to pending', async () => {
-			// Create task and set to in-progress
-			const task = await helpers.taskMaster('add-task', ['--title', 'Revert task', '--description', 'Will go back to pending'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-
-			// Revert to pending
-			const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'pending'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-			expect(result.stdout).toContain('pending');
-		});
-	});
-
-	describe('Multiple tasks', () => {
-		it('should change status for multiple tasks', async () => {
-			// Create multiple tasks
-			const task1 = await helpers.taskMaster('add-task', ['--title', 'First task', '--description', 'Task 1'], { cwd: testDir });
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-			
-			const task2 = await helpers.taskMaster('add-task', ['--title', 'Second task', '--description', 'Task 2'], { cwd: testDir });
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-			
-			const task3 = await helpers.taskMaster('add-task', ['--title', 'Third task', '--description', 'Task 3'], { cwd: testDir });
-			const taskId3 = helpers.extractTaskId(task3.stdout);
-
-			// Set multiple tasks to in-progress
-			const result = await helpers.taskMaster('set-status', ['--id', `${taskId1},${taskId2}`, '--status', 'in-progress'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-
-			// Verify both are in-progress
-			const listResult = await helpers.taskMaster('list', ['--status', 'in-progress'], { cwd: testDir });
-			expect(listResult.stdout).toContain('First');
-			expect(listResult.stdout).toContain('Second');
-			expect(listResult.stdout).not.toContain('Third');
-		});
-	});
-
-	describe('Subtask status', () => {
-		it.skip('should change subtask status', async () => {
-			// Skipped: This test requires AI functionality (expand command) which is not available in test environment
-			// The expand command needs API credentials to generate subtasks
-		});
-
-		it.skip('should update parent status when all subtasks complete', async () => {
-			// Skipped: This test requires AI functionality (expand command) which is not available in test environment
-			// The expand command needs API credentials to generate subtasks
-		});
-	});
-
-	describe('Dependency constraints', () => {
-		it('should handle status change with dependencies', async () => {
-			// Create dependent tasks
-			const task1 = await helpers.taskMaster('add-task', ['--title', 'Dependency task', '--description', 'Must be done first'], { cwd: testDir });
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-			
-			const task2 = await helpers.taskMaster('add-task', ['--title', 'Dependent task', '--description', 'Depends on first'], { cwd: testDir });
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-			
-			// Add dependency
-			await helpers.taskMaster('add-dependency', ['--id', taskId2, '--depends-on', taskId1], { cwd: testDir });
-
-			// Try to set dependent task to done while dependency is pending
-			const result = await helpers.taskMaster('set-status', ['--id', taskId2, '--status', 'done'], { cwd: testDir });
-			
-			// Implementation may warn or prevent this
-			expect(result).toHaveExitCode(0);
-		});
-
-		it('should unblock tasks when dependencies complete', async () => {
-			// Create dependency chain
-			const task1 = await helpers.taskMaster('add-task', ['--title', 'Base task', '--description', 'No dependencies'], { cwd: testDir });
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-			
-			const task2 = await helpers.taskMaster('add-task', ['--title', 'Blocked task', '--description', 'Waiting on base'], { cwd: testDir });
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-			
-			// Add dependency and set to review
-			await helpers.taskMaster('add-dependency', ['--id', taskId2, '--depends-on', taskId1], { cwd: testDir });
-			await helpers.taskMaster('set-status', ['--id', taskId2, '--status', 'review'], { cwd: testDir });
-
-			// Complete dependency
-			await helpers.taskMaster('set-status', ['--id', taskId1, '--status', 'done'], { cwd: testDir });
-
-			// Blocked task might auto-transition or remain review
-			const showResult = await helpers.taskMaster('show', [taskId2], { cwd: testDir });
-			expect(showResult.stdout).toContain('Blocked');
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail with invalid status', async () => {
-			const task = await helpers.taskMaster('add-task', ['--title', 'Test task', '--description', 'Test'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'invalid-status'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Invalid status');
-		});
-
-		it('should fail with non-existent task ID', async () => {
-			const result = await helpers.taskMaster('set-status', ['--id', '999', '--status', 'done'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('not found');
-		});
-
-		it('should fail when required parameters missing', async () => {
-			// Missing status
-			const task = await helpers.taskMaster('add-task', ['--title', 'Test', '--description', 'Test'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			const result = await helpers.taskMaster('set-status', ['--id', taskId], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('required');
-		});
-	});
-
-	describe('Tag context', () => {
-		it('should set status for task in specific tag', async () => {
-			// Create tags and tasks
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-			
-			// Add task to master
-			const masterTask = await helpers.taskMaster('add-task', ['--title', 'Master task', '--description', 'In master'], { cwd: testDir });
-			const masterId = helpers.extractTaskId(masterTask.stdout);
-
-			// Add task to feature
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-			const featureTask = await helpers.taskMaster('add-task', ['--title', 'Feature task', '--description', 'In feature'], { cwd: testDir });
-			const featureId = helpers.extractTaskId(featureTask.stdout);
-
-			// Set status with tag context
-			const result = await helpers.taskMaster('set-status', ['--id', featureId, '--status', 'in-progress', '--tag', 'feature'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-
-			// Verify status in correct tag
-			const listResult = await helpers.taskMaster('list', ['--status', 'in-progress'], { cwd: testDir });
-			expect(listResult.stdout).toContain('Feature');
-		});
-	});
-
-	describe('Status transitions', () => {
-		it('should handle all valid status transitions', async () => {
-			const task = await helpers.taskMaster('add-task', ['--title', 'Status test', '--description', 'Testing all statuses'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Test all transitions
-			const statuses = ['pending', 'in-progress', 'review', 'done', 'pending'];
-			
-			for (const status of statuses) {
-				const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', status], { cwd: testDir });
-				expect(result).toHaveExitCode(0);
-				expect(result.stdout).toContain('Successfully updated task');
-			}
-		});
-
-		it('should update timestamps on status change', async () => {
-			const task = await helpers.taskMaster('add-task', ['--title', 'Timestamp test', '--description', 'Check timestamps'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Wait a bit
-			await new Promise(resolve => setTimeout(resolve, 100));
-
-			// Change status
-			const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-
-			// Status change should update modified timestamp
-			// (exact verification depends on show command output format)
-		});
-	});
-
-	describe('Output options', () => {
-		it('should support basic status setting', async () => {
-			const task = await helpers.taskMaster('add-task', ['--title', 'Basic test', '--description', 'Test basic functionality'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Set status without any special flags
-			const result = await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'done'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-		});
-
-		it('should show affected tasks summary', async () => {
-			// Create multiple tasks
-			const tasks = [];
-			for (let i = 1; i <= 3; i++) {
-				const task = await helpers.taskMaster('add-task', ['--title', `Task ${i}`, '--description', `Description ${i}`], { cwd: testDir });
-				tasks.push(helpers.extractTaskId(task.stdout));
-			}
-
-			// Set all to in-progress
-			const result = await helpers.taskMaster('set-status', ['--id', tasks.join(','), '--status', 'in-progress'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-			// May show count of affected tasks
-		});
-	});
-});

tests/e2e/tests/commands/show.test.js

@@ -1,387 +0,0 @@
-/**
- * E2E tests for show command
- * Tests task display functionality
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('task-master show', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-show-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('show');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic task display', () => {
-		it('should show a single task', async () => {
-			// Create a task
-			const task = await helpers.taskMaster('add-task', ['--title', '"Test task"', '--description', '"A detailed description of the task"'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Show the task
-			const result = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Test task');
-			expect(result.stdout).toContain('A detailed description of the task');
-			expect(result.stdout).toContain(taskId);
-			expect(result.stdout).toContain('Status:');
-			expect(result.stdout).toContain('Priority:');
-		});
-
-		it('should show task with all fields', async () => {
-			// Create a comprehensive task
-			const task = await helpers.taskMaster('add-task', [
-				'--title', '"Complete task"',
-				'--description', '"Task with all fields populated"',
-				'--priority', 'high'
-			], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Set to in-progress
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-
-			// Show the task
-			const result = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Complete task');
-			expect(result.stdout).toContain('Task with all fields populated');
-			expect(result.stdout).toContain('high');
-			expect(result.stdout).toContain('in-progress');
-		});
-	});
-
-	describe('Task with dependencies', () => {
-		it('should show task dependencies', async () => {
-			// Create dependency tasks
-			const dep1 = await helpers.taskMaster('add-task', ['--title', '"Dependency 1"', '--description', '"First dependency"'], { cwd: testDir });
-			const depId1 = helpers.extractTaskId(dep1.stdout);
-			
-			const dep2 = await helpers.taskMaster('add-task', ['--title', '"Dependency 2"', '--description', '"Second dependency"'], { cwd: testDir });
-			const depId2 = helpers.extractTaskId(dep2.stdout);
-			
-			const main = await helpers.taskMaster('add-task', ['--title', '"Main task"', '--description', '"Has dependencies"'], { cwd: testDir });
-			const mainId = helpers.extractTaskId(main.stdout);
-
-			// Add dependencies
-			await helpers.taskMaster('add-dependency', ['--id', mainId, '--depends-on', depId1], { cwd: testDir });
-			await helpers.taskMaster('add-dependency', ['--id', mainId, '--depends-on', depId2], { cwd: testDir });
-
-			// Show the task
-			const result = await helpers.taskMaster('show', [mainId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Dependencies:');
-			expect(result.stdout).toContain(depId1);
-			expect(result.stdout).toContain(depId2);
-		});
-
-		it('should show tasks that depend on this task', async () => {
-			// Create base task
-			const base = await helpers.taskMaster('add-task', ['--title', '"Base task"', '--description', '"Others depend on this"'], { cwd: testDir });
-			const baseId = helpers.extractTaskId(base.stdout);
-			
-			// Create dependent tasks
-			const dep1 = await helpers.taskMaster('add-task', ['--title', 'Dependent 1', '--description', 'Depends on base'], { cwd: testDir });
-			const depId1 = helpers.extractTaskId(dep1.stdout);
-			
-			const dep2 = await helpers.taskMaster('add-task', ['--title', 'Dependent 2', '--description', 'Also depends on base'], { cwd: testDir });
-			const depId2 = helpers.extractTaskId(dep2.stdout);
-
-			// Add dependencies
-			await helpers.taskMaster('add-dependency', ['--id', depId1, '--depends-on', baseId], { cwd: testDir });
-			await helpers.taskMaster('add-dependency', ['--id', depId2, '--depends-on', baseId], { cwd: testDir });
-
-			// Show the base task
-			const result = await helpers.taskMaster('show', [baseId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			// May show dependent tasks or blocking information
-		});
-	});
-
-	describe('Task with subtasks', () => {
-		it('should show task with subtasks', async () => {
-			// Create parent task
-			const parent = await helpers.taskMaster('add-task', ['--title', 'Parent task', '--description', 'Has subtasks'], { cwd: testDir });
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Add subtasks manually
-			await helpers.taskMaster('add-subtask', ['--parent', parentId, '--title', 'Subtask 1', '--description', 'First subtask'], { cwd: testDir });
-			await helpers.taskMaster('add-subtask', ['--parent', parentId, '--title', 'Subtask 2', '--description', 'Second subtask'], { cwd: testDir });
-			await helpers.taskMaster('add-subtask', ['--parent', parentId, '--title', 'Subtask 3', '--description', 'Third subtask'], { cwd: testDir });
-
-			// Show the parent task
-			const result = await helpers.taskMaster('show', [parentId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Parent');
-			expect(result.stdout).toContain('Subtasks');
-			expect(result.stdout).toContain(`${parentId}.1`);
-			expect(result.stdout).toContain(`${parentId}.2`);
-			expect(result.stdout).toContain(`${parentId}.3`);
-		});
-
-		it('should show subtask details', async () => {
-			// Create parent with subtasks
-			const parent = await helpers.taskMaster('add-task', ['--title', 'Parent', '--description', 'Parent task'], { cwd: testDir });
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Expand
-			await helpers.taskMaster('expand', ['-i', parentId, '-n', '2'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-
-			// Show a specific subtask
-			const result = await helpers.taskMaster('show', [`${parentId}.1`], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain(`${parentId}.1`);
-			// Should show subtask details
-		});
-
-		it('should show subtask progress', async () => {
-			// Create parent with subtasks
-			const parent = await helpers.taskMaster('add-task', ['--title', 'Project', '--description', 'Multi-step project'], { cwd: testDir });
-			const parentId = helpers.extractTaskId(parent.stdout);
-
-			// Expand
-			await helpers.taskMaster('expand', ['-i', parentId, '-n', '4'], {
-				cwd: testDir,
-				timeout: 60000
-			});
-
-			// Complete some subtasks
-			await helpers.taskMaster('set-status', ['--id', `${parentId}.1`, '--status', 'done'], { cwd: testDir });
-			await helpers.taskMaster('set-status', ['--id', `${parentId}.2`, '--status', 'done'], { cwd: testDir });
-			await helpers.taskMaster('set-status', ['--id', `${parentId}.3`, '--status', 'in-progress'], { cwd: testDir });
-
-			// Show parent task
-			const result = await helpers.taskMaster('show', [parentId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Project');
-			// May show progress indicator or completion percentage
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail when showing non-existent task', async () => {
-			const result = await helpers.taskMaster('show', ['999'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			// The command currently returns exit code 0 but shows error message in stdout
-			expect(result.exitCode).toBe(0);
-			expect(result.stdout).toContain('not found');
-		});
-
-		it('should fail when task ID not provided', async () => {
-			const result = await helpers.taskMaster('show', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Please provide a task ID');
-		});
-
-		it('should handle invalid task ID format', async () => {
-			const result = await helpers.taskMaster('show', ['invalid-id'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			// Command accepts invalid ID format but shows error in output
-			expect(result.exitCode).toBe(0);
-			expect(result.stdout).toContain('not found');
-		});
-	});
-
-	describe('Tag context', () => {
-		it('should show task from specific tag', async () => {
-			// Create tags and tasks
-			await helpers.taskMaster('add-tag', ['feature'], { cwd: testDir });
-			
-			// Add task to feature tag
-			await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-			const task = await helpers.taskMaster('add-task', ['--title', 'Feature task', '--description', 'In feature tag'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Show with tag context
-			const result = await helpers.taskMaster('show', [taskId, '--tag', 'feature'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Feature');
-			expect(result.stdout).toContain('In');
-		});
-
-		it('should indicate task tag in output', async () => {
-			// Create task in non-master tag
-			await helpers.taskMaster('add-tag', ['development'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['development'], { cwd: testDir });
-			
-			const task = await helpers.taskMaster('add-task', ['--title', 'Dev task', '--description', 'Development work'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Show the task
-			const result = await helpers.taskMaster('show', [taskId, '--tag', 'development'], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			// May show tag information in output
-		});
-	});
-
-	describe('Output formats', () => {
-		it('should show task with timestamps', async () => {
-			// Create task
-			const task = await helpers.taskMaster('add-task', ['--title', 'Timestamped task', '--description', 'Check timestamps'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Show with verbose or detailed flag if supported
-			const result = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			// May show created/modified timestamps
-		});
-
-		it('should show task history if available', async () => {
-			// Create task and make changes
-			const task = await helpers.taskMaster('add-task', ['--title', 'Task with history', '--description', 'Original description'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Update status multiple times
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'review'], { cwd: testDir });
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'in-progress'], { cwd: testDir });
-			await helpers.taskMaster('set-status', ['--id', taskId, '--status', 'done'], { cwd: testDir });
-
-			// Show task - may include history
-			const result = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Task');
-		});
-	});
-
-	describe('Complex task structures', () => {
-		it('should show task with multiple levels of subtasks', async () => {
-			// Create main task
-			const main = await helpers.taskMaster('add-task', ['--title', 'Main project', '--description', 'Top level'], { cwd: testDir });
-			const mainId = helpers.extractTaskId(main.stdout);
-
-			// Add subtasks manually
-			await helpers.taskMaster('add-subtask', ['--parent', mainId, '--title', 'Subtask 1', '--description', 'First level subtask'], { cwd: testDir });
-			await helpers.taskMaster('add-subtask', ['--parent', mainId, '--title', 'Subtask 2', '--description', 'Second level subtask'], { cwd: testDir });
-
-			// Show main task
-			const result = await helpers.taskMaster('show', [mainId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Main');
-			expect(result.stdout).toContain('Subtasks');
-		});
-
-		it('should show task with dependencies and subtasks', async () => {
-			// Create dependency
-			const dep = await helpers.taskMaster('add-task', ['--title', '"Prerequisite"', '--description', '"Must be done first"'], { cwd: testDir });
-			const depId = helpers.extractTaskId(dep.stdout);
-
-			// Create main task with dependency
-			const main = await helpers.taskMaster('add-task', ['--title', '"Complex task"', '--description', '"Has both deps and subtasks"'], { cwd: testDir });
-			const mainId = helpers.extractTaskId(main.stdout);
-			await helpers.taskMaster('add-dependency', ['--id', mainId, '--depends-on', depId], { cwd: testDir });
-
-			// Add subtasks manually
-			await helpers.taskMaster('add-subtask', ['--parent', mainId, '--title', 'Subtask 1', '--description', 'First subtask'], { cwd: testDir });
-			await helpers.taskMaster('add-subtask', ['--parent', mainId, '--title', 'Subtask 2', '--description', 'Second subtask'], { cwd: testDir });
-
-			// Show the complex task
-			const result = await helpers.taskMaster('show', [mainId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Complex task');
-			expect(result.stdout).toContain('Dependencies:');
-			expect(result.stdout).toContain('Subtasks');
-		});
-	});
-
-	describe('Display options', () => {
-		it('should show task in compact format if supported', async () => {
-			const task = await helpers.taskMaster('add-task', ['--title', 'Compact display', '--description', 'Test compact view'], { cwd: testDir });
-			const taskId = helpers.extractTaskId(task.stdout);
-
-			// Try compact flag if supported
-			const result = await helpers.taskMaster('show', [taskId], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Compact');
-		});
-
-		it('should show task with color coding for status', async () => {
-			// Create tasks with different statuses
-			const pending = await helpers.taskMaster('add-task', ['--title', 'Pending task', '--description', 'Status: pending'], { cwd: testDir });
-			const pendingId = helpers.extractTaskId(pending.stdout);
-
-			const inProgress = await helpers.taskMaster('add-task', ['--title', 'Active task', '--description', 'Status: in-progress'], { cwd: testDir });
-			const inProgressId = helpers.extractTaskId(inProgress.stdout);
-			await helpers.taskMaster('set-status', ['--id', inProgressId, '--status', 'in-progress'], { cwd: testDir });
-
-			const done = await helpers.taskMaster('add-task', ['--title', 'Completed task', '--description', 'Status: done'], { cwd: testDir });
-			const doneId = helpers.extractTaskId(done.stdout);
-			await helpers.taskMaster('set-status', ['--id', doneId, '--status', 'done'], { cwd: testDir });
-
-			// Show each task - output may include color codes or status indicators
-			const pendingResult = await helpers.taskMaster('show', [pendingId], { cwd: testDir });
-			expect(pendingResult).toHaveExitCode(0);
-
-			const inProgressResult = await helpers.taskMaster('show', [inProgressId], { cwd: testDir });
-			expect(inProgressResult).toHaveExitCode(0);
-			expect(inProgressResult.stdout).toContain('► in-progress');
-
-			const doneResult = await helpers.taskMaster('show', [doneId], { cwd: testDir });
-			expect(doneResult).toHaveExitCode(0);
-			expect(doneResult.stdout).toContain('✓ done');
-		});
-	});
-});

tests/e2e/tests/commands/sync-readme.test.js

@@ -1,737 +0,0 @@
-/**
- * Comprehensive E2E tests for sync-readme command
- * Tests README.md synchronization with task list
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync,
-	chmodSync
-} from 'fs';
-import { join, basename } from 'path';
-import { tmpdir } from 'os';
-
-describe('sync-readme command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-sync-readme-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('sync-readme');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Creating README.md', () => {
-		it('should create README.md when it does not exist', async () => {
-			// Add a test task
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Test task', '--description', 'Task for README sync'],
-				{ cwd: testDir }
-			);
-
-			// Run sync-readme
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully synced tasks to README.md');
-
-			// Verify README.md was created
-			const readmePath = join(testDir, 'README.md');
-			expect(existsSync(readmePath)).toBe(true);
-
-			// Verify content
-			const readmeContent = readFileSync(readmePath, 'utf8');
-			expect(readmeContent).toContain('Test');
-			expect(readmeContent).toContain('<!-- TASKMASTER_EXPORT_START -->');
-			expect(readmeContent).toContain('<!-- TASKMASTER_EXPORT_END -->');
-			expect(readmeContent).toContain('Taskmaster Export');
-			expect(readmeContent).toContain('Powered by [Task Master]');
-		});
-
-		it('should create basic README structure with project name', async () => {
-			// Run sync-readme without any tasks
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain default project title
-			expect(readmeContent).toContain('# Taskmaster');
-			expect(readmeContent).toContain('This project is managed using Task Master');
-		});
-	});
-
-	describe('Updating existing README.md', () => {
-		beforeEach(() => {
-			// Create an existing README with custom content
-			const readmePath = join(testDir, 'README.md');
-			writeFileSync(
-				readmePath,
-				`# My Project
-
-This is my awesome project.
-
-## Features
-- Feature 1
-- Feature 2
-
-## Installation
-Run npm install
-
-`
-			);
-		});
-
-		it('should preserve existing README content', async () => {
-			// Add a task
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'New feature', '--description', 'Implement feature 3'],
-				{ cwd: testDir }
-			);
-
-			// Run sync-readme
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Original content should be preserved
-			expect(readmeContent).toContain('# My Project');
-			expect(readmeContent).toContain('This is my awesome project');
-			expect(readmeContent).toContain('## Features');
-			expect(readmeContent).toContain('- Feature 1');
-			expect(readmeContent).toContain('## Installation');
-
-			// Task list should be appended
-			expect(readmeContent).toContain('New');
-			expect(readmeContent).toContain('<!-- TASKMASTER_EXPORT_START -->');
-			expect(readmeContent).toContain('<!-- TASKMASTER_EXPORT_END -->');
-		});
-
-		it('should replace existing task section between markers', async () => {
-			// Add initial task section to README
-			const readmePath = join(testDir, 'README.md');
-			let content = readFileSync(readmePath, 'utf8');
-			content += `
-<!-- TASKMASTER_EXPORT_START -->
-Old task content that should be replaced
-<!-- TASKMASTER_EXPORT_END -->
-`;
-			writeFileSync(readmePath, content);
-
-			// Add new tasks
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 1', '--description', 'First task'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 2', '--description', 'Second task'],
-				{ cwd: testDir }
-			);
-
-			// Run sync-readme
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const updatedContent = readFileSync(readmePath, 'utf8');
-
-			// Old content should be replaced
-			expect(updatedContent).not.toContain('Old task content that should be replaced');
-
-			// New tasks should be present
-			expect(updatedContent).toContain('Task 1');
-			expect(updatedContent).toContain('Task 2');
-
-			// Original content before markers should be preserved
-			expect(updatedContent).toContain('# My Project');
-			expect(updatedContent).toContain('This is my awesome project');
-		});
-	});
-
-	describe('Task list formatting', () => {
-		beforeEach(async () => {
-			// Create tasks with different properties
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'High priority task',
-					'--description',
-					'Urgent task',
-					'--priority',
-					'high'
-				],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'In progress task',
-					'--description',
-					'Working on it',
-					'--priority',
-					'medium'
-				],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId2, '--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			const task3 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Completed task', '--description', 'All done'],
-				{ cwd: testDir }
-			);
-			const taskId3 = helpers.extractTaskId(task3.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId3, '--status', 'done'],
-				{ cwd: testDir }
-			);
-		});
-
-		it('should format tasks in markdown table', async () => {
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain markdown table headers
-			expect(readmeContent).toContain('| ID |');
-			expect(readmeContent).toContain('| Title |');
-			expect(readmeContent).toContain('| Status |');
-			expect(readmeContent).toContain('| Priority |');
-
-			// Should contain task data
-			expect(readmeContent).toContain('High priority task');
-			expect(readmeContent).toContain('high');
-			expect(readmeContent).toContain('In progress task');
-			expect(readmeContent).toContain('in-progress');
-			expect(readmeContent).toContain('Completed task');
-			expect(readmeContent).toContain('done');
-		});
-
-		it('should include metadata in export header', async () => {
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain export metadata
-			expect(readmeContent).toContain('Taskmaster Export');
-			expect(readmeContent).toContain('without subtasks');
-			expect(readmeContent).toContain('Status filter: none');
-			expect(readmeContent).toContain('Powered by [Task Master](https://task-master.dev');
-
-			// Should contain timestamp
-			expect(readmeContent).toMatch(/\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC/);
-		});
-	});
-
-	describe('Subtasks support', () => {
-		let parentTaskId;
-
-		beforeEach(async () => {
-			// Create parent task
-			const parentResult = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Main task', '--description', 'Has subtasks'],
-				{ cwd: testDir }
-			);
-			parentTaskId = helpers.extractTaskId(parentResult.stdout);
-
-			// Add subtasks
-			await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentTaskId,
-					'--title',
-					'Subtask 1',
-					'--description',
-					'First subtask'
-				],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					parentTaskId,
-					'--title',
-					'Subtask 2',
-					'--description',
-					'Second subtask'
-				],
-				{ cwd: testDir }
-			);
-		});
-
-		it('should not include subtasks by default', async () => {
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain parent task
-			expect(readmeContent).toContain('Main task');
-
-			// Should not contain subtasks
-			expect(readmeContent).not.toContain('Subtask 1');
-			expect(readmeContent).not.toContain('Subtask 2');
-
-			// Metadata should indicate no subtasks
-			expect(readmeContent).toContain('without subtasks');
-		});
-
-		it('should include subtasks with --with-subtasks flag', async () => {
-			const result = await helpers.taskMaster('sync-readme', ['--with-subtasks'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain parent and subtasks
-			expect(readmeContent).toContain('Main task');
-			expect(readmeContent).toContain('Subtask 1');
-			expect(readmeContent).toContain('Subtask 2');
-
-			// Should show subtask IDs
-			expect(readmeContent).toContain(`${parentTaskId}.1`);
-			expect(readmeContent).toContain(`${parentTaskId}.2`);
-
-			// Metadata should indicate subtasks included
-			expect(readmeContent).toContain('with subtasks');
-		});
-	});
-
-	describe('Status filtering', () => {
-		beforeEach(async () => {
-			// Create tasks with different statuses
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Pending task', '--description', 'Not started'],
-				{ cwd: testDir }
-			);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Active task', '--description', 'In progress'],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId2, '--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			const task3 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Done task', '--description', 'Completed'],
-				{ cwd: testDir }
-			);
-			const taskId3 = helpers.extractTaskId(task3.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId3, '--status', 'done'],
-				{ cwd: testDir }
-			);
-		});
-
-		it('should filter by pending status', async () => {
-			const result = await helpers.taskMaster(
-				'sync-readme',
-				['--status', 'pending'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('status: pending');
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should only contain pending task
-			expect(readmeContent).toContain('Pending task');
-			expect(readmeContent).not.toContain('Active task');
-			expect(readmeContent).not.toContain('Done task');
-
-			// Metadata should indicate status filter
-			expect(readmeContent).toContain('Status filter: pending');
-		});
-
-		it('should filter by done status', async () => {
-			const result = await helpers.taskMaster(
-				'sync-readme',
-				['--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should only contain done task
-			expect(readmeContent).toContain('Done task');
-			expect(readmeContent).not.toContain('Pending task');
-			expect(readmeContent).not.toContain('Active task');
-
-			// Metadata should indicate status filter
-			expect(readmeContent).toContain('Status filter: done');
-		});
-	});
-
-	describe('Tag support', () => {
-		beforeEach(async () => {
-			// Create tasks in master tag
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task', '--description', 'In master tag'],
-				{ cwd: testDir }
-			);
-
-			// Create new tag and add tasks
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-branch', '--description', 'Feature work'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster('use-tag', ['feature-branch'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Feature task',
-					'--description',
-					'In feature tag',
-					'--tag',
-					'feature-branch'
-				],
-				{ cwd: testDir }
-			);
-		});
-
-		it('should sync tasks from current active tag', async () => {
-			// Ensure we're on feature-branch tag
-			await helpers.taskMaster('use-tag', ['feature-branch'], { cwd: testDir });
-
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain feature task from active tag
-			expect(readmeContent).toContain('Feature task');
-			expect(readmeContent).not.toContain('Master task');
-		});
-
-		it('should sync master tag tasks when on master', async () => {
-			// Switch back to master tag
-			await helpers.taskMaster('use-tag', ['master'], { cwd: testDir });
-
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain master task
-			expect(readmeContent).toContain('Master task');
-			expect(readmeContent).not.toContain('Feature task');
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should handle missing tasks file gracefully', async () => {
-			// Remove tasks file
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			if (existsSync(tasksPath)) {
-				rmSync(tasksPath);
-			}
-
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Error');
-		});
-
-		it('should handle invalid tasks file', async () => {
-			// Create invalid tasks file
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			writeFileSync(tasksPath, '{ invalid json }');
-
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-		});
-
-		it('should handle read-only README file', async () => {
-			// Skip this test on Windows as chmod doesn't work the same way
-			if (process.platform === 'win32') {
-				return;
-			}
-
-			// Create read-only README
-			const readmePath = join(testDir, 'README.md');
-			writeFileSync(readmePath, '# Read Only');
-			
-			// Make file read-only
-			chmodSync(readmePath, 0o444);
-
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			// Restore write permissions for cleanup
-			chmodSync(readmePath, 0o644);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('Failed to sync tasks to README');
-		});
-	});
-
-	describe('File path handling', () => {
-		it('should use custom tasks file path', async () => {
-			// Create custom tasks file
-			const customPath = join(testDir, 'custom-tasks.json');
-			writeFileSync(
-				customPath,
-				JSON.stringify({
-					master: {
-						tasks: [
-							{
-								id: 1,
-								title: 'Custom file task',
-								description: 'From custom file',
-								status: 'pending',
-								priority: 'medium',
-								dependencies: []
-							}
-						]
-					}
-				})
-			);
-
-			const result = await helpers.taskMaster(
-				'sync-readme',
-				['--file', customPath],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			expect(readmeContent).toContain('Custom file task');
-		});
-	});
-
-	describe('Multiple sync operations', () => {
-		it('should handle multiple sync operations correctly', async () => {
-			// First sync
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Initial task', '--description', 'First sync'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster('sync-readme', [], { cwd: testDir });
-
-			// Add more tasks
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Second task', '--description', 'Second sync'],
-				{ cwd: testDir }
-			);
-
-			// Second sync
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain both tasks
-			expect(readmeContent).toContain('Initial');
-			expect(readmeContent).toContain('Second');
-
-			// Should only have one set of markers
-			const startMatches = (readmeContent.match(/<!-- TASKMASTER_EXPORT_START -->/g) || []).length;
-			const endMatches = (readmeContent.match(/<!-- TASKMASTER_EXPORT_END -->/g) || []).length;
-			expect(startMatches).toBe(1);
-			expect(endMatches).toBe(1);
-		});
-	});
-
-	describe('UTM tracking', () => {
-		it('should include proper UTM parameters in Task Master link', async () => {
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Test task', '--description', 'For UTM test'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-
-			const readmePath = join(testDir, 'README.md');
-			const readmeContent = readFileSync(readmePath, 'utf8');
-
-			// Should contain Task Master link with UTM parameters
-			expect(readmeContent).toContain('https://task-master.dev?');
-			expect(readmeContent).toContain('utm_source=github-readme');
-			expect(readmeContent).toContain('utm_medium=readme-export');
-			expect(readmeContent).toContain('utm_campaign=');
-			expect(readmeContent).toContain('utm_content=task-export-link');
-
-			// UTM campaign should be based on folder name
-			const folderName = basename(testDir);
-			const cleanFolderName = folderName
-				.toLowerCase()
-				.replace(/[^a-z0-9]/g, '-')
-				.replace(/-+/g, '-')
-				.replace(/^-|-$/g, '');
-			expect(readmeContent).toContain(`utm_campaign=${cleanFolderName}`);
-		});
-	});
-
-	describe('Output formatting', () => {
-		it('should show export details in console output', async () => {
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Test task', '--description', 'For output test'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster(
-				'sync-readme',
-				['--with-subtasks', '--status', 'pending'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Syncing tasks to README.md');
-			expect(result.stdout).toContain('(with subtasks)');
-			expect(result.stdout).toContain('(status: pending)');
-			expect(result.stdout).toContain('Successfully synced tasks to README.md');
-			expect(result.stdout).toContain('Export details: with subtasks, status: pending');
-			expect(result.stdout).toContain('Location:');
-			expect(result.stdout).toContain('README.md');
-		});
-
-		it('should show proper output without filters', async () => {
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Test task', '--description', 'No filters'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('sync-readme', [], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Syncing tasks to README.md');
-			expect(result.stdout).not.toContain('(with subtasks)');
-			expect(result.stdout).not.toContain('(status:');
-			expect(result.stdout).toContain('Export details: without subtasks');
-		});
-	});
-});

tests/e2e/tests/commands/tags.test.js

@@ -1,503 +0,0 @@
-/**
- * Comprehensive E2E tests for tags command
- * Tests listing tags with various states and configurations
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('tags command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-tags-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('tags');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic listing', () => {
-		it('should show only master tag when no other tags exist', async () => {
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('master');
-			expect(result.stdout).toContain('●'); // Current tag indicator
-			expect(result.stdout).toContain('(current)');
-			expect(result.stdout).toContain('Tasks');
-			expect(result.stdout).toContain('Completed');
-		});
-
-		it('should list multiple tags after creation', async () => {
-			// Create additional tags
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-a', '--description', 'Feature A development'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-b', '--description', 'Feature B development'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-tag',
-				['bugfix-123', '--description', 'Fix for issue 123'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('master');
-			expect(result.stdout).toContain('feature-a');
-			expect(result.stdout).toContain('feature-b');
-			expect(result.stdout).toContain('bugfix-123');
-			// Master should be marked as current
-			expect(result.stdout).toMatch(/●\s*master\s*\(current\)/);
-		});
-	});
-
-	describe('Active tag indicator', () => {
-		it('should show current tag indicator correctly', async () => {
-			// Create a new tag
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-xyz', '--description', 'Feature XYZ'],
-				{ cwd: testDir }
-			);
-
-			// List tags - master should be current
-			let result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toMatch(/●\s*master\s*\(current\)/);
-			expect(result.stdout).not.toMatch(/●\s*feature-xyz\s*\(current\)/);
-
-			// Switch to feature-xyz
-			await helpers.taskMaster('use-tag', ['feature-xyz'], { cwd: testDir });
-
-			// List tags again - feature-xyz should be current
-			result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toMatch(/●\s*feature-xyz\s*\(current\)/);
-			expect(result.stdout).not.toMatch(/●\s*master\s*\(current\)/);
-		});
-
-		it('should sort tags with current tag first', async () => {
-			// Create tags in alphabetical order
-			await helpers.taskMaster('add-tag', ['aaa-tag'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['bbb-tag'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['zzz-tag'], { cwd: testDir });
-
-			// Switch to zzz-tag
-			await helpers.taskMaster('use-tag', ['zzz-tag'], { cwd: testDir });
-
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-
-			// Extract tag names from output to verify order
-			const lines = result.stdout.split('\n');
-			const tagLines = lines.filter(line => 
-				line.includes('aaa-tag') || 
-				line.includes('bbb-tag') || 
-				line.includes('zzz-tag') || 
-				line.includes('master')
-			);
-
-			// zzz-tag should appear first (current), followed by alphabetical order
-			expect(tagLines[0]).toContain('zzz-tag');
-			expect(tagLines[0]).toContain('(current)');
-		});
-	});
-
-	describe('Task counts', () => {
-		// Note: Tests involving add-task are commented out due to projectRoot error in test environment
-		// These tests work in production but fail in the test environment
-		/*
-		it('should show correct task counts for each tag', async () => {
-			// Add tasks to master tag
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task 1', '--description', 'First task in master'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Master task 2', '--description', 'Second task in master'],
-				{ cwd: testDir }
-			);
-
-			// Create feature tag and add tasks
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-tag', '--description', 'Feature development'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster('use-tag', ['feature-tag'], { cwd: testDir });
-
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Feature task 1', '--description', 'First feature task'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Feature task 2', '--description', 'Second feature task'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Feature task 3', '--description', 'Third feature task'],
-				{ cwd: testDir }
-			);
-
-			// Mark one task as completed
-			const task3 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Feature task 4', '--description', 'Fourth feature task'],
-				{ cwd: testDir }
-			);
-			const taskId = helpers.extractTaskId(task3.stdout);
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			// Verify task counts in output
-			const output = result.stdout;
-			
-			// Master should have 2 tasks, 0 completed
-			const masterLine = output.split('\n').find(line => line.includes('master') && !line.includes('feature'));
-			expect(masterLine).toMatch(/2\s+0/);
-
-			// Feature-tag should have 4 tasks, 1 completed
-			const featureLine = output.split('\n').find(line => line.includes('feature-tag'));
-			expect(featureLine).toMatch(/4\s+1/);
-		});
-		*/
-
-		it('should handle tags with no tasks', async () => {
-			// Create empty tag
-			await helpers.taskMaster(
-				'add-tag',
-				['empty-tag', '--description', 'Tag with no tasks'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			const emptyLine = result.stdout.split('\n').find(line => line.includes('empty-tag'));
-			expect(emptyLine).toContain('empty-tag');
-			// Check that the line contains the tag name and two zeros for tasks and completed
-			expect(emptyLine).toMatch(/0\s*.*0\s*/); // 0 tasks, 0 completed
-		});
-	});
-
-	describe('Metadata display', () => {
-		it('should show metadata when --show-metadata flag is used', async () => {
-			// Create tags with descriptions
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-auth', '--description', 'Authentication feature implementation'],
-				{ cwd: testDir }
-			);
-			await helpers.taskMaster(
-				'add-tag',
-				['refactor-db', '--description', 'Database layer refactoring for better performance'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('tags', ['--show-metadata'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Created');
-			expect(result.stdout).toContain('Description');
-			expect(result.stdout).toContain('Authentication');
-			expect(result.stdout).toContain('Database');
-		});
-
-		it('should truncate long descriptions', async () => {
-			const longDescription = 'This is a very long description that should be truncated in the display to fit within the table column width constraints and maintain proper formatting across different terminal sizes';
-			
-			await helpers.taskMaster(
-				'add-tag',
-				['long-desc-tag', '--description', longDescription],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('tags', ['--show-metadata'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			// Should contain beginning of description but be truncated
-			expect(result.stdout).toContain('This');
-			// Should not contain the full description
-			expect(result.stdout).not.toContain('different terminal sizes');
-		});
-
-		it('should show creation dates in metadata', async () => {
-			await helpers.taskMaster(
-				'add-tag',
-				['dated-tag', '--description', 'Tag with date'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('tags', ['--show-metadata'], {
-				cwd: testDir
-			});
-
-			expect(result).toHaveExitCode(0);
-			// Should show date in format like MM/DD/YYYY or similar
-			const datePattern = /\d{1,2}\/\d{1,2}\/\d{4}|\d{4}-\d{2}-\d{2}/;
-			expect(result.stdout).toMatch(datePattern);
-		});
-	});
-
-	describe('Tag creation and copying', () => {
-		// Note: Tests involving add-task are commented out due to projectRoot error in test environment
-		/*
-		it('should list tag created with --copy-from-current', async () => {
-			// Add tasks to master
-			await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task to copy', '--description', 'Will be copied'],
-				{ cwd: testDir }
-			);
-
-			// Create tag copying from current (master)
-			await helpers.taskMaster(
-				'add-tag',
-				['copied-tag', '--copy-from-current', '--description', 'Copied from master'],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('copied-tag');
-			
-			// Both tags should have 1 task
-			const masterLine = result.stdout.split('\n').find(line => line.includes('master') && !line.includes('copied'));
-			const copiedLine = result.stdout.split('\n').find(line => line.includes('copied-tag'));
-			expect(masterLine).toMatch(/1\s+0/);
-			expect(copiedLine).toMatch(/1\s+0/);
-		});
-		*/
-
-		it('should list tag created from branch name', async () => {
-			// This test might need adjustment based on git branch availability
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('master');
-		});
-	});
-
-	describe('Edge cases and formatting', () => {
-		it('should handle special characters in tag names', async () => {
-			// Create tags with special characters (if allowed)
-			const specialTags = ['feature_underscore', 'feature-dash', 'feature.dot'];
-			
-			for (const tagName of specialTags) {
-				const result = await helpers.taskMaster(
-					'add-tag',
-					[tagName, '--description', `Tag with ${tagName}`],
-					{ cwd: testDir, allowFailure: true }
-				);
-				
-				// If creation succeeded, it should be listed
-				if (result.exitCode === 0) {
-					const listResult = await helpers.taskMaster('tags', [], { cwd: testDir });
-					expect(listResult.stdout).toContain(tagName);
-				}
-			}
-		});
-
-		it('should maintain table alignment with varying data', async () => {
-			// Create tags with varying name lengths
-			await helpers.taskMaster('add-tag', ['a'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['very-long-tag-name-here'], { cwd: testDir });
-
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			// Check that table borders are present and aligned
-			const lines = result.stdout.split('\n');
-			const tableBorderLines = lines.filter(line => line.includes('─') || line.includes('│'));
-			expect(tableBorderLines.length).toBeGreaterThan(0);
-		});
-
-		it('should handle empty tag list gracefully', async () => {
-			// Remove all tags except master (if possible)
-			// This is mainly to test the formatting when minimal tags exist
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Tag Name');
-			expect(result.stdout).toContain('Tasks');
-			expect(result.stdout).toContain('Completed');
-		});
-	});
-
-	describe('Performance', () => {
-		it('should handle listing many tags efficiently', async () => {
-			// Create many tags sequentially to avoid race conditions
-			for (let i = 1; i <= 20; i++) {
-				await helpers.taskMaster(
-					'add-tag',
-					[`tag-${i}`, '--description', `Tag number ${i}`],
-					{ cwd: testDir }
-				);
-			}
-
-			const startTime = Date.now();
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			const endTime = Date.now();
-
-			expect(result).toHaveExitCode(0);
-			// Should have created all tags plus master = 21 total
-			expect(result.stdout).toContain('Found 21 tags');
-			expect(result.stdout).toContain('tag-1');
-			expect(result.stdout).toContain('tag-10');
-
-			// Should complete within reasonable time (2 seconds)
-			expect(endTime - startTime).toBeLessThan(2000);
-		});
-	});
-
-	describe('Integration with other commands', () => {
-		it('should reflect changes made by use-tag command', async () => {
-			// Create and switch between tags
-			await helpers.taskMaster('add-tag', ['dev'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['staging'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['prod'], { cwd: testDir });
-
-			// Switch to staging
-			await helpers.taskMaster('use-tag', ['staging'], { cwd: testDir });
-
-			const result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toMatch(/●\s*staging\s*\(current\)/);
-			expect(result.stdout).not.toMatch(/●\s*master\s*\(current\)/);
-			expect(result.stdout).not.toMatch(/●\s*dev\s*\(current\)/);
-			expect(result.stdout).not.toMatch(/●\s*prod\s*\(current\)/);
-		});
-
-		// Note: Tests involving add-task are commented out due to projectRoot error in test environment
-		/*
-		it('should show updated task counts after task operations', async () => {
-			// Create a tag and add tasks
-			await helpers.taskMaster('add-tag', ['work'], { cwd: testDir });
-			await helpers.taskMaster('use-tag', ['work'], { cwd: testDir });
-
-			// Add tasks
-			const task1 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 1', '--description', 'First'],
-				{ cwd: testDir }
-			);
-			const taskId1 = helpers.extractTaskId(task1.stdout);
-
-			const task2 = await helpers.taskMaster(
-				'add-task',
-				['--title', 'Task 2', '--description', 'Second'],
-				{ cwd: testDir }
-			);
-			const taskId2 = helpers.extractTaskId(task2.stdout);
-
-			// Check initial counts
-			let result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			let workLine = result.stdout.split('\n').find(line => line.includes('work'));
-			expect(workLine).toMatch(/2\s+0/); // 2 tasks, 0 completed
-
-			// Complete one task
-			await helpers.taskMaster(
-				'set-status',
-				['--id', taskId1, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			// Check updated counts
-			result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			workLine = result.stdout.split('\n').find(line => line.includes('work'));
-			expect(workLine).toMatch(/2\s+1/); // 2 tasks, 1 completed
-
-			// Remove a task
-			await helpers.taskMaster('remove-task', ['--id', taskId2], { cwd: testDir });
-
-			// Check final counts
-			result = await helpers.taskMaster('tags', [], { cwd: testDir });
-			workLine = result.stdout.split('\n').find(line => line.includes('work'));
-			expect(workLine).toMatch(/1\s+1/); // 1 task, 1 completed
-		});
-		*/
-	});
-
-	// Note: The 'tg' alias mentioned in the command definition doesn't appear to be implemented
-	// in the current codebase, so this test section is commented out
-	/*
-	describe('Command aliases', () => {
-		it('should work with tg alias', async () => {
-			// Create some tags
-			await helpers.taskMaster('add-tag', ['test-alias'], { cwd: testDir });
-
-			const result = await helpers.taskMaster('tg', [], { cwd: testDir });
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('master');
-			expect(result.stdout).toContain('test-alias');
-			expect(result.stdout).toContain('Tag Name');
-			expect(result.stdout).toContain('Tasks');
-			expect(result.stdout).toContain('Completed');
-		});
-	});
-	*/
-});

tests/e2e/tests/commands/update-subtask.test.js

@@ -1,655 +0,0 @@
-/**
- * Comprehensive E2E tests for update-subtask command
- * Tests all aspects of subtask updates including AI-powered updates
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-describe('update-subtask command', () => {
-	let testDir;
-	let helpers;
-	let parentTaskId;
-	let subtaskId;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-update-subtask-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('update-subtask');
-		helpers = context.helpers;
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Copy configuration files
-		copyConfigFiles(testDir);
-
-		// Ensure tasks.json exists (bug workaround)
-		const tasksJsonPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		if (!existsSync(tasksJsonPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksJsonPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-
-		// Create a parent task with subtask
-		const parentResult = await helpers.taskMaster(
-			'add-task',
-			['--title', '"Parent task"', '--description', '"Task with subtasks"'],
-			{ cwd: testDir }
-		);
-		parentTaskId = helpers.extractTaskId(parentResult.stdout);
-
-		// Create a subtask
-		const subtaskResult = await helpers.taskMaster(
-			'add-subtask',
-			[
-				'--parent',
-				parentTaskId,
-				'--title',
-				'Initial subtask',
-				'--description',
-				'Basic subtask description'
-			],
-			{ cwd: testDir }
-		);
-		// Extract subtask ID (should be like "1.1")
-		const match = subtaskResult.stdout.match(/subtask #?(\d+\.\d+)/i);
-		subtaskId = match ? match[1] : '1.1';
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic subtask updates', () => {
-		it('should update subtask with additional information', async () => {
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				[
-					'--id',
-					subtaskId,
-					'--prompt',
-					'Add implementation details: Use async/await pattern'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated subtask');
-
-			// Verify update - check that the subtask still exists and command was successful
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-
-		it('should update subtask with research mode', async () => {
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				[
-					'--id',
-					subtaskId,
-					'--prompt',
-					'Research best practices for error handling',
-					'--research'
-				],
-				{ cwd: testDir, timeout: 30000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify research results were added
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-
-		it('should update subtask status', async () => {
-			// Note: update-subtask doesn't have --status option, it only appends information
-			// Use set-status command for status changes
-			const result = await helpers.taskMaster(
-				'set-status',
-				['--id', subtaskId, '--status', 'done'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify status update
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout.toLowerCase()).toContain('done');
-		});
-	});
-
-	describe('AI-powered subtask updates', () => {
-		it('should update subtask using AI prompt', async () => {
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				[
-					'--id',
-					subtaskId,
-					'--prompt',
-					'Add: use async/await'
-				],
-				{ cwd: testDir, timeout: 20000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated subtask');
-
-			// Verify AI enhanced the subtask - check that command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			// The command should have succeeded and subtask should still exist
-			expect(showResult.stdout).toContain('Initial subtask');
-		}, 30000);
-
-		it.skip('should enhance subtask with technical details', async () => {
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				[
-					'--id',
-					subtaskId,
-					'--prompt',
-					'Add technical requirements and edge cases to consider'
-				],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Check that subtask was enhanced
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			// Verify the command succeeded and subtask still exists
-			expect(showResult.stdout).toContain('Initial subtask');
-		}, 30000);
-
-		it('should update subtask with research mode', async () => {
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				[
-					'--id',
-					subtaskId,
-					'--prompt',
-					'Add industry best practices for error handling',
-					'--research'
-				],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Research mode should add comprehensive content
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			// Verify the command succeeded and subtask still exists
-			expect(showResult.stdout).toContain('Initial subtask');
-		}, 40000);
-	});
-
-	describe('Multiple subtask updates', () => {
-		it('should update multiple subtasks sequentially', async () => {
-			// Create another subtask
-			const subtask2Result = await helpers.taskMaster(
-				'add-subtask',
-				['--parent', parentTaskId, '--title', 'Second subtask'],
-				{ cwd: testDir }
-			);
-			const match = subtask2Result.stdout.match(/subtask #?(\d+\.\d+)/i);
-			const subtaskId2 = match ? match[1] : '1.2';
-
-			// Update first subtask
-			await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'First subtask updated'],
-				{ cwd: testDir }
-			);
-
-			// Update second subtask
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId2, '--prompt', 'Second subtask updated'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify both updates
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-			expect(showResult.stdout).toContain('Second subtask');
-		});
-	});
-
-	describe('Subtask metadata updates', () => {
-		it('should add priority to subtask', async () => {
-			// update-subtask doesn't support --priority, use update-subtask with prompt
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Set priority to high'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify the command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-
-		it('should add estimated time to subtask', async () => {
-			// update-subtask doesn't support --estimated-time, use update-subtask with prompt
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Add estimated time: 2 hours'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify the command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-
-		it('should add assignee to subtask', async () => {
-			// update-subtask doesn't support --assignee, use update-subtask with prompt
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Assign to john.doe@example.com'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify the command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-	});
-
-	describe('Combined updates', () => {
-		it('should update title and notes together', async () => {
-			// update-subtask doesn't support --notes or direct title changes
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Add: v2'],
-				{ cwd: testDir, timeout: 20000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify the command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-
-		it('should combine manual update with AI prompt', async () => {
-			// First update status separately
-			await helpers.taskMaster(
-				'set-status',
-				['--id', subtaskId, '--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			// Then update with AI prompt
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Add acceptance criteria'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify updates
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		}, 30000);
-	});
-
-	describe('Append mode', () => {
-		it('should append to subtask notes', async () => {
-			// First add some initial notes
-			await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Add initial notes'],
-				{ cwd: testDir }
-			);
-
-			// Then append more information
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Add additional considerations'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify the command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-	});
-
-	describe('Nested subtasks', () => {
-		it('should update nested subtask', async () => {
-			// Create a nested subtask
-			const nestedResult = await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					subtaskId,
-					'--title',
-					'Nested subtask',
-					'--description',
-					'A nested subtask'
-				],
-				{ cwd: testDir }
-			);
-			const match = nestedResult.stdout.match(/subtask #?(\d+\.\d+\.\d+)/i);
-			const nestedId = match ? match[1] : '1.1.1';
-
-			// Update nested subtask
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', nestedId, '--prompt', 'Updated nested subtask'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify update
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Nested subtask');
-		});
-	});
-
-	describe('Tag-specific subtask updates', () => {
-		it.skip('should update subtask in specific tag', async () => {
-			// Create a tag and add task to it
-			await helpers.taskMaster('add-tag', ['feature-y'], { cwd: testDir });
-
-			// Create task in tag
-			const tagTaskResult = await helpers.taskMaster(
-				'add-task',
-				['--prompt', 'Task in feature-y', '--tag', 'feature-y'],
-				{ cwd: testDir }
-			);
-			const tagTaskId = helpers.extractTaskId(tagTaskResult.stdout);
-
-			// Add subtask to tagged task
-			const tagSubtaskResult = await helpers.taskMaster(
-				'add-subtask',
-				[
-					'--parent',
-					tagTaskId,
-					'--title',
-					'Subtask in feature tag',
-					'--tag',
-					'feature-y'
-				],
-				{ cwd: testDir }
-			);
-			const match = tagSubtaskResult.stdout.match(/subtask #?(\d+\.\d+)/i);
-			const tagSubtaskId = match ? match[1] : '1.1';
-
-			// Update subtask in specific tag
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', tagSubtaskId, '--prompt', 'Tag update', '--tag', 'feature-y'],
-				{ cwd: testDir, timeout: 20000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify update in correct tag
-			const showResult = await helpers.taskMaster(
-				'show',
-				[tagTaskId, '--tag', 'feature-y'],
-				{ cwd: testDir }
-			);
-			expect(showResult.stdout).toContain('Subtask in feature tag');
-		});
-	});
-
-	describe('Output formats', () => {
-		it('should output in JSON format', async () => {
-			// update-subtask doesn't support --output option
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'JSON test update'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated subtask');
-		});
-	});
-
-	describe('Error handling', () => {
-		it('should fail with non-existent subtask ID', async () => {
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', '99.99', '--prompt', 'This should fail'],
-				{ cwd: testDir, allowFailure: true, timeout: 10000 }
-			);
-
-			// The command might succeed but show an error message
-			if (result.exitCode === 0) {
-				// Check that it at least mentions the subtask wasn't found
-				const output = result.stdout + (result.stderr || '');
-				expect(output).toMatch(/99\.99|not found|does not exist|invalid/i);
-			} else {
-				expect(result.exitCode).not.toBe(0);
-			}
-		});
-
-		it('should fail with invalid subtask ID format', async () => {
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', 'invalid-id', '--prompt', 'This should fail'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr || result.stdout).toContain('Invalid subtask ID');
-		});
-
-		it('should fail with invalid priority', async () => {
-			// update-subtask doesn't have --priority option
-			// This test should check for unknown option error
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--priority', 'invalid-priority'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('unknown option');
-		});
-
-		it('should fail with invalid status', async () => {
-			// update-subtask doesn't have --status option
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--status', 'invalid-status'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('unknown option');
-		});
-	});
-
-	describe('Performance and edge cases', () => {
-		it('should handle very long subtask titles', async () => {
-			const longPrompt = 'This is a very detailed subtask update. '.repeat(10);
-
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', longPrompt],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify the command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-
-		it('should update subtask without affecting parent task', async () => {
-			const originalParentTitle = 'Parent task';
-
-			// Update subtask
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				[
-					'--id',
-					subtaskId,
-					'--prompt',
-					'Completely different subtask information'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify parent task remains unchanged
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain(originalParentTitle);
-		});
-
-		it('should handle subtask updates with special characters', async () => {
-			const specialPrompt =
-				'Add subtask info with special chars: @#$% & quotes and apostrophes';
-
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', specialPrompt],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify the command succeeded
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-	});
-
-	describe('Dry run mode', () => {
-		it('should preview updates without applying them', async () => {
-			// update-subtask doesn't support --dry-run
-			const result = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Dry run test', '--dry-run'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			// update-subtask doesn't support --dry-run, expect failure
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('unknown option');
-
-			// Verify subtask was NOT actually updated
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Initial subtask');
-		});
-	});
-
-	describe('Integration with other commands', () => {
-		it('should reflect updates in parent task expansion', async () => {
-			// Update subtask with AI
-			const updateResult = await helpers.taskMaster(
-				'update-subtask',
-				['--id', subtaskId, '--prompt', 'Add detailed implementation steps'],
-				{ cwd: testDir, timeout: 30000 }
-			);
-
-			expect(updateResult).toHaveExitCode(0);
-
-			// Verify parent task exists and subtask is still there
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Parent task');
-			expect(showResult.stdout).toContain('Initial subtask');
-		}, 60000);
-
-		it('should update subtask after parent task status change', async () => {
-			// Change parent task status
-			await helpers.taskMaster(
-				'set-status',
-				['--id', parentTaskId, '--status', 'in-progress'],
-				{
-					cwd: testDir
-				}
-			);
-
-			// Update subtask status separately
-			const result = await helpers.taskMaster(
-				'set-status',
-				['--id', subtaskId, '--status', 'in-progress'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify both statuses
-			const showResult = await helpers.taskMaster('show', [parentTaskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout.toLowerCase()).toContain('in-progress');
-		});
-	});
-});

tests/e2e/tests/commands/update-task.test.js

@@ -1,496 +0,0 @@
-/**
- * E2E tests for update-task command
- * Tests AI-powered single task updates using prompts
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-describe('update-task command', () => {
-	let testDir;
-	let helpers;
-	let taskId;
-	let tasksPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-update-task-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('update-task');
-		helpers = context.helpers;
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Copy configuration files
-		copyConfigFiles(testDir);
-
-		// Set up tasks path
-		tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-
-		// Ensure tasks.json exists after init
-		if (!existsSync(tasksPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-
-		// Create a test task for updates
-		const addResult = await helpers.taskMaster(
-			'add-task',
-			[
-				'--title',
-				'"Initial task"',
-				'--description',
-				'"Basic task for testing updates"'
-			],
-			{ cwd: testDir }
-		);
-		taskId = helpers.extractTaskId(addResult.stdout);
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Basic AI-powered updates', () => {
-		it('should update task with simple prompt', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Make this task about implementing user authentication'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-			expect(result.stdout).toContain('AI Usage Summary');
-		}, 30000);
-
-		it('should update task with detailed requirements', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Update this task to be about building a REST API with endpoints for user management, including GET, POST, PUT, DELETE operations'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-
-			// Verify the update happened by checking the stdout contains update success
-			// Note: The actual content depends on the AI model's response
-			expect(result.stdout).toContain('Successfully updated task');
-		}, 30000);
-
-		it('should enhance task with implementation details', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Add detailed implementation steps, technical requirements, and testing strategies'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-		}, 30000);
-	});
-
-	describe('Append mode', () => {
-		it('should append information to task', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Add a note that this task is blocked by infrastructure setup',
-					'--append'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully appended to task');
-		}, 30000);
-
-		it('should append multiple updates with timestamps', async () => {
-			// First append
-			await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Progress update: Started initial research',
-					'--append'
-				],
-				{ cwd: testDir }
-			);
-
-			// Second append
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Progress update: Completed design phase',
-					'--append'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify both updates are present
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Implementation Details');
-		}, 45000);
-	});
-
-	describe('Research mode', () => {
-		it.skip('should update task with research-backed information', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Research and add current best practices for React component testing',
-					'--research'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-
-			// Should show research was used
-			const outputLower = result.stdout.toLowerCase();
-			expect(outputLower).toMatch(/research|perplexity/);
-		}, 60000);
-
-		it.skip('should enhance task with industry standards using research', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Research and add OWASP security best practices for web applications',
-					'--research'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-		}, 60000);
-	});
-
-	describe('Tag context', () => {
-		it('should update task in specific tag', async () => {
-			// Create a new tag
-			await helpers.taskMaster(
-				'add-tag',
-				['feature-x', '--description', '"Feature X development"'],
-				{ cwd: testDir }
-			);
-
-			// Add a task to the tag
-			await helpers.taskMaster('use-tag', ['feature-x'], { cwd: testDir });
-			const addResult = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Feature X task"',
-					'--description',
-					'"Task in feature branch"'
-				],
-				{ cwd: testDir }
-			);
-			const featureTaskId = helpers.extractTaskId(addResult.stdout);
-
-			// Update the task with tag context
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					featureTaskId,
-					'--prompt',
-					'Update this to include feature toggle implementation',
-					'--tag',
-					'feature-x'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// The output includes an emoji before the tag
-			expect(result.stdout).toMatch(/🏷️\s*tag:\s*feature-x/);
-			expect(result.stdout).toContain('Successfully updated task');
-		}, 60000);
-	});
-
-	describe('Complex prompts', () => {
-		it('should handle multi-line prompts', async () => {
-			// Use a single line prompt to avoid shell interpretation issues
-			const complexPrompt =
-				'Update this task with: 1) Add acceptance criteria 2) Include performance requirements 3) Define success metrics 4) Add rollback plan';
-
-			const result = await helpers.taskMaster(
-				'update-task',
-				['-f', tasksPath, '--id', taskId, '--prompt', complexPrompt],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-		}, 30000);
-
-		it('should handle technical specification prompts', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Convert this into a technical specification with API endpoints, data models, and error handling strategies'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-		}, 30000);
-	});
-
-	describe('Error handling', () => {
-		it('should fail with non-existent task ID', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					'999',
-					'--prompt',
-					'Update non-existent task'
-				],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('not found');
-		});
-
-		it('should fail without required parameters', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				['-f', tasksPath],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('required');
-		});
-
-		it('should fail without prompt', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				['-f', tasksPath, '--id', taskId],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('required');
-		});
-
-		it('should handle invalid task file path', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					'/invalid/path/tasks.json',
-					'--id',
-					taskId,
-					'--prompt',
-					'Update task'
-				],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('does not exist');
-		});
-	});
-
-	describe('Integration scenarios', () => {
-		it('should update task and preserve subtasks', async () => {
-			// First expand the task
-			await helpers.taskMaster('expand', ['--id', taskId, '--num', '3'], {
-				cwd: testDir
-			});
-
-			// Then update the parent task
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Update the main task description to focus on microservices architecture'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated task');
-
-			// Verify subtasks are preserved
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Subtasks');
-		}, 60000);
-
-		it('should update task with dependencies intact', async () => {
-			// Create another task
-			const depResult = await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'"Dependency task"',
-					'--description',
-					'"This task must be done first"'
-				],
-				{ cwd: testDir }
-			);
-			const depId = helpers.extractTaskId(depResult.stdout);
-
-			// Add dependency
-			await helpers.taskMaster(
-				'add-dependency',
-				['--id', taskId, '--depends-on', depId],
-				{ cwd: testDir }
-			);
-
-			// Update the task
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Update this task to include database migration requirements'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify dependency is preserved
-			const showResult = await helpers.taskMaster('show', [taskId], {
-				cwd: testDir
-			});
-			expect(showResult.stdout).toContain('Dependencies:');
-		}, 45000);
-	});
-
-	describe('Output and telemetry', () => {
-		it('should show AI usage telemetry', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Add unit test requirements'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('AI Usage Summary');
-			expect(result.stdout).toContain('Model:');
-			expect(result.stdout).toContain('Tokens:');
-			expect(result.stdout).toContain('Est. Cost:');
-		}, 30000);
-
-		it('should show update progress', async () => {
-			const result = await helpers.taskMaster(
-				'update-task',
-				[
-					'-f',
-					tasksPath,
-					'--id',
-					taskId,
-					'--prompt',
-					'Add deployment checklist'
-				],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Updating Task #' + taskId);
-			expect(result.stdout).toContain('Successfully updated task');
-		}, 30000);
-	});
-});

tests/e2e/tests/commands/update.test.js

@@ -1,450 +0,0 @@
-/**
- * Comprehensive E2E tests for update command (bulk update)
- * Tests all aspects of bulk task updates including AI-powered updates
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import {
-	mkdtempSync,
-	existsSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-	mkdirSync
-} from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { copyConfigFiles } from '../../utils/test-setup.js';
-
-// Skip AI-dependent tests if API access is not available
-describe('update command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-update-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('update');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Copy configuration files
-		copyConfigFiles(testDir);
-
-		// Create some test tasks for bulk updates
-		const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		const tasksData = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						title: 'Setup authentication',
-						description: 'Implement user authentication',
-						priority: 'medium',
-						status: 'pending',
-						details: 'Basic auth implementation',
-						dependencies: [],
-						testStrategy: 'Unit tests for auth logic',
-						subtasks: []
-					},
-					{
-						id: 2,
-						title: 'Create database schema',
-						description: 'Design database structure',
-						priority: 'high',
-						status: 'pending',
-						details: 'PostgreSQL schema',
-						dependencies: [],
-						testStrategy: 'Schema validation tests',
-						subtasks: []
-					},
-					{
-						id: 3,
-						title: 'Build API endpoints',
-						description: 'RESTful API development',
-						priority: 'medium',
-						status: 'in-progress',
-						details: 'Express.js endpoints',
-						dependencies: ['1', '2'],
-						testStrategy: 'API integration tests',
-						subtasks: []
-					}
-				]
-			}
-		};
-		mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-		writeFileSync(tasksPath, JSON.stringify(tasksData, null, 2));
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Bulk task updates with prompts', () => {
-		it('should update all tasks with general prompt', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--prompt', 'Add security considerations to all tasks', '--from', '1'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated');
-			expect(result.stdout).toContain('3 tasks');
-
-			// Verify tasks were updated
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-
-			// Verify we still have 3 tasks and they have been processed
-			expect(tasks.master.tasks.length).toBe(3);
-			// The AI should have updated the tasks in some way - just verify the structure is intact
-			const allTasksValid = tasks.master.tasks.every(
-				(t) => t.id && t.title && t.description && t.details
-			);
-			expect(allTasksValid).toBe(true);
-		}, 60000);
-
-		it('should update tasks from ID 2 onwards', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '2', '--prompt', 'Add performance optimization notes'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated');
-			expect(result.stdout).toContain('2 tasks');
-		}, 60000);
-
-		it('should update all tasks from ID 1', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '1', '--prompt', 'Add estimated time requirements'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Should update all 3 tasks
-			expect(result.stdout).toContain('Successfully updated');
-			expect(result.stdout).toContain('3 tasks');
-
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-
-			// Verify tasks were updated
-			const hasTimeEstimates = tasks.master.tasks.some(
-				(t) =>
-					t.details &&
-					(t.details.includes('time') ||
-						t.details.includes('hour') ||
-						t.details.includes('day'))
-			);
-			expect(hasTimeEstimates).toBe(true);
-		}, 60000);
-
-		it('should update tasks by priority filter', async () => {
-			// The update command doesn't support priority filtering
-			// It only supports --from to update from a specific ID onwards
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '1', '--prompt', 'Add testing requirements'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Should update all 3 tasks
-			expect(result.stdout).toContain('Successfully updated');
-			expect(result.stdout).toContain('3 tasks');
-		}, 60000);
-	});
-
-	describe('Research mode updates', () => {
-		it('should update tasks with research-backed information', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '1', '--prompt', 'Add OAuth2 best practices', '--research'],
-				{ cwd: testDir, timeout: 90000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated');
-
-			// Research mode should produce more detailed updates
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const tasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			const authTask = tasks.master.tasks.find((t) => t.id === 1);
-
-			// Check for detailed OAuth2 information
-			expect(authTask.details.length).toBeGreaterThan(100);
-			const hasOAuthInfo =
-				authTask.details.toLowerCase().includes('oauth') ||
-				authTask.details.toLowerCase().includes('authorization');
-			expect(hasOAuthInfo).toBe(true);
-		}, 120000);
-	});
-
-	describe('Multiple filter combinations', () => {
-		it('should update tasks matching all filters', async () => {
-			// Add more tasks with different combinations
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const currentTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			currentTasks.master.tasks.push(
-				{
-					id: 4,
-					title: 'Security audit',
-					description: 'Perform security review',
-					priority: 'high',
-					status: 'pending',
-					details: 'Initial security check',
-					dependencies: [],
-					testStrategy: 'Security testing',
-					subtasks: []
-				},
-				{
-					id: 5,
-					title: 'Performance testing',
-					description: 'Load testing',
-					priority: 'high',
-					status: 'in_progress',
-					details: 'Using JMeter',
-					dependencies: [],
-					testStrategy: 'Performance testing',
-					subtasks: []
-				}
-			);
-			writeFileSync(tasksPath, JSON.stringify(currentTasks, null, 2));
-
-			// The update command doesn't support status or priority filtering
-			// Update from task 2 onwards to get tasks 2, 3, 4, 5, and 6
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '2', '--prompt', 'Add compliance requirements'],
-				{ cwd: testDir, timeout: 120000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// Should update tasks 2, 3, 4, 5 (4 tasks total)
-			expect(result.stdout).toContain('Successfully updated');
-			expect(result.stdout).toContain('4 tasks');
-		}, 180000);
-
-		it('should handle empty filter results gracefully', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '999', '--prompt', 'This should not update anything'],
-				{ cwd: testDir, timeout: 30000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('No tasks to update');
-		}, 45000);
-	});
-
-	describe('Tag support', () => {
-		it('should update tasks in specific tag', async () => {
-			// Create a new tag with tasks
-			await helpers.taskMaster('add-tag', ['feature-x'], { cwd: testDir });
-
-			// Switch to the tag and add task
-			await helpers.taskMaster('use-tag', ['feature-x'], { cwd: testDir });
-			await helpers.taskMaster(
-				'add-task',
-				[
-					'--title',
-					'Feature X implementation',
-					'--description',
-					'Feature X task'
-				],
-				{ cwd: testDir }
-			);
-
-			const result = await helpers.taskMaster(
-				'update',
-				['--tag', 'feature-x', '--prompt', 'Add deployment considerations'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			// The command might show "No tasks to update" if no tasks match the criteria
-			// or "Successfully updated" if tasks were updated
-			expect(result.stdout).toMatch(/Successfully updated|No tasks to update/);
-		}, 60000);
-
-		it('should update tasks across multiple tags', async () => {
-			// Create multiple tags
-			await helpers.taskMaster('add-tag', ['backend'], { cwd: testDir });
-			await helpers.taskMaster('add-tag', ['frontend'], { cwd: testDir });
-
-			// Update all tasks across all tags
-			const result = await helpers.taskMaster(
-				'update',
-				['--prompt', 'Add error handling strategies'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated');
-		}, 60000);
-	});
-
-	describe('Output formats', () => {
-		it('should support JSON output format', async () => {
-			// The update command doesn't support --output option
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '1', '--prompt', 'Add monitoring requirements'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated');
-		}, 60000);
-	});
-
-	describe('Error handling', () => {
-		it('should fail without prompt', async () => {
-			const result = await helpers.taskMaster('update', ['--from', '1'], {
-				cwd: testDir,
-				allowFailure: true
-			});
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('prompt');
-		});
-
-		it('should handle invalid task IDs gracefully', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '999', '--prompt', 'Update non-existent tasks'],
-				{ cwd: testDir }
-			);
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('No tasks to update');
-		});
-
-		it('should handle missing required --from parameter', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--prompt', 'Test missing from parameter'],
-				{ cwd: testDir }
-			);
-
-			// The --from parameter defaults to '1' so this should succeed
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated');
-		});
-
-		it('should handle using --id instead of --from', async () => {
-			const result = await helpers.taskMaster(
-				'update',
-				['--id', '1', '--prompt', 'Test wrong parameter'],
-				{ cwd: testDir, allowFailure: true }
-			);
-
-			expect(result.exitCode).not.toBe(0);
-			expect(result.stderr).toContain('unknown option');
-		});
-	});
-
-	describe('Performance and edge cases', () => {
-		it('should handle updating many tasks efficiently', async () => {
-			// Add many tasks
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const currentTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-
-			for (let i = 4; i <= 20; i++) {
-				currentTasks.master.tasks.push({
-					id: i,
-					title: `Task ${i}`,
-					description: `Description for task ${i}`,
-					priority: i % 3 === 0 ? 'high' : 'medium',
-					status: 'pending',
-					details: `Details for task ${i}`,
-					dependencies: [],
-					testStrategy: 'Unit tests',
-					subtasks: []
-				});
-			}
-			writeFileSync(tasksPath, JSON.stringify(currentTasks, null, 2));
-
-			const startTime = Date.now();
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '1', '--prompt', 'Add brief implementation notes'],
-				{ cwd: testDir, timeout: 120000 }
-			);
-			const duration = Date.now() - startTime;
-
-			expect(result).toHaveExitCode(0);
-			expect(result.stdout).toContain('Successfully updated');
-			expect(result.stdout).toContain('20 tasks');
-			expect(duration).toBeLessThan(120000); // Should complete within 2 minutes
-		}, 150000);
-
-		it('should preserve task relationships during updates', async () => {
-			// Add tasks with dependencies
-			const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-			const currentTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			currentTasks.master.tasks[1].dependencies = [1];
-			currentTasks.master.tasks[2].dependencies = [1, 2];
-			writeFileSync(tasksPath, JSON.stringify(currentTasks, null, 2));
-
-			const result = await helpers.taskMaster(
-				'update',
-				['--from', '1', '--prompt', 'Clarify implementation order'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			expect(result).toHaveExitCode(0);
-
-			// Verify dependencies are preserved
-			const updatedTasks = JSON.parse(readFileSync(tasksPath, 'utf8'));
-			expect(updatedTasks.master.tasks[1].dependencies).toEqual([1]);
-			expect(updatedTasks.master.tasks[2].dependencies).toEqual([1, 2]);
-		}, 60000);
-	});
-
-	// Note: The update command doesn't support dry-run mode
-
-	describe('Integration with other commands', () => {
-		it('should work with expand command on bulk-updated tasks', async () => {
-			// First bulk update
-			await helpers.taskMaster(
-				'update',
-				['--from', '1', '--prompt', 'Add detailed specifications'],
-				{ cwd: testDir, timeout: 45000 }
-			);
-
-			// Then expand the updated task
-			const expandResult = await helpers.taskMaster('expand', ['--id', '1'], {
-				cwd: testDir,
-				timeout: 45000
-			});
-
-			expect(expandResult).toHaveExitCode(0);
-			expect(expandResult.stdout).toContain(
-				'Successfully parsed 5 subtasks from AI response'
-			);
-		}, 90000);
-	});
-});

tests/e2e/tests/commands/use-tag.test.js

@@ -1,169 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('use-tag command', () => {
-	let testDir;
-	let helpers;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-use-tag-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('use-tag');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Create tasks file path
-		const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-
-		// Create a test project with multiple tags
-		const tasksData = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task in master',
-						status: 'pending',
-						tags: ['master']
-					},
-					{
-						id: 3,
-						description: 'Task in both',
-						status: 'pending',
-						tags: ['master', 'feature']
-					}
-				]
-			},
-			feature: {
-				tasks: [
-					{
-						id: 2,
-						description: 'Task in feature',
-						status: 'pending',
-						tags: ['feature']
-					},
-					{
-						id: 3,
-						description: 'Task in both',
-						status: 'pending',
-						tags: ['master', 'feature']
-					}
-				]
-			},
-			release: {
-				tasks: []
-			},
-			metadata: {
-				nextId: 4,
-				activeTag: 'master'
-			}
-		};
-		writeFileSync(tasksPath, JSON.stringify(tasksData, null, 2));
-	});
-
-	afterEach(async () => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should switch to an existing tag', async () => {
-		const result = await helpers.taskMaster('use-tag', ['feature'], {
-			cwd: testDir
-		});
-
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Successfully switched to tag "feature"');
-
-		// Verify the active tag was updated in state.json
-		const statePath = join(testDir, '.taskmaster/state.json');
-		const stateData = JSON.parse(readFileSync(statePath, 'utf8'));
-		expect(stateData.currentTag).toBe('feature');
-	});
-
-	it('should show error when switching to non-existent tag', async () => {
-		const result = await helpers.taskMaster('use-tag', ['nonexistent'], {
-			cwd: testDir
-		});
-
-		expect(result).toHaveExitCode(1);
-		expect(result.stderr).toContain('Tag "nonexistent" does not exist');
-	});
-
-	it('should switch from feature tag back to master', async () => {
-		// First switch to feature
-		await helpers.taskMaster('use-tag', ['feature'], { cwd: testDir });
-
-		// Then switch back to master
-		const result = await helpers.taskMaster('use-tag', ['master'], {
-			cwd: testDir
-		});
-
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Successfully switched to tag "master"');
-
-		// Verify the active tag was updated in state.json
-		const statePath = join(testDir, '.taskmaster/state.json');
-		const stateData = JSON.parse(readFileSync(statePath, 'utf8'));
-		expect(stateData.currentTag).toBe('master');
-	});
-
-	it('should handle switching to the same tag gracefully', async () => {
-		const result = await helpers.taskMaster('use-tag', ['master'], {
-			cwd: testDir
-		});
-
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Successfully switched to tag "master"');
-	});
-
-	it('should work with custom tasks file path', async () => {
-		const tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		const customTasksPath = join(testDir, 'custom-tasks.json');
-		const content = readFileSync(tasksPath, 'utf8');
-		writeFileSync(customTasksPath, content);
-
-		const result = await helpers.taskMaster(
-			'use-tag',
-			['feature', '-f', customTasksPath],
-			{ cwd: testDir }
-		);
-
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Successfully switched to tag "feature"');
-
-		// Verify the active tag was updated in state.json
-		const statePath = join(testDir, '.taskmaster/state.json');
-		const stateData = JSON.parse(readFileSync(statePath, 'utf8'));
-		expect(stateData.currentTag).toBe('feature');
-	});
-
-	it('should fail when tasks file does not exist', async () => {
-		const nonExistentPath = join(testDir, 'nonexistent.json');
-		const result = await helpers.taskMaster(
-			'use-tag',
-			['feature', '-f', nonExistentPath],
-			{ cwd: testDir }
-		);
-
-		expect(result).toHaveExitCode(1);
-		expect(result.stderr).toContain('does not exist');
-	});
-});

tests/e2e/tests/commands/validate-dependencies.test.js

@@ -1,375 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { mkdtempSync, existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-describe('task-master validate-dependencies command', () => {
-	let testDir;
-	let helpers;
-	let tasksPath;
-
-	beforeEach(async () => {
-		// Create test directory
-		testDir = mkdtempSync(join(tmpdir(), 'task-master-validate-dependencies-command-'));
-
-		// Initialize test helpers
-		const context = global.createTestContext('validate-dependencies command');
-		helpers = context.helpers;
-
-		// Copy .env file if it exists
-		const mainEnvPath = join(process.cwd(), '.env');
-		const testEnvPath = join(testDir, '.env');
-		if (existsSync(mainEnvPath)) {
-			const envContent = readFileSync(mainEnvPath, 'utf8');
-			writeFileSync(testEnvPath, envContent);
-		}
-
-		// Initialize task-master project
-		const initResult = await helpers.taskMaster('init', ['-y'], {
-			cwd: testDir
-		});
-		expect(initResult).toHaveExitCode(0);
-
-		// Set up tasks path
-		tasksPath = join(testDir, '.taskmaster/tasks/tasks.json');
-		
-		// Ensure tasks.json exists (bug workaround)
-		if (!existsSync(tasksPath)) {
-			mkdirSync(join(testDir, '.taskmaster/tasks'), { recursive: true });
-			writeFileSync(tasksPath, JSON.stringify({ master: { tasks: [] } }));
-		}
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (testDir && existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should validate tasks with no dependency issues', async () => {
-		// Create test tasks with valid dependencies
-		const validTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1],
-						subtasks: []
-					},
-					{
-						id: 3,
-						description: 'Task 3',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [1, 2],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		mkdirSync(dirname(tasksPath), { recursive: true });
-		writeFileSync(tasksPath, JSON.stringify(validTasks, null, 2));
-
-		// Run validate-dependencies command
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should succeed with no issues
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Checking for invalid dependencies');
-		expect(result.stdout).toContain('All Dependencies Are Valid');
-	});
-
-	it('should detect circular dependencies', async () => {
-		// Create test tasks with circular dependencies
-		const circularTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [3], // Circular: 1 -> 3 -> 2 -> 1
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1],
-						subtasks: []
-					},
-					{
-						id: 3,
-						description: 'Task 3',
-						status: 'pending',
-						priority: 'low',
-						dependencies: [2],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(circularTasks, null, 2));
-
-		// Run validate-dependencies command
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should detect circular dependency
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('[CIRCULAR]');
-		expect(result.stdout).toContain('Task 1');
-		expect(result.stdout).toContain('Task 2');
-		expect(result.stdout).toContain('Task 3');
-	});
-
-	it('should detect missing dependencies', async () => {
-		// Create test tasks with missing dependencies
-		const missingDepTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [999], // Non-existent task
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1, 888], // Mix of valid and invalid
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(missingDepTasks, null, 2));
-
-		// Run validate-dependencies command
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should detect missing dependencies
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Dependency validation failed');
-		expect(result.stdout).toContain('Task 1');
-		expect(result.stdout).toContain('999');
-		expect(result.stdout).toContain('Task 2');
-		expect(result.stdout).toContain('888');
-	});
-
-	it('should validate subtask dependencies', async () => {
-		// Create test tasks with subtask dependencies
-		const subtaskDepTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [],
-						subtasks: [
-							{
-								id: 1,
-								description: 'Subtask 1.1',
-								status: 'pending',
-								priority: 'medium',
-								dependencies: ['999'] // Invalid dependency
-							},
-							{
-								id: 2,
-								description: 'Subtask 1.2',
-								status: 'pending',
-								priority: 'low',
-								dependencies: ['1.1'] // Valid subtask dependency
-							}
-						]
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(subtaskDepTasks, null, 2));
-
-		// Run validate-dependencies command
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should detect invalid subtask dependency
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Dependency validation failed');
-		expect(result.stdout).toContain('Subtask 1.1');
-		expect(result.stdout).toContain('999');
-	});
-
-	it('should detect self-dependencies', async () => {
-		// Create test tasks with self-dependencies
-		const selfDepTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'pending',
-						priority: 'high',
-						dependencies: [1], // Self-dependency
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [],
-						subtasks: [
-							{
-								id: 1,
-								description: 'Subtask 2.1',
-								status: 'pending',
-								priority: 'low',
-								dependencies: ['2.1'] // Self-dependency
-							}
-						]
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(selfDepTasks, null, 2));
-
-		// Run validate-dependencies command
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should detect self-dependencies
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('Dependency validation failed');
-		expect(result.stdout).toContain('depends on itself');
-	});
-
-	it('should handle completed task dependencies', async () => {
-		// Create test tasks where some dependencies are completed
-		const completedDepTasks = {
-			master: {
-				tasks: [
-					{
-						id: 1,
-						description: 'Task 1',
-						status: 'done',
-						priority: 'high',
-						dependencies: [],
-						subtasks: []
-					},
-					{
-						id: 2,
-						description: 'Task 2',
-						status: 'pending',
-						priority: 'medium',
-						dependencies: [1], // Depends on completed task (valid)
-						subtasks: []
-					},
-					{
-						id: 3,
-						description: 'Task 3',
-						status: 'done',
-						priority: 'low',
-						dependencies: [2], // Completed task depends on pending (might be flagged)
-						subtasks: []
-					}
-				]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(completedDepTasks, null, 2));
-
-		// Run validate-dependencies command
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Check output
-		expect(result).toHaveExitCode(0);
-		// Depending on implementation, might flag completed tasks with pending dependencies
-	});
-
-	it('should work with tag option', async () => {
-		// Create tasks with different tags
-		const multiTagTasks = {
-			master: {
-				tasks: [{
-					id: 1,
-					description: 'Master task',
-					dependencies: [999] // Invalid
-				}]
-			},
-			feature: {
-				tasks: [{
-					id: 1,
-					description: 'Feature task',
-					dependencies: [2] // Valid within tag
-				}, {
-					id: 2,
-					description: 'Feature task 2',
-					dependencies: []
-				}]
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(multiTagTasks, null, 2));
-
-		// Validate feature tag
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath, '--tag', 'feature'], { cwd: testDir });
-
-		expect(result).toHaveExitCode(0);
-		expect(result.stdout).toContain('All Dependencies Are Valid');
-
-		// Validate master tag
-		const result2 = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath, '--tag', 'master'], { cwd: testDir });
-
-		expect(result2.exitCode).toBe(0);
-		expect(result2.stdout).toContain('Dependency validation failed');
-		expect(result2.stdout).toContain('999');
-	});
-
-	it('should handle empty task list', async () => {
-		// Create empty tasks file
-		const emptyTasks = {
-			master: {
-				tasks: []
-			}
-		};
-
-		writeFileSync(tasksPath, JSON.stringify(emptyTasks, null, 2));
-
-		// Run validate-dependencies command
-		const result = await helpers.taskMaster('validate-dependencies', ['-f', tasksPath], { cwd: testDir });
-
-		// Should handle gracefully
-		expect(result).toHaveExitCode(0);
-		// Just check for the content without worrying about exact table formatting
-		expect(result.stdout).toMatch(/Tasks checked:\s*0/);
-	});
-});

tests/e2e/tests/mcp/expand-task-cli.test.js

@@ -1,284 +0,0 @@
-const { exec } = require('child_process');
-const { promisify } = require('util');
-const fs = require('fs').promises;
-const path = require('path');
-
-const execAsync = promisify(exec);
-
-// Helper function to run MCP inspector CLI commands
-async function runMCPCommand(method, args = {}) {
-    const serverPath = path.join(__dirname, '../../../../mcp-server/server.js');
-    let command = `npx @modelcontextprotocol/inspector --cli node ${serverPath} --method ${method}`;
-    
-    // Add tool-specific arguments
-    if (args.toolName) {
-        command += ` --tool-name ${args.toolName}`;
-    }
-    
-    // Add tool arguments
-    if (args.toolArgs) {
-        for (const [key, value] of Object.entries(args.toolArgs)) {
-            command += ` --tool-arg ${key}=${value}`;
-        }
-    }
-    
-    try {
-        const { stdout, stderr } = await execAsync(command, {
-            timeout: 60000, // 60 second timeout for AI operations
-            env: { ...process.env, NODE_ENV: 'test' }
-        });
-        
-        if (stderr && !stderr.includes('DeprecationWarning')) {
-            console.error('MCP Command stderr:', stderr);
-        }
-        
-        return { stdout, stderr };
-    } catch (error) {
-        console.error('MCP Command failed:', error);
-        throw error;
-    }
-}
-
-describe('MCP Inspector CLI - expand_task Tool Tests', () => {
-    const testProjectPath = path.join(__dirname, '../../../../test-fixtures/mcp-expand-test-project');
-    const tasksDir = path.join(testProjectPath, '.taskmaster/tasks');
-    const tasksFile = path.join(tasksDir, 'tasks.json');
-    
-    beforeAll(async () => {
-        // Create test project directory structure
-        await fs.mkdir(tasksDir, { recursive: true });
-        
-        // Create sample tasks data
-        const sampleTasks = {
-            tasks: [
-                {
-                    id: 1,
-                    description: 'Implement user authentication system',
-                    status: 'pending',
-                    tags: ['master'],
-                    subtasks: []
-                },
-                {
-                    id: 2,
-                    description: 'Create API endpoints',
-                    status: 'pending',
-                    tags: ['master'],
-                    subtasks: [
-                        {
-                            id: '2.1',
-                            description: 'Setup Express server',
-                            status: 'pending'
-                        }
-                    ]
-                },
-                {
-                    id: 3,
-                    description: 'Design database schema',
-                    status: 'completed',
-                    tags: ['master']
-                }
-            ],
-            tags: {
-                master: {
-                    name: 'master',
-                    description: 'Main development branch'
-                }
-            },
-            activeTag: 'master',
-            metadata: {
-                nextId: 4,
-                version: '1.0.0'
-            }
-        };
-        
-        await fs.writeFile(tasksFile, JSON.stringify(sampleTasks, null, 2));
-    });
-    
-    afterAll(async () => {
-        // Clean up test project
-        await fs.rm(testProjectPath, { recursive: true, force: true });
-    });
-    
-    it('should list available tools including expand_task', async () => {
-        const { stdout } = await runMCPCommand('tools/list');
-        const response = JSON.parse(stdout);
-        
-        expect(response).toHaveProperty('tools');
-        expect(Array.isArray(response.tools)).toBe(true);
-        
-        const expandTaskTool = response.tools.find(tool => tool.name === 'expand_task');
-        expect(expandTaskTool).toBeDefined();
-        expect(expandTaskTool.description).toContain('Expand a task into subtasks');
-    });
-    
-    it('should expand a task without existing subtasks', async () => {
-        // Skip if no API key is set
-        if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
-            console.log('Skipping test: No AI API key found in environment');
-            return;
-        }
-
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'expand_task',
-            toolArgs: {
-                id: '1',
-                projectRoot: testProjectPath,
-                num: '3',
-                prompt: 'Focus on security and authentication best practices'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        expect(response).toHaveProperty('content');
-        expect(Array.isArray(response.content)).toBe(true);
-        
-        // Parse the text content to get result
-        const textContent = response.content.find(c => c.type === 'text');
-        expect(textContent).toBeDefined();
-        
-        const result = JSON.parse(textContent.text);
-        expect(result.task).toBeDefined();
-        expect(result.task.id).toBe(1);
-        expect(result.subtasksAdded).toBeGreaterThan(0);
-        
-        // Verify the task was actually updated
-        const updatedTasks = JSON.parse(await fs.readFile(tasksFile, 'utf8'));
-        const expandedTask = updatedTasks.tasks.find(t => t.id === 1);
-        expect(expandedTask.subtasks.length).toBeGreaterThan(0);
-    });
-    
-    it('should handle expansion with force flag for task with existing subtasks', async () => {
-        // Skip if no API key is set
-        if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
-            console.log('Skipping test: No AI API key found in environment');
-            return;
-        }
-
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'expand_task',
-            toolArgs: {
-                id: '2',
-                projectRoot: testProjectPath,
-                force: 'true',
-                num: '2'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        const textContent = response.content.find(c => c.type === 'text');
-        const result = JSON.parse(textContent.text);
-        
-        expect(result.task).toBeDefined();
-        expect(result.task.id).toBe(2);
-        expect(result.subtasksAdded).toBe(2);
-    });
-    
-    it('should reject expansion of completed task', async () => {
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'expand_task',
-            toolArgs: {
-                id: '3',
-                projectRoot: testProjectPath
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        expect(response).toHaveProperty('content');
-        
-        const textContent = response.content.find(c => c.type === 'text');
-        expect(textContent.text).toContain('Error');
-        expect(textContent.text).toContain('completed');
-    });
-    
-    it('should handle invalid task ID', async () => {
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'expand_task',
-            toolArgs: {
-                id: '999',
-                projectRoot: testProjectPath
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        const textContent = response.content.find(c => c.type === 'text');
-        expect(textContent.text).toContain('Error');
-        expect(textContent.text).toContain('not found');
-    });
-    
-    it('should handle missing required parameters', async () => {
-        try {
-            await runMCPCommand('tools/call', {
-                toolName: 'expand_task',
-                toolArgs: {
-                    // Missing id and projectRoot
-                    num: '3'
-                }
-            });
-            fail('Should have thrown an error');
-        } catch (error) {
-            expect(error.message).toContain('validation');
-        }
-    });
-    
-    it('should work with custom tasks file path', async () => {
-        // Skip if no API key is set
-        if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
-            console.log('Skipping test: No AI API key found in environment');
-            return;
-        }
-
-        // Create custom tasks file
-        const customDir = path.join(testProjectPath, 'custom');
-        await fs.mkdir(customDir, { recursive: true });
-        const customTasksPath = path.join(customDir, 'my-tasks.json');
-        await fs.copyFile(tasksFile, customTasksPath);
-        
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'expand_task',
-            toolArgs: {
-                id: '1',
-                projectRoot: testProjectPath,
-                file: 'custom/my-tasks.json',
-                num: '2'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        const textContent = response.content.find(c => c.type === 'text');
-        const result = JSON.parse(textContent.text);
-        
-        expect(result.task).toBeDefined();
-        expect(result.subtasksAdded).toBe(2);
-        
-        // Verify the custom file was updated
-        const updatedData = JSON.parse(await fs.readFile(customTasksPath, 'utf8'));
-        const task = updatedData.tasks.find(t => t.id === 1);
-        expect(task.subtasks.length).toBe(2);
-    });
-    
-    it('should handle expansion with research flag', async () => {
-        // Skip if no API key is set
-        if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY && !process.env.PERPLEXITY_API_KEY) {
-            console.log('Skipping test: No AI API key found in environment');
-            return;
-        }
-
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'expand_task',
-            toolArgs: {
-                id: '1',
-                projectRoot: testProjectPath,
-                research: 'true',
-                num: '2'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        const textContent = response.content.find(c => c.type === 'text');
-        
-        // Even if research fails, expansion should still work
-        const result = JSON.parse(textContent.text);
-        expect(result.task).toBeDefined();
-        expect(result.subtasksAdded).toBeGreaterThanOrEqual(0);
-    });
-});

tests/e2e/tests/mcp/get-tasks-cli.test.js

@@ -1,211 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const execAsync = promisify(exec);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Helper function to run MCP inspector CLI commands
-async function runMCPCommand(method, args = {}) {
-    const serverPath = path.join(__dirname, '../../../../mcp-server/server.js');
-    let command = `npx @modelcontextprotocol/inspector --cli node ${serverPath} --method ${method}`;
-    
-    // Add tool-specific arguments
-    if (args.toolName) {
-        command += ` --tool-name ${args.toolName}`;
-    }
-    
-    // Add tool arguments
-    if (args.toolArgs) {
-        for (const [key, value] of Object.entries(args.toolArgs)) {
-            command += ` --tool-arg ${key}=${value}`;
-        }
-    }
-    
-    try {
-        const { stdout, stderr } = await execAsync(command, {
-            timeout: 30000, // 30 second timeout
-            env: { ...process.env, NODE_ENV: 'test' }
-        });
-        
-        if (stderr && !stderr.includes('DeprecationWarning')) {
-            console.error('MCP Command stderr:', stderr);
-        }
-        
-        return { stdout, stderr };
-    } catch (error) {
-        console.error('MCP Command failed:', error);
-        throw error;
-    }
-}
-
-describe('MCP Inspector CLI - get_tasks Tool Tests', () => {
-    const testProjectPath = path.join(__dirname, '../../../../test-fixtures/mcp-test-project');
-    const tasksFile = path.join(testProjectPath, '.task-master/tasks.json');
-    
-    beforeAll(async () => {
-        // Create test project directory and tasks file
-        await fs.mkdir(path.join(testProjectPath, '.task-master'), { recursive: true });
-        
-        // Create sample tasks data
-        const sampleTasks = {
-            tasks: [
-                {
-                    id: 'task-1',
-                    description: 'Implement user authentication',
-                    status: 'pending',
-                    type: 'feature',
-                    priority: 1,
-                    dependencies: [],
-                    subtasks: [
-                        {
-                            id: 'subtask-1-1',
-                            description: 'Set up JWT tokens',
-                            status: 'done',
-                            type: 'implementation'
-                        },
-                        {
-                            id: 'subtask-1-2',
-                            description: 'Create login endpoint',
-                            status: 'pending',
-                            type: 'implementation'
-                        }
-                    ]
-                },
-                {
-                    id: 'task-2',
-                    description: 'Add database migrations',
-                    status: 'done',
-                    type: 'infrastructure',
-                    priority: 2,
-                    dependencies: [],
-                    subtasks: []
-                },
-                {
-                    id: 'task-3',
-                    description: 'Fix memory leak in worker process',
-                    status: 'blocked',
-                    type: 'bug',
-                    priority: 1,
-                    dependencies: ['task-1'],
-                    subtasks: []
-                }
-            ],
-            metadata: {
-                version: '1.0.0',
-                lastUpdated: new Date().toISOString()
-            }
-        };
-        
-        await fs.writeFile(tasksFile, JSON.stringify(sampleTasks, null, 2));
-    });
-    
-    afterAll(async () => {
-        // Clean up test project
-        await fs.rm(testProjectPath, { recursive: true, force: true });
-    });
-    
-    it('should list available tools including get_tasks', async () => {
-        const { stdout } = await runMCPCommand('tools/list');
-        const response = JSON.parse(stdout);
-        
-        expect(response).toHaveProperty('tools');
-        expect(Array.isArray(response.tools)).toBe(true);
-        
-        const getTasksTool = response.tools.find(tool => tool.name === 'get_tasks');
-        expect(getTasksTool).toBeDefined();
-        expect(getTasksTool.description).toContain('Get all tasks from Task Master');
-    });
-    
-    it('should get all tasks without filters', async () => {
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'get_tasks',
-            toolArgs: {
-                file: tasksFile
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        expect(response).toHaveProperty('content');
-        expect(Array.isArray(response.content)).toBe(true);
-        
-        // Parse the text content to get tasks
-        const textContent = response.content.find(c => c.type === 'text');
-        expect(textContent).toBeDefined();
-        
-        const tasksData = JSON.parse(textContent.text);
-        expect(tasksData.tasks).toHaveLength(3);
-        expect(tasksData.tasks[0].description).toBe('Implement user authentication');
-    });
-    
-    it('should filter tasks by status', async () => {
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'get_tasks',
-            toolArgs: {
-                file: tasksFile,
-                status: 'pending'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        const textContent = response.content.find(c => c.type === 'text');
-        const tasksData = JSON.parse(textContent.text);
-        
-        expect(tasksData.tasks).toHaveLength(1);
-        expect(tasksData.tasks[0].status).toBe('pending');
-        expect(tasksData.tasks[0].description).toBe('Implement user authentication');
-    });
-    
-    it('should filter tasks by multiple statuses', async () => {
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'get_tasks',
-            toolArgs: {
-                file: tasksFile,
-                status: 'done,blocked'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        const textContent = response.content.find(c => c.type === 'text');
-        const tasksData = JSON.parse(textContent.text);
-        
-        expect(tasksData.tasks).toHaveLength(2);
-        expect(tasksData.tasks.map(t => t.status).sort()).toEqual(['blocked', 'done']);
-    });
-    
-    it('should include subtasks when requested', async () => {
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'get_tasks',
-            toolArgs: {
-                file: tasksFile,
-                withSubtasks: 'true'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        const textContent = response.content.find(c => c.type === 'text');
-        const tasksData = JSON.parse(textContent.text);
-        
-        const taskWithSubtasks = tasksData.tasks.find(t => t.id === 'task-1');
-        expect(taskWithSubtasks.subtasks).toHaveLength(2);
-        expect(taskWithSubtasks.subtasks[0].description).toBe('Set up JWT tokens');
-    });
-    
-    it('should handle non-existent file gracefully', async () => {
-        const { stdout } = await runMCPCommand('tools/call', {
-            toolName: 'get_tasks',
-            toolArgs: {
-                file: '/non/existent/path/tasks.json'
-            }
-        });
-        
-        const response = JSON.parse(stdout);
-        expect(response).toHaveProperty('error');
-        expect(response.error).toHaveProperty('message');
-        expect(response.error.message).toContain('not found');
-    });
-});

tests/e2e/tests/mcp/get-tasks.test.js

@@ -1,207 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import fs from 'fs';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const projectRoot = join(__dirname, '../../../..');
-
-describe('MCP Server - get_tasks tool', () => {
-	let client;
-	let transport;
-
-	beforeAll(async () => {
-		// Create transport by spawning the server
-		transport = new StdioClientTransport({
-			command: 'node',
-			args: ['mcp-server/server.js'],
-			env: process.env,
-			cwd: projectRoot
-		});
-
-		// Create client
-		client = new Client(
-			{
-				name: 'test-client',
-				version: '1.0.0'
-			},
-			{
-				capabilities: {
-					sampling: {}
-				}
-			}
-		);
-
-		// Connect to server
-		await client.connect(transport);
-	});
-
-	afterAll(async () => {
-		if (client) {
-			await client.close();
-		}
-	});
-
-	it('should connect to MCP server successfully', async () => {
-		const tools = await client.listTools();
-		expect(tools.tools).toBeDefined();
-		expect(tools.tools.length).toBeGreaterThan(0);
-
-		const toolNames = tools.tools.map((t) => t.name);
-		expect(toolNames).toContain('get_tasks');
-		expect(toolNames).toContain('initialize_project');
-	});
-
-	it('should initialize project successfully', async () => {
-		const result = await client.callTool({
-			name: 'initialize_project',
-			arguments: {
-				projectRoot: projectRoot
-			}
-		});
-
-		expect(result.content).toBeDefined();
-		expect(result.content[0].type).toBe('text');
-		expect(result.content[0].text).toContain(
-			'Project initialized successfully'
-		);
-	});
-
-	it('should handle missing tasks file gracefully', async () => {
-		const result = await client.callTool({
-			name: 'get_tasks',
-			arguments: {
-				projectRoot: projectRoot,
-				file: '.taskmaster/non-existent-tasks.json'
-			}
-		});
-
-		expect(result.isError).toBe(true);
-		expect(result.content[0].text).toContain('Error');
-	});
-
-	it('should get tasks with fixture data', async () => {
-		// Create a temporary tasks file with proper structure
-		const testTasksPath = join(projectRoot, '.taskmaster/test-tasks.json');
-		const testTasks = {
-			tasks: [
-				{
-					id: 'test-001',
-					description: 'Test task 1',
-					status: 'pending',
-					priority: 'high',
-					estimatedMinutes: 30,
-					actualMinutes: 0,
-					dependencies: [],
-					tags: ['test'],
-					subtasks: [
-						{
-							id: 'test-001-1',
-							description: 'Test subtask 1.1',
-							status: 'pending',
-							priority: 'medium',
-							estimatedMinutes: 15,
-							actualMinutes: 0
-						}
-					]
-				},
-				{
-					id: 'test-002',
-					description: 'Test task 2',
-					status: 'in_progress',
-					priority: 'medium',
-					estimatedMinutes: 60,
-					actualMinutes: 15,
-					dependencies: ['test-001'],
-					tags: ['test', 'demo'],
-					subtasks: []
-				}
-			]
-		};
-
-		// Write test tasks file
-		fs.writeFileSync(testTasksPath, JSON.stringify(testTasks, null, 2));
-
-		try {
-			const result = await client.callTool({
-				name: 'get_tasks',
-				arguments: {
-					projectRoot: projectRoot,
-					file: '.taskmaster/test-tasks.json',
-					withSubtasks: true
-				}
-			});
-
-			expect(result.isError).toBeFalsy();
-			expect(result.content[0].text).toContain('2 tasks found');
-			expect(result.content[0].text).toContain('Test task 1');
-			expect(result.content[0].text).toContain('Test task 2');
-			expect(result.content[0].text).toContain('Test subtask 1.1');
-		} finally {
-			// Cleanup
-			if (fs.existsSync(testTasksPath)) {
-				fs.unlinkSync(testTasksPath);
-			}
-		}
-	});
-
-	it('should filter tasks by status', async () => {
-		// Create a temporary tasks file
-		const testTasksPath = join(
-			projectRoot,
-			'.taskmaster/test-status-tasks.json'
-		);
-		const testTasks = {
-			tasks: [
-				{
-					id: 'status-001',
-					description: 'Pending task',
-					status: 'pending',
-					priority: 'high',
-					estimatedMinutes: 30,
-					actualMinutes: 0,
-					dependencies: [],
-					tags: ['test'],
-					subtasks: []
-				},
-				{
-					id: 'status-002',
-					description: 'Done task',
-					status: 'done',
-					priority: 'medium',
-					estimatedMinutes: 60,
-					actualMinutes: 60,
-					dependencies: [],
-					tags: ['test'],
-					subtasks: []
-				}
-			]
-		};
-
-		fs.writeFileSync(testTasksPath, JSON.stringify(testTasks, null, 2));
-
-		try {
-			// Test filtering by 'done' status
-			const result = await client.callTool({
-				name: 'get_tasks',
-				arguments: {
-					projectRoot: projectRoot,
-					file: '.taskmaster/test-status-tasks.json',
-					status: 'done'
-				}
-			});
-
-			expect(result.isError).toBeFalsy();
-			expect(result.content[0].text).toContain('1 task found');
-			expect(result.content[0].text).toContain('Done task');
-			expect(result.content[0].text).not.toContain('Pending task');
-		} finally {
-			// Cleanup
-			if (fs.existsSync(testTasksPath)) {
-				fs.unlinkSync(testTasksPath);
-			}
-		}
-	});
-});

tests/e2e/tests/providers.test.js

@@ -1,325 +0,0 @@
-const { exec } = require('child_process');
-const { promisify } = require('util');
-const fs = require('fs').promises;
-const path = require('path');
-const os = require('os');
-
-const execAsync = promisify(exec);
-
-// Helper function to run task-master commands
-async function runTaskMaster(args, options = {}) {
-    const taskMasterPath = path.join(__dirname, '../../../scripts/task-master.js');
-    const command = `node ${taskMasterPath} ${args.join(' ')}`;
-    
-    try {
-        const { stdout, stderr } = await execAsync(command, {
-            cwd: options.cwd || process.cwd(),
-            timeout: options.timeout || 30000,
-            env: { ...process.env, NODE_ENV: 'test' }
-        });
-        
-        return {
-            exitCode: 0,
-            stdout: stdout.trim(),
-            stderr: stderr.trim()
-        };
-    } catch (error) {
-        return {
-            exitCode: error.code || 1,
-            stdout: (error.stdout || '').trim(),
-            stderr: (error.stderr || error.message || '').trim()
-        };
-    }
-}
-
-// Helper to extract task ID from output
-function extractTaskId(output) {
-    const idMatch = output.match(/Task #?(\d+(?:\.\d+)?)/i);
-    return idMatch ? idMatch[1] : null;
-}
-
-// Helper function to wait
-function wait(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-// Test configuration
-const testConfig = {
-    providers: [
-        { name: 'OpenAI GPT-4', model: 'openai:gpt-4', flags: [] },
-        { name: 'OpenAI GPT-3.5', model: 'openai:gpt-3.5-turbo', flags: [] },
-        { name: 'Anthropic Claude 3 Opus', model: 'anthropic:claude-3-opus-20240229', flags: [] },
-        { name: 'Anthropic Claude 3 Sonnet', model: 'anthropic:claude-3-sonnet-20240229', flags: [] },
-        { name: 'Anthropic Claude 3 Haiku', model: 'anthropic:claude-3-haiku-20240307', flags: [] },
-        { name: 'Google Gemini Pro', model: 'google:gemini-pro', flags: [] },
-        { name: 'Groq Llama 3 70B', model: 'groq:llama3-70b-8192', flags: [] },
-        { name: 'Groq Mixtral', model: 'groq:mixtral-8x7b-32768', flags: [] }
-    ],
-    prompts: {
-        addTask: 'Create a comprehensive plan to build a task management CLI application with file-based storage and AI integration'
-    }
-};
-
-describe('Multi-Provider Functionality Tests', () => {
-    let testDir;
-    
-    beforeAll(async () => {
-        // Create temporary test directory
-        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'task-master-provider-test-'));
-        
-        // Initialize task-master in test directory
-        const initResult = await runTaskMaster(['init'], { cwd: testDir });
-        if (initResult.exitCode !== 0) {
-            throw new Error(`Failed to initialize task-master: ${initResult.stderr}`);
-        }
-    });
-    
-    afterAll(async () => {
-        // Clean up test directory
-        if (testDir) {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
-    
-    // Check if any AI API keys are available
-    const hasAIKeys = !!(
-        process.env.OPENAI_API_KEY ||
-        process.env.ANTHROPIC_API_KEY ||
-        process.env.GOOGLE_API_KEY ||
-        process.env.GROQ_API_KEY
-    );
-    
-    const testCondition = hasAIKeys ? it : it.skip;
-    
-    testCondition('should test add-task across multiple AI providers', async () => {
-        const results = {
-            providerComparison: {},
-            summary: {
-                totalProviders: 0,
-                successfulProviders: 0,
-                failedProviders: 0,
-                averageExecutionTime: 0,
-                successRate: '0%'
-            }
-        };
-        
-        // Filter providers based on available API keys
-        const availableProviders = testConfig.providers.filter(provider => {
-            if (provider.model.startsWith('openai:') && !process.env.OPENAI_API_KEY) return false;
-            if (provider.model.startsWith('anthropic:') && !process.env.ANTHROPIC_API_KEY) return false;
-            if (provider.model.startsWith('google:') && !process.env.GOOGLE_API_KEY) return false;
-            if (provider.model.startsWith('groq:') && !process.env.GROQ_API_KEY) return false;
-            return true;
-        });
-        
-        results.summary.totalProviders = availableProviders.length;
-        let totalExecutionTime = 0;
-        
-        // Process providers in batches to avoid rate limits
-        const batchSize = 3;
-        for (let i = 0; i < availableProviders.length; i += batchSize) {
-            const batch = availableProviders.slice(i, i + batchSize);
-            
-            const batchPromises = batch.map(async (provider) => {
-                const providerResult = {
-                    status: 'failed',
-                    taskId: null,
-                    executionTime: 0,
-                    subtaskCount: 0,
-                    features: {
-                        hasTitle: false,
-                        hasDescription: false,
-                        hasSubtasks: false,
-                        hasDependencies: false
-                    },
-                    error: null,
-                    taskDetails: null
-                };
-                
-                const startTime = Date.now();
-                
-                try {
-                    console.log(`\nTesting provider: ${provider.name} with model: ${provider.model}`);
-                    
-                    // Step 1: Set the main model for this provider
-                    console.log(`Setting model to ${provider.model}...`);
-                    const setModelResult = await runTaskMaster(
-                        ['models', '--set-main', provider.model],
-                        { cwd: testDir }
-                    );
-                    expect(setModelResult.exitCode).toBe(0);
-                    
-                    // Step 2: Execute add-task with standard prompt
-                    console.log(`Adding task with ${provider.name}...`);
-                    const addTaskArgs = ['add-task', '--prompt', testConfig.prompts.addTask];
-                    if (provider.flags && provider.flags.length > 0) {
-                        addTaskArgs.push(...provider.flags);
-                    }
-                    
-                    const addTaskResult = await runTaskMaster(addTaskArgs, {
-                        cwd: testDir,
-                        timeout: 120000 // 2 minutes timeout for AI tasks
-                    });
-                    
-                    expect(addTaskResult.exitCode).toBe(0);
-                    
-                    // Step 3: Extract task ID from output
-                    const taskId = extractTaskId(addTaskResult.stdout);
-                    expect(taskId).toBeTruthy();
-                    providerResult.taskId = taskId;
-                    console.log(`✓ Created task ${taskId} with ${provider.name}`);
-                    
-                    // Step 4: Get task details
-                    const showResult = await runTaskMaster(['show', taskId], { cwd: testDir });
-                    expect(showResult.exitCode).toBe(0);
-                    
-                    providerResult.taskDetails = showResult.stdout;
-                    
-                    // Analyze task features
-                    providerResult.features.hasTitle = 
-                        showResult.stdout.includes('Title:') || 
-                        showResult.stdout.includes('Task:');
-                    providerResult.features.hasDescription = 
-                        showResult.stdout.includes('Description:');
-                    providerResult.features.hasSubtasks = 
-                        showResult.stdout.includes('Subtasks:');
-                    providerResult.features.hasDependencies = 
-                        showResult.stdout.includes('Dependencies:');
-                    
-                    // Count subtasks
-                    const subtaskMatches = showResult.stdout.match(/\d+\.\d+/g);
-                    providerResult.subtaskCount = subtaskMatches ? subtaskMatches.length : 0;
-                    
-                    providerResult.status = 'success';
-                    results.summary.successfulProviders++;
-                } catch (error) {
-                    providerResult.status = 'failed';
-                    providerResult.error = error.message;
-                    results.summary.failedProviders++;
-                    console.error(`${provider.name} test failed: ${error.message}`);
-                }
-                
-                providerResult.executionTime = Date.now() - startTime;
-                totalExecutionTime += providerResult.executionTime;
-                
-                results.providerComparison[provider.name] = providerResult;
-            });
-            
-            // Wait for batch to complete
-            await Promise.all(batchPromises);
-            
-            // Small delay between batches to avoid rate limits
-            if (i + batchSize < availableProviders.length) {
-                console.log('Waiting 2 seconds before next batch...');
-                await wait(2000);
-            }
-        }
-        
-        // Calculate summary statistics
-        results.summary.averageExecutionTime = Math.round(
-            totalExecutionTime / availableProviders.length
-        );
-        results.summary.successRate = `${Math.round(
-            (results.summary.successfulProviders / results.summary.totalProviders) * 100
-        )}%`;
-        
-        // Log summary
-        console.log('\n=== Provider Test Summary ===');
-        console.log(`Total providers tested: ${results.summary.totalProviders}`);
-        console.log(`Successful: ${results.summary.successfulProviders}`);
-        console.log(`Failed: ${results.summary.failedProviders}`);
-        console.log(`Success rate: ${results.summary.successRate}`);
-        console.log(`Average execution time: ${results.summary.averageExecutionTime}ms`);
-        
-        // Log provider comparison details
-        console.log('\n=== Provider Feature Comparison ===');
-        Object.entries(results.providerComparison).forEach(([providerName, result]) => {
-            console.log(`\n${providerName}:`);
-            console.log(`  Status: ${result.status}`);
-            console.log(`  Task ID: ${result.taskId || 'N/A'}`);
-            console.log(`  Execution Time: ${result.executionTime}ms`);
-            console.log(`  Subtask Count: ${result.subtaskCount}`);
-            console.log(`  Features:`);
-            console.log(`    - Has Title: ${result.features.hasTitle}`);
-            console.log(`    - Has Description: ${result.features.hasDescription}`);
-            console.log(`    - Has Subtasks: ${result.features.hasSubtasks}`);
-            console.log(`    - Has Dependencies: ${result.features.hasDependencies}`);
-            if (result.error) {
-                console.log(`  Error: ${result.error}`);
-            }
-        });
-        
-        // Assertions
-        expect(results.summary.successfulProviders).toBeGreaterThan(0);
-        expect(results.summary.successRate).not.toBe('0%');
-    }, 300000); // 5 minute timeout for entire test
-    
-    testCondition('should maintain task quality across different providers', async () => {
-        const standardPrompt = 'Create a simple todo list feature with add, remove, and list functionality';
-        const providerResults = [];
-        
-        // Test a subset of providers to check quality consistency
-        const testProviders = [
-            { name: 'OpenAI GPT-4', model: 'openai:gpt-4' },
-            { name: 'Anthropic Claude 3 Sonnet', model: 'anthropic:claude-3-sonnet-20240229' }
-        ].filter(provider => {
-            if (provider.model.startsWith('openai:') && !process.env.OPENAI_API_KEY) return false;
-            if (provider.model.startsWith('anthropic:') && !process.env.ANTHROPIC_API_KEY) return false;
-            return true;
-        });
-        
-        for (const provider of testProviders) {
-            console.log(`\nTesting quality with ${provider.name}...`);
-            
-            // Set model
-            const setModelResult = await runTaskMaster(
-                ['models', '--set-main', provider.model],
-                { cwd: testDir }
-            );
-            expect(setModelResult.exitCode).toBe(0);
-            
-            // Add task
-            const addTaskResult = await runTaskMaster(
-                ['add-task', '--prompt', standardPrompt],
-                { cwd: testDir, timeout: 60000 }
-            );
-            expect(addTaskResult.exitCode).toBe(0);
-            
-            const taskId = extractTaskId(addTaskResult.stdout);
-            expect(taskId).toBeTruthy();
-            
-            // Get task details
-            const showResult = await runTaskMaster(['show', taskId], { cwd: testDir });
-            expect(showResult.exitCode).toBe(0);
-            
-            // Analyze quality metrics
-            const subtaskCount = (showResult.stdout.match(/\d+\.\d+/g) || []).length;
-            const hasDescription = showResult.stdout.includes('Description:');
-            const wordCount = showResult.stdout.split(/\s+/).length;
-            
-            providerResults.push({
-                provider: provider.name,
-                taskId,
-                subtaskCount,
-                hasDescription,
-                wordCount
-            });
-        }
-        
-        // Compare quality metrics
-        console.log('\n=== Quality Comparison ===');
-        providerResults.forEach(result => {
-            console.log(`\n${result.provider}:`);
-            console.log(`  Subtasks: ${result.subtaskCount}`);
-            console.log(`  Has Description: ${result.hasDescription}`);
-            console.log(`  Word Count: ${result.wordCount}`);
-        });
-        
-        // Basic quality assertions
-        providerResults.forEach(result => {
-            expect(result.subtaskCount).toBeGreaterThan(0);
-            expect(result.hasDescription).toBe(true);
-            expect(result.wordCount).toBeGreaterThan(50); // Reasonable task detail
-        });
-    }, 180000); // 3 minute timeout
-});

tests/e2e/utils/error-handler.js

@@ -1,247 +0,0 @@
-import { writeFileSync } from 'fs';
-import { join } from 'path';
-import chalk from 'chalk';
-
-export class ErrorHandler {
-	constructor(logger) {
-		this.logger = logger;
-		this.errors = [];
-		this.warnings = [];
-	}
-
-	/**
-	 * Handle and categorize errors
-	 */
-	handleError(error, context = {}) {
-		const errorInfo = {
-			timestamp: new Date().toISOString(),
-			message: error.message || 'Unknown error',
-			stack: error.stack,
-			context,
-			type: this.categorizeError(error)
-		};
-
-		this.errors.push(errorInfo);
-		this.logger.error(`[${errorInfo.type}] ${errorInfo.message}`);
-
-		if (context.critical) {
-			throw error;
-		}
-
-		return errorInfo;
-	}
-
-	/**
-	 * Add a warning
-	 */
-	addWarning(message, context = {}) {
-		const warning = {
-			timestamp: new Date().toISOString(),
-			message,
-			context
-		};
-
-		this.warnings.push(warning);
-		this.logger.warning(message);
-	}
-
-	/**
-	 * Categorize error types
-	 */
-	categorizeError(error) {
-		const message = error.message.toLowerCase();
-
-		if (
-			message.includes('command not found') ||
-			message.includes('not found')
-		) {
-			return 'DEPENDENCY_ERROR';
-		}
-		if (message.includes('permission') || message.includes('access denied')) {
-			return 'PERMISSION_ERROR';
-		}
-		if (message.includes('timeout')) {
-			return 'TIMEOUT_ERROR';
-		}
-		if (message.includes('api') || message.includes('rate limit')) {
-			return 'API_ERROR';
-		}
-		if (message.includes('json') || message.includes('parse')) {
-			return 'PARSE_ERROR';
-		}
-		if (message.includes('file') || message.includes('directory')) {
-			return 'FILE_ERROR';
-		}
-
-		return 'GENERAL_ERROR';
-	}
-
-	/**
-	 * Get error summary
-	 */
-	getSummary() {
-		const errorsByType = {};
-
-		this.errors.forEach((error) => {
-			if (!errorsByType[error.type]) {
-				errorsByType[error.type] = [];
-			}
-			errorsByType[error.type].push(error);
-		});
-
-		return {
-			totalErrors: this.errors.length,
-			totalWarnings: this.warnings.length,
-			errorsByType,
-			criticalErrors: this.errors.filter((e) => e.context.critical),
-			recentErrors: this.errors.slice(-5)
-		};
-	}
-
-	/**
-	 * Generate error report
-	 */
-	generateReport(outputPath) {
-		const summary = this.getSummary();
-		const report = {
-			generatedAt: new Date().toISOString(),
-			summary: {
-				totalErrors: summary.totalErrors,
-				totalWarnings: summary.totalWarnings,
-				errorTypes: Object.keys(summary.errorsByType)
-			},
-			errors: this.errors,
-			warnings: this.warnings,
-			recommendations: this.generateRecommendations(summary)
-		};
-
-		writeFileSync(outputPath, JSON.stringify(report, null, 2));
-		return report;
-	}
-
-	/**
-	 * Generate recommendations based on errors
-	 */
-	generateRecommendations(summary) {
-		const recommendations = [];
-
-		if (summary.errorsByType.DEPENDENCY_ERROR) {
-			recommendations.push({
-				type: 'DEPENDENCY',
-				message: 'Install missing dependencies using npm install or check PATH',
-				errors: summary.errorsByType.DEPENDENCY_ERROR.length
-			});
-		}
-
-		if (summary.errorsByType.PERMISSION_ERROR) {
-			recommendations.push({
-				type: 'PERMISSION',
-				message: 'Check file permissions or run with appropriate privileges',
-				errors: summary.errorsByType.PERMISSION_ERROR.length
-			});
-		}
-
-		if (summary.errorsByType.API_ERROR) {
-			recommendations.push({
-				type: 'API',
-				message: 'Check API keys, rate limits, or network connectivity',
-				errors: summary.errorsByType.API_ERROR.length
-			});
-		}
-
-		if (summary.errorsByType.TIMEOUT_ERROR) {
-			recommendations.push({
-				type: 'TIMEOUT',
-				message:
-					'Consider increasing timeout values or optimizing slow operations',
-				errors: summary.errorsByType.TIMEOUT_ERROR.length
-			});
-		}
-
-		return recommendations;
-	}
-
-	/**
-	 * Display error summary in console
-	 */
-	displaySummary() {
-		const summary = this.getSummary();
-
-		if (summary.totalErrors === 0 && summary.totalWarnings === 0) {
-			console.log(chalk.green('✅ No errors or warnings detected'));
-			return;
-		}
-
-		console.log(chalk.red.bold(`\n🚨 Error Summary:`));
-		console.log(chalk.red(`   Total Errors: ${summary.totalErrors}`));
-		console.log(chalk.yellow(`   Total Warnings: ${summary.totalWarnings}`));
-
-		if (summary.totalErrors > 0) {
-			console.log(chalk.red.bold('\n   Error Types:'));
-			Object.entries(summary.errorsByType).forEach(([type, errors]) => {
-				console.log(chalk.red(`     - ${type}: ${errors.length}`));
-			});
-
-			if (summary.criticalErrors.length > 0) {
-				console.log(
-					chalk.red.bold(
-						`\n   ⚠️  Critical Errors: ${summary.criticalErrors.length}`
-					)
-				);
-				summary.criticalErrors.forEach((error) => {
-					console.log(chalk.red(`     - ${error.message}`));
-				});
-			}
-		}
-
-		const recommendations = this.generateRecommendations(summary);
-		if (recommendations.length > 0) {
-			console.log(chalk.yellow.bold('\n💡 Recommendations:'));
-			recommendations.forEach((rec) => {
-				console.log(chalk.yellow(`   - ${rec.message}`));
-			});
-		}
-	}
-
-	/**
-	 * Clear all errors and warnings
-	 */
-	clear() {
-		this.errors = [];
-		this.warnings = [];
-	}
-}
-
-/**
- * Global error handler for uncaught exceptions
- */
-export function setupGlobalErrorHandlers(errorHandler, logger) {
-	process.on('uncaughtException', (error) => {
-		logger.error(`Uncaught Exception: ${error.message}`);
-		errorHandler.handleError(error, {
-			critical: true,
-			source: 'uncaughtException'
-		});
-		process.exit(1);
-	});
-
-	process.on('unhandledRejection', (reason, promise) => {
-		logger.error(`Unhandled Rejection at: ${promise}, reason: ${reason}`);
-		errorHandler.handleError(new Error(String(reason)), {
-			critical: false,
-			source: 'unhandledRejection'
-		});
-	});
-
-	process.on('SIGINT', () => {
-		logger.info('\nReceived SIGINT, shutting down gracefully...');
-		errorHandler.displaySummary();
-		process.exit(130);
-	});
-
-	process.on('SIGTERM', () => {
-		logger.info('\nReceived SIGTERM, shutting down...');
-		errorHandler.displaySummary();
-		process.exit(143);
-	});
-}

tests/e2e/utils/llm-analyzer.js

@@ -1,171 +0,0 @@
-import { readFileSync } from 'fs';
-import fetch from 'node-fetch';
-
-export class LLMAnalyzer {
-	constructor(config, logger) {
-		this.config = config;
-		this.logger = logger;
-		this.apiKey = process.env.ANTHROPIC_API_KEY;
-		this.apiEndpoint = 'https://api.anthropic.com/v1/messages';
-	}
-
-	async analyzeLog(logFile, providerSummaryFile = null) {
-		if (!this.config.llmAnalysis.enabled) {
-			this.logger.info('LLM analysis is disabled in configuration');
-			return null;
-		}
-
-		if (!this.apiKey) {
-			this.logger.error('ANTHROPIC_API_KEY not found in environment');
-			return null;
-		}
-
-		try {
-			const logContent = readFileSync(logFile, 'utf8');
-			const prompt = this.buildAnalysisPrompt(logContent, providerSummaryFile);
-
-			const response = await this.callLLM(prompt);
-			const analysis = this.parseResponse(response);
-
-			// Calculate and log cost
-			if (response.usage) {
-				const cost = this.calculateCost(response.usage);
-				this.logger.addCost(cost);
-				this.logger.info(`LLM Analysis AI Cost: $${cost.toFixed(6)} USD`);
-			}
-
-			return analysis;
-		} catch (error) {
-			this.logger.error(`LLM analysis failed: ${error.message}`);
-			return null;
-		}
-	}
-
-	buildAnalysisPrompt(logContent, providerSummaryFile) {
-		let providerSummary = '';
-		if (providerSummaryFile) {
-			try {
-				providerSummary = readFileSync(providerSummaryFile, 'utf8');
-			} catch (error) {
-				this.logger.warning(
-					`Could not read provider summary file: ${error.message}`
-				);
-			}
-		}
-
-		return `Analyze the following E2E test log for the task-master tool. The log contains output from various 'task-master' commands executed sequentially.
-
-Your goal is to:
-1. Verify if the key E2E steps completed successfully based on the log messages (e.g., init, parse PRD, list tasks, analyze complexity, expand task, set status, manage models, add/remove dependencies, add/update/remove tasks/subtasks, generate files).
-2. **Specifically analyze the Multi-Provider Add-Task Test Sequence:**
-   a. Identify which providers were tested for \`add-task\`. Look for log steps like "Testing Add-Task with Provider: ..." and the summary log 'provider_add_task_summary.log'.
-   b. For each tested provider, determine if \`add-task\` succeeded or failed. Note the created task ID if successful.
-   c. Review the corresponding \`add_task_show_output_<provider>_id_<id>.log\` file (if created) for each successful \`add-task\` execution.
-   d. **Compare the quality and completeness** of the task generated by each successful provider based on their \`show\` output. Assign a score (e.g., 1-10, 10 being best) based on relevance to the prompt, detail level, and correctness.
-   e. Note any providers where \`add-task\` failed or where the task ID could not be extracted.
-3. Identify any general explicit "[ERROR]" messages or stack traces throughout the *entire* log.
-4. Identify any potential warnings or unusual output that might indicate a problem even if not marked as an explicit error.
-5. Provide an overall assessment of the test run's health based *only* on the log content.
-
-${providerSummary ? `\nProvider Summary:\n${providerSummary}\n` : ''}
-
-Return your analysis **strictly** in the following JSON format. Do not include any text outside of the JSON structure:
-
-{
-  "overall_status": "Success|Failure|Warning",
-  "verified_steps": [ "Initialization", "PRD Parsing", /* ...other general steps observed... */ ],
-  "provider_add_task_comparison": {
-     "prompt_used": "... (extract from log if possible or state 'standard auth prompt') ...",
-     "provider_results": {
-       "anthropic": { "status": "Success|Failure|ID_Extraction_Failed|Set_Model_Failed", "task_id": "...", "score": "X/10 | N/A", "notes": "..." },
-       "openai": { "status": "Success|Failure|...", "task_id": "...", "score": "X/10 | N/A", "notes": "..." },
-       /* ... include all tested providers ... */
-     },
-     "comparison_summary": "Brief overall comparison of generated tasks..."
-  },
-  "detected_issues": [ { "severity": "Error|Warning|Anomaly", "description": "...", "log_context": "[Optional, short snippet from log near the issue]" } ],
-  "llm_summary_points": [ "Overall summary point 1", "Provider comparison highlight", "Any major issues noted" ]
-}
-
-Here is the main log content:
-
-${logContent}`;
-	}
-
-	async callLLM(prompt) {
-		const payload = {
-			model: this.config.llmAnalysis.model,
-			max_tokens: this.config.llmAnalysis.maxTokens,
-			messages: [{ role: 'user', content: prompt }]
-		};
-
-		const response = await fetch(this.apiEndpoint, {
-			method: 'POST',
-			headers: {
-				'Content-Type': 'application/json',
-				'x-api-key': this.apiKey,
-				'anthropic-version': '2023-06-01'
-			},
-			body: JSON.stringify(payload)
-		});
-
-		if (!response.ok) {
-			const error = await response.text();
-			throw new Error(`LLM API call failed: ${response.status} - ${error}`);
-		}
-
-		return response.json();
-	}
-
-	parseResponse(response) {
-		try {
-			const content = response.content[0].text;
-			const jsonStart = content.indexOf('{');
-			const jsonEnd = content.lastIndexOf('}');
-
-			if (jsonStart === -1 || jsonEnd === -1) {
-				throw new Error('No JSON found in response');
-			}
-
-			const jsonString = content.substring(jsonStart, jsonEnd + 1);
-			return JSON.parse(jsonString);
-		} catch (error) {
-			this.logger.error(`Failed to parse LLM response: ${error.message}`);
-			return null;
-		}
-	}
-
-	calculateCost(usage) {
-		const modelCosts = {
-			'claude-3-7-sonnet-20250219': {
-				input: 3.0, // per 1M tokens
-				output: 15.0 // per 1M tokens
-			}
-		};
-
-		const costs = modelCosts[this.config.llmAnalysis.model] || {
-			input: 0,
-			output: 0
-		};
-		const inputCost = (usage.input_tokens / 1000000) * costs.input;
-		const outputCost = (usage.output_tokens / 1000000) * costs.output;
-
-		return inputCost + outputCost;
-	}
-
-	formatReport(analysis) {
-		if (!analysis) return null;
-
-		const report = {
-			title: 'TASKMASTER E2E Test Analysis Report',
-			timestamp: new Date().toISOString(),
-			status: analysis.overall_status,
-			summary: analysis.llm_summary_points,
-			verifiedSteps: analysis.verified_steps,
-			providerComparison: analysis.provider_add_task_comparison,
-			issues: analysis.detected_issues
-		};
-
-		return report;
-	}
-}

tests/e2e/utils/logger.cjs

@@ -1,109 +0,0 @@
-// Simple console colors fallback if chalk is not available
-const colors = {
-	green: (text) => `\x1b[32m${text}\x1b[0m`,
-	red: (text) => `\x1b[31m${text}\x1b[0m`,
-	yellow: (text) => `\x1b[33m${text}\x1b[0m`,
-	blue: (text) => `\x1b[34m${text}\x1b[0m`,
-	cyan: (text) => `\x1b[36m${text}\x1b[0m`,
-	gray: (text) => `\x1b[90m${text}\x1b[0m`
-};
-
-class TestLogger {
-	constructor(testName = 'test') {
-		this.testName = testName;
-		this.startTime = Date.now();
-		this.stepCount = 0;
-		this.logBuffer = [];
-		this.totalCost = 0;
-	}
-
-	_formatMessage(level, message, options = {}) {
-		const timestamp = new Date().toISOString();
-		const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(2);
-		const formattedMessage = `[${timestamp}] [${elapsed}s] [${level}] ${message}`;
-
-		// Add to buffer for later saving if needed
-		this.logBuffer.push(formattedMessage);
-
-		return formattedMessage;
-	}
-
-	_log(level, message, color) {
-		const formatted = this._formatMessage(level, message);
-
-		if (process.env.E2E_VERBOSE !== 'false') {
-			console.log(color ? color(formatted) : formatted);
-		}
-	}
-
-	info(message) {
-		this._log('INFO', message, colors.blue);
-	}
-
-	success(message) {
-		this._log('SUCCESS', message, colors.green);
-	}
-
-	error(message) {
-		this._log('ERROR', message, colors.red);
-	}
-
-	warning(message) {
-		this._log('WARNING', message, colors.yellow);
-	}
-
-	step(message) {
-		this.stepCount++;
-		this._log('STEP', `Step ${this.stepCount}: ${message}`, colors.cyan);
-	}
-
-	debug(message) {
-		if (process.env.DEBUG) {
-			this._log('DEBUG', message, colors.gray);
-		}
-	}
-
-	flush() {
-		// In CommonJS version, we'll just clear the buffer
-		// Real implementation would write to file if needed
-		this.logBuffer = [];
-	}
-
-	summary() {
-		const duration = ((Date.now() - this.startTime) / 1000).toFixed(2);
-		const summary = `Test completed in ${duration}s`;
-		this.info(summary);
-		return {
-			duration: parseFloat(duration),
-			steps: this.stepCount,
-			totalCost: this.totalCost
-		};
-	}
-
-	extractAndAddCost(output) {
-		// Extract cost information from LLM output
-		const costPatterns = [
-			/Total Cost: \$?([\d.]+)/i,
-			/Cost: \$?([\d.]+)/i,
-			/Estimated cost: \$?([\d.]+)/i
-		];
-
-		for (const pattern of costPatterns) {
-			const match = output.match(pattern);
-			if (match) {
-				const cost = parseFloat(match[1]);
-				this.totalCost += cost;
-				this.debug(
-					`Added cost: $${cost} (Total: $${this.totalCost.toFixed(4)})`
-				);
-				break;
-			}
-		}
-	}
-
-	getTotalCost() {
-		return this.totalCost;
-	}
-}
-
-module.exports = { TestLogger };

tests/e2e/utils/logger.js

@@ -1,134 +0,0 @@
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
-import chalk from 'chalk';
-
-export class TestLogger {
-	constructor(logDir, testRunId) {
-		this.logDir = logDir;
-		this.testRunId = testRunId;
-		this.startTime = Date.now();
-		this.stepCount = 0;
-		this.logFile = join(logDir, `e2e_run_${testRunId}.log`);
-		this.logBuffer = [];
-		this.totalCost = 0;
-
-		// Ensure log directory exists
-		if (!existsSync(logDir)) {
-			mkdirSync(logDir, { recursive: true });
-		}
-	}
-
-	formatDuration(milliseconds) {
-		const totalSeconds = Math.floor(milliseconds / 1000);
-		const minutes = Math.floor(totalSeconds / 60);
-		const seconds = totalSeconds % 60;
-		return `${minutes}m${seconds.toString().padStart(2, '0')}s`;
-	}
-
-	getElapsedTime() {
-		return this.formatDuration(Date.now() - this.startTime);
-	}
-
-	formatLogEntry(level, message) {
-		const timestamp = new Date().toISOString();
-		const elapsed = this.getElapsedTime();
-		return `[${level}] [${elapsed}] ${timestamp} ${message}`;
-	}
-
-	log(level, message, options = {}) {
-		const formattedMessage = this.formatLogEntry(level, message);
-
-		// Add to buffer
-		this.logBuffer.push(formattedMessage);
-
-		// Console output with colors
-		let coloredMessage = formattedMessage;
-		switch (level) {
-			case 'INFO':
-				coloredMessage = chalk.blue(formattedMessage);
-				break;
-			case 'SUCCESS':
-				coloredMessage = chalk.green(formattedMessage);
-				break;
-			case 'ERROR':
-				coloredMessage = chalk.red(formattedMessage);
-				break;
-			case 'WARNING':
-				coloredMessage = chalk.yellow(formattedMessage);
-				break;
-		}
-
-		// Only output to console if debugging or it's an error
-		if ((process.env.DEBUG_TESTS || level === 'ERROR') && !process.env.JEST_SILENT_MODE) {
-			console.log(coloredMessage);
-		}
-
-		// Write to file if immediate flush requested
-		if (options.flush) {
-			this.flush();
-		}
-	}
-
-	info(message) {
-		this.log('INFO', message);
-	}
-
-	success(message) {
-		this.log('SUCCESS', message);
-	}
-
-	error(message) {
-		this.log('ERROR', message);
-	}
-
-	warning(message) {
-		this.log('WARNING', message);
-	}
-
-	step(message) {
-		this.stepCount++;
-		const separator = '='.repeat(45);
-		this.log(
-			'STEP',
-			`\n${separator}\n  STEP ${this.stepCount}: ${message}\n${separator}`
-		);
-	}
-
-	addCost(cost) {
-		if (typeof cost === 'number' && !Number.isNaN(cost)) {
-			this.totalCost += cost;
-		}
-	}
-
-	extractAndAddCost(output) {
-		const costRegex = /Est\. Cost: \$(\d+\.\d+)/g;
-		let match;
-		while ((match = costRegex.exec(output)) !== null) {
-			const cost = parseFloat(match[1]);
-			this.addCost(cost);
-		}
-	}
-
-	flush() {
-		writeFileSync(this.logFile, this.logBuffer.join('\n'), 'utf8');
-	}
-
-	getSummary() {
-		const duration = this.formatDuration(Date.now() - this.startTime);
-		const successCount = this.logBuffer.filter((line) =>
-			line.includes('[SUCCESS]')
-		).length;
-		const errorCount = this.logBuffer.filter((line) =>
-			line.includes('[ERROR]')
-		).length;
-
-		return {
-			duration,
-			totalSteps: this.stepCount,
-			successCount,
-			errorCount,
-			totalCost: this.totalCost.toFixed(6),
-			logFile: this.logFile
-		};
-	}
-}

tests/e2e/utils/test-helpers.cjs

@@ -1,246 +0,0 @@
-const { spawn } = require('child_process');
-const {
-	readFileSync,
-	existsSync,
-	copyFileSync,
-	writeFileSync,
-	readdirSync
-} = require('fs');
-const { join } = require('path');
-
-class TestHelpers {
-	constructor(logger) {
-		this.logger = logger;
-	}
-
-	/**
-	 * Execute a command and return output
-	 * @param {string} command - Command to execute
-	 * @param {string[]} args - Command arguments
-	 * @param {Object} options - Execution options
-	 * @returns {Promise<{stdout: string, stderr: string, exitCode: number}>}
-	 */
-	async executeCommand(command, args = [], options = {}) {
-		return new Promise((resolve) => {
-			const spawnOptions = {
-				cwd: options.cwd || process.cwd(),
-				env: { ...process.env, ...options.env },
-				shell: true
-			};
-
-			// When using shell: true, pass the full command as a single string
-			const fullCommand =
-				args.length > 0 ? `${command} ${args.join(' ')}` : command;
-			const child = spawn(fullCommand, [], spawnOptions);
-			let stdout = '';
-			let stderr = '';
-
-			child.stdout.on('data', (data) => {
-				stdout += data.toString();
-			});
-
-			child.stderr.on('data', (data) => {
-				stderr += data.toString();
-			});
-
-			child.on('close', (exitCode) => {
-				const output = stdout + stderr;
-
-				// Extract and log costs
-				this.logger.extractAndAddCost(output);
-
-				resolve({ stdout, stderr, exitCode });
-			});
-
-			// Handle timeout
-			if (options.timeout) {
-				setTimeout(() => {
-					child.kill('SIGTERM');
-				}, options.timeout);
-			}
-		});
-	}
-
-	/**
-	 * Execute task-master command
-	 * @param {string} subcommand - Task-master subcommand
-	 * @param {string[]} args - Command arguments
-	 * @param {Object} options - Execution options
-	 */
-	async taskMaster(subcommand, args = [], options = {}) {
-		const fullArgs = [subcommand, ...args];
-		this.logger.info(`Executing: task-master ${fullArgs.join(' ')}`);
-
-		const result = await this.executeCommand('task-master', fullArgs, options);
-
-		if (result.exitCode !== 0 && !options.allowFailure) {
-			this.logger.error(`Command failed with exit code ${result.exitCode}`);
-			this.logger.error(`stderr: ${result.stderr}`);
-		}
-
-		return result;
-	}
-
-	/**
-	 * Check if a file exists
-	 */
-	fileExists(filePath) {
-		return existsSync(filePath);
-	}
-
-	/**
-	 * Read JSON file
-	 */
-	readJson(filePath) {
-		try {
-			const content = readFileSync(filePath, 'utf8');
-			return JSON.parse(content);
-		} catch (error) {
-			this.logger.error(
-				`Failed to read JSON file ${filePath}: ${error.message}`
-			);
-			return null;
-		}
-	}
-
-	/**
-	 * Copy file
-	 */
-	copyFile(source, destination) {
-		try {
-			copyFileSync(source, destination);
-			return true;
-		} catch (error) {
-			this.logger.error(
-				`Failed to copy file from ${source} to ${destination}: ${error.message}`
-			);
-			return false;
-		}
-	}
-
-	/**
-	 * Write file
-	 */
-	writeFile(filePath, content) {
-		try {
-			writeFileSync(filePath, content, 'utf8');
-			return true;
-		} catch (error) {
-			this.logger.error(`Failed to write file ${filePath}: ${error.message}`);
-			return false;
-		}
-	}
-
-	/**
-	 * Read file
-	 */
-	readFile(filePath) {
-		try {
-			return readFileSync(filePath, 'utf8');
-		} catch (error) {
-			this.logger.error(`Failed to read file ${filePath}: ${error.message}`);
-			return null;
-		}
-	}
-
-	/**
-	 * List files in directory
-	 */
-	listFiles(dirPath) {
-		try {
-			return readdirSync(dirPath);
-		} catch (error) {
-			this.logger.error(`Failed to list files in ${dirPath}: ${error.message}`);
-			return [];
-		}
-	}
-
-	/**
-	 * Wait for a specified duration
-	 */
-	async wait(milliseconds) {
-		return new Promise((resolve) => setTimeout(resolve, milliseconds));
-	}
-
-	/**
-	 * Verify task exists in tasks.json
-	 */
-	verifyTaskExists(tasksFile, taskId, tagName = 'master') {
-		const tasks = this.readJson(tasksFile);
-		if (!tasks || !tasks[tagName]) return false;
-
-		return tasks[tagName].tasks.some((task) => task.id === taskId);
-	}
-
-	/**
-	 * Get task count for a tag
-	 */
-	getTaskCount(tasksFile, tagName = 'master') {
-		const tasks = this.readJson(tasksFile);
-		if (!tasks || !tasks[tagName]) return 0;
-
-		return tasks[tagName].tasks.length;
-	}
-
-	/**
-	 * Extract task ID from command output
-	 */
-	extractTaskId(output) {
-		// First try to match the new numbered format (#123)
-		const numberedMatch = output.match(/#(\d+(?:\.\d+)?)/);
-		if (numberedMatch) {
-			return numberedMatch[1];
-		}
-
-		// Fallback to older patterns
-		const patterns = [
-			/✓ Added new task #(\d+(?:\.\d+)?)/,
-			/✅ New task created successfully:.*?(\d+(?:\.\d+)?)/,
-			/Task (\d+(?:\.\d+)?) Created Successfully/,
-			/Task created with ID: (\d+(?:\.\d+)?)/,
-			/Created task (\d+(?:\.\d+)?)/
-		];
-
-		for (const pattern of patterns) {
-			const match = output.match(pattern);
-			if (match) {
-				return match[1];
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * Run multiple async operations in parallel
-	 */
-	async runParallel(operations) {
-		return Promise.all(operations);
-	}
-
-	/**
-	 * Run operations with concurrency limit
-	 */
-	async runWithConcurrency(operations, limit = 3) {
-		const results = [];
-		const executing = [];
-
-		for (const operation of operations) {
-			const promise = operation().then((result) => {
-				executing.splice(executing.indexOf(promise), 1);
-				return result;
-			});
-
-			results.push(promise);
-			executing.push(promise);
-
-			if (executing.length >= limit) {
-				await Promise.race(executing);
-			}
-		}
-
-		return Promise.all(results);
-	}
-}
-
-module.exports = { TestHelpers };

tests/e2e/utils/test-helpers.js

@@ -1,204 +0,0 @@
-import { spawn } from 'child_process';
-import { readFileSync, existsSync, copyFileSync } from 'fs';
-import { join } from 'path';
-
-export class TestHelpers {
-	constructor(logger) {
-		this.logger = logger;
-	}
-
-	/**
-	 * Execute a command and return output
-	 * @param {string} command - Command to execute
-	 * @param {string[]} args - Command arguments
-	 * @param {Object} options - Execution options
-	 * @returns {Promise<{stdout: string, stderr: string, exitCode: number}>}
-	 */
-	async executeCommand(command, args = [], options = {}) {
-		return new Promise((resolve) => {
-			const spawnOptions = {
-				cwd: options.cwd || process.cwd(),
-				env: { ...process.env, ...options.env },
-				shell: true
-			};
-
-			// When using shell: true, pass the full command as a single string
-			// Quote arguments that contain spaces
-			const quotedArgs = args.map((arg) => {
-				// If arg contains spaces and doesn't already have quotes, wrap it in quotes
-				if (
-					arg?.includes(' ') &&
-					!arg?.startsWith('"') &&
-					!arg?.startsWith("'")
-				) {
-					return `"${arg}"`;
-				}
-				return arg;
-			});
-			const fullCommand =
-				args.length > 0 ? `${command} ${quotedArgs.join(' ')}` : command;
-			const child = spawn(fullCommand, [], spawnOptions);
-			let stdout = '';
-			let stderr = '';
-
-			child.stdout.on('data', (data) => {
-				stdout += data.toString();
-			});
-
-			child.stderr.on('data', (data) => {
-				stderr += data.toString();
-			});
-
-			child.on('close', (exitCode) => {
-				const output = stdout + stderr;
-
-				// Extract and log costs
-				this.logger.extractAndAddCost(output);
-
-				resolve({ stdout, stderr, exitCode });
-			});
-
-			// Handle timeout
-			if (options.timeout) {
-				setTimeout(() => {
-					child.kill('SIGTERM');
-				}, options.timeout);
-			}
-		});
-	}
-
-	/**
-	 * Execute task-master command
-	 * @param {string} subcommand - Task-master subcommand
-	 * @param {string[]} args - Command arguments
-	 * @param {Object} options - Execution options
-	 */
-	async taskMaster(subcommand, args = [], options = {}) {
-		const fullArgs = [subcommand, ...args];
-		this.logger.info(`Executing: task-master ${fullArgs.join(' ')}`);
-
-		const result = await this.executeCommand('task-master', fullArgs, options);
-
-		if (result.exitCode !== 0 && !options.allowFailure) {
-			this.logger.error(`Command failed with exit code ${result.exitCode}`);
-			this.logger.error(`stderr: ${result.stderr}`);
-		}
-
-		return result;
-	}
-
-	/**
-	 * Check if a file exists
-	 */
-	fileExists(filePath) {
-		return existsSync(filePath);
-	}
-
-	/**
-	 * Read JSON file
-	 */
-	readJson(filePath) {
-		try {
-			const content = readFileSync(filePath, 'utf8');
-			return JSON.parse(content);
-		} catch (error) {
-			this.logger.error(
-				`Failed to read JSON file ${filePath}: ${error.message}`
-			);
-			return null;
-		}
-	}
-
-	/**
-	 * Copy file
-	 */
-	copyFile(source, destination) {
-		try {
-			copyFileSync(source, destination);
-			return true;
-		} catch (error) {
-			this.logger.error(
-				`Failed to copy file from ${source} to ${destination}: ${error.message}`
-			);
-			return false;
-		}
-	}
-
-	/**
-	 * Wait for a specified duration
-	 */
-	async wait(milliseconds) {
-		return new Promise((resolve) => setTimeout(resolve, milliseconds));
-	}
-
-	/**
-	 * Verify task exists in tasks.json
-	 */
-	verifyTaskExists(tasksFile, taskId, tagName = 'master') {
-		const tasks = this.readJson(tasksFile);
-		if (!tasks || !tasks[tagName]) return false;
-
-		return tasks[tagName].tasks.some((task) => task.id === taskId);
-	}
-
-	/**
-	 * Get task count for a tag
-	 */
-	getTaskCount(tasksFile, tagName = 'master') {
-		const tasks = this.readJson(tasksFile);
-		if (!tasks || !tasks[tagName]) return 0;
-
-		return tasks[tagName].tasks.length;
-	}
-
-	/**
-	 * Extract task ID from command output
-	 */
-	extractTaskId(output) {
-		const patterns = [
-			/✓ Added new task #(\d+(?:\.\d+)?)/,
-			/✅ New task created successfully:.*?(\d+(?:\.\d+)?)/,
-			/Task (\d+(?:\.\d+)?) Created Successfully/
-		];
-
-		for (const pattern of patterns) {
-			const match = output.match(pattern);
-			if (match) {
-				return match[1];
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * Run multiple async operations in parallel
-	 */
-	async runParallel(operations) {
-		return Promise.all(operations);
-	}
-
-	/**
-	 * Run operations with concurrency limit
-	 */
-	async runWithConcurrency(operations, limit = 3) {
-		const results = [];
-		const executing = [];
-
-		for (const operation of operations) {
-			const promise = operation().then((result) => {
-				executing.splice(executing.indexOf(promise), 1);
-				return result;
-			});
-
-			results.push(promise);
-			executing.push(promise);
-
-			if (executing.length >= limit) {
-				await Promise.race(executing);
-			}
-		}
-
-		return Promise.all(results);
-	}
-}

tests/e2e/utils/test-setup.js

@@ -1,28 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Copy configuration files from main project to test directory
- * @param {string} testDir - The test directory path
- */
-export function copyConfigFiles(testDir) {
-    // Copy .env file if it exists
-    const mainEnvPath = join(process.cwd(), '.env');
-    const testEnvPath = join(testDir, '.env');
-    if (existsSync(mainEnvPath)) {
-        const envContent = readFileSync(mainEnvPath, 'utf8');
-        writeFileSync(testEnvPath, envContent);
-    }
-
-    // Copy config.json file if it exists
-    const mainConfigPath = join(process.cwd(), '.taskmaster/config.json');
-    const testConfigDir = join(testDir, '.taskmaster');
-    const testConfigPath = join(testConfigDir, 'config.json');
-    if (existsSync(mainConfigPath)) {
-        if (!existsSync(testConfigDir)) {
-            mkdirSync(testConfigDir, { recursive: true });
-        }
-        const configContent = readFileSync(mainConfigPath, 'utf8');
-        writeFileSync(testConfigPath, configContent);
-    }
-}

tests/unit/task-master.test.js

@@ -109,16 +109,15 @@ describe('initTaskMaster', () => {
 			expect(taskMaster.getProjectRoot()).toBe(tempDir);
 		});
 
-		test('should throw error when no project markers found', () => {
+		test('should return cwd when no project markers found cuz we changed the behavior of this function', () => {
 			// Arrange - Empty temp directory, no project markers
 			process.chdir(tempDir);
 
-			// Act & Assert
-			expect(() => {
-				initTaskMaster({});
-			}).toThrow(
-				'Unable to find project root. No project markers found. Run "init" command first.'
-			);
+			// Act
+			const taskMaster = initTaskMaster({});
+
+			// Assert
+			expect(taskMaster.getProjectRoot()).toBe(tempDir);
 		});
 	});