fix: Remove task-master-ai as a dependency from the package.json generated during init

.changeset/fifty-squids-wear.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": patch
+---
+
+Add CI for testing

.changeset/red-lights-mix.md

@@ -0,0 +1,5 @@
+---
+"task-master-ai": patch
+---
+
+Fix github actions creating npm releases on next branch push

.changeset/sharp-flies-call.md

@@ -1,7 +0,0 @@
----
-'task-master-ai': minor
----
-
-Add TASK_MASTER_PROJECT_ROOT env variable supported in mcp.json and .env for project root resolution
-
-- Some users were having issues where the MCP wasn't able to detect the location of their project root, you can now set the `TASK_MASTER_PROJECT_ROOT` environment variable to the root of your project.

.changeset/tidy-seals-rule.md

@@ -1,5 +0,0 @@
----
-'task-master-ai': patch
----
-
-Fix add-task MCP command causing an error

.changeset/two-bats-smoke.md

@@ -0,0 +1,302 @@
+---
+"task-master-ai": patch
+---
+
+- Adjusts the MCP server invokation in the mcp.json we ship with `task-master init`. Fully functional now.
+- Rename the npx -y command. It's now `npx -y task-master-ai task-master-mcp`
+- Add additional binary alias: `task-master-mcp-server` pointing to the same MCP server script
+
+- **Significant improvements to model configuration:**
+  - Increase context window from 64k to 128k tokens (MAX_TOKENS=128000) for handling larger codebases
+  - Reduce temperature from 0.4 to 0.2 for more consistent, deterministic outputs
+  - Set default model to "claude-3-7-sonnet-20250219" in configuration
+  - Update Perplexity model to "sonar-pro" for research operations
+  - Increase default subtasks generation from 4 to 5 for more granular task breakdown
+  - Set consistent default priority to "medium" for all new tasks
+
+- **Clarify environment configuration approaches:**
+  - For direct MCP usage: Configure API keys directly in `.cursor/mcp.json`
+  - For npm package usage: Configure API keys in `.env` file
+  - Update templates with clearer placeholder values and formatting
+  - Provide explicit documentation about configuration methods in both environments
+  - Use consistent placeholder format "YOUR_ANTHROPIC_API_KEY_HERE" in mcp.json
+
+- Rename MCP tools to better align with API conventions and natural language in client chat:
+  - Rename `list-tasks` to `get-tasks` for more intuitive client requests like "get my tasks"
+  - Rename `show-task` to `get-task` for consistency with GET-based API naming conventions
+
+- **Refine AI-based MCP tool implementation patterns:**
+  - Establish clear responsibilities for direct functions vs MCP tools when handling AI operations
+  - Update MCP direct function signatures to expect `context = { session }` for AI-based tools, without `reportProgress`
+  - Clarify that AI client initialization, API calls, and response parsing should be handled within the direct function
+  - Define standard error codes for AI operations (`AI_CLIENT_ERROR`, `RESPONSE_PARSING_ERROR`, etc.)
+  - Document that `reportProgress` should not be used within direct functions due to client validation issues
+  - Establish that progress indication within direct functions should use standard logging (`log.info()`)
+  - Clarify that `AsyncOperationManager` should manage progress reporting at the MCP tool layer, not in direct functions
+  - Update `mcp.mdc` rule to reflect the refined patterns for AI-based MCP tools
+  - **Document and implement the Logger Wrapper Pattern:**
+    - Add comprehensive documentation in `mcp.mdc` and `utilities.mdc` on the Logger Wrapper Pattern
+    - Explain the dual purpose of the wrapper: preventing runtime errors and controlling output format
+    - Include implementation examples with detailed explanations of why and when to use this pattern
+    - Clearly document that this pattern has proven successful in resolving issues in multiple MCP tools
+    - Cross-reference between rule files to ensure consistent guidance
+  - **Fix critical issue in `analyze-project-complexity` MCP tool:**
+    - Implement proper logger wrapper in `analyzeTaskComplexityDirect` to fix `mcpLog[level] is not a function` errors
+    - Update direct function to handle both Perplexity and Claude AI properly for research-backed analysis
+    - Improve silent mode handling with proper wasSilent state tracking
+    - Add comprehensive error handling for AI client errors and report file parsing
+    - Ensure proper report format detection and analysis with fallbacks
+    - Fix variable name conflicts between the `report` logging function and data structures in `analyzeTaskComplexity`
+  - **Fix critical issue in `update-task` MCP tool:**
+    - Implement proper logger wrapper in `updateTaskByIdDirect` to ensure mcpLog[level] calls work correctly
+    - Update Zod schema in `update-task.js` to accept both string and number type IDs
+    - Fix silent mode implementation with proper try/finally blocks
+    - Add comprehensive error handling for missing parameters, invalid task IDs, and failed updates
+  - **Refactor `update-subtask` MCP tool to follow established patterns:**
+    - Update `updateSubtaskByIdDirect` function to accept `context = { session }` parameter
+    - Add proper AI client initialization with error handling for both Anthropic and Perplexity
+    - Implement the Logger Wrapper Pattern to prevent mcpLog[level] errors
+    - Support both string and number subtask IDs with appropriate validation
+    - Update MCP tool to pass session to direct function but not reportProgress
+    - Remove commented-out calls to reportProgress for cleaner code
+    - Add comprehensive error handling for various failure scenarios
+    - Implement proper silent mode with try/finally blocks
+    - Ensure detailed successful update response information
+  - **Fix issues in `set-task-status` MCP tool:**
+    - Remove reportProgress parameter as it's not needed
+    - Improve project root handling for better session awareness
+    - Reorganize function call arguments for setTaskStatusDirect
+    - Add proper silent mode handling with try/catch/finally blocks
+    - Enhance logging for both success and error cases
+  - **Refactor `update` MCP tool to follow established patterns:**
+    - Update `updateTasksDirect` function to accept `context = { session }` parameter
+    - Add proper AI client initialization with error handling
+    - Update MCP tool to pass session to direct function but not reportProgress
+    - Simplify parameter validation using string type for 'from' parameter
+    - Improve error handling for AI client errors
+    - Implement proper silent mode handling with try/finally blocks
+    - Use `isSilentMode()` function instead of accessing global variables directly
+  - **Refactor `expand-task` MCP tool to follow established patterns:**
+    - Update `expandTaskDirect` function to accept `context = { session }` parameter
+    - Add proper AI client initialization with error handling
+    - Update MCP tool to pass session to direct function but not reportProgress
+    - Add comprehensive tests for the refactored implementation
+    - Improve error handling for AI client errors
+    - Remove non-existent 'force' parameter from direct function implementation
+    - Ensure direct function parameters match core function parameters
+    - Implement proper silent mode handling with try/finally blocks
+    - Use `isSilentMode()` function instead of accessing global variables directly
+  - **Refactor `parse-prd` MCP tool to follow established patterns:**
+    - Update `parsePRDDirect` function to accept `context = { session }` parameter for proper AI initialization
+    - Implement AI client initialization with proper error handling using `getAnthropicClientForMCP`
+    - Add the Logger Wrapper Pattern to ensure proper logging via `mcpLog`
+    - Update the core `parsePRD` function to accept an AI client parameter
+    - Implement proper silent mode handling with try/finally blocks
+    - Remove `reportProgress` usage from MCP tool for better client compatibility
+    - Fix console output that was breaking the JSON response format
+    - Improve error handling with specific error codes
+    - Pass session object to the direct function correctly
+    - Update task-manager-core.js to export AI client utilities for better organization
+    - Ensure proper option passing between functions to maintain logging context
+
+- **Update MCP Logger to respect silent mode:**
+  - Import and check `isSilentMode()` function in logger implementation
+  - Skip all logging when silent mode is enabled
+  - Prevent console output from interfering with JSON responses
+  - Fix "Unexpected token 'I', "[INFO] Gene"... is not valid JSON" errors by suppressing log output during silent mode
+
+- **Refactor `expand-all` MCP tool to follow established patterns:**
+    - Update `expandAllTasksDirect` function to accept `context = { session }` parameter
+    - Add proper AI client initialization with error handling for research-backed expansion
+    - Pass session to direct function but not reportProgress in the MCP tool
+    - Implement directory switching to work around core function limitations
+    - Add comprehensive error handling with specific error codes
+    - Ensure proper restoration of working directory after execution
+    - Use try/finally pattern for both silent mode and directory management
+    - Add comprehensive tests for the refactored implementation
+
+- **Standardize and improve silent mode implementation across MCP direct functions:**
+  - Add proper import of all silent mode utilities: `import { enableSilentMode, disableSilentMode, isSilentMode } from 'utils.js'`
+  - Replace direct access to global silentMode variable with `isSilentMode()` function calls
+  - Implement consistent try/finally pattern to ensure silent mode is always properly disabled
+  - Add error handling with finally blocks to prevent silent mode from remaining enabled after errors
+  - Create proper mixed parameter/global silent mode check pattern: `const isSilent = options.silentMode || (typeof options.silentMode === 'undefined' && isSilentMode())`
+  - Update all direct functions to follow the new implementation pattern
+  - Fix issues with silent mode not being properly disabled when errors occur
+
+- **Improve parameter handling between direct functions and core functions:**
+  - Verify direct function parameters match core function signatures
+  - Remove extraction and use of parameters that don't exist in core functions (e.g., 'force')
+  - Implement appropriate type conversion for parameters (e.g., `parseInt(args.id, 10)`)
+  - Set defaults that match core function expectations
+  - Add detailed documentation on parameter matching in guidelines
+  - Add explicit examples of correct parameter handling patterns
+
+- **Create standardized MCP direct function implementation checklist:**
+  - Comprehensive imports and dependencies section
+  - Parameter validation and matching guidelines
+  - Silent mode implementation best practices
+  - Error handling and response format patterns
+  - Path resolution and core function call guidelines
+  - Function export and testing verification steps
+  - Specific issues to watch for related to silent mode, parameters, and error cases
+  - Add checklist to subtasks for uniform implementation across all direct functions
+
+- **Implement centralized AI client utilities for MCP tools:**
+  - Create new `ai-client-utils.js` module with standardized client initialization functions
+  - Implement session-aware AI client initialization for both Anthropic and Perplexity
+  - Add comprehensive error handling with user-friendly error messages
+  - Create intelligent AI model selection based on task requirements
+  - Implement model configuration utilities that respect session environment variables
+  - Add extensive unit tests for all utility functions
+  - Significantly improve MCP tool reliability for AI operations
+  - **Specific implementations include:**
+    - `getAnthropicClientForMCP`: Initializes Anthropic client with session environment variables
+    - `getPerplexityClientForMCP`: Initializes Perplexity client with session environment variables
+    - `getModelConfig`: Retrieves model parameters from session or fallbacks to defaults
+    - `getBestAvailableAIModel`: Selects the best available model based on requirements
+    - `handleClaudeError`: Processes Claude API errors into user-friendly messages
+  - **Updated direct functions to use centralized AI utilities:**
+    - Refactored `addTaskDirect` to use the new AI client utilities with proper AsyncOperationManager integration
+    - Implemented comprehensive error handling for API key validation, AI processing, and response parsing
+    - Added session-aware parameter handling with proper propagation of context to AI streaming functions
+    - Ensured proper fallback to process.env when session variables aren't available
+
+- **Refine AI services for reusable operations:**
+  - Refactor `ai-services.js` to support consistent AI operations across CLI and MCP
+  - Implement shared helpers for streaming responses, prompt building, and response parsing
+  - Standardize client initialization patterns with proper session parameter handling
+  - Enhance error handling and loading indicator management
+  - Fix process exit issues to prevent MCP server termination on API errors
+  - Ensure proper resource cleanup in all execution paths
+  - Add comprehensive test coverage for AI service functions
+  - **Key improvements include:**
+    - Stream processing safety with explicit completion detection
+    - Standardized function parameter patterns
+    - Session-aware parameter extraction with sensible defaults
+    - Proper cleanup using try/catch/finally patterns
+
+- **Optimize MCP response payloads:**
+  - Add custom `processTaskResponse` function to `get-task` MCP tool to filter out unnecessary `allTasks` array data
+  - Significantly reduce response size by returning only the specific requested task instead of all tasks
+  - Preserve dependency status relationships for the UI/CLI while keeping MCP responses lean and efficient
+
+- **Implement complete remove-task functionality:**
+  - Add `removeTask` core function to permanently delete tasks or subtasks from tasks.json
+  - Implement CLI command `remove-task` with confirmation prompt and force flag support
+  - Create MCP `remove_task` tool for AI-assisted task removal
+  - Automatically handle dependency cleanup by removing references to deleted tasks
+  - Update task files after removal to maintain consistency
+  - Provide robust error handling and detailed feedback messages
+
+- **Update Cursor rules and documentation:**
+  - Enhance `new_features.mdc` with comprehensive guidelines for implementing removal commands
+  - Update `commands.mdc` with best practices for confirmation flows and cleanup procedures
+  - Expand `mcp.mdc` with detailed instructions for MCP tool implementation patterns
+  - Add examples of proper error handling and parameter validation to all relevant rules
+  - Include new sections about handling dependencies during task removal operations
+  - Document naming conventions and implementation patterns for destructive operations
+  - Update silent mode implementation documentation with proper examples
+  - Add parameter handling guidelines emphasizing matching with core functions
+  - Update architecture documentation with dedicated section on silent mode implementation
+
+- **Implement silent mode across all direct functions:**
+  - Add `enableSilentMode` and `disableSilentMode` utility imports to all direct function files
+  - Wrap all core function calls with silent mode to prevent console logs from interfering with JSON responses
+  - Add comprehensive error handling to ensure silent mode is disabled even when errors occur
+  - Fix "Unexpected token 'I', "[INFO] Gene"... is not valid JSON" errors by suppressing log output
+  - Apply consistent silent mode pattern across all MCP direct functions
+  - Maintain clean JSON responses for better integration with client tools
+
+- **Implement AsyncOperationManager for background task processing:**
+  - Add new `async-manager.js` module to handle long-running operations asynchronously
+  - Support background execution of computationally intensive tasks like expansion and analysis
+  - Implement unique operation IDs with UUID generation for reliable tracking
+  - Add operation status tracking (pending, running, completed, failed)
+  - Create `get_operation_status` MCP tool to check on background task progress
+  - Forward progress reporting from background tasks to the client
+  - Implement operation history with automatic cleanup of completed operations
+  - Support proper error handling in background tasks with detailed status reporting
+  - Maintain context (log, session) for background operations ensuring consistent behavior
+
+- **Implement initialize_project command:**
+  - Add new MCP tool to allow project setup via integrated MCP clients
+  - Create `initialize_project` direct function with proper parameter handling
+  - Improve onboarding experience by adding to mcp.json configuration
+  - Support project-specific metadata like name, description, and version
+  - Handle shell alias creation with proper confirmation
+  - Improve first-time user experience in AI environments
+
+- **Refactor project root handling for MCP Server:**
+  - **Prioritize Session Roots**: MCP tools now extract the project root path directly from `session.roots[0].uri` provided by the client (e.g., Cursor).
+  - **New Utility `getProjectRootFromSession`**: Added to `mcp-server/src/tools/utils.js` to encapsulate session root extraction and decoding. **Further refined for more reliable detection, especially in integrated environments, including deriving root from script path and avoiding fallback to '/'.**
+  - **Simplify `findTasksJsonPath`**: The core path finding utility in `mcp-server/src/core/utils/path-utils.js` now prioritizes the `projectRoot` passed in `args` (originating from the session). Removed checks for `TASK_MASTER_PROJECT_ROOT` env var (we do not use this anymore) and package directory fallback. **Enhanced error handling to include detailed debug information (paths searched, CWD, server dir, etc.) and clearer potential solutions when `tasks.json` is not found.**
+  - **Retain CLI Fallbacks**: Kept `lastFoundProjectRoot` cache check and CWD search in `findTasksJsonPath` for compatibility with direct CLI usage.
+
+- Updated all MCP tools to use the new project root handling:
+  - Tools now call `getProjectRootFromSession` to determine the root.
+  - This root is passed explicitly as `projectRoot` in the `args` object to the corresponding `*Direct` function.
+  - Direct functions continue to use the (now simplified) `findTasksJsonPath` to locate `tasks.json` within the provided root.
+  - This ensures tools work reliably in integrated environments without requiring the user to specify `--project-root`.
+
+- Add comprehensive PROJECT_MARKERS array for detecting common project files (used in CLI fallback logic).
+- Improved error messages with specific troubleshooting guidance.
+- **Enhanced logging:**
+    - Indicate the source of project root selection more clearly.
+    - **Add verbose logging in `get-task.js` to trace session object content and resolved project root path, aiding debugging.**
+
+- DRY refactoring by centralizing path utilities in `core/utils/path-utils.js` and session handling in `tools/utils.js`.
+- Keep caching of `lastFoundProjectRoot` for CLI performance.
+
+- Split monolithic task-master-core.js into separate function files within direct-functions directory.
+- Implement update-task MCP command for updating a single task by ID.
+- Implement update-subtask MCP command for appending information to specific subtasks.
+- Implement generate MCP command for creating individual task files from tasks.json.
+- Implement set-status MCP command for updating task status.
+- Implement get-task MCP command for displaying detailed task information (renamed from show-task).
+- Implement next-task MCP command for finding the next task to work on.
+- Implement expand-task MCP command for breaking down tasks into subtasks.
+- Implement add-task MCP command for creating new tasks using AI assistance.
+- Implement add-subtask MCP command for adding subtasks to existing tasks.
+- Implement remove-subtask MCP command for removing subtasks from parent tasks.
+- Implement expand-all MCP command for expanding all tasks into subtasks.
+- Implement analyze-complexity MCP command for analyzing task complexity.
+- Implement clear-subtasks MCP command for clearing subtasks from parent tasks.
+- Implement remove-dependency MCP command for removing dependencies from tasks.
+- Implement validate-dependencies MCP command for checking validity of task dependencies.
+- Implement fix-dependencies MCP command for automatically fixing invalid dependencies.
+- Implement complexity-report MCP command for displaying task complexity analysis reports.
+- Implement add-dependency MCP command for creating dependency relationships between tasks.
+- Implement get-tasks MCP command for listing all tasks (renamed from list-tasks).
+- Implement `initialize_project` MCP tool to allow project setup via MCP client and radically improve and simplify onboarding by adding to mcp.json (e.g., Cursor).
+
+- Enhance documentation and tool descriptions:
+  - Create new `taskmaster.mdc` Cursor rule for comprehensive MCP tool and CLI command reference.
+  - Bundle taskmaster.mdc with npm package and include in project initialization.
+  - Add detailed descriptions for each tool's purpose, parameters, and common use cases.
+  - Include natural language patterns and keywords for better intent recognition.
+  - Document parameter descriptions with clear examples and default values.
+  - Add usage examples and context for each command/tool.
+  - **Update documentation (`mcp.mdc`, `utilities.mdc`, `architecture.mdc`, `new_features.mdc`, `commands.mdc`) to reflect the new session-based project root handling and the preferred MCP vs. CLI interaction model.**
+  - Improve clarity around project root auto-detection in tool documentation.
+  - Update tool descriptions to better reflect their actual behavior and capabilities.
+  - Add cross-references between related tools and commands.
+  - Include troubleshooting guidance in tool descriptions.
+  - **Add default values for `DEFAULT_SUBTASKS` and `DEFAULT_PRIORITY` to the example `.cursor/mcp.json` configuration.**
+
+- Document MCP server naming conventions in architecture.mdc and mcp.mdc files (file names use kebab-case, direct functions use camelCase with Direct suffix, tool registration functions use camelCase with Tool suffix, and MCP tool names use snake_case).
+- Update MCP tool naming to follow more intuitive conventions that better align with natural language requests in client chat applications.
+- Enhance task show view with a color-coded progress bar for visualizing subtask completion percentage.
+- Add "cancelled" status to UI module status configurations for marking tasks as cancelled without deletion.
+- Improve MCP server resource documentation with comprehensive implementation examples and best practices.
+- Enhance progress bars with status breakdown visualization showing proportional sections for different task statuses.
+- Add improved status tracking for both tasks and subtasks with detailed counts by status.
+- Optimize progress bar display with width constraints to prevent UI overflow on smaller terminals.
+- Improve status counts display with clear text labels beside status icons for better readability.
+- Treat deferred and cancelled tasks as effectively complete for progress calculation while maintaining visual distinction.
+- **Fix `reportProgress` calls** to use the correct `{ progress, total? }` format.
+- **Standardize logging in core task-manager functions (`expandTask`, `expandAllTasks`, `updateTasks`, `updateTaskById`, `updateSubtaskById`, `parsePRD`, `analyzeTaskComplexity`):**
+  - Implement a local `report` function in each to handle context-aware logging.
+  - Use `report` to choose between `mcpLog` (if available) and global `log` (from `utils.js`).
+  - Only call global `log` when `outputFormat` is 'text' and silent mode is off.
+  - Wrap CLI UI elements (tables, boxes, spinners) in `outputFormat === 'text'` checks.

.cursor/mcp.json

@@ -1,18 +1,17 @@
 {
 	"mcpServers": {
-		"task-master-ai": {
+		"taskmaster-ai": {
 			"command": "node",
 			"args": ["./mcp-server/server.js"],
 			"env": {
-				"ANTHROPIC_API_KEY": "ANTHROPIC_API_KEY_HERE",
-				"PERPLEXITY_API_KEY": "PERPLEXITY_API_KEY_HERE",
-				"OPENAI_API_KEY": "OPENAI_API_KEY_HERE",
-				"GOOGLE_API_KEY": "GOOGLE_API_KEY_HERE",
-				"XAI_API_KEY": "XAI_API_KEY_HERE",
-				"OPENROUTER_API_KEY": "OPENROUTER_API_KEY_HERE",
-				"MISTRAL_API_KEY": "MISTRAL_API_KEY_HERE",
-				"AZURE_OPENAI_API_KEY": "AZURE_OPENAI_API_KEY_HERE",
-				"OLLAMA_API_KEY": "OLLAMA_API_KEY_HERE"
+				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
+				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
+				"MODEL": "claude-3-7-sonnet-20250219",
+				"PERPLEXITY_MODEL": "sonar-pro",
+				"MAX_TOKENS": 128000,
+				"TEMPERATURE": 0.2,
+				"DEFAULT_SUBTASKS": 5,
+				"DEFAULT_PRIORITY": "medium"
 			}
 		}
 	}

.cursor/rules/ai_providers.mdc

@@ -1,155 +0,0 @@
----
-description: Guidelines for managing Task Master AI providers and models.
-globs: 
-alwaysApply: false
----
-# Task Master AI Provider Management
-
-This rule guides AI assistants on how to view, configure, and interact with the different AI providers and models supported by Task Master. For internal implementation details of the service layer, see [`ai_services.mdc`](mdc:.cursor/rules/ai_services.mdc).
-
--   **Primary Interaction:**
-    -   Use the `models` MCP tool or the `task-master models` CLI command to manage AI configurations. See [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc) for detailed command/tool usage.
-
--   **Configuration Roles:**
-    -   Task Master uses three roles for AI models:
-        -   `main`: Primary model for general tasks (generation, updates).
-        -   `research`: Model used when the `--research` flag or `research: true` parameter is used (typically models with web access or specialized knowledge).
-        -   `fallback`: Model used if the primary (`main`) model fails.
-    -   Each role is configured with a specific `provider:modelId` pair (e.g., `openai:gpt-4o`).
-
--   **Viewing Configuration & Available Models:**
-    -   To see the current model assignments for each role and list all models available for assignment:
-        -   **MCP Tool:** `models` (call with no arguments or `listAvailableModels: true`)
-        -   **CLI Command:** `task-master models`
-    -   The output will show currently assigned models and a list of others, prefixed with their provider (e.g., `google:gemini-2.5-pro-exp-03-25`).
-
--   **Setting Models for Roles:**
-    -   To assign a model to a role:
-        -   **MCP Tool:** `models` with `setMain`, `setResearch`, or `setFallback` parameters.
-        -   **CLI Command:** `task-master models` with `--set-main`, `--set-research`, or `--set-fallback` flags.
-    -   **Crucially:** When providing the model ID to *set*, **DO NOT include the `provider:` prefix**. Use only the model ID itself.
-        -   ✅ **DO:** `models(setMain='gpt-4o')` or `task-master models --set-main=gpt-4o`
-        -   ❌ **DON'T:** `models(setMain='openai:gpt-4o')` or `task-master models --set-main=openai:gpt-4o`
-    -   The tool/command will automatically determine the provider based on the model ID.
-
--   **Setting Custom Models (Ollama/OpenRouter):**
-    -   To set a model ID not in the internal list for Ollama or OpenRouter:
-        -   **MCP Tool:** Use `models` with `set<Role>` and **also** `ollama: true` or `openrouter: true`.
-            -   Example: `models(setMain='my-custom-ollama-model', ollama=true)`
-            -   Example: `models(setMain='some-openrouter-model', openrouter=true)`
-        -   **CLI Command:** Use `task-master models` with `--set-<role>` and **also** `--ollama` or `--openrouter`.
-            -   Example: `task-master models --set-main=my-custom-ollama-model --ollama`
-            -   Example: `task-master models --set-main=some-openrouter-model --openrouter`
-        -   **Interactive Setup:** Use `task-master models --setup` and select the `Ollama (Enter Custom ID)` or `OpenRouter (Enter Custom ID)` options.
-    -   **OpenRouter Validation:** When setting a custom OpenRouter model, Taskmaster attempts to validate the ID against the live OpenRouter API.
-    -   **Ollama:** No live validation occurs for custom Ollama models; ensure the model is available on your Ollama server.
-
--   **Supported Providers & Required API Keys:**
-    -   Task Master integrates with various providers via the Vercel AI SDK.
-    -   **API keys are essential** for most providers and must be configured correctly.
-    -   **Key Locations** (See [`dev_workflow.mdc`](mdc:.cursor/rules/dev_workflow.mdc) - Configuration Management):
-        -   **MCP/Cursor:** Set keys in the `env` section of `.cursor/mcp.json`.
-        -   **CLI:** Set keys in a `.env` file in the project root.
-    -   **Provider List & Keys:**
-        -   **`anthropic`**: Requires `ANTHROPIC_API_KEY`.
-        -   **`google`**: Requires `GOOGLE_API_KEY`.
-        -   **`openai`**: Requires `OPENAI_API_KEY`.
-        -   **`perplexity`**: Requires `PERPLEXITY_API_KEY`.
-        -   **`xai`**: Requires `XAI_API_KEY`.
-        -   **`mistral`**: Requires `MISTRAL_API_KEY`.
-        -   **`azure`**: Requires `AZURE_OPENAI_API_KEY` and `AZURE_OPENAI_ENDPOINT`.
-        -   **`openrouter`**: Requires `OPENROUTER_API_KEY`.
-        -   **`ollama`**: Might require `OLLAMA_API_KEY` (not currently supported) *and* `OLLAMA_BASE_URL` (default: `http://localhost:11434/api`). *Check specific setup.*
-
--   **Troubleshooting:**
-    -   If AI commands fail (especially in MCP context):
-        1.  **Verify API Key:** Ensure the correct API key for the *selected provider* (check `models` output) exists in the appropriate location (`.cursor/mcp.json` env or `.env`).
-        2.  **Check Model ID:** Ensure the model ID set for the role is valid (use `models` listAvailableModels/`task-master models`).
-        3.  **Provider Status:** Check the status of the external AI provider's service.
-        4.  **Restart MCP:** If changes were made to configuration or provider code, restart the MCP server.
-
-## Adding a New AI Provider (Vercel AI SDK Method)
-
-Follow these steps to integrate a new AI provider that has an official Vercel AI SDK adapter (`@ai-sdk/<provider>`):
-
-1.  **Install Dependency:**
-    -   Install the provider-specific package:
-        ```bash
-        npm install @ai-sdk/<provider-name>
-        ```
-
-2.  **Create Provider Module:**
-    -   Create a new file in `src/ai-providers/` named `<provider-name>.js`.
-    -   Use existing modules (`openai.js`, `anthropic.js`, etc.) as a template.
-    -   **Import:**
-        -   Import the provider's `create<ProviderName>` function from `@ai-sdk/<provider-name>`.
-        -   Import `generateText`, `streamText`, `generateObject` from the core `ai` package.
-        -   Import the `log` utility from `../../scripts/modules/utils.js`.
-    -   **Implement Core Functions:**
-        -   `generate<ProviderName>Text(params)`:
-            -   Accepts `params` (apiKey, modelId, messages, etc.).
-            -   Instantiate the client: `const client = create<ProviderName>({ apiKey });`
-            -   Call `generateText({ model: client(modelId), ... })`.
-            -   Return `result.text`.
-            -   Include basic validation and try/catch error handling.
-        -   `stream<ProviderName>Text(params)`:
-            -   Similar structure to `generateText`.
-            -   Call `streamText({ model: client(modelId), ... })`.
-            -   Return the full stream result object.
-            -   Include basic validation and try/catch.
-        -   `generate<ProviderName>Object(params)`:
-            -   Similar structure.
-            -   Call `generateObject({ model: client(modelId), schema, messages, ... })`.
-            -   Return `result.object`.
-            -   Include basic validation and try/catch.
-    -   **Export Functions:** Export the three implemented functions (`generate<ProviderName>Text`, `stream<ProviderName>Text`, `generate<ProviderName>Object`).
-
-3.  **Integrate with Unified Service:**
-    -   Open `scripts/modules/ai-services-unified.js`.
-    -   **Import:** Add `import * as <providerName> from '../../src/ai-providers/<provider-name>.js';`
-    -   **Map:** Add an entry to the `PROVIDER_FUNCTIONS` map:
-        ```javascript
-        '<provider-name>': {
-            generateText: <providerName>.generate<ProviderName>Text,
-            streamText: <providerName>.stream<ProviderName>Text,
-            generateObject: <providerName>.generate<ProviderName>Object
-        },
-        ```
-
-4.  **Update Configuration Management:**
-    -   Open `scripts/modules/config-manager.js`.
-    -   **`MODEL_MAP`:** Add the new `<provider-name>` key to the `MODEL_MAP` loaded from `supported-models.json` (or ensure the loading handles new providers dynamically if `supported-models.json` is updated first).
-    -   **`VALID_PROVIDERS`:** Ensure the new `<provider-name>` is included in the `VALID_PROVIDERS` array (this should happen automatically if derived from `MODEL_MAP` keys).
-    -   **API Key Handling:**
-        -   Update the `keyMap` in `_resolveApiKey` and `isApiKeySet` with the correct environment variable name (e.g., `PROVIDER_API_KEY`).
-        -   Update the `switch` statement in `getMcpApiKeyStatus` to check the corresponding key in `mcp.json` and its placeholder value.
-        -   Add a case to the `switch` statement in `getMcpApiKeyStatus` for the new provider, including its placeholder string if applicable.
-    -   **Ollama Exception:** If adding Ollama or another provider *not* requiring an API key, add a specific check at the beginning of `isApiKeySet` and `getMcpApiKeyStatus` to return `true` immediately for that provider.
-
-5.  **Update Supported Models List:**
-    -   Edit `scripts/modules/supported-models.json`.
-    -   Add a new key for the `<provider-name>`.
-    -   Add an array of model objects under the provider key, each including:
-        -   `id`: The specific model identifier (e.g., `claude-3-opus-20240229`).
-        -   `name`: A user-friendly name (optional).
-        -   `swe_score`, `cost_per_1m_tokens`: (Optional) Add performance/cost data if available.
-        -   `allowed_roles`: An array of roles (`"main"`, `"research"`, `"fallback"`) the model is suitable for.
-        -   `max_tokens`: (Optional but recommended) The maximum token limit for the model.
-
-6.  **Update Environment Examples:**
-    -   Add the new `PROVIDER_API_KEY` to `.env.example`.
-    -   Add the new `PROVIDER_API_KEY` with its placeholder (`YOUR_PROVIDER_API_KEY_HERE`) to the `env` section for `taskmaster-ai` in `.cursor/mcp.json.example` (if it exists) or update instructions.
-
-7.  **Add Unit Tests:**
-    -   Create `tests/unit/ai-providers/<provider-name>.test.js`.
-    -   Mock the `@ai-sdk/<provider-name>` module and the core `ai` module functions (`generateText`, `streamText`, `generateObject`).
-    -   Write tests for each exported function (`generate<ProviderName>Text`, etc.) to verify:
-        -   Correct client instantiation.
-        -   Correct parameters passed to the mocked Vercel AI SDK functions.
-        -   Correct handling of results.
-        -   Error handling (missing API key, SDK errors).
-
-8.  **Documentation:**
-    -   Update any relevant documentation (like `README.md` or other rules) mentioning supported providers or configuration.
-
-*(Note: For providers **without** an official Vercel AI SDK adapter, the process would involve directly using the provider's own SDK or API within the `src/ai-providers/<provider-name>.js` module and manually constructing responses compatible with the unified service layer, which is significantly more complex.)*

.cursor/rules/ai_services.mdc

@@ -1,102 +0,0 @@
----
-description: Guidelines for interacting with the unified AI service layer.
-globs: scripts/modules/ai-services-unified.js, scripts/modules/task-manager/*.js, scripts/modules/commands.js
----
-
-# AI Services Layer Guidelines
-
-This document outlines the architecture and usage patterns for interacting with Large Language Models (LLMs) via Task Master's unified AI service layer (`ai-services-unified.js`). The goal is to centralize configuration, provider selection, API key management, fallback logic, and error handling.
-
-**Core Components:**
-
-*   **Configuration (`.taskmasterconfig` & [`config-manager.js`](mdc:scripts/modules/config-manager.js)):**
-    *   Defines the AI provider and model ID for different **roles** (`main`, `research`, `fallback`).
-    *   Stores parameters like `maxTokens` and `temperature` per role.
-    *   Managed via the `task-master models --setup` CLI command.
-    *   [`config-manager.js`](mdc:scripts/modules/config-manager.js) provides **getters** (e.g., `getMainProvider()`, `getParametersForRole()`) to access these settings. Core logic should **only** use these getters for *non-AI related application logic* (e.g., `getDefaultSubtasks`). The unified service fetches necessary AI parameters internally based on the `role`.
-    *   **API keys** are **NOT** stored here; they are resolved via `resolveEnvVariable` (in [`utils.js`](mdc:scripts/modules/utils.js)) from `.env` (for CLI) or the MCP `session.env` object (for MCP calls). See [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc) and [`dev_workflow.mdc`](mdc:.cursor/rules/dev_workflow.mdc).
-
-*   **Unified Service (`ai-services-unified.js`):**
-    *   Exports primary interaction functions: `generateTextService`, `generateObjectService`. (Note: `streamTextService` exists but has known reliability issues with some providers/payloads).
-    *   Contains the core `_unifiedServiceRunner` logic.
-    *   Internally uses `config-manager.js` getters to determine the provider/model/parameters based on the requested `role`.
-    *   Implements the **fallback sequence** (e.g., main -> fallback -> research) if the primary provider/model fails.
-    *   Constructs the `messages` array required by the Vercel AI SDK.
-    *   Implements **retry logic** for specific API errors (`_attemptProviderCallWithRetries`).
-    *   Resolves API keys automatically via `_resolveApiKey` (using `resolveEnvVariable`).
-    *   Maps requests to the correct provider implementation (in `src/ai-providers/`) via `PROVIDER_FUNCTIONS`.
-    *   Returns a structured object containing the primary AI result (`mainResult`) and telemetry data (`telemetryData`). See [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc) for details on how this telemetry data is propagated and handled.
-
-*   **Provider Implementations (`src/ai-providers/*.js`):**
-    *   Contain provider-specific wrappers around Vercel AI SDK functions (`generateText`, `generateObject`).
-
-**Usage Pattern (from Core Logic like `task-manager/*.js`):**
-
-1.  **Import Service:** Import `generateTextService` or `generateObjectService` from `../ai-services-unified.js`.
-    ```javascript
-    // Preferred for most tasks (especially with complex JSON)
-    import { generateTextService } from '../ai-services-unified.js';
-
-    // Use if structured output is reliable for the specific use case
-    // import { generateObjectService } from '../ai-services-unified.js';
-    ```
-
-2.  **Prepare Parameters:** Construct the parameters object for the service call.
-    *   `role`: **Required.** `'main'`, `'research'`, or `'fallback'`. Determines the initial provider/model/parameters used by the unified service.
-    *   `session`: **Required if called from MCP context.** Pass the `session` object received by the direct function wrapper. The unified service uses `session.env` to find API keys.
-    *   `systemPrompt`: Your system instruction string.
-    *   `prompt`: The user message string (can be long, include stringified data, etc.).
-    *   (For `generateObjectService` only): `schema` (Zod schema), `objectName`.
-
-3.  **Call Service:** Use `await` to call the service function.
-    ```javascript
-    // Example using generateTextService (most common)
-    try {
-        const resultText = await generateTextService({
-            role: useResearch ? 'research' : 'main', // Determine role based on logic
-            session: context.session, // Pass session from context object
-            systemPrompt: "You are...",
-            prompt: userMessageContent
-        });
-        // Process the raw text response (e.g., parse JSON, use directly)
-        // ...
-    } catch (error) {
-        // Handle errors thrown by the unified service (if all fallbacks/retries fail)
-        report('error', `Unified AI service call failed: ${error.message}`);
-        throw error;
-    }
-
-    // Example using generateObjectService (use cautiously)
-    try {
-        const resultObject = await generateObjectService({
-            role: 'main',
-            session: context.session,
-            schema: myZodSchema,
-            objectName: 'myDataObject',
-            systemPrompt: "You are...",
-            prompt: userMessageContent
-        });
-        // resultObject is already a validated JS object
-        // ...
-    } catch (error) {
-        report('error', `Unified AI service call failed: ${error.message}`);
-        throw error;
-    }
-    ```
-
-4.  **Handle Results/Errors:** Process the returned text/object or handle errors thrown by the unified service layer.
-
-**Key Implementation Rules & Gotchas:**
-
-*   ✅ **DO**: Centralize **all** LLM calls through `generateTextService` or `generateObjectService`.
-*   ✅ **DO**: Determine the appropriate `role` (`main`, `research`, `fallback`) in your core logic and pass it to the service.
-*   ✅ **DO**: Pass the `session` object (received in the `context` parameter, especially from direct function wrappers) to the service call when in MCP context.
-*   ✅ **DO**: Ensure API keys are correctly configured in `.env` (for CLI) or `.cursor/mcp.json` (for MCP).
-*   ✅ **DO**: Ensure `.taskmasterconfig` exists and has valid provider/model IDs for the roles you intend to use (manage via `task-master models --setup`).
-*   ✅ **DO**: Use `generateTextService` and implement robust manual JSON parsing (with Zod validation *after* parsing) when structured output is needed, as `generateObjectService` has shown unreliability with some providers/schemas.
-*   ❌ **DON'T**: Import or call anything from the old `ai-services.js`, `ai-client-factory.js`, or `ai-client-utils.js` files.
-*   ❌ **DON'T**: Initialize AI clients (Anthropic, Perplexity, etc.) directly within core logic (`task-manager/`) or MCP direct functions.
-*   ❌ **DON'T**: Fetch AI-specific parameters (model ID, max tokens, temp) using `config-manager.js` getters *for the AI call*. Pass the `role` instead.
-*   ❌ **DON'T**: Implement fallback or retry logic outside `ai-services-unified.js`.
-*   ❌ **DON'T**: Handle API key resolution outside the service layer (it uses `utils.js` internally).
-*   ⚠️ **generateObjectService Caution**: Be aware of potential reliability issues with `generateObjectService` across different providers and complex schemas. Prefer `generateTextService` + manual parsing as a more robust alternative for structured data needs.

.cursor/rules/architecture.mdc

@@ -3,6 +3,7 @@ description: Describes the high-level architecture of the Task Master CLI applic
 globs: scripts/modules/*.js
 alwaysApply: false
 ---
+
 # Application Architecture Overview
 
 - **Modular Structure**: The Task Master CLI is built using a modular architecture, with distinct modules responsible for different aspects of the application. This promotes separation of concerns, maintainability, and testability.
@@ -13,75 +14,148 @@ alwaysApply: false
     - **Purpose**: Defines and registers all CLI commands using Commander.js.
     - **Responsibilities** (See also: [`commands.mdc`](mdc:.cursor/rules/commands.mdc)):
       - Parses command-line arguments and options.
-      - Invokes appropriate core logic functions from `scripts/modules/`.
-      - Handles user input/output for CLI.
-      - Implements CLI-specific validation.
+      - Invokes appropriate functions from other modules to execute commands.
+      - Handles user input and output related to command execution.
+      - Implements input validation and error handling for CLI commands.
+    - **Key Components**:
+      - `programInstance` (Commander.js `Command` instance): Manages command definitions.
+      - `registerCommands(programInstance)`: Function to register all application commands.
+      - Command action handlers: Functions executed when a specific command is invoked.
 
-  - **[`task-manager.js`](mdc:scripts/modules/task-manager.js) & `task-manager/` directory: Task Data & Core Logic**
-    - **Purpose**: Contains core functions for task data manipulation (CRUD), AI interactions, and related logic.
+  - **[`task-manager.js`](mdc:scripts/modules/task-manager.js): Task Data Management**
+    - **Purpose**: Manages task data, including loading, saving, creating, updating, deleting, and querying tasks.
     - **Responsibilities**:
-      - Reading/writing `tasks.json`.
-      - Implementing functions for task CRUD, parsing PRDs, expanding tasks, updating status, etc.
-      - **Delegating AI interactions** to the `ai-services-unified.js` layer.
-      - Accessing non-AI configuration via `config-manager.js` getters.
-    - **Key Files**: Individual files within `scripts/modules/task-manager/` handle specific actions (e.g., `add-task.js`, `expand-task.js`).
+      - Reads and writes task data to `tasks.json` file.
+      - Implements functions for task CRUD operations (Create, Read, Update, Delete).
+      - Handles task parsing from PRD documents using AI.
+      - Manages task expansion and subtask generation.
+      - Updates task statuses and properties.
+      - Implements task listing and display logic.
+      - Performs task complexity analysis using AI.
+    - **Key Functions**:
+      - `readTasks(tasksPath)` / `writeTasks(tasksPath, tasksData)`: Load and save task data.
+      - `parsePRD(prdFilePath, outputPath, numTasks)`: Parses PRD document to create tasks.
+      - `expandTask(taskId, numSubtasks, useResearch, prompt, force)`: Expands a task into subtasks.
+      - `setTaskStatus(tasksPath, taskIdInput, newStatus)`: Updates task status.
+      - `listTasks(tasksPath, statusFilter, withSubtasks)`: Lists tasks with filtering and subtask display options.
+      - `analyzeComplexity(tasksPath, reportPath, useResearch, thresholdScore)`: Analyzes task complexity.
 
   - **[`dependency-manager.js`](mdc:scripts/modules/dependency-manager.js): Dependency Management**
-    - **Purpose**: Manages task dependencies.
-    - **Responsibilities**: Add/remove/validate/fix dependencies.
+    - **Purpose**: Manages task dependencies, including adding, removing, validating, and fixing dependency relationships.
+    - **Responsibilities**:
+      - Adds and removes task dependencies.
+      - Validates dependency relationships to prevent circular dependencies and invalid references.
+      - Fixes invalid dependencies by removing non-existent or self-referential dependencies.
+      - Provides functions to check for circular dependencies.
+    - **Key Functions**:
+      - `addDependency(tasksPath, taskId, dependencyId)`: Adds a dependency between tasks.
+      - `removeDependency(tasksPath, taskId, dependencyId)`: Removes a dependency.
+      - `validateDependencies(tasksPath)`: Validates task dependencies.
+      - `fixDependencies(tasksPath)`: Fixes invalid task dependencies.
+      - `isCircularDependency(tasks, taskId, dependencyChain)`: Detects circular dependencies.
 
   - **[`ui.js`](mdc:scripts/modules/ui.js): User Interface Components**
-    - **Purpose**: Handles CLI output formatting (tables, colors, boxes, spinners).
-    - **Responsibilities**: Displaying tasks, reports, progress, suggestions.
+    - **Purpose**: Handles all user interface elements, including displaying information, formatting output, and providing user feedback.
+    - **Responsibilities**:
+      - Displays task lists, task details, and command outputs in a formatted way.
+      - Uses `chalk` for colored output and `boxen` for boxed messages.
+      - Implements table display using `cli-table3`.
+      - Shows loading indicators using `ora`.
+      - Provides helper functions for status formatting, dependency display, and progress reporting.
+      - Suggests next actions to the user after command execution.
+    - **Key Functions**:
+      - `displayTaskList(tasks, statusFilter, withSubtasks)`: Displays a list of tasks in a table.
+      - `displayTaskDetails(task)`: Displays detailed information for a single task.
+      - `displayComplexityReport(reportPath)`: Displays the task complexity report.
+      - `startLoadingIndicator(message)` / `stopLoadingIndicator(indicator)`: Manages loading indicators.
+      - `getStatusWithColor(status)`: Returns status string with color formatting.
+      - `formatDependenciesWithStatus(dependencies, allTasks, inTable)`: Formats dependency list with status indicators.
 
-  - **[`ai-services-unified.js`](mdc:scripts/modules/ai-services-unified.js): Unified AI Service Layer**
-    - **Purpose**: Centralized interface for all LLM interactions using Vercel AI SDK.
-    - **Responsibilities** (See also: [`ai_services.mdc`](mdc:.cursor/rules/ai_services.mdc)):
-      - Exports `generateTextService`, `generateObjectService`.
-      - Handles provider/model selection based on `role` and `.taskmasterconfig`.
-      - Resolves API keys (from `.env` or `session.env`).
-      - Implements fallback and retry logic.
-      - Orchestrates calls to provider-specific implementations (`src/ai-providers/`).
-    - Telemetry data generated by the AI service layer is propagated upwards through core logic, direct functions, and MCP tools. See [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc) for the detailed integration pattern.
+  - **[`ai-services.js`](mdc:scripts/modules/ai-services.js) (Conceptual): AI Integration**
+    - **Purpose**:  Abstracts interactions with AI models (like Anthropic Claude and Perplexity AI) for various features. *Note: This module might be implicitly implemented within `task-manager.js` and `utils.js` or could be explicitly created for better organization as the project evolves.*
+    - **Responsibilities**:
+      - Handles API calls to AI services.
+      - Manages prompts and parameters for AI requests.
+      - Parses AI responses and extracts relevant information.
+      - Implements logic for task complexity analysis, task expansion, and PRD parsing using AI.
+    - **Potential Functions**:
+      - `getAIResponse(prompt, model, maxTokens, temperature)`: Generic function to interact with AI model.
+      - `analyzeTaskComplexityWithAI(taskDescription)`: Sends task description to AI for complexity analysis.
+      - `expandTaskWithAI(taskDescription, numSubtasks, researchContext)`: Generates subtasks using AI.
+      - `parsePRDWithAI(prdContent)`: Extracts tasks from PRD content using AI.
 
-  - **[`src/ai-providers/*.js`](mdc:src/ai-providers/): Provider-Specific Implementations**
-    - **Purpose**: Provider-specific wrappers for Vercel AI SDK functions.
-    - **Responsibilities**: Interact directly with Vercel AI SDK adapters.
-
-  - **[`config-manager.js`](mdc:scripts/modules/config-manager.js): Configuration Management**
-    - **Purpose**: Loads, validates, and provides access to configuration.
+  - **[`utils.js`](mdc:scripts/modules/utils.js): Utility Functions and Configuration**
+    - **Purpose**: Provides reusable utility functions and global configuration settings used across the **CLI application**.
     - **Responsibilities** (See also: [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc)):
-      - Reads and merges `.taskmasterconfig` with defaults.
-      - Provides getters (e.g., `getMainProvider`, `getLogLevel`, `getDefaultSubtasks`) for accessing settings.
-      - **Note**: Does **not** store or directly handle API keys (keys are in `.env` or MCP `session.env`).
-
-  - **[`utils.js`](mdc:scripts/modules/utils.js): Core Utility Functions**
-    - **Purpose**: Low-level, reusable CLI utilities.
-    - **Responsibilities** (See also: [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc)):
-      - Logging (`log` function), File I/O (`readJSON`, `writeJSON`), String utils (`truncate`).
-      - Task utils (`findTaskById`), Dependency utils (`findCycles`).
-      - API Key Resolution (`resolveEnvVariable`).
-      - Silent Mode Control (`enableSilentMode`, `disableSilentMode`).
+      - Manages global configuration settings loaded from environment variables and defaults.
+      - Implements logging utility with different log levels and output formatting.
+      - Provides file system operation utilities (read/write JSON files).
+      - Includes string manipulation utilities (e.g., `truncate`, `sanitizePrompt`).
+      - Offers task-specific utility functions (e.g., `formatTaskId`, `findTaskById`, `taskExists`).
+      - Implements graph algorithms like cycle detection for dependency management.
+      - **Silent Mode Control**: Provides `enableSilentMode` and `disableSilentMode` functions to control log output.
+    - **Key Components**:
+      - `CONFIG`: Global configuration object.
+      - `log(level, ...args)`: Logging function.
+      - `readJSON(filepath)` / `writeJSON(filepath, data)`: File I/O utilities for JSON files.
+      - `truncate(text, maxLength)`: String truncation utility.
+      - `formatTaskId(id)` / `findTaskById(tasks, taskId)`: Task ID and search utilities.
+      - `findCycles(subtaskId, dependencyMap)`: Cycle detection algorithm.
+      - `enableSilentMode()` / `disableSilentMode()`: Control console logging output.
 
   - **[`mcp-server/`](mdc:mcp-server/): MCP Server Integration**
-    - **Purpose**: Provides MCP interface using FastMCP.
+    - **Purpose**: Provides an MCP (Model Context Protocol) interface for Task Master, allowing integration with external tools like Cursor. Uses FastMCP framework.
     - **Responsibilities** (See also: [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)):
-      - Registers tools (`mcp-server/src/tools/*.js`). Tool `execute` methods **should be wrapped** with the `withNormalizedProjectRoot` HOF (from `tools/utils.js`) to ensure consistent path handling.
-      - The HOF provides a normalized `args.projectRoot` to the `execute` method.
-      - Tool `execute` methods call **direct function wrappers** (`mcp-server/src/core/direct-functions/*.js`), passing the normalized `projectRoot` and other args.
-      - Direct functions use path utilities (`mcp-server/src/core/utils/`) to resolve paths based on `projectRoot` from session.
-      - Direct functions implement silent mode, logger wrappers, and call core logic functions from `scripts/modules/`.
-      - Manages MCP caching and response formatting.
+      - Registers Task Master functionalities as tools consumable via MCP.
+      - Handles MCP requests via tool `execute` methods defined in `mcp-server/src/tools/*.js`.
+      - Tool `execute` methods call corresponding **direct function wrappers**.
+      - Tool `execute` methods use `getProjectRootFromSession` (from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js)) to determine the project root from the client session and pass it to the direct function.
+      - **Direct function wrappers (`*Direct` functions in `mcp-server/src/core/direct-functions/*.js`) contain the main logic for handling MCP requests**, including path resolution, argument validation, caching, and calling core Task Master functions.
+      - Direct functions use `findTasksJsonPath` (from [`core/utils/path-utils.js`](mdc:mcp-server/src/core/utils/path-utils.js)) to locate `tasks.json` based on the provided `projectRoot`.
+      - **Silent Mode Implementation**: Direct functions use `enableSilentMode` and `disableSilentMode` to prevent logs from interfering with JSON responses.
+      - **Async Operations**: Uses `AsyncOperationManager` to handle long-running operations in the background.
+      - **Project Initialization**: Provides `initialize_project` command for setting up new projects from within integrated clients.
+      - Tool `execute` methods use `handleApiResult` from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) to process the result from the direct function and format the final MCP response.
+      - Uses CLI execution via `executeTaskMasterCommand` as a fallback only when necessary.
+      - **Implements Robust Path Finding**: The utility [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) (specifically `getProjectRootFromSession`) and [`core/utils/path-utils.js`](mdc:mcp-server/src/core/utils/path-utils.js) (specifically `findTasksJsonPath`) work together. The tool gets the root via session, passes it to the direct function, which uses `findTasksJsonPath` to locate the specific `tasks.json` file within that root.
+      - **Implements Caching**: Utilizes a caching layer (`ContextManager` with `lru-cache`). Caching logic is invoked *within* the direct function wrappers using the `getCachedOrExecute` utility for performance-sensitive read operations.
+      - Standardizes response formatting and data filtering using utilities in [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js).
+      - **Resource Management**: Provides access to static and dynamic resources.
+    - **Key Components**:
+      - `mcp-server/src/index.js`: Main server class definition with FastMCP initialization, resource registration, and server lifecycle management.
+      - `mcp-server/src/server.js`: Main server setup and initialization.
+      - `mcp-server/src/tools/`: Directory containing individual tool definitions. Each tool's `execute` method orchestrates the call to core logic and handles the response.
+      - `mcp-server/src/tools/utils.js`: Provides MCP-specific utilities like `handleApiResult`, `processMCPResponseData`, `getCachedOrExecute`, and **`getProjectRootFromSession`**.
+      - `mcp-server/src/core/utils/`: Directory containing utility functions specific to the MCP server, like **`path-utils.js` for resolving `tasks.json` within a given root** and **`async-manager.js` for handling background operations**.
+      - `mcp-server/src/core/direct-functions/`: Directory containing individual files for each **direct function wrapper (`*Direct`)**. These files contain the primary logic for MCP tool execution.
+      - `mcp-server/src/core/resources/`: Directory containing resource handlers for task templates, workflow definitions, and other static/dynamic data exposed to LLM clients.
+      - [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js): Acts as an import/export hub, collecting and exporting direct functions from the `direct-functions` directory and MCP utility functions.
+    - **Naming Conventions**:
+      - **Files** use **kebab-case**: `list-tasks.js`, `set-task-status.js`, `parse-prd.js`
+      - **Direct Functions** use **camelCase** with `Direct` suffix: `listTasksDirect`, `setTaskStatusDirect`, `parsePRDDirect`
+      - **Tool Registration Functions** use **camelCase** with `Tool` suffix: `registerListTasksTool`, `registerSetTaskStatusTool`
+      - **MCP Tool Names** use **snake_case**: `list_tasks`, `set_task_status`, `parse_prd_document`
+      - **Resource Handlers** use **camelCase** with pattern URI: `@mcp.resource("tasks://templates/{template_id}")`
+    - **AsyncOperationManager**:
+      - **Purpose**: Manages background execution of long-running operations.
+      - **Location**: `mcp-server/src/core/utils/async-manager.js`
+      - **Key Features**:
+        - Operation tracking with unique IDs using UUID
+        - Status management (pending, running, completed, failed)
+        - Progress reporting forwarded from background tasks
+        - Operation history with automatic cleanup of completed operations
+        - Context preservation (log, session, reportProgress)
+        - Robust error handling for background tasks
+      - **Usage**: Used for CPU-intensive operations like task expansion and PRD parsing
 
-  - **[`init.js`](mdc:scripts/init.js): Project Initialization Logic**
-    - **Purpose**: Sets up new Task Master project structure.
-    - **Responsibilities**: Creates directories, copies templates, manages `package.json`, sets up `.cursor/mcp.json`.
+- **Data Flow and Module Dependencies**:
 
-- **Data Flow and Module Dependencies (Updated)**:
-
-  - **CLI**: `bin/task-master.js` -> `scripts/dev.js` (loads `.env`) -> `scripts/modules/commands.js` -> Core Logic (`scripts/modules/*`) -> Unified AI Service (`ai-services-unified.js`) -> Provider Adapters -> LLM API.
-  - **MCP**: External Tool -> `mcp-server/server.js` -> Tool (`mcp-server/src/tools/*`) -> Direct Function (`mcp-server/src/core/direct-functions/*`) -> Core Logic (`scripts/modules/*`) -> Unified AI Service (`ai-services-unified.js`) -> Provider Adapters -> LLM API.
-  - **Configuration**: Core logic needing non-AI settings calls `config-manager.js` getters (passing `session.env` via `explicitRoot` if from MCP). Unified AI Service internally calls `config-manager.js` getters (using `role`) for AI params and `utils.js` (`resolveEnvVariable` with `session.env`) for API keys.
+  - **Commands Initiate Actions**: User commands entered via the CLI (handled by [`commands.js`](mdc:scripts/modules/commands.js)) are the entry points for most operations.
+  - **Command Handlers Delegate to Managers**: Command handlers in [`commands.js`](mdc:scripts/modules/commands.js) call functions in [`task-manager.js`](mdc:scripts/modules/task-manager.js) and [`dependency-manager.js`](mdc:scripts/modules/dependency-manager.js) to perform core task and dependency management logic.
+  - **UI for Presentation**:  [`ui.js`](mdc:scripts/modules/ui.js) is used by command handlers and task/dependency managers to display information to the user. UI functions primarily consume data and format it for output, without modifying core application state.
+  - **Utilities for Common Tasks**: [`utils.js`](mdc:scripts/modules/utils.js) provides helper functions used by all other modules for configuration, logging, file operations, and common data manipulations.
+  - **AI Services Integration**: AI functionalities (complexity analysis, task expansion, PRD parsing) are invoked from [`task-manager.js`](mdc:scripts/modules/task-manager.js) and potentially [`commands.js`](mdc:scripts/modules/commands.js), likely using functions that would reside in a dedicated `ai-services.js` module or be integrated within `utils.js` or `task-manager.js`.
+  - **MCP Server Interaction**: External tools interact with the `mcp-server`. MCP Tool `execute` methods use `getProjectRootFromSession` to find the project root, then call direct function wrappers (in `mcp-server/src/core/direct-functions/`) passing the root in `args`. These wrappers handle path finding for `tasks.json` (using `path-utils.js`), validation, caching, call the core logic from `scripts/modules/` (passing logging context via the standard wrapper pattern detailed in mcp.mdc), and return a standardized result. The final MCP response is formatted by `mcp-server/src/tools/utils.js`. See [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) for details.
 
 ## Silent Mode Implementation Pattern in MCP Direct Functions
 
@@ -279,8 +353,19 @@ The `initialize_project` command provides a way to set up a new Task Master proj
   - Configures project metadata (name, description, version)
   - Handles shell alias creation if requested
   - Works in both interactive and non-interactive modes
-  - Creates necessary directories and files for a new project
-  - Sets up `tasks.json` and initial task files
-  - Configures project metadata (name, description, version)
-  - Handles shell alias creation if requested
-  - Works in both interactive and non-interactive modes
+
+## Async Operation Management
+
+The AsyncOperationManager provides background task execution capabilities:
+
+- **Location**: `mcp-server/src/core/utils/async-manager.js`
+- **Key Components**:
+  - `asyncOperationManager` singleton instance
+  - `addOperation(operationFn, args, context)` method
+  - `getStatus(operationId)` method
+- **Usage Flow**:
+  1. Client calls an MCP tool that may take time to complete
+  2. Tool uses AsyncOperationManager to run the operation in background
+  3. Tool returns immediate response with operation ID
+  4. Client polls `get_operation_status` tool with the ID
+  5. Once completed, client can access operation results

.cursor/rules/commands.mdc

@@ -24,7 +24,7 @@ While this document details the implementation of Task Master's **CLI commands**
   programInstance
     .command('command-name')
     .description('Clear, concise description of what the command does')
-    .option('-o, --option <value>', 'Option description', 'default value')
+    .option('-s, --short-option <value>', 'Option description', 'default value')
     .option('--long-option <value>', 'Option description')
     .action(async (options) => {
       // Command implementation
@@ -34,8 +34,7 @@ While this document details the implementation of Task Master's **CLI commands**
 - **Command Handler Organization**:
   - ✅ DO: Keep action handlers concise and focused
   - ✅ DO: Extract core functionality to appropriate modules
-  - ✅ DO: Have the action handler import and call the relevant functions from core modules, like `task-manager.js` or `init.js`, passing the parsed `options`.
-  - ✅ DO: Perform basic parameter validation, such as checking for required options, within the action handler or at the start of the called core function.
+  - ✅ DO: Include validation for required parameters
   - ❌ DON'T: Implement business logic in command handlers
 
 ## Best Practices for Removal/Delete Commands
@@ -44,7 +43,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
 
 - **Confirmation Prompts**:
   - ✅ **DO**: Include a confirmation prompt by default for destructive operations
-  - ✅ **DO**: Provide a `--yes` or `-y` flag to skip confirmation, useful for scripting or automation
+  - ✅ **DO**: Provide a `--yes` or `-y` flag to skip confirmation for scripting/automation
   - ✅ **DO**: Show what will be deleted in the confirmation message
   - ❌ **DON'T**: Perform destructive operations without user confirmation unless explicitly overridden
 
@@ -78,7 +77,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
 
 - **File Path Handling**:
   - ✅ **DO**: Use `path.join()` to construct file paths
-  - ✅ **DO**: Follow established naming conventions for tasks, like `task_001.txt`
+  - ✅ **DO**: Follow established naming conventions for tasks (e.g., `task_001.txt`)
   - ✅ **DO**: Check if files exist before attempting to delete them
   - ✅ **DO**: Handle file deletion errors gracefully
   - ❌ **DON'T**: Construct paths with string concatenation
@@ -166,10 +165,10 @@ When implementing commands that delete or remove data (like `remove-task` or `re
   - ✅ DO: Use descriptive, action-oriented names
 
 - **Option Names**:
-  - ✅ DO: Use kebab-case for long-form option names, like `--output-format`
-  - ✅ DO: Provide single-letter shortcuts when appropriate, like `-f, --file`
+  - ✅ DO: Use kebab-case for long-form option names (`--output-format`)
+  - ✅ DO: Provide single-letter shortcuts when appropriate (`-f, --file`)
   - ✅ DO: Use consistent option names across similar commands
-  - ❌ DON'T: Use different names for the same concept, such as `--file` in one command and `--path` in another
+  - ❌ DON'T: Use different names for the same concept (`--file` in one command, `--path` in another)
 
   ```javascript
   // ✅ DO: Use consistent option naming
@@ -181,7 +180,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
   .option('-p, --path <dir>', 'Output directory') // Should be --output
   ```
 
-  > **Note**: Although options are defined with kebab-case, like `--num-tasks`, Commander.js stores them internally as camelCase properties. Access them in code as `options.numTasks`, not `options['num-tasks']`.
+  > **Note**: Although options are defined with kebab-case (`--num-tasks`), Commander.js stores them internally as camelCase properties. Access them in code as `options.numTasks`, not `options['num-tasks']`.
 
 - **Boolean Flag Conventions**:
   - ✅ DO: Use positive flags with `--skip-` prefix for disabling behavior
@@ -210,7 +209,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
 - **Required Parameters**:
   - ✅ DO: Check that required parameters are provided
   - ✅ DO: Provide clear error messages when parameters are missing
-  - ✅ DO: Use early returns with `process.exit(1)` for validation failures
+  - ✅ DO: Use early returns with process.exit(1) for validation failures
 
   ```javascript
   // ✅ DO: Validate required parameters early
@@ -221,7 +220,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
   ```
 
 - **Parameter Type Conversion**:
-  - ✅ DO: Convert string inputs to appropriate types, such as numbers or booleans
+  - ✅ DO: Convert string inputs to appropriate types (numbers, booleans)
   - ✅ DO: Handle conversion errors gracefully
 
   ```javascript
@@ -254,7 +253,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
   const taskId = parseInt(options.id, 10);
   if (isNaN(taskId) || taskId <= 0) {
     console.error(chalk.red(`Error: Invalid task ID: ${options.id}. Task ID must be a positive integer.`));
-    console.log(chalk.yellow("Usage example: task-master update-task --id='23' --prompt='Update with new information.\\nEnsure proper error handling.'"));
+    console.log(chalk.yellow('Usage example: task-master update-task --id=\'23\' --prompt=\'Update with new information.\nEnsure proper error handling.\''));
     process.exit(1);
   }
   
@@ -392,9 +391,9 @@ When implementing commands that delete or remove data (like `remove-task` or `re
   process.on('uncaughtException', (err) => {
     // Handle Commander-specific errors
     if (err.code === 'commander.unknownOption') {
-      const option = err.message.match(/'([^']+)'/)?.[1]; // Safely extract option name
+      const option = err.message.match(/'([^']+)'/)?.[1];
       console.error(chalk.red(`Error: Unknown option '${option}'`));
-      console.error(chalk.yellow("Run 'task-master <command> --help' to see available options"));
+      console.error(chalk.yellow(`Run 'task-master <command> --help' to see available options`));
       process.exit(1);
     }
     
@@ -464,9 +463,9 @@ When implementing commands that delete or remove data (like `remove-task` or `re
     .option('-f, --file <path>', 'Path to the tasks file', 'tasks/tasks.json')
     .option('-p, --parent <id>', 'ID of the parent task (required)')
     .option('-i, --task-id <id>', 'Existing task ID to convert to subtask')
-    .option('-t, --title <title>', 'Title for the new subtask, required if not converting')
-    .option('-d, --description <description>', 'Description for the new subtask, optional')
-    .option('--details <details>', 'Implementation details for the new subtask, optional')
+    .option('-t, --title <title>', 'Title for the new subtask (when not converting)')
+    .option('-d, --description <description>', 'Description for the new subtask (when not converting)')
+    .option('--details <details>', 'Implementation details for the new subtask (when not converting)')
     .option('--dependencies <ids>', 'Comma-separated list of subtask IDs this subtask depends on')
     .option('--status <status>', 'Initial status for the subtask', 'pending')
     .option('--skip-generate', 'Skip regenerating task files')
@@ -489,8 +488,8 @@ When implementing commands that delete or remove data (like `remove-task` or `re
     .command('remove-subtask')
     .description('Remove a subtask from its parent task, optionally converting it to a standalone task')
     .option('-f, --file <path>', 'Path to the tasks file', 'tasks/tasks.json')
-    .option('-i, --id <id>', 'ID of the subtask to remove in format parentId.subtaskId, required')
-    .option('-c, --convert', 'Convert the subtask to a standalone task instead of deleting')
+    .option('-i, --id <id>', 'ID of the subtask to remove in format "parentId.subtaskId" (required)')
+    .option('-c, --convert', 'Convert the subtask to a standalone task')
     .option('--skip-generate', 'Skip regenerating task files')
     .action(async (options) => {
       // Implementation with detailed error handling
@@ -513,8 +512,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
   // ✅ DO: Implement version checking function
   async function checkForUpdate() {
     // Implementation details...
-    // Example return structure:
-    return { currentVersion, latestVersion, updateAvailable };
+    return { currentVersion, latestVersion, needsUpdate };
   }
   
   // ✅ DO: Implement semantic version comparison
@@ -554,7 +552,7 @@ When implementing commands that delete or remove data (like `remove-task` or `re
       
       // After command execution, check if an update is available
       const updateInfo = await updateCheckPromise;
-      if (updateInfo.updateAvailable) {
+      if (updateInfo.needsUpdate) {
         displayUpgradeNotification(updateInfo.currentVersion, updateInfo.latestVersion);
       }
     } catch (error) {

.cursor/rules/dev_workflow.mdc

@@ -3,6 +3,7 @@ description: Guide for using Task Master to manage task-driven development workf
 globs: **/*
 alwaysApply: true
 ---
+
 # Task Master Development Workflow
 
 This guide outlines the typical process for using Task Master to manage software development projects.
@@ -28,55 +29,53 @@ Task Master offers two primary ways to interact:
 
 ## Standard Development Workflow Process
 
--   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`](mdc:.cursor/rules/taskmaster.mdc)) to generate initial tasks.json
+-   Start new projects by running `init` tool / `task-master init` or `parse_prd` / `task-master parse-prd --input='<prd-file.txt>'` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to generate initial tasks.json
 -   Begin coding sessions with `get_tasks` / `task-master list` (see [`taskmaster.mdc`](mdc:.cursor/rules/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`](mdc:.cursor/rules/taskmaster.mdc)).
--   Analyze task complexity with `analyze_project_complexity` / `task-master analyze-complexity --research` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) before breaking down tasks
+-   Analyze task complexity with `analyze_complexity` / `task-master analyze-complexity --research` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) before breaking down tasks
 -   Review complexity report using `complexity_report` / `task-master complexity-report` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
 -   Select tasks based on dependencies (all marked 'done'), priority level, and ID order
 -   Clarify tasks by checking task files in tasks/ directory or asking for user input
 -   View specific task details using `get_task` / `task-master show <id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to understand implementation requirements
--   Break down complex tasks using `expand_task` / `task-master expand --id=<id> --force --research` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) with appropriate flags like `--force` (to replace existing subtasks) and `--research`.
+-   Break down complex tasks using `expand_task` / `task-master expand --id=<id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) with appropriate flags
 -   Clear existing subtasks if needed using `clear_subtasks` / `task-master clear-subtasks --id=<id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) before regenerating
 -   Implement code following task details, dependencies, and project standards
 -   Verify tasks according to test strategies before marking as complete (See [`tests.mdc`](mdc:.cursor/rules/tests.mdc))
 -   Mark completed tasks with `set_task_status` / `task-master set-status --id=<id> --status=done` (see [`taskmaster.mdc`](mdc:.cursor/rules/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`](mdc:.cursor/rules/taskmaster.mdc))
--   Add new tasks discovered during implementation using `add_task` / `task-master add-task --prompt="..." --research` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
+-   Add new tasks discovered during implementation using `add_task` / `task-master add-task --prompt="..."` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
 -   Add new subtasks as needed using `add_subtask` / `task-master add-subtask --parent=<id> --title="..."` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
 -   Append notes or details to subtasks using `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='Add implementation notes here...\nMore details...'` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
 -   Generate task files with `generate` / `task-master generate` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) after updating tasks.json
 -   Maintain valid dependency structure with `add_dependency`/`remove_dependency` tools or `task-master add-dependency`/`remove-dependency` commands, `validate_dependencies` / `task-master validate-dependencies`, and `fix_dependencies` / `task-master fix-dependencies` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) when needed
 -   Respect dependency chains and task priorities when selecting work
 -   Report progress regularly using `get_tasks` / `task-master list`
--   Reorganize tasks as needed using `move_task` / `task-master move --from=<id> --to=<id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to change task hierarchy or ordering
 
 ## Task Complexity Analysis
 
--   Run `analyze_project_complexity` / `task-master analyze-complexity --research` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) for comprehensive analysis
+-   Run `analyze_complexity` / `task-master analyze-complexity --research` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) for comprehensive analysis
 -   Review complexity report via `complexity_report` / `task-master complexity-report` (see [`taskmaster.mdc`](mdc:.cursor/rules/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
+-   Note that reports are automatically used by the `expand` 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>`.
+-   For tasks with complexity analysis, use `expand_task` / `task-master expand --id=<id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc))
+-   Otherwise use `expand_task` / `task-master expand --id=<id> --num=<number>`
+-   Add `--research` flag to leverage Perplexity AI for research-backed expansion
+-   Use `--prompt="<context>"` to provide additional context when needed
+-   Review and adjust generated subtasks as necessary
+-   Use `--all` flag with `expand` or `expand_all` to expand multiple pending tasks at once
+-   If subtasks need regeneration, clear them first with `clear_subtasks` / `task-master clear-subtasks` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
 
 ## 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.
+-   Use `update` / `task-master update --from=<futureTaskId> --prompt='<explanation>\nUpdate context...'` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to update multiple future tasks.
+-   Use `update_task` / `task-master update-task --id=<taskId> --prompt='<explanation>\nUpdate context...'` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to update a single specific task.
 
 ## Task Status Management
 
@@ -98,32 +97,28 @@ Task Master offers two primary ways to interact:
 - **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`).
+- Refer to [`tasks.mdc`](mdc:.cursor/rules/tasks.mdc) for more details on the task data structure.
 
-## Configuration Management (Updated)
+## Environment Variables Configuration
 
-Taskmaster configuration is managed through two main mechanisms:
-
-1.  **`.taskmasterconfig` 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.
-    *   **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.
-
-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`).
-
-**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.
+- Task Master behavior is configured via environment variables:
+  - **ANTHROPIC_API_KEY** (Required): Your Anthropic API key for Claude.
+  - **MODEL**: Claude model to use (e.g., `claude-3-opus-20240229`).
+  - **MAX_TOKENS**: Maximum tokens for AI responses.
+  - **TEMPERATURE**: Temperature for AI model responses.
+  - **DEBUG**: Enable debug logging (`true`/`false`).
+  - **LOG_LEVEL**: Console output level (`debug`, `info`, `warn`, `error`).
+  - **DEFAULT_SUBTASKS**: Default number of subtasks for `expand`.
+  - **DEFAULT_PRIORITY**: Default priority for new tasks.
+  - **PROJECT_NAME**: Project name used in metadata.
+  - **PROJECT_VERSION**: Project version used in metadata.
+  - **PERPLEXITY_API_KEY**: API key for Perplexity AI (for `--research` flags).
+  - **PERPLEXITY_MODEL**: Perplexity model to use (e.g., `sonar-medium-online`).
+- See [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc) for default values and examples.
 
 ## Determining the Next Task
 
-- Run `next_task` / `task-master next` to show the next task to work on.
+- Run `next_task` / `task-master next` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) 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:
@@ -138,7 +133,7 @@ Taskmaster configuration is managed through two main mechanisms:
 
 ## Viewing Specific Task Details
 
-- Run `get_task` / `task-master show <id>` to view a specific task.
+- Run `get_task` / `task-master show <id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) 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
@@ -148,32 +143,13 @@ Taskmaster configuration is managed through two main mechanisms:
 
 ## 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.
+- Use `add_dependency` / `task-master add-dependency --id=<id> --depends-on=<id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) to add a dependency
+- Use `remove_dependency` / `task-master remove-dependency --id=<id> --depends-on=<id>` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)) 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:
@@ -188,14 +164,14 @@ Once a task has been broken down into subtasks using `expand_task` or similar me
     *   Gather *all* relevant details from this exploration phase.
 
 3.  **Log the Plan:**
-    *   Run `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<detailed plan>'`.
+    *   Run `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<detailed plan>'` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
     *   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`.
+    *   Set the subtask status using `set_task_status` / `task-master set-status --id=<subtaskId> --status=in-progress` (see [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc)).
     *   Start coding based on the logged plan.
 
 6.  **Refine and Log Progress (Iteration 2+):**
@@ -213,7 +189,7 @@ Once a task has been broken down into subtasks using `expand_task` or similar me
 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`).
+    *   Create new or update existing Cursor rules in the `.cursor/rules/` directory to capture these patterns, following the guidelines in [`cursor_rules.mdc`](mdc:.cursor/rules/cursor_rules.mdc) and [`self_improve.mdc`](mdc:.cursor/rules/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`.
@@ -222,10 +198,10 @@ Once a task has been broken down into subtasks using `expand_task` or similar me
     *   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.
+    *   Consider if a Changeset is needed according to [`changeset.mdc`](mdc:.cursor/rules/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`).
+    *   Identify the next subtask in the dependency chain (e.g., using `next_task` / `task-master next`) and repeat this iterative process starting from step 1.
 
 ## Code Analysis & Refactoring Techniques
 

.cursor/rules/glossary.mdc

@@ -3,6 +3,7 @@ description: Glossary of other Cursor rules
 globs: **/*
 alwaysApply: true
 ---
+
 # Glossary of Task Master Cursor Rules
 
 This file provides a quick reference to the purpose of each rule file located in the `.cursor/rules` directory.
@@ -22,5 +23,4 @@ This file provides a quick reference to the purpose of each rule file located in
 - **[`tests.mdc`](mdc:.cursor/rules/tests.mdc)**: Guidelines for implementing and maintaining tests for Task Master CLI.
 - **[`ui.mdc`](mdc:.cursor/rules/ui.mdc)**: Guidelines for implementing and maintaining user interface components.
 - **[`utilities.mdc`](mdc:.cursor/rules/utilities.mdc)**: Guidelines for implementing utility functions.
-- **[`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc)**: Guidelines for integrating AI usage telemetry across Task Master.
 

.cursor/rules/mcp.mdc

@@ -3,6 +3,7 @@ description: Guidelines for implementing and interacting with the Task Master MC
 globs: mcp-server/src/**/*, scripts/modules/**/*
 alwaysApply: false
 ---
+
 # Task Master MCP Server Guidelines
 
 This document outlines the architecture and implementation patterns for the Task Master Model Context Protocol (MCP) server, designed for integration with tools like Cursor.
@@ -89,54 +90,69 @@ When implementing a new direct function in `mcp-server/src/core/direct-functions
      ```
 
 5. **Handling Logging Context (`mcpLog`)**:
-   - **Requirement**: Core functions (like those in `task-manager.js`) may accept an `options` object containing an optional `mcpLog` property. If provided, the core function expects this object to have methods like `mcpLog.info(...)`, `mcpLog.error(...)`.
-   - **Solution: The Logger Wrapper Pattern**: When calling a core function from a direct function, pass the `log` object provided by FastMCP *wrapped* in the standard `logWrapper` object. This ensures the core function receives a logger with the expected method structure.
+   - **Requirement**: Core functions that use the internal `report` helper function (common in `task-manager.js`, `dependency-manager.js`, etc.) expect the `options` object to potentially contain an `mcpLog` property. This `mcpLog` object **must** have callable methods for each log level (e.g., `mcpLog.info(...)`, `mcpLog.error(...)`).
+   - **Challenge**: The `log` object provided by FastMCP to the direct function's context, while functional, might not perfectly match this expected structure or could change in the future. Passing it directly can lead to runtime errors like `mcpLog[level] is not a function`.
+   - **Solution: The Logger Wrapper Pattern**: To reliably bridge the FastMCP `log` object and the core function's `mcpLog` expectation, use a simple wrapper object within the direct function:
      ```javascript
      // Standard logWrapper pattern within a Direct Function
      const logWrapper = {
        info: (message, ...args) => log.info(message, ...args),
        warn: (message, ...args) => log.warn(message, ...args),
        error: (message, ...args) => log.error(message, ...args),
-       debug: (message, ...args) => log.debug && log.debug(message, ...args),
-       success: (message, ...args) => log.info(message, ...args)
+       debug: (message, ...args) => log.debug && log.debug(message, ...args), // Handle optional debug
+       success: (message, ...args) => log.info(message, ...args) // Map success to info if needed
      };
 
      // ... later when calling the core function ...
      await coreFunction(
        // ... other arguments ...
+       tasksPath, 
+       taskId,
        { 
          mcpLog: logWrapper, // Pass the wrapper object
-         session // Also pass session if needed by core logic or AI service
+         session 
        },
        'json' // Pass 'json' output format if supported by core function
      );
      ```
-   - **JSON Output**: Passing `mcpLog` (via the wrapper) often triggers the core function to use a JSON-friendly output format, suppressing spinners/boxes.
-   - ✅ **DO**: Implement this pattern in direct functions calling core functions that might use `mcpLog`.
+   - **Critical For JSON Output Format**: Passing the `logWrapper` as `mcpLog` serves a dual purpose:
+     1. **Prevents Runtime Errors**: It ensures the `mcpLog[level](...)` calls within the core function succeed
+     2. **Controls Output Format**: In functions like `updateTaskById` and `updateSubtaskById`, the presence of `mcpLog` in the options triggers setting `outputFormat = 'json'` (instead of 'text'). This prevents UI elements (spinners, boxes) from being generated, which would break the JSON response.
+   - **Proven Solution**: This pattern has successfully fixed multiple issues in our MCP tools (including `update-task` and `update-subtask`), where direct passing of the `log` object or omitting `mcpLog` led to either runtime errors or JSON parsing failures from UI output.
+   - **When To Use**: Implement this wrapper in any direct function that calls a core function with an `options` object that might use `mcpLog` for logging or output format control.
+   - **Why it Works**: The `logWrapper` explicitly defines the `.info()`, `.warn()`, `.error()`, etc., methods that the core function's `report` helper needs, ensuring the `mcpLog[level](...)` call succeeds. It simply forwards the logging calls to the actual FastMCP `log` object.
+   - **Combined with Silent Mode**: Remember that using the `logWrapper` for `mcpLog` is **necessary *in addition* to using `enableSilentMode()` / `disableSilentMode()`** (see next point). The wrapper handles structured logging *within* the core function, while silent mode suppresses direct `console.log` and UI elements (spinners, boxes) that would break the MCP JSON response.
 
 6. **Silent Mode Implementation**:
-    - ✅ **DO**: Import silent mode utilities: `import { enableSilentMode, disableSilentMode, isSilentMode } from '../../../../scripts/modules/utils.js';`
-    - ✅ **DO**: Wrap core function calls *within direct functions* using `enableSilentMode()` / `disableSilentMode()` in a `try/finally` block if the core function might produce console output (spinners, boxes, direct `console.log`) that isn't reliably controlled by passing `{ mcpLog }` or an `outputFormat` parameter.
-    - ✅ **DO**: Always disable silent mode in the `finally` block.
-    - ❌ **DON'T**: Wrap calls to the unified AI service (`generateTextService`, `generateObjectService`) in silent mode; their logging is handled internally.
-    - **Example (Direct Function Guaranteeing Silence & using Log Wrapper)**:
+    - ✅ **DO**: Import silent mode utilities at the top: `import { enableSilentMode, disableSilentMode, isSilentMode } from '../../../../scripts/modules/utils.js';`
+    - ✅ **DO**: Ensure core Task Master functions called from direct functions do **not** pollute `stdout` with console output (banners, spinners, logs) that would break MCP's JSON communication.
+      - **Preferred**: Modify the core function to accept an `outputFormat: 'json'` parameter and check it internally before printing UI elements. Pass `'json'` from the direct function.
+      - **Required Fallback/Guarantee**: If the core function cannot be modified or its output suppression is unreliable, **wrap the core function call** within the direct function using `enableSilentMode()` / `disableSilentMode()` in a `try/finally` block. This guarantees no console output interferes with the MCP response.
+    - ✅ **DO**: Use `isSilentMode()` function to check global silent mode status if needed (rare in direct functions), NEVER access the global `silentMode` variable directly.
+    - ❌ **DON'T**: Wrap AI client initialization or AI API calls in `enable/disableSilentMode`; their logging is controlled via the `log` object (passed potentially within the `logWrapper` for core functions).
+    - ❌ **DON'T**: Assume a core function is silent just because it *should* be. Verify or use the `enable/disableSilentMode` wrapper.
+    - **Example (Direct Function Guaranteeing Silence and using Log Wrapper)**:
       ```javascript
       export async function coreWrapperDirect(args, log, context = {}) {
         const { session } = context;
         const tasksPath = findTasksJsonPath(args, log);
-        const logWrapper = { /* ... */ };
+        
+        // Create the logger wrapper
+        const logWrapper = { /* ... as defined above ... */ };
 
         enableSilentMode(); // Ensure silence for direct console output
         try {
+          // Call core function, passing wrapper and 'json' format
           const result = await coreFunction(
              tasksPath, 
              args.param1, 
-             { mcpLog: logWrapper, session }, // Pass context
-             'json' // Request JSON format if supported
+             { mcpLog: logWrapper, session }, 
+             'json' // Explicitly request JSON format if supported
           ); 
           return { success: true, data: result };
         } catch (error) {
            log.error(`Error: ${error.message}`);
+           // Return standardized error object
            return { success: false, error: { /* ... */ } };
         } finally {
            disableSilentMode(); // Critical: Always disable in finally
@@ -147,6 +163,32 @@ When implementing a new direct function in `mcp-server/src/core/direct-functions
 7. **Debugging MCP/Core Logic Interaction**:
     - ✅ **DO**: If an MCP tool fails with unclear errors (like JSON parsing failures), run the equivalent `task-master` CLI command in the terminal. The CLI often provides more detailed error messages originating from the core logic (e.g., `ReferenceError`, stack traces) that are obscured by the MCP layer.
 
+### Specific Guidelines for AI-Based Direct Functions
+
+Direct functions that interact with AI (e.g., `addTaskDirect`, `expandTaskDirect`) have additional responsibilities:
+
+- **Context Parameter**: These functions receive an additional `context` object as their third parameter. **Critically, this object should only contain `{ session }`**. Do NOT expect or use `reportProgress` from this context.
+  ```javascript
+  export async function yourAIDirect(args, log, context = {}) {
+    const { session } = context; // Only expect session
+    // ...
+  }
+  ```
+- **AI Client Initialization**:
+  - ✅ **DO**: Use the utilities from [`mcp-server/src/core/utils/ai-client-utils.js`](mdc:mcp-server/src/core/utils/ai-client-utils.js) (e.g., `getAnthropicClientForMCP(session, log)`) to get AI client instances. These correctly use the `session` object to resolve API keys.
+  - ✅ **DO**: Wrap client initialization in a try/catch block and return a specific `AI_CLIENT_ERROR` on failure.
+- **AI Interaction**:
+  - ✅ **DO**: Build prompts using helper functions where appropriate (e.g., from `ai-prompt-helpers.js`).
+  - ✅ **DO**: Make the AI API call using appropriate helpers (e.g., `_handleAnthropicStream`). Pass the `log` object to these helpers for internal logging. **Do NOT pass `reportProgress`**.
+  - ✅ **DO**: Parse the AI response using helpers (e.g., `parseTaskJsonResponse`) and handle parsing errors with a specific code (e.g., `RESPONSE_PARSING_ERROR`).
+- **Calling Core Logic**:
+  - ✅ **DO**: After successful AI interaction, call the relevant core Task Master function (from `scripts/modules/`) if needed (e.g., `addTaskDirect` calls `addTask`).
+  - ✅ **DO**: Pass necessary data, including potentially the parsed AI results, to the core function.
+  - ✅ **DO**: If the core function can produce console output, call it with an `outputFormat: 'json'` argument (or similar, depending on the function) to suppress CLI output. Ensure the core function is updated to respect this. Use `enableSilentMode/disableSilentMode` around the core function call as a fallback if `outputFormat` is not supported or insufficient.
+- **Progress Indication**:
+  - ❌ **DON'T**: Call `reportProgress` within the direct function.
+  - ✅ **DO**: If intermediate progress status is needed *within* the long-running direct function, use standard logging: `log.info('Progress: Processing AI response...')`.
+
 ## Tool Definition and Execution
 
 ### Tool Structure
@@ -179,78 +221,151 @@ server.addTool({
 The `execute` function receives validated arguments and the FastMCP context:
 
 ```javascript
+// Standard signature
+execute: async (args, context) => {
+  // Tool implementation
+}
+
 // Destructured signature (recommended)
-execute: async (args, { log, session }) => {
+execute: async (args, { log, reportProgress, session }) => {
   // Tool implementation
 }
 ```
 
-- **args**: Validated parameters.
-- **context**: Contains `{ log, session }` from FastMCP. (Removed `reportProgress`).
+- **args**: The first parameter contains all the validated parameters defined in the tool's schema.
+- **context**: The second parameter is an object containing `{ log, reportProgress, session }` provided by FastMCP.
+  - ✅ **DO**: Use `{ log, session }` when calling direct functions.
+  - ⚠️ **WARNING**: Avoid passing `reportProgress` down to direct functions due to client compatibility issues. See Progress Reporting Convention below.
 
-### Standard Tool Execution Pattern with Path Normalization (Updated)
+### Standard Tool Execution Pattern
 
-To ensure consistent handling of project paths across different client environments (Windows, macOS, Linux, WSL) and input formats (e.g., `file:///...`, URI encoded paths), all MCP tool `execute` methods that require access to the project root **MUST** be wrapped with the `withNormalizedProjectRoot` Higher-Order Function (HOF).
+The `execute` method within each MCP tool (in `mcp-server/src/tools/*.js`) should follow this standard pattern:
 
-This HOF, defined in [`mcp-server/src/tools/utils.js`](mdc:mcp-server/src/tools/utils.js), performs the following before calling the tool's core logic:
+1.  **Log Entry**: Log the start of the tool execution with relevant arguments.
+2.  **Get Project Root**: Use the `getProjectRootFromSession(session, log)` utility (from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js)) to extract the project root path from the client session. Fall back to `args.projectRoot` if the session doesn't provide a root.
+3.  **Call Direct Function**: Invoke the corresponding `*Direct` function wrapper (e.g., `listTasksDirect` from [`task-master-core.js`](mdc:mcp-server/src/core/task-master-core.js)), passing an updated `args` object that includes the resolved `projectRoot`. Crucially, the third argument (context) passed to the direct function should **only include `{ log, session }`**. **Do NOT pass `reportProgress`**.
+    ```javascript
+    // Example call to a non-AI direct function
+    const result = await someDirectFunction({ ...args, projectRoot }, log); 
     
-1.  **Determines the Raw Root:** It prioritizes `args.projectRoot` if provided by the client, otherwise it calls `getRawProjectRootFromSession` to extract the path from the session.
-2.  **Normalizes the Path:** It uses the `normalizeProjectRoot` helper to decode URIs, strip `file://` prefixes, fix potential Windows drive letter prefixes (e.g., `/C:/`), convert backslashes (`\`) to forward slashes (`/`), and resolve the path to an absolute path suitable for the server's OS.
-3.  **Injects Normalized Path:** It updates the `args` object by replacing the original `projectRoot` (or adding it) with the normalized, absolute path.
-4.  **Executes Original Logic:** It calls the original `execute` function body, passing the updated `args` object.
-
-**Implementation Example:**
+    // Example call to an AI-based direct function
+    const resultAI = await someAIDirect({ ...args, projectRoot }, log, { session }); 
+    ```
+4.  **Handle Result**: Receive the result object (`{ success, data/error, fromCache }`) from the `*Direct` function.
+5.  **Format Response**: Pass this result object to the `handleApiResult` utility (from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js)) for standardized MCP response formatting and error handling.
+6.  **Return**: Return the formatted response object provided by `handleApiResult`.
 
 ```javascript
-// In mcp-server/src/tools/your-tool.js
-import {
-    handleApiResult,
-    createErrorResponse,
-    withNormalizedProjectRoot // <<< Import HOF
-} from './utils.js';
-import { yourDirectFunction } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js'; // If needed
+// Example execute method structure for a tool calling an AI-based direct function
+import { getProjectRootFromSession, handleApiResult, createErrorResponse } from './utils.js';
+import { someAIDirectFunction } from '../core/task-master-core.js';
 
-export function registerYourTool(server) {
-    server.addTool({
-        name: "your_tool",
-        description: "...".
-        parameters: z.object({
-            // ... other parameters ...
-            projectRoot: z.string().optional().describe('...') // projectRoot is optional here, HOF handles fallback
-        }),
-        // Wrap the entire execute function
-        execute: withNormalizedProjectRoot(async (args, { log, session }) => {
-            // args.projectRoot is now guaranteed to be normalized and absolute
-            const { /* other args */, projectRoot } = args;
+// ... inside server.addTool({...})
+execute: async (args, { log, session }) => { // Note: reportProgress is omitted here
+  try {
+    log.info(`Starting AI tool execution with args: ${JSON.stringify(args)}`);
 
-            try {
-                log.info(`Executing your_tool with normalized root: ${projectRoot}`);
+    // 1. Get Project Root
+    let rootFolder = getProjectRootFromSession(session, log);
+    if (!rootFolder && args.projectRoot) { // Fallback if needed
+      rootFolder = args.projectRoot;
+      log.info(`Using project root from args as fallback: ${rootFolder}`);
+    }
 
-                // Resolve paths using the normalized projectRoot
-                let tasksPath = findTasksJsonPath({ projectRoot, file: args.file }, log);
+    // 2. Call AI-Based Direct Function (passing only log and session in context)
+    const result = await someAIDirectFunction({
+      ...args,
+      projectRoot: rootFolder // Ensure projectRoot is explicitly passed
+    }, log, { session }); // Pass session here, NO reportProgress
 
-                // Call direct function, passing normalized projectRoot if needed by direct func
-                const result = await yourDirectFunction(
-                    {
-                        /* other args */,
-                        projectRoot // Pass it if direct function needs it
-                    },
-                    log,
-                    { session }
-                );
+    // 3. Handle and Format Response
+    return handleApiResult(result, log);
 
-                return handleApiResult(result, log);
-            } catch (error) {
-                log.error(`Error in your_tool: ${error.message}`);
-                return createErrorResponse(error.message);
-            }
-        }) // End HOF wrap
-    });
+  } catch (error) {
+    log.error(`Error during AI tool execution: ${error.message}`);
+    return createErrorResponse(error.message);
+  }
 }
 ```
 
-By using this HOF, the core logic within the `execute` method and any downstream functions (like `findTasksJsonPath` or direct functions) can reliably expect `args.projectRoot` to be a clean, absolute path suitable for the server environment.
+### Using AsyncOperationManager for Background Tasks
+
+For tools that execute potentially long-running operations *where the AI call is just one part* (e.g., `expand-task`, `update`), use the AsyncOperationManager. The `add-task` command, as refactored, does *not* require this in the MCP tool layer because the direct function handles the primary AI work and returns the final result synchronously from the perspective of the MCP tool.
+
+For tools that *do* use `AsyncOperationManager`:
+
+```javascript
+import { AsyncOperationManager } from '../utils/async-operation-manager.js'; // Correct path assuming utils location
+import { getProjectRootFromSession, createContentResponse, createErrorResponse } from './utils.js';
+import { someIntensiveDirect } from '../core/task-master-core.js';
+
+// ... inside server.addTool({...})
+execute: async (args, { log, session }) => { // Note: reportProgress omitted
+  try {
+    log.info(`Starting background operation with args: ${JSON.stringify(args)}`);
+
+    // 1. Get Project Root
+    let rootFolder = getProjectRootFromSession(session, log);
+    if (!rootFolder && args.projectRoot) {
+      rootFolder = args.projectRoot;
+      log.info(`Using project root from args as fallback: ${rootFolder}`);
+    }
+    
+    // Create operation description
+    const operationDescription = `Expanding task ${args.id}...`; // Example
+
+    // 2. Start async operation using AsyncOperationManager
+    const operation = AsyncOperationManager.createOperation(
+      operationDescription,
+      async (reportProgressCallback) => { // This callback is provided by AsyncOperationManager
+        // This runs in the background
+        try {
+          // Report initial progress *from the manager's callback*
+          reportProgressCallback({ progress: 0, status: 'Starting operation...' });
+
+          // Call the direct function (passing only session context)
+          const result = await someIntensiveDirect(
+            { ...args, projectRoot: rootFolder }, 
+            log, 
+            { session } // Pass session, NO reportProgress
+          );
+
+          // Report final progress *from the manager's callback*
+          reportProgressCallback({
+            progress: 100,
+            status: result.success ? 'Operation completed' : 'Operation failed',
+            result: result.data, // Include final data if successful
+            error: result.error   // Include error object if failed
+          });
+
+          return result; // Return the direct function's result
+        } catch (error) {
+          // Handle errors within the async task
+           reportProgressCallback({
+            progress: 100,
+            status: 'Operation failed critically',
+            error: { message: error.message, code: error.code || 'ASYNC_OPERATION_FAILED' }
+          });
+          throw error; // Re-throw for the manager to catch
+        }
+      }
+    );
+
+    // 3. Return immediate response with operation ID
+    return {
+        status: 202, // StatusCodes.ACCEPTED
+        body: {
+            success: true,
+            message: 'Operation started',
+            operationId: operation.id
+        }
+    };
+  } catch (error) {
+    log.error(`Error starting background operation: ${error.message}`);
+    return createErrorResponse(`Failed to start operation: ${error.message}`); // Use standard error response
+  }
+}
+```
 
 ### Project Initialization Tool
 
@@ -302,13 +417,19 @@ log.error(`Error occurred: ${error.message}`, { stack: error.stack });
 log.info('Progress: 50% - AI call initiated...'); // Example progress logging
 ```
 
-## Session Usage Convention
+### Progress Reporting Convention
+
+- ⚠️ **DEPRECATED within Direct Functions**: The `reportProgress` function passed in the `context` object should **NOT** be called from within `*Direct` functions. Doing so can cause client-side validation errors due to missing/incorrect `progressToken` handling.
+- ✅ **DO**: For tools using `AsyncOperationManager`, use the `reportProgressCallback` function *provided by the manager* within the background task definition (as shown in the `AsyncOperationManager` example above) to report progress updates for the *overall operation*.
+- ✅ **DO**: If finer-grained progress needs to be indicated *during* the execution of a `*Direct` function (whether called directly or via `AsyncOperationManager`), use `log.info()` statements (e.g., `log.info('Progress: Parsing AI response...')`).
+
+### Session Usage Convention
 
 The `session` object (destructured from `context`) contains authenticated session data and client information.
 
 - **Authentication**: Access user-specific data (`session.userId`, etc.) if authentication is implemented.
 - **Project Root**: The primary use in Task Master is accessing `session.roots` to determine the client's project root directory via the `getProjectRootFromSession` utility (from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js)). See the Standard Tool Execution Pattern above.
-- **Environment Variables**: The `session.env` object provides access to environment variables set in the MCP client configuration (e.g., `.cursor/mcp.json`). This is the **primary mechanism** for the unified AI service layer (`ai-services-unified.js`) to securely access **API keys** when called from MCP context.
+- **Environment Variables**: The `session.env` object is critical for AI tools. Pass the `session` object to the `*Direct` function's context, and then to AI client utility functions (like `getAnthropicClientForMCP`) which will extract API keys and other relevant environment settings (e.g., `MODEL`, `MAX_TOKENS`) from `session.env`.
 - **Capabilities**: Can be used to check client capabilities (`session.clientCapabilities`).
 
 ## Direct Function Wrappers (`*Direct`)
@@ -317,25 +438,24 @@ These functions, located in `mcp-server/src/core/direct-functions/`, form the co
 
 - **Purpose**: Bridge MCP tools and core Task Master modules (`scripts/modules/*`). Handle AI interactions if applicable.
 - **Responsibilities**:
-  - Receive `args` (including `projectRoot`), `log`, and optionally `{ session }` context.
-  - Find `tasks.json` using `findTasksJsonPath`.
-  - Validate arguments.
-  - **Implement Caching (if applicable)**: Use `getCachedOrExecute`.
-  - **Call Core Logic**: Invoke function from `scripts/modules/*`.
-    - Pass `outputFormat: 'json'` if applicable.
-    - Wrap with `enableSilentMode/disableSilentMode` if needed.
-    - Pass `{ mcpLog: logWrapper, session }` context if core logic needs it.
-  - Handle errors.
-  - Return standardized result object.
-  - ❌ **DON'T**: Call `reportProgress`.
-  - ❌ **DON'T**: Initialize AI clients or call AI services directly.
+  - Receive `args` (including the `projectRoot` determined by the tool), `log` object, and optionally a `context` object (containing **only `{ session }` if needed).
+  - **Find `tasks.json`**: Use `findTasksJsonPath(args, log)` from [`core/utils/path-utils.js`](mdc:mcp-server/src/core/utils/path-utils.js).
+  - Validate arguments specific to the core logic.
+  - **Handle AI Logic (if applicable)**: Initialize AI clients (using `session` from context), build prompts, make AI calls, parse responses.
+  - **Implement Caching (if applicable)**: Use `getCachedOrExecute` from [`tools/utils.js`](mdc:mcp-server/src/tools/utils.js) for read operations.
+  - **Call Core Logic**: Call the underlying function from the core Task Master modules, passing necessary data (including AI results if applicable).
+    - ✅ **DO**: Pass `outputFormat: 'json'` (or similar) to the core function if it might produce console output.
+    - ✅ **DO**: Wrap the core function call with `enableSilentMode/disableSilentMode` if necessary.
+  - Handle errors gracefully (AI errors, core logic errors, file errors).
+  - Return a standardized result object: `{ success: boolean, data?: any, error?: { code: string, message: string }, fromCache?: boolean }`.
+  - ❌ **DON'T**: Call `reportProgress`. Use `log.info` for progress indication if needed.
 
 ## Key Principles
 
 - **Prefer Direct Function Calls**: MCP tools should always call `*Direct` wrappers instead of `executeTaskMasterCommand`.
 - **Standardized Execution Flow**: Follow the pattern: MCP Tool -> `getProjectRootFromSession` -> `*Direct` Function -> Core Logic / AI Logic.
 - **Path Resolution via Direct Functions**: The `*Direct` function is responsible for finding the exact `tasks.json` path using `findTasksJsonPath`, relying on the `projectRoot` passed in `args`.
-- **AI Logic in Core Modules**: AI interactions (prompt building, calling unified service) reside within the core logic functions (`scripts/modules/*`), not direct functions.
+- **AI Logic in Direct Functions**: For AI-based tools, the `*Direct` function handles AI client initialization, calls, and parsing, using the `session` object passed in its context.
 - **Silent Mode in Direct Functions**: Wrap *core function* calls (from `scripts/modules`) with `enableSilentMode()` and `disableSilentMode()` if they produce console output not handled by `outputFormat`. Do not wrap AI calls.
 - **Selective Async Processing**: Use `AsyncOperationManager` in the *MCP Tool layer* for operations involving multiple steps or long waits beyond a single AI call (e.g., file processing + AI call + file writing). Simple AI calls handled entirely within the `*Direct` function (like `addTaskDirect`) may not need it at the tool layer.
 - **No `reportProgress` in Direct Functions**: Do not pass or use `reportProgress` within `*Direct` functions. Use `log.info()` for internal progress or report progress from the `AsyncOperationManager` callback in the MCP tool layer.
@@ -360,7 +480,7 @@ Follow these steps to add MCP support for an existing Task Master command (see [
 
 1.  **Ensure Core Logic Exists**: Verify the core functionality is implemented and exported from the relevant module in `scripts/modules/`. Ensure the core function can suppress console output (e.g., via an `outputFormat` parameter).
 
-2. **Create Direct Function File in `mcp-server/src/core/direct-functions/`**:
+2.  **Create Direct Function File in `mcp-server/src/core/direct-functions/`**:
     - Create a new file (e.g., `your-command.js`) using **kebab-case** naming.
     - Import necessary core functions, `findTasksJsonPath`, silent mode utilities, and potentially AI client/prompt utilities.
     - Implement `async function yourCommandDirect(args, log, context = {})` using **camelCase** with `Direct` suffix. **Remember `context` should only contain `{ session }` if needed (for AI keys/config).**
@@ -522,8 +642,3 @@ Follow these steps to add MCP support for an existing Task Master command (see [
       // Add more functions as implemented
     };
     ```
-
-## Telemetry Integration
-
-- Direct functions calling core logic that involves AI should receive and pass through `telemetryData` within their successful `data` payload. See [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc) for the standard pattern.
-- MCP tools use `handleApiResult`, which ensures the `data` object (potentially including `telemetryData`) from the direct function is correctly included in the final response.

.cursor/rules/new_features.mdc

@@ -3,6 +3,7 @@ description: Guidelines for integrating new features into the Task Master CLI
 globs: scripts/modules/*.js
 alwaysApply: false
 ---
+
 # Task Master Feature Integration Guidelines
 
 ## Feature Placement Decision Process
@@ -24,17 +25,11 @@ alwaysApply: false
 The standard pattern for adding a feature follows this workflow:
 
 1. **Core Logic**: Implement the business logic in the appropriate module (e.g., [`task-manager.js`](mdc:scripts/modules/task-manager.js)).
-2. **AI Integration (If Applicable)**: 
-   - Import necessary service functions (e.g., `generateTextService`, `streamTextService`) from [`ai-services-unified.js`](mdc:scripts/modules/ai-services-unified.js).
-   - Prepare parameters (`role`, `session`, `systemPrompt`, `prompt`).
-   - Call the service function.
-   - Handle the response (direct text or stream object).
-   - **Important**: Prefer `generateTextService` for calls sending large context (like stringified JSON) where incremental display is not needed. See [`ai_services.mdc`](mdc:.cursor/rules/ai_services.mdc) for detailed usage patterns and cautions.
-3. **UI Components**: Add any display functions to [`ui.js`](mdc:scripts/modules/ui.js) following [`ui.mdc`](mdc:.cursor/rules/ui.mdc).
-4. **Command Integration**: Add the CLI command to [`commands.js`](mdc:scripts/modules/commands.js) following [`commands.mdc`](mdc:.cursor/rules/commands.mdc).
-5. **Testing**: Write tests for all components of the feature (following [`tests.mdc`](mdc:.cursor/rules/tests.mdc))
-6. **Configuration**: Update configuration settings or add new ones in [`config-manager.js`](mdc:scripts/modules/config-manager.js) and ensure getters/setters are appropriate. Update documentation in [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc) and [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc). Update the `.taskmasterconfig` structure if needed.
-7. **Documentation**: Update help text and documentation in [`dev_workflow.mdc`](mdc:.cursor/rules/dev_workflow.mdc) and [`taskmaster.mdc`](mdc:.cursor/rules/taskmaster.mdc).
+2. **UI Components**: Add any display functions to [`ui.js`](mdc:scripts/modules/ui.js) following [`ui.mdc`](mdc:.cursor/rules/ui.mdc).
+3. **Command Integration**: Add the CLI command to [`commands.js`](mdc:scripts/modules/commands.js) following [`commands.mdc`](mdc:.cursor/rules/commands.mdc).
+4. **Testing**: Write tests for all components of the feature (following [`tests.mdc`](mdc:.cursor/rules/tests.mdc))
+5. **Configuration**: Update any configuration in [`utils.js`](mdc:scripts/modules/utils.js) if needed, following [`utilities.mdc`](mdc:.cursor/rules/utilities.mdc).
+6. **Documentation**: Update help text and documentation in [dev_workflow.mdc](mdc:scripts/modules/dev_workflow.mdc)
 
 ## Critical Checklist for New Features
 
@@ -195,8 +190,6 @@ The standard pattern for adding a feature follows this workflow:
   - ✅ **DO**: If an MCP tool fails with vague errors (e.g., JSON parsing issues like `Unexpected token ... is not valid JSON`), **try running the equivalent CLI command directly in the terminal** (e.g., `task-master expand --all`). CLI output often provides much more specific error messages (like missing function definitions or stack traces from the core logic) that pinpoint the root cause.
   - ❌ **DON'T**: Rely solely on MCP logs if the error is unclear; use the CLI as a complementary debugging tool for core logic issues.
 
-- **Telemetry Integration**: Ensure AI calls correctly handle and propagate `telemetryData` as described in [`telemetry.mdc`](mdc:.cursor/rules/telemetry.mdc).
-
 ```javascript
 // 1. CORE LOGIC: Add function to appropriate module (example in task-manager.js)
 /**
@@ -218,29 +211,7 @@ export {
 ```
 
 ```javascript
-// 2. AI Integration: Add import and use necessary service functions
-import { generateTextService } from './ai-services-unified.js';
-
-// Example usage:
-async function handleAIInteraction() {
-  const role = 'user';
-  const session = 'exampleSession';
-  const systemPrompt = 'You are a helpful assistant.';
-  const prompt = 'What is the capital of France?';
-
-  const result = await generateTextService(role, session, systemPrompt, prompt);
-  console.log(result);
-}
-
-// Export from the module
-export {
-  // ... existing exports ...
-  handleAIInteraction,
-};
-```
-
-```javascript
-// 3. UI COMPONENTS: Add display function to ui.js
+// 2. UI COMPONENTS: Add display function to ui.js
 /**
  * Display archive operation results
  * @param {string} archivePath - Path to the archive file
@@ -261,7 +232,7 @@ export {
 ```
 
 ```javascript
-// 4. COMMAND INTEGRATION: Add to commands.js
+// 3. COMMAND INTEGRATION: Add to commands.js
 import { archiveTasks } from './task-manager.js';
 import { displayArchiveResults } from './ui.js';
 
@@ -481,7 +452,7 @@ npm test
 For each new feature:
 
 1. Add help text to the command definition
-2. Update [`dev_workflow.mdc`](mdc:.cursor/rules/dev_workflow.mdc) with command reference
+2. Update [`dev_workflow.mdc`](mdc:scripts/modules/dev_workflow.mdc) with command reference
 3. Consider updating [`architecture.mdc`](mdc:.cursor/rules/architecture.mdc) if the feature significantly changes module responsibilities.
 
 Follow the existing command reference format:
@@ -524,24 +495,14 @@ Integrating Task Master commands with the MCP server (for use by tools like Curs
 
 4.  **Create MCP Tool (`mcp-server/src/tools/`)**:
     - Create a new file (e.g., `your-command.js`) using **kebab-case**.
-    - Import `zod`, `handleApiResult`, **`withNormalizedProjectRoot` HOF**, and your `yourCommandDirect` function.
+    - Import `zod`, `handleApiResult`, `createErrorResponse`, **`getProjectRootFromSession`**, and your `yourCommandDirect` function.
     - Implement `registerYourCommandTool(server)`.
-    - **Define parameters**: Make `projectRoot` optional (`z.string().optional().describe(...)`) as the HOF handles fallback.
-    - Consider if this operation should run in the background using `AsyncOperationManager`.
-    - Implement the standard `execute` method **wrapped with `withNormalizedProjectRoot`**:
-      ```javascript
-      execute: withNormalizedProjectRoot(async (args, { log, session }) => {
-          // args.projectRoot is now normalized
-          const { projectRoot /*, other args */ } = args;
-          // ... resolve tasks path if needed using normalized projectRoot ...
-          const result = await yourCommandDirect(
-              { /* other args */, projectRoot /* if needed by direct func */ }, 
-              log, 
-              { session }
-          );
-          return handleApiResult(result, log);
-      })
-      ```
+    - Define the tool `name` using **snake_case** (e.g., `your_command`).
+    - Define the `parameters` using `zod`. **Crucially, define `projectRoot` as optional**: `projectRoot: z.string().optional().describe(...)`. Include `file` if applicable.
+    - Implement the standard `async execute(args, { log, reportProgress, session })` method:
+      - Get `rootFolder` using `getProjectRootFromSession` (with fallback to `args.projectRoot`).
+      - Call `yourCommandDirect({ ...args, projectRoot: rootFolder }, log)`. 
+      - Pass the result to `handleApiResult(result, log, 'Error Message')`.
 
 5.  **Register Tool**: Import and call `registerYourCommandTool` in `mcp-server/src/tools/index.js`.
 

.cursor/rules/self_improve.mdc

@@ -69,4 +69,5 @@ alwaysApply: true
   - Update references to external docs
   - Maintain links between related rules
   - Document breaking changes
+
 Follow [cursor_rules.mdc](mdc:.cursor/rules/cursor_rules.mdc) for proper rule formatting and structure.

.cursor/rules/taskmaster.mdc

@@ -3,13 +3,14 @@ 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.
+This document provides a detailed reference for interacting with Taskmaster, covering both the recommended MCP tools (for integrations like Cursor) and the corresponding `task-master` CLI commands (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. 
+**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. See [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc) for MCP implementation details and [`commands.mdc`](mdc:.cursor/rules/commands.mdc) for CLI implementation guidelines.
 
-**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`.
+**Important:** Several MCP tools involve AI processing and are long-running operations that may take up to a minute to complete. When using these tools, always inform users that the operation is in progress and to wait patiently for results. The AI-powered tools include: `parse_prd`, `analyze_project_complexity`, `update_subtask`, `update_task`, `update`, `expand_all`, `expand_task`, and `add_task`.
 
 ---
 
@@ -23,64 +24,34 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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'.`
+    *   `--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>`)
+    *   `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`)
+    *   `skipInstall`: `Skip installing dependencies (default: false).` (CLI: `--skip-install`)
+    *   `addAliases`: `Add shell aliases (tm, taskmaster) (default: false).` (CLI: `--aliases`)
+    *   `yes`: `Skip prompts and use defaults/provided arguments (default: 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 scripts/example_prd.txt. 
+
 
 ### 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.`
+*   **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 'tasks/tasks.json'.` (CLI: `-o, --output <file>`)
+    *   `output`: `Specify where Taskmaster should save the generated 'tasks.json' file (default: '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 `scripts/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.`
-    *   `--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 `.taskmasterconfig` 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 .taskmasterconfig 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.
+*   **Notes:** Task Master will strictly adhere to any specific requirements mentioned in the PRD (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.
 
 ---
 
@@ -92,9 +63,9 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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, e.g., 'pending' or 'done'.` (CLI: `-s, --status <status>`)
+    *   `status`: `Show only Taskmaster tasks matching this status (e.g., 'pending', 'done').` (CLI: `-s, --status <status>`)
     *   `withSubtasks`: `Include subtasks indented under their parent tasks in the list.` (CLI: `--with-subtasks`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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`)
@@ -103,7 +74,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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>`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file (default relies on auto-detection).` (CLI: `-f, --file <file>`)
 *   **Usage:** Identify what to work on next according to the plan.
 
 ### 5. Get Task Details (`get_task`)
@@ -112,8 +83,8 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **CLI Command:** `task-master show [id] [options]`
 *   **Description:** `Display detailed information for a specific Taskmaster task or subtask by its ID.`
 *   **Key Parameters/Options:**
-    *   `id`: `Required. The ID of the Taskmaster task, e.g., '15', or subtask, e.g., '15.2', you want to view.` (CLI: `[id]` positional or `-i, --id <id>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `id`: `Required. The ID of the Taskmaster task (e.g., '15') or subtask (e.g., '15.2') you want to view.` (CLI: `[id]` positional or `-i, --id <id>`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file (default relies on auto-detection).` (CLI: `-f, --file <file>`)
 *   **Usage:** Understand the full details, implementation notes, and test strategy for a specific task before starting work.
 
 ---
@@ -126,11 +97,10 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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', 'low'; default: 'medium').` (CLI: `--priority <priority>`)
+    *   `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.
 
@@ -142,13 +112,13 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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>`)
+    *   `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>`)
+    *   `dependencies`: `Specify IDs of other tasks or subtasks (e.g., '15', '16.1') that must be done before this new subtask.` (CLI: `--dependencies <ids>`)
+    *   `status`: `Set the initial status for the new subtask (default: 'pending').` (CLI: `-s, --status <status>`)
     *   `skipGenerate`: `Prevent Taskmaster from automatically regenerating markdown task files after adding the subtask.` (CLI: `--skip-generate`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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`)
@@ -157,10 +127,10 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `from`: `Required. The ID of the first task Taskmaster should update. All tasks with this ID or higher (and 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 Perplexity AI for more informed updates based on external knowledge (requires PERPLEXITY_API_KEY).` (CLI: `-r, --research`)
+    *   `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.
 
@@ -168,12 +138,12 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 
 *   **MCP Tool:** `update_task`
 *   **CLI Command:** `task-master update-task [options]`
-*   **Description:** `Modify a specific Taskmaster task or subtask by its ID, incorporating new information or changes.`
+*   **Description:** `Modify a specific Taskmaster task (or subtask) by its ID, incorporating new information or changes.`
 *   **Key Parameters/Options:**
-    *   `id`: `Required. The specific ID of the Taskmaster task, e.g., '15', or subtask, e.g., '15.2', you want to update.` (CLI: `-i, --id <id>`)
+    *   `id`: `Required. The specific ID of the Taskmaster task (e.g., '15') or subtask (e.g., '15.2') 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>`)
-    *   `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `research`: `Enable Taskmaster to use Perplexity AI for more informed updates (requires PERPLEXITY_API_KEY).` (CLI: `-r, --research`)
+    *   `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 or feedback. Example CLI: `task-master update-task --id='15' --prompt='Clarification: Use PostgreSQL instead of MySQL.\nUpdate schema details...'`
 *   **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.
 
@@ -183,10 +153,10 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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 specific ID of the Taskmaster subtask, e.g., '15.2', you want to add information to.` (CLI: `-i, --id <id>`)
+    *   `id`: `Required. The specific ID of the Taskmaster subtask (e.g., '15.2') you want to add information to.` (CLI: `-i, --id <id>`)
     *   `prompt`: `Required. Provide the information or notes Taskmaster should append to the subtask's details. Ensure this adds *new* information not already present.` (CLI: `-p, --prompt <text>`)
-    *   `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `research`: `Enable Taskmaster to use Perplexity AI for more informed updates (requires PERPLEXITY_API_KEY).` (CLI: `-r, --research`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file (default relies on auto-detection).` (CLI: `-f, --file <file>`)
 *   **Usage:** Add implementation notes, code snippets, or clarifications to a subtask during development. Before calling, review the subtask's current details to append only fresh insights, helping to build a detailed log of the implementation journey and avoid redundancy. Example CLI: `task-master update-subtask --id='15.2' --prompt='Discovered that the API requires header X.\nImplementation needs adjustment...'`
 *   **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.
 
@@ -194,11 +164,11 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 
 *   **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'.`
+*   **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>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `id`: `Required. The ID(s) of the Taskmaster task(s) or subtask(s) (e.g., '15', '15.2', '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>`)
+    *   `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`)
@@ -207,9 +177,9 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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>`)
+    *   `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`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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.
 
@@ -221,28 +191,28 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 
 *   **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.`
+*   **Description:** `Use Taskmaster's AI to break down a complex task (or all tasks) into smaller, manageable subtasks.`
 *   **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`)
-    *   `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.
+    *   `num`: `Suggests how many subtasks Taskmaster should aim to create (uses complexity analysis by default).` (CLI: `-n, --num <number>`)
+    *   `research`: `Enable Taskmaster to use Perplexity AI for more informed subtask generation (requires PERPLEXITY_API_KEY).` (CLI: `-r, --research`)
+    *   `prompt`: `Provide extra context or specific instructions to Taskmaster for generating the subtasks.` (CLI: `-p, --prompt <text>`)
+    *   `force`: `Use this to make Taskmaster replace existing subtasks with newly generated ones.` (CLI: `--force`)
+    *   `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.
 *   **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.`
+*   **Description:** `Tell Taskmaster to automatically expand all 'pending' tasks based on complexity analysis.`
 *   **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`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `num`: `Suggests how many subtasks Taskmaster should aim to create per task.` (CLI: `-n, --num <number>`)
+    *   `research`: `Enable Perplexity AI for more informed subtask generation (requires PERPLEXITY_API_KEY).` (CLI: `-r, --research`)
+    *   `prompt`: `Provide extra context for Taskmaster to apply generally during expansion.` (CLI: `-p, --prompt <text>`)
+    *   `force`: `Make Taskmaster replace existing subtasks.` (CLI: `--force`)
+    *   `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.
 
@@ -252,9 +222,9 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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>`)
+    *   `id`: `The ID(s) of the Taskmaster parent task(s) whose subtasks you want to remove (e.g., '15', '16,18').` (Required unless using `all`) (CLI: `-i, --id <ids>`)
     *   `all`: `Tell Taskmaster to remove subtasks from all parent tasks.` (CLI: `--all`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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`)
@@ -263,53 +233,28 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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>`)
+    *   `id`: `Required. The ID(s) of the Taskmaster subtask(s) to remove (e.g., '15.2', '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`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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>`)
-    *   `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`)
+### 17. 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>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <path>`)
+    *   `dependsOn`: `Required. The ID of the Taskmaster task that must be completed first (the prerequisite).` (CLI: `-d, --depends-on <id>`)
+    *   `file`: `Path to your Taskmaster 'tasks.json' file (default relies on auto-detection).` (CLI: `-f, --file <file>`)
 *   **Usage:** Establish the correct order of execution between tasks.
 
-### 19. Remove Dependency (`remove_dependency`)
+### 18. Remove Dependency (`remove_dependency`)
 
 *   **MCP Tool:** `remove_dependency`
 *   **CLI Command:** `task-master remove-dependency [options]`
@@ -317,32 +262,32 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **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>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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`)
+### 19. 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:**
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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`)
+### 20. 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:**
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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`)
+### 21. Analyze Project Complexity (`analyze_project_complexity`)
 
 *   **MCP Tool:** `analyze_project_complexity`
 *   **CLI Command:** `task-master analyze-complexity [options]`
@@ -350,12 +295,12 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 *   **Key Parameters/Options:**
     *   `output`: `Where to save the complexity analysis report (default: 'scripts/task-complexity-report.json').` (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`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `research`: `Enable Perplexity AI for more accurate complexity analysis (requires PERPLEXITY_API_KEY).` (CLI: `-r, --research`)
+    *   `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`)
+### 22. View Complexity Report (`complexity_report`)
 
 *   **MCP Tool:** `complexity_report`
 *   **CLI Command:** `task-master complexity-report [options]`
@@ -368,40 +313,41 @@ This document provides a detailed reference for interacting with Taskmaster, cov
 
 ## File Management
 
-### 24. Generate Task Files (`generate`)
+### 23. 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>`)
-    *   `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
+    *   `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.
 
 ---
 
-## Environment Variables Configuration (Updated)
+## Environment Variables Configuration
 
-Taskmaster primarily uses the **`.taskmasterconfig`** file (in project root) for configuration (models, parameters, logging level, etc.), managed via `task-master models --setup`.
+Taskmaster's behavior can be customized via environment variables. These affect both CLI and MCP server operation:
 
-Environment variables are used **only** for sensitive API keys related to AI providers and specific overrides like the Ollama base URL:
+*   **ANTHROPIC_API_KEY** (Required): Your Anthropic API key for Claude.
+*   **MODEL**: Claude model to use (default: `claude-3-opus-20240229`). 
+*   **MAX_TOKENS**: Maximum tokens for AI responses (default: 8192).
+*   **TEMPERATURE**: Temperature for AI model responses (default: 0.7).
+*   **DEBUG**: Enable debug logging (`true`/`false`, default: `false`).
+*   **LOG_LEVEL**: Console output level (`debug`, `info`, `warn`, `error`, default: `info`).
+*   **DEFAULT_SUBTASKS**: Default number of subtasks for `expand` (default: 5).
+*   **DEFAULT_PRIORITY**: Default priority for new tasks (default: `medium`).
+*   **PROJECT_NAME**: Project name used in metadata.
+*   **PROJECT_VERSION**: Project version used in metadata.
+*   **PERPLEXITY_API_KEY**: API key for Perplexity AI (for `--research` flags).
+*   **PERPLEXITY_MODEL**: Perplexity model to use (default: `sonar-medium-online`).
 
-*   **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`
-    *   `OLLANA_API_KEY` (Requires `OLLAMA_BASE_URL` too)
-*   **Endpoints (Optional/Provider Specific inside .taskmasterconfig):**
-    *   `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 `.taskmasterconfig` via `task-master models` command or `models` MCP tool.
+Set these in your `.env` file in the project root or in your environment before running Taskmaster.
 
 ---
 
-For details on how these commands fit into the development process, see the [Development Workflow Guide](mdc:.cursor/rules/dev_workflow.mdc).
+For implementation details:
+*   CLI commands: See [`commands.mdc`](mdc:.cursor/rules/commands.mdc)
+*   MCP server: See [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)
+*   Task structure: See [`tasks.mdc`](mdc:.cursor/rules/tasks.mdc)
+*   Workflow: See [`dev_workflow.mdc`](mdc:.cursor/rules/dev_workflow.mdc)

.cursor/rules/telemetry.mdc

@@ -1,228 +0,0 @@
----
-description: Guidelines for integrating AI usage telemetry across Task Master.
-globs: scripts/modules/**/*.js,mcp-server/src/**/*.js
-alwaysApply: true
----
-
-# AI Usage Telemetry Integration
-
-This document outlines the standard pattern for capturing, propagating, and handling AI usage telemetry data (cost, tokens, model, etc.) across the Task Master stack. This ensures consistent telemetry for both CLI and MCP interactions.
-
-## Overview
-
-Telemetry data is generated within the unified AI service layer ([`ai-services-unified.js`](mdc:scripts/modules/ai-services-unified.js)) and then passed upwards through the calling functions.
-
-- **Data Source**: [`ai-services-unified.js`](mdc:scripts/modules/ai-services-unified.js) (specifically its `generateTextService`, `generateObjectService`, etc.) returns an object like `{ mainResult: AI_CALL_OUTPUT, telemetryData: TELEMETRY_OBJECT }`.
-- **`telemetryData` Object Structure**:
-  ```json
-  {
-    "timestamp": "ISO_STRING_DATE",
-    "userId": "USER_ID_FROM_CONFIG",
-    "commandName": "invoking_command_or_tool_name",
-    "modelUsed": "ai_model_id",
-    "providerName": "ai_provider_name",
-    "inputTokens": NUMBER,
-    "outputTokens": NUMBER,
-    "totalTokens": NUMBER,
-    "totalCost": NUMBER, // e.g., 0.012414
-    "currency": "USD" // e.g., "USD"
-  }
-  ```
-
-## Integration Pattern by Layer
-
-The key principle is that each layer receives telemetry data from the layer below it (if applicable) and passes it to the layer above it, or handles it for display in the case of the CLI.
-
-### 1. Core Logic Functions (e.g., in `scripts/modules/task-manager/`)
-
-Functions in this layer that invoke AI services are responsible for handling the `telemetryData` they receive from [`ai-services-unified.js`](mdc:scripts/modules/ai-services-unified.js).
-
-- **Actions**:
-    1.  Call the appropriate AI service function (e.g., `generateObjectService`).
-        -   Pass `commandName` (e.g., `add-task`, `expand-task`) and `outputType` (e.g., `cli` or `mcp`) in the `params` object to the AI service. The `outputType` can be derived from context (e.g., presence of `mcpLog`).
-    2.  The AI service returns an object, e.g., `aiServiceResponse = { mainResult: {/*AI output*/}, telemetryData: {/*telemetry data*/} }`.
-    3.  Extract `aiServiceResponse.mainResult` for the core processing.
-    4.  **Must return an object that includes `aiServiceResponse.telemetryData`**.
-        Example: `return { operationSpecificData: /*...*/, telemetryData: aiServiceResponse.telemetryData };`
-
-- **CLI Output Handling (If Applicable)**:
-    -   If the core function also handles CLI output (e.g., it has an `outputFormat` parameter that can be `'text'` or `'cli'`):
-        1.  Check if `outputFormat === 'text'` (or `'cli'`).
-        2.  If so, and if `aiServiceResponse.telemetryData` is available, call `displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli')` from [`scripts/modules/ui.js`](mdc:scripts/modules/ui.js).
-        - This ensures telemetry is displayed directly to CLI users after the main command output.
-
-- **Example Snippet (Core Logic in `scripts/modules/task-manager/someAiAction.js`)**:
-  ```javascript
-  import { generateObjectService } from '../ai-services-unified.js';
-  import { displayAiUsageSummary } from '../ui.js';
-
-  async function performAiRelatedAction(params, context, outputFormat = 'text') {
-    const { commandNameFromContext, /* other context vars */ } = context;
-    let aiServiceResponse = null;
-
-    try {
-      aiServiceResponse = await generateObjectService({
-        // ... other parameters for AI service ...
-        commandName: commandNameFromContext || 'default-action-name',
-        outputType: context.mcpLog ? 'mcp' : 'cli' // Derive outputType
-      });
-
-      const usefulAiOutput = aiServiceResponse.mainResult.object;
-      // ... do work with usefulAiOutput ...
-
-      if (outputFormat === 'text' && aiServiceResponse.telemetryData) {
-        displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli');
-      }
-
-      return {
-        actionData: /* results of processing */,
-        telemetryData: aiServiceResponse.telemetryData
-      };
-    } catch (error) {
-      // ... handle error ...
-      throw error;
-    }
-  }
-  ```
-
-### 2. Direct Function Wrappers (in `mcp-server/src/core/direct-functions/`)
-
-These functions adapt core logic for the MCP server, ensuring structured responses.
-
-- **Actions**:
-    1.  Call the corresponding core logic function.
-        -   Pass necessary context (e.g., `session`, `mcpLog`, `projectRoot`).
-        -   Provide the `commandName` (typically derived from the MCP tool name) and `outputType: 'mcp'` in the context object passed to the core function.
-        -   If the core function supports an `outputFormat` parameter, pass `'json'` to suppress CLI-specific UI.
-    2.  The core logic function returns an object (e.g., `coreResult = { actionData: ..., telemetryData: ... }`).
-    3.  Include `coreResult.telemetryData` as a field within the `data` object of the successful response returned by the direct function.
-
-- **Example Snippet (Direct Function `someAiActionDirect.js`)**:
-  ```javascript
-  import { performAiRelatedAction } from '../../../../scripts/modules/task-manager/someAiAction.js'; // Core function
-  import { createLogWrapper } from '../../tools/utils.js'; // MCP Log wrapper
-
-  export async function someAiActionDirect(args, log, context = {}) {
-    const { session } = context;
-    // ... prepare arguments for core function from args, including args.projectRoot ...
-
-    try {
-      const coreResult = await performAiRelatedAction(
-        { /* parameters for core function */ },
-        { // Context for core function
-          session,
-          mcpLog: createLogWrapper(log),
-          projectRoot: args.projectRoot,
-          commandNameFromContext: 'mcp_tool_some_ai_action', // Example command name
-          outputType: 'mcp'
-        },
-        'json' // Request 'json' output format from core function
-      );
-
-      return {
-        success: true,
-        data: {
-          operationSpecificData: coreResult.actionData,
-          telemetryData: coreResult.telemetryData // Pass telemetry through
-        }
-      };
-    } catch (error) {
-      // ... error handling, return { success: false, error: ... } ...
-    }
-  }
-  ```
-
-### 3. MCP Tools (in `mcp-server/src/tools/`)
-
-These are the exposed endpoints for MCP clients.
-
-- **Actions**:
-    1.  Call the corresponding direct function wrapper.
-    2.  The direct function returns an object structured like `{ success: true, data: { operationSpecificData: ..., telemetryData: ... } }` (or an error object).
-    3.  Pass this entire result object to `handleApiResult(result, log)` from [`mcp-server/src/tools/utils.js`](mdc:mcp-server/src/tools/utils.js).
-    4.  `handleApiResult` ensures that the `data` field from the direct function's response (which correctly includes `telemetryData`) is part of the final MCP response.
-
-- **Example Snippet (MCP Tool `some_ai_action.js`)**:
-  ```javascript
-  import { someAiActionDirect } from '../core/task-master-core.js';
-  import { handleApiResult, withNormalizedProjectRoot } from './utils.js';
-  // ... zod for parameters ...
-
-  export function registerSomeAiActionTool(server) {
-    server.addTool({
-      name: "some_ai_action",
-      // ... description, parameters ...
-      execute: withNormalizedProjectRoot(async (args, { log, session }) => {
-        try {
-          const resultFromDirectFunction = await someAiActionDirect(
-            { /* args including projectRoot */ },
-            log,
-            { session }
-          );
-          return handleApiResult(resultFromDirectFunction, log); // This passes the nested telemetryData through
-        } catch (error) {
-          // ... error handling ...
-        }
-      })
-    });
-  }
-  ```
-
-### 4. CLI Commands (`scripts/modules/commands.js`)
-
-These define the command-line interface.
-
-- **Actions**:
-    1.  Call the appropriate core logic function.
-    2.  Pass `outputFormat: 'text'` (or ensure the core function defaults to text-based output for CLI).
-    3.  The core logic function (as per Section 1) is responsible for calling `displayAiUsageSummary` if telemetry data is available and it's in CLI mode.
-    4.  The command action itself **should not** call `displayAiUsageSummary` if the core logic function already handles this. This avoids duplicate display.
-
-- **Example Snippet (CLI Command in `commands.js`)**:
-  ```javascript
-  // In scripts/modules/commands.js
-  import { performAiRelatedAction } from './task-manager/someAiAction.js'; // Core function
-
-  programInstance
-    .command('some-cli-ai-action')
-    // ... .option() ...
-    .action(async (options) => {
-      try {
-        const projectRoot = findProjectRoot() || '.'; // Example root finding
-        // ... prepare parameters for core function from command options ...
-        await performAiRelatedAction(
-          { /* parameters for core function */ },
-          { // Context for core function
-            projectRoot,
-            commandNameFromContext: 'some-cli-ai-action',
-            outputType: 'cli'
-          },
-          'text' // Explicitly request text output format for CLI
-        );
-        // Core function handles displayAiUsageSummary internally for 'text' outputFormat
-      } catch (error) {
-        // ... error handling ...
-      }
-    });
-  ```
-
-## Summary Flow
-
-The telemetry data flows as follows:
-
-1.  **[`ai-services-unified.js`](mdc:scripts/modules/ai-services-unified.js)**: Generates `telemetryData` and returns `{ mainResult, telemetryData }`.
-2.  **Core Logic Function**:
-    *   Receives `{ mainResult, telemetryData }`.
-    *   Uses `mainResult`.
-    *   If CLI (`outputFormat: 'text'`), calls `displayAiUsageSummary(telemetryData)`.
-    *   Returns `{ operationSpecificData, telemetryData }`.
-3.  **Direct Function Wrapper**:
-    *   Receives `{ operationSpecificData, telemetryData }` from core logic.
-    *   Returns `{ success: true, data: { operationSpecificData, telemetryData } }`.
-4.  **MCP Tool**:
-    *   Receives direct function response.
-    *   `handleApiResult` ensures the final MCP response to the client is `{ success: true, data: { operationSpecificData, telemetryData } }`.
-5.  **CLI Command**:
-    *   Calls core logic with `outputFormat: 'text'`. Display is handled by core logic.
-
-This pattern ensures telemetry is captured and appropriately handled/exposed across all interaction modes.

.cursor/rules/tests.mdc

@@ -5,8 +5,6 @@ globs: "**/*.test.js,tests/**/*"
 
 # Testing Guidelines for Task Master CLI
 
-*Note:* Never use asynchronous operations in tests. Always mock tests properly based on the way the tested functions are defined and used. Do not arbitrarily create tests. Based them on the low-level details and execution of the underlying code being tested. 
-
 ## Test Organization Structure
 
 - **Unit Tests** (See [`architecture.mdc`](mdc:.cursor/rules/architecture.mdc) for module breakdown)
@@ -90,122 +88,6 @@ describe('Feature or Function Name', () => {
 });
 ```
 
-## Commander.js Command Testing Best Practices
-
-When testing CLI commands built with Commander.js, several special considerations must be made to avoid common pitfalls:
-
-- **Direct Action Handler Testing**
-  - ✅ **DO**: Test the command action handlers directly rather than trying to mock the entire Commander.js chain
-  - ✅ **DO**: Create simplified test-specific implementations of command handlers that match the original behavior
-  - ✅ **DO**: Explicitly handle all options, including defaults and shorthand flags (e.g., `-p` for `--prompt`)
-  - ✅ **DO**: Include null/undefined checks in test implementations for parameters that might be optional
-  - ✅ **DO**: Use fixtures from `tests/fixtures/` for consistent sample data across tests
-  
-  ```javascript
-  // ✅ DO: Create a simplified test version of the command handler
-  const testAddTaskAction = async (options) => {
-    options = options || {}; // Ensure options aren't undefined
-    
-    // Validate parameters
-    const isManualCreation = options.title && options.description;
-    const prompt = options.prompt || options.p; // Handle shorthand flags
-    
-    if (!prompt && !isManualCreation) {
-      throw new Error('Expected error message');
-    }
-    
-    // Call the mocked task manager
-    return mockTaskManager.addTask(/* parameters */);
-  };
-  
-  test('should handle required parameters correctly', async () => {
-    // Call the test implementation directly
-    await expect(async () => {
-      await testAddTaskAction({ file: 'tasks.json' });
-    }).rejects.toThrow('Expected error message');
-  });
-  ```
-
-- **Commander Chain Mocking (If Necessary)**
-  - ✅ **DO**: Mock ALL chainable methods (`option`, `argument`, `action`, `on`, etc.)
-  - ✅ **DO**: Return `this` (or the mock object) from all chainable method mocks
-  - ✅ **DO**: Remember to mock not only the initial object but also all objects returned by methods
-  - ✅ **DO**: Implement a mechanism to capture the action handler for direct testing
-  
-  ```javascript
-  // If you must mock the Commander.js chain:
-  const mockCommand = {
-    command: jest.fn().mockReturnThis(),
-    description: jest.fn().mockReturnThis(),
-    option: jest.fn().mockReturnThis(),
-    argument: jest.fn().mockReturnThis(), // Don't forget this one
-    action: jest.fn(fn => { 
-      actionHandler = fn; // Capture the handler for testing
-      return mockCommand; 
-    }),
-    on: jest.fn().mockReturnThis() // Don't forget this one
-  };
-  ```
-
-- **Parameter Handling**
-  - ✅ **DO**: Check for both main flag and shorthand flags (e.g., `prompt` and `p`)
-  - ✅ **DO**: Handle parameters like Commander would (comma-separated lists, etc.)
-  - ✅ **DO**: Set proper default values as defined in the command
-  - ✅ **DO**: Validate that required parameters are actually required in tests
-  
-  ```javascript
-  // Parse dependencies like Commander would
-  const dependencies = options.dependencies 
-    ? options.dependencies.split(',').map(id => id.trim())
-    : [];
-  ```
-
-- **Environment and Session Handling**
-  - ✅ **DO**: Properly mock session objects when required by functions
-  - ✅ **DO**: Reset environment variables between tests if modified
-  - ✅ **DO**: Use a consistent pattern for environment-dependent tests
-  
-  ```javascript
-  // Session parameter mock pattern
-  const sessionMock = { session: process.env };
-  
-  // In test:
-  expect(mockAddTask).toHaveBeenCalledWith(
-    expect.any(String),
-    'Test prompt',
-    [],
-    'medium',
-    sessionMock,
-    false,
-    null,
-    null
-  );
-  ```
-
-- **Common Pitfalls to Avoid**
-  - ❌ **DON'T**: Try to use the real action implementation without proper mocking
-  - ❌ **DON'T**: Mock Commander partially - either mock it completely or test the action directly
-  - ❌ **DON'T**: Forget to handle optional parameters that may be undefined
-  - ❌ **DON'T**: Neglect to test shorthand flag functionality (e.g., `-p`, `-r`)
-  - ❌ **DON'T**: Create circular dependencies in your test mocks
-  - ❌ **DON'T**: Access variables before initialization in your test implementations
-  - ❌ **DON'T**: Include actual command execution in unit tests
-  - ❌ **DON'T**: Overwrite the same file path in multiple tests
-  
-  ```javascript
-  // ❌ DON'T: Create circular references in mocks
-  const badMock = {
-    method: jest.fn().mockImplementation(() => badMock.method())
-  };
-  
-  // ❌ DON'T: Access uninitialized variables
-  const badImplementation = () => {
-    const result = uninitialized;
-    let uninitialized = 'value';
-    return result;
-  };
-  ```
-
 ## Jest Module Mocking Best Practices
 
 - **Mock Hoisting Behavior**
@@ -283,97 +165,107 @@ When testing ES modules (`"type": "module"` in package.json), traditional mockin
   - Imported functions may not use your mocked dependencies even with proper jest.mock() setup
   - ES module exports are read-only properties (cannot be reassigned during tests)
 
-- **Mocking Modules Statically Imported**
-  - For modules imported with standard `import` statements at the top level:
-    - Use `jest.mock('path/to/module', factory)` **before** any imports.
-    - Jest hoists these mocks.
-    - Ensure the factory function returns the mocked structure correctly.
-
-- **Mocking Dependencies for Dynamically Imported Modules**
-  - **Problem**: Standard `jest.mock()` often fails for dependencies of modules loaded later using dynamic `import('path/to/module')`. The mocks aren't applied correctly when the dynamic import resolves.
-  - **Solution**: Use `jest.unstable_mockModule(modulePath, factory)` **before** the dynamic `import()` call.
+- **Mocking Entire Modules**
   ```javascript
-  // 1. Define mock function instances
-  const mockExistsSync = jest.fn();
-  const mockReadFileSync = jest.fn();
-  // ... other mocks
+  // Mock the entire module with custom implementation
+  jest.mock('../../scripts/modules/task-manager.js', () => {
+    // Get original implementation for functions you want to preserve
+    const originalModule = jest.requireActual('../../scripts/modules/task-manager.js');
     
-  // 2. Mock the dependency module *before* the dynamic import
-  jest.unstable_mockModule('fs', () => ({
-    __esModule: true, // Important for ES module mocks
-    // Mock named exports
-    existsSync: mockExistsSync,
-    readFileSync: mockReadFileSync,
-    // Mock default export if necessary
-    // default: { ... }
-  }));
-
-  // 3. Dynamically import the module under test (e.g., in beforeAll or test case)
-  let moduleUnderTest;
-  beforeAll(async () => {
-    // Ensure mocks are reset if needed before import
-    mockExistsSync.mockReset();
-    mockReadFileSync.mockReset();
-    // ... reset other mocks ...
-
-    // Import *after* unstable_mockModule is called
-    moduleUnderTest = await import('../../scripts/modules/module-using-fs.js');
+    // Return mix of original and mocked functionality
+    return {
+      ...originalModule,
+      generateTaskFiles: jest.fn() // Replace specific functions
+    };
   });
   
-  // 4. Now tests can use moduleUnderTest, and its 'fs' calls will hit the mocks
-  test('should use mocked fs.readFileSync', () => {
-    mockReadFileSync.mockReturnValue('mock data');
-    moduleUnderTest.readFileAndProcess();
-    expect(mockReadFileSync).toHaveBeenCalled();
-    // ... other assertions
-  });
-  ```
-  - ✅ **DO**: Call `jest.unstable_mockModule()` before `await import()`.
-  - ✅ **DO**: Include `__esModule: true` in the mock factory for ES modules.
-  - ✅ **DO**: Mock named and default exports as needed within the factory.
-  - ✅ **DO**: Reset mock functions (`mockFn.mockReset()`) before the dynamic import if they might have been called previously.
+  // Import after mocks
+  import * as taskManager from '../../scripts/modules/task-manager.js';
   
-- **Mocking Entire Modules (Static Import)**
-  ```javascript
-  // Mock the entire module with custom implementation for static imports
-  // ... (existing example remains valid) ...
+  // Now you can use the mock directly
+  const { generateTaskFiles } = taskManager;
   ```
 
 - **Direct Implementation Testing**
   - Instead of calling the actual function which may have module-scope reference issues:
   ```javascript
-  // ... (existing example remains valid) ...
+  test('should perform expected actions', () => {
+    // Setup mocks for this specific test
+    mockReadJSON.mockImplementationOnce(() => sampleData);
+    
+    // Manually simulate the function's behavior
+    const data = mockReadJSON('path/file.json');
+    mockValidateAndFixDependencies(data, 'path/file.json');
+    
+    // Skip calling the actual function and verify mocks directly
+    expect(mockReadJSON).toHaveBeenCalledWith('path/file.json');
+    expect(mockValidateAndFixDependencies).toHaveBeenCalledWith(data, 'path/file.json');
+  });
   ```
 
 - **Avoiding Module Property Assignment**
   ```javascript
-  // ... (existing example remains valid) ...
+  // ❌ DON'T: This causes "Cannot assign to read only property" errors
+  const utils = await import('../../scripts/modules/utils.js');
+  utils.readJSON = mockReadJSON; // Error: read-only property
+  
+  // ✅ DO: Use the module factory pattern in jest.mock()
+  jest.mock('../../scripts/modules/utils.js', () => ({
+    readJSON: mockReadJSONFunc,
+    writeJSON: mockWriteJSONFunc
+  }));
   ```
 
 - **Handling Mock Verification Failures**
   - If verification like `expect(mockFn).toHaveBeenCalled()` fails:
-    1.  Check that your mock setup (`jest.mock` or `jest.unstable_mockModule`) is correctly placed **before** imports (static or dynamic).
-    2.  Ensure you're using the right mock instance and it's properly passed to the module.
-    3.  Verify your test invokes behavior that *should* call the mock.
-    4.  Use `jest.clearAllMocks()` or specific `mockFn.mockReset()` in `beforeEach` to prevent state leakage between tests.
-    5.  **Check Console Assertions**: If verifying `console.log`, `console.warn`, or `console.error` calls, ensure your assertion matches the *actual* arguments passed. If the code logs a single formatted string, assert against that single string (using `expect.stringContaining` or exact match), not multiple `expect.stringContaining` arguments.
-        ```javascript
-        // Example: Code logs console.error(`Error: ${message}. Details: ${details}`)
-        // ❌ DON'T: Assert multiple arguments if only one is logged
-        // expect(console.error).toHaveBeenCalledWith(
-        //   expect.stringContaining('Error:'),
-        //   expect.stringContaining('Details:')
-        // );
-        // ✅ DO: Assert the single string argument
-        expect(console.error).toHaveBeenCalledWith(
-           expect.stringContaining('Error: Specific message. Details: More details')
-        );
-        // or for exact match:
-        expect(console.error).toHaveBeenCalledWith(
-           'Error: Specific message. Details: More details'
-        );
-        ```
-    6.  Consider implementing a simpler test that *only* verifies the mock behavior in isolation.
+    1. Check that your mock setup is before imports
+    2. Ensure you're using the right mock instance
+    3. Verify your test invokes behavior that would call the mock
+    4. Use `jest.clearAllMocks()` in beforeEach to reset mock state
+    5. Consider implementing a simpler test that directly verifies mock behavior
+
+- **Full Example Pattern**
+  ```javascript
+  // 1. Define mock implementations
+  const mockReadJSON = jest.fn();
+  const mockValidateAndFixDependencies = jest.fn();
+  
+  // 2. Mock modules
+  jest.mock('../../scripts/modules/utils.js', () => ({
+    readJSON: mockReadJSON,
+    // Include other functions as needed
+  }));
+  
+  jest.mock('../../scripts/modules/dependency-manager.js', () => ({
+    validateAndFixDependencies: mockValidateAndFixDependencies
+  }));
+  
+  // 3. Import after mocks
+  import * as taskManager from '../../scripts/modules/task-manager.js';
+  
+  describe('generateTaskFiles function', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+    
+    test('should generate task files', () => {
+      // 4. Setup test-specific mock behavior
+      const sampleData = { tasks: [{ id: 1, title: 'Test' }] };
+      mockReadJSON.mockReturnValueOnce(sampleData);
+      
+      // 5. Create direct implementation test
+      // Instead of calling: taskManager.generateTaskFiles('path', 'dir')
+      
+      // Simulate reading data
+      const data = mockReadJSON('path');
+      expect(mockReadJSON).toHaveBeenCalledWith('path');
+      
+      // Simulate other operations the function would perform
+      mockValidateAndFixDependencies(data, 'path');
+      expect(mockValidateAndFixDependencies).toHaveBeenCalledWith(data, 'path');
+    });
+  });
+  ```
 
 ## Mocking Guidelines
 
@@ -660,102 +552,6 @@ npm test -- -t "pattern to match"
   });
   ```
 
-## Testing AI Service Integrations
-
-- **DO NOT import real AI service clients**
-  - ❌ DON'T: Import actual AI clients from their libraries
-  - ✅ DO: Create fully mocked versions that return predictable responses
-
-  ```javascript
-  // ❌ DON'T: Import and instantiate real AI clients
-  import { Anthropic } from '@anthropic-ai/sdk';
-  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
-
-  // ✅ DO: Mock the entire module with controlled behavior
-  jest.mock('@anthropic-ai/sdk', () => ({
-    Anthropic: jest.fn().mockImplementation(() => ({
-      messages: {
-        create: jest.fn().mockResolvedValue({
-          content: [{ type: 'text', text: 'Mocked AI response' }]
-        })
-      }
-    }))
-  }));
-  ```
-
-- **DO NOT rely on environment variables for API keys**
-  - ❌ DON'T: Assume environment variables are set in tests
-  - ✅ DO: Set mock environment variables in test setup
-
-  ```javascript
-  // In tests/setup.js or at the top of test file
-  process.env.ANTHROPIC_API_KEY = 'test-mock-api-key-for-tests';
-  process.env.PERPLEXITY_API_KEY = 'test-mock-perplexity-key-for-tests';
-  ```
-
-- **DO NOT use real AI client initialization logic**
-  - ❌ DON'T: Use code that attempts to initialize or validate real AI clients
-  - ✅ DO: Create test-specific paths that bypass client initialization
-
-  ```javascript
-  // ❌ DON'T: Test functions that require valid AI client initialization
-  // This will fail without proper API keys or network access
-  test('should use AI client', async () => {
-    const result = await functionThatInitializesAIClient();
-    expect(result).toBeDefined();
-  });
-
-  // ✅ DO: Test with bypassed initialization or manual task paths
-  test('should handle manual task creation without AI', () => {
-    // Using a path that doesn't require AI client initialization
-    const result = addTaskDirect({ 
-      title: 'Manual Task', 
-      description: 'Test Description'
-    }, mockLogger);
-    
-    expect(result.success).toBe(true);
-  });
-  ```
-
-## Testing Asynchronous Code
-
-- **DO NOT rely on asynchronous operations in tests**
-  - ❌ DON'T: Use real async/await or Promise resolution in tests
-  - ✅ DO: Make all mocks return synchronous values when possible
-
-  ```javascript
-  // ❌ DON'T: Use real async functions that might fail unpredictably
-  test('should handle async operation', async () => {
-    const result = await realAsyncFunction(); // Can time out or fail for external reasons
-    expect(result).toBe(expectedValue);
-  });
-
-  // ✅ DO: Make async operations synchronous in tests
-  test('should handle operation', () => {
-    mockAsyncFunction.mockReturnValue({ success: true, data: 'test' });
-    const result = functionUnderTest();
-    expect(result).toEqual({ success: true, data: 'test' });
-  });
-  ```
-
-- **DO NOT test exact error messages**
-  - ❌ DON'T: Assert on exact error message text that might change
-  - ✅ DO: Test for error presence and general properties
-
-  ```javascript
-  // ❌ DON'T: Test for exact error message text
-  expect(result.error).toBe('Could not connect to API: Network error');
-
-  // ✅ DO: Test for general error properties or message patterns
-  expect(result.success).toBe(false);
-  expect(result.error).toContain('Could not connect');
-  // Or even better:
-  expect(result).toMatchObject({ 
-    success: false,
-    error: expect.stringContaining('connect')
-  });
-  ```
-
 ## Reliable Testing Techniques
 
 - **Create Simplified Test Functions**
@@ -768,125 +564,99 @@ npm test -- -t "pattern to match"
   const setTaskStatus = async (taskId, newStatus) => {
     const tasksPath = 'tasks/tasks.json';
     const data = await readJSON(tasksPath);
-    // [implementation]
+    // Update task status logic
     await writeJSON(tasksPath, data);
-    return { success: true };
+    return data;
   };
   
-  // Test-friendly version (easier to test)
-  const updateTaskStatus = (tasks, taskId, newStatus) => {
-    // Pure logic without side effects
-    const updatedTasks = [...tasks];
-    const taskIndex = findTaskById(updatedTasks, taskId);
-    if (taskIndex === -1) return { success: false, error: 'Task not found' };
-    updatedTasks[taskIndex].status = newStatus;
-    return { success: true, tasks: updatedTasks };
+  // Test-friendly simplified function (easy to test)
+  const testSetTaskStatus = (tasksData, taskIdInput, newStatus) => {
+    // Same core logic without file operations
+    // Update task status logic on provided tasksData object
+    return tasksData; // Return updated data for assertions
   };
   ```
 
+- **Avoid Real File System Operations**
+  - Never write to real files during tests
+  - Create test-specific versions of file operation functions
+  - Mock all file system operations including read, write, exists, etc.
+  - Verify function behavior using the in-memory data structures
+  
+  ```javascript
+  // Mock file operations
+  const mockReadJSON = jest.fn();
+  const mockWriteJSON = jest.fn();
+  
+  jest.mock('../../scripts/modules/utils.js', () => ({
+    readJSON: mockReadJSON,
+    writeJSON: mockWriteJSON,
+  }));
+  
+  test('should update task status correctly', () => {
+    // Setup mock data
+    const testData = JSON.parse(JSON.stringify(sampleTasks));
+    mockReadJSON.mockReturnValue(testData);
+    
+    // Call the function that would normally modify files
+    const result = testSetTaskStatus(testData, '1', 'done');
+    
+    // Assert on the in-memory data structure
+    expect(result.tasks[0].status).toBe('done');
+  });
+  ```
+
+- **Data Isolation Between Tests**
+  - Always create fresh copies of test data for each test
+  - Use `JSON.parse(JSON.stringify(original))` for deep cloning
+  - Reset all mocks before each test with `jest.clearAllMocks()`
+  - Avoid state that persists between tests
+  
+  ```javascript
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Deep clone the test data
+    testTasksData = JSON.parse(JSON.stringify(sampleTasks));
+  });
+  ```
+
+- **Test All Path Variations**
+  - Regular tasks and subtasks
+  - Single items and multiple items
+  - Success paths and error paths
+  - Edge cases (empty data, invalid inputs, etc.)
+  
+  ```javascript
+  // Multiple test cases covering different scenarios
+  test('should update regular task status', () => {
+    /* test implementation */
+  });
+  
+  test('should update subtask status', () => {
+    /* test implementation */
+  });
+  
+  test('should update multiple tasks when given comma-separated IDs', () => {
+    /* test implementation */
+  });
+  
+  test('should throw error for non-existent task ID', () => {
+    /* test implementation */
+  });
+  ```
+
+- **Stabilize Tests With Predictable Input/Output**
+  - Use consistent, predictable test fixtures
+  - Avoid random values or time-dependent data
+  - Make tests deterministic for reliable CI/CD
+  - Control all variables that might affect test outcomes
+  
+  ```javascript
+  // Use a specific known date instead of current date
+  const fixedDate = new Date('2023-01-01T12:00:00Z');
+  jest.spyOn(global, 'Date').mockImplementation(() => fixedDate);
+  ```
+
 See [tests/README.md](mdc:tests/README.md) for more details on the testing approach.
 
 Refer to [jest.config.js](mdc:jest.config.js) for Jest configuration options. 
-
-## Variable Hoisting and Module Initialization Issues
-
-When testing ES modules or working with complex module imports, you may encounter variable hoisting and initialization issues. These can be particularly tricky to debug and often appear as "Cannot access 'X' before initialization" errors.
-
-- **Understanding Module Initialization Order**
-  - ✅ **DO**: Declare and initialize global variables at the top of modules
-  - ✅ **DO**: Use proper function declarations to avoid hoisting issues
-  - ✅ **DO**: Initialize variables before they are referenced, especially in imported modules
-  - ✅ **DO**: Be aware that imports are hoisted to the top of the file
-  
-  ```javascript
-  // ✅ DO: Define global state variables at the top of the module
-  let silentMode = false; // Declare and initialize first
-  
-  const CONFIG = { /* configuration */ };
-  
-  function isSilentMode() {
-    return silentMode; // Reference variable after it's initialized
-  }
-  
-  function log(level, message) {
-    if (isSilentMode()) return; // Use the function instead of accessing variable directly
-    // ...
-  }
-  ```
-
-- **Testing Modules with Initialization-Dependent Functions**
-  - ✅ **DO**: Create test-specific implementations that initialize all variables correctly
-  - ✅ **DO**: Use factory functions in mocks to ensure proper initialization order
-  - ✅ **DO**: Be careful with how you mock or stub functions that depend on module state
-  
-  ```javascript
-  // ✅ DO: Test-specific implementation that avoids initialization issues
-  const testLog = (level, ...args) => {
-    // Local implementation with proper initialization
-    const isSilent = false; // Explicit initialization
-    if (isSilent) return;
-    // Test implementation...
-  };
-  ```
-
-- **Common Hoisting-Related Errors to Avoid**
-  - ❌ **DON'T**: Reference variables before their declaration in module scope
-  - ❌ **DON'T**: Create circular dependencies between modules
-  - ❌ **DON'T**: Rely on variable initialization order across module boundaries
-  - ❌ **DON'T**: Define functions that use hoisted variables before they're initialized
-  
-  ```javascript
-  // ❌ DON'T: Create reference-before-initialization patterns
-  function badFunction() {
-    if (silentMode) { /* ... */ } // ReferenceError if silentMode is declared later
-  }
-  
-  let silentMode = false;
-  
-  // ❌ DON'T: Create cross-module references that depend on initialization order
-  // module-a.js
-  import { getSetting } from './module-b.js';
-  export const config = { value: getSetting() };
-  
-  // module-b.js
-  import { config } from './module-a.js';
-  export function getSetting() {
-    return config.value; // Circular dependency causing initialization issues
-  }
-  ```
-
-- **Dynamic Imports as a Solution**
-  - ✅ **DO**: Use dynamic imports (`import()`) to avoid initialization order issues
-  - ✅ **DO**: Structure modules to avoid circular dependencies that cause initialization issues
-  - ✅ **DO**: Consider factory functions for modules with complex state
-  
-  ```javascript
-  // ✅ DO: Use dynamic imports to avoid initialization issues
-  async function getTaskManager() {
-    return import('./task-manager.js');
-  }
-  
-  async function someFunction() {
-    const taskManager = await getTaskManager();
-    return taskManager.someMethod();
-  }
-  ```
-
-- **Testing Approach for Modules with Initialization Issues**
-  - ✅ **DO**: Create self-contained test implementations rather than using real implementations
-  - ✅ **DO**: Mock dependencies at module boundaries instead of trying to mock deep dependencies
-  - ✅ **DO**: Isolate module-specific state in tests
-  
-  ```javascript
-  // ✅ DO: Create isolated test implementation instead of reusing module code
-  test('should log messages when not in silent mode', () => {
-    // Local test implementation instead of importing from module
-    const testLog = (level, message) => {
-      if (false) return; // Always non-silent for this test
-      mockConsole(level, message);
-    };
-    
-    testLog('info', 'test message');
-    expect(mockConsole).toHaveBeenCalledWith('info', 'test message');
-  });
-  ``` 

.cursor/rules/utilities.mdc

@@ -3,6 +3,7 @@ description: Guidelines for implementing utility functions
 globs: scripts/modules/utils.js, mcp-server/src/**/*
 alwaysApply: false
 ---
+
 # Utility Function Guidelines
 
 ## General Principles
@@ -78,30 +79,28 @@ alwaysApply: false
   }
   ```
 
-## Configuration Management (via `config-manager.js`)
+## Configuration Management (in `scripts/modules/utils.js`)
 
-Taskmaster configuration (excluding API keys) is primarily managed through the `.taskmasterconfig` file located in the project root and accessed via getters in [`scripts/modules/config-manager.js`](mdc:scripts/modules/config-manager.js).
+- **Environment Variables**:
+  - ✅ DO: Provide default values for all configuration
+  - ✅ DO: Use environment variables for customization
+  - ✅ DO: Document available configuration options
+  - ❌ DON'T: Hardcode values that should be configurable
 
-- **`.taskmasterconfig` File**:
-  - ✅ DO: Use this JSON file to store settings like AI model selections (main, research, fallback), parameters (temperature, maxTokens), logging level, default priority/subtasks, etc.
-  - ✅ DO: Manage this file using the `task-master models --setup` CLI command or the `models` MCP tool.
-  - ✅ DO: Rely on [`config-manager.js`](mdc:scripts/modules/config-manager.js) to load this file (using the correct project root passed from MCP or found via CLI utils), merge with defaults, and provide validated settings.
-  - ❌ DON'T: Store API keys in this file.
-  - ❌ DON'T: Manually edit this file unless necessary.
-
-- **Configuration Getters (`config-manager.js`)**:
-  - ✅ DO: Import and use specific getters from `config-manager.js` (e.g., `getMainProvider()`, `getLogLevel()`, `getMainMaxTokens()`) to access configuration values *needed for application logic* (like `getDefaultSubtasks`).
-  - ✅ DO: Pass the `explicitRoot` parameter to getters if calling from MCP direct functions to ensure the correct project's config is loaded.
-  - ❌ DON'T: Call AI-specific getters (like `getMainModelId`, `getMainMaxTokens`) from core logic functions (`scripts/modules/task-manager/*`). Instead, pass the `role` to the unified AI service.
-  - ❌ DON'T: Access configuration values directly from environment variables (except API keys).
-
-- **API Key Handling (`utils.js` & `ai-services-unified.js`)**:
-  - ✅ DO: Store API keys **only** in `.env` (for CLI, loaded by `dotenv` in `scripts/dev.js`) or `.cursor/mcp.json` (for MCP, accessed via `session.env`).
-  - ✅ DO: Use `isApiKeySet(providerName, session)` from `config-manager.js` to check if a provider's key is available *before* potentially attempting an AI call if needed, but note the unified service performs its own internal check.
-  - ✅ DO: Understand that the unified service layer (`ai-services-unified.js`) internally resolves API keys using `resolveEnvVariable(key, session)` from `utils.js`.
-
-- **Error Handling**:
-  - ✅ DO: Handle potential `ConfigurationError` if the `.taskmasterconfig` file is missing or invalid when accessed via `getConfig` (e.g., in `commands.js` or direct functions).
+  ```javascript
+  // ✅ DO: Set up configuration with defaults and environment overrides
+  const CONFIG = {
+    model: process.env.MODEL || 'claude-3-opus-20240229', // Updated default model
+    maxTokens: parseInt(process.env.MAX_TOKENS || '4000'),
+    temperature: parseFloat(process.env.TEMPERATURE || '0.7'),
+    debug: process.env.DEBUG === "true",
+    logLevel: process.env.LOG_LEVEL || "info",
+    defaultSubtasks: parseInt(process.env.DEFAULT_SUBTASKS || "3"),
+    defaultPriority: process.env.DEFAULT_PRIORITY || "medium",
+    projectName: process.env.PROJECT_NAME || "Task Master Project", // Generic project name
+    projectVersion: "1.5.0" // Version should be updated via release process
+  };
+  ```
 
 ## Logging Utilities (in `scripts/modules/utils.js`)
 
@@ -428,69 +427,36 @@ Taskmaster configuration (excluding API keys) is primarily managed through the `
 
 ## MCP Server Tool Utilities (`mcp-server/src/tools/utils.js`)
 
-These utilities specifically support the implementation and execution of MCP tools.
-
-- **`normalizeProjectRoot(rawPath, log)`**:
-    - **Purpose**: Takes a raw project root path (potentially URI encoded, with `file://` prefix, Windows slashes) and returns a normalized, absolute path suitable for the server's OS.
-    - **Logic**: Decodes URI, strips `file://`, handles Windows drive prefix (`/C:/`), replaces `\` with `/`, uses `path.resolve()`.
-    - **Usage**: Used internally by `withNormalizedProjectRoot` HOF.
-
-- **`getRawProjectRootFromSession(session, log)`**:
-    - **Purpose**: Extracts the *raw* project root URI string from the session object (`session.roots[0].uri` or `session.roots.roots[0].uri`) without performing normalization.
-    - **Usage**: Used internally by `withNormalizedProjectRoot` HOF as a fallback if `args.projectRoot` isn't provided.
-
-- **`withNormalizedProjectRoot(executeFn)`**:
-    - **Purpose**: A Higher-Order Function (HOF) designed to wrap a tool's `execute` method.
-    - **Logic**: 
-        1. Determines the raw project root (from `args.projectRoot` or `getRawProjectRootFromSession`).
-        2. Normalizes the raw path using `normalizeProjectRoot`.
-        3. Injects the normalized, absolute path back into the `args` object as `args.projectRoot`.
-        4. Calls the original `executeFn` with the updated `args`.
-    - **Usage**: Should wrap the `execute` function of *every* MCP tool that needs a reliable, normalized project root path.
-    - **Example**:
-      ```javascript
-      // In mcp-server/src/tools/your-tool.js
-      import { withNormalizedProjectRoot } from './utils.js';
-      
-      export function registerYourTool(server) {
-          server.addTool({
-              // ... name, description, parameters ...
-              execute: withNormalizedProjectRoot(async (args, context) => {
-                  // args.projectRoot is now normalized here
-                  const { projectRoot /*, other args */ } = args;
-                  // ... rest of tool logic using normalized projectRoot ...
-              })
-          });
-      }
-      ```
-
-- **`handleApiResult(result, log, errorPrefix, processFunction)`**:
-    - **Purpose**: Standardizes the formatting of responses returned by direct functions (`{ success, data/error, fromCache }`) into the MCP response format.
-    - **Usage**: Call this at the end of the tool's `execute` method, passing the result from the direct function call.
-
-- **`createContentResponse(content)` / `createErrorResponse(errorMessage)`**:
-    - **Purpose**: Helper functions to create the basic MCP response structure for success or error messages.
-    - **Usage**: Used internally by `handleApiResult` and potentially directly for simple responses.
-
-- **`createLogWrapper(log)`**:
-    - **Purpose**: Creates a logger object wrapper with standard methods (`info`, `warn`, `error`, `debug`, `success`) mapping to the passed MCP `log` object's methods. Ensures compatibility when passing loggers to core functions.
-    - **Usage**: Used within direct functions before passing the `log` object down to core logic that expects the standard method names.
-
-- **`getCachedOrExecute({ cacheKey, actionFn, log })`**:
-    - **Purpose**: Utility for implementing caching within direct functions. Checks cache for `cacheKey`; if miss, executes `actionFn`, caches successful result, and returns.
-    - **Usage**: Wrap the core logic execution within a direct function call.
-
-- **`processMCPResponseData(taskOrData, fieldsToRemove)`**:
-    - **Purpose**: Utility to filter potentially sensitive or large fields (like `details`, `testStrategy`) from task objects before sending the response back via MCP.
-    - **Usage**: Passed as the default `processFunction` to `handleApiResult`.
+- **Purpose**: These utilities specifically support the MCP server tools ([`mcp-server/src/tools/*.js`](mdc:mcp-server/src/tools/*.js)), handling MCP communication patterns, response formatting, caching integration, and the CLI fallback mechanism.
+- **Refer to [`mcp.mdc`](mdc:.cursor/rules/mcp.mdc)** for detailed usage patterns within the MCP tool `execute` methods and direct function wrappers.
 
 - **`getProjectRootFromSession(session, log)`**: 
-    - **Purpose**: Legacy function to extract *and normalize* the project root from the session. Replaced by the HOF pattern but potentially still used.
-    - **Recommendation**: Prefer using the `withNormalizedProjectRoot` HOF in tools instead of calling this directly.
+    - ✅ **DO**: Call this utility **within the MCP tool's `execute` method** to extract the project root path from the `session` object.
+    - Decodes the `file://` URI and handles potential errors.
+    - Returns the project path string or `null`.
+    - The returned path should then be passed in the `args` object when calling the corresponding `*Direct` function (e.g., `yourDirectFunction({ ...args, projectRoot: rootFolder }, log)`).
 
-- **`executeTaskMasterCommand(...)`**: 
-    - **Purpose**: Executes `task-master` CLI command as a fallback. 
-    - **Recommendation**: Deprecated for most uses; prefer direct function calls.
+- **`handleApiResult(result, log, errorPrefix, processFunction)`**:
+    - ✅ **DO**: Call this from the MCP tool's `execute` method after receiving the result from the `*Direct` function wrapper.
+    - Takes the standard `{ success, data/error, fromCache }` object.
+    - Formats the standard MCP success or error response, including the `fromCache` flag.
+    - Uses `processMCPResponseData` by default to filter response data.
+
+- **`executeTaskMasterCommand(command, log, args, projectRootRaw)`**:
+    - Executes a Task Master CLI command as a child process.
+    - Handles fallback between global `task-master` and local `node scripts/dev.js`.
+    - ❌ **DON'T**: Use this as the primary method for MCP tools. Prefer direct function calls via `*Direct` wrappers.
+
+- **`processMCPResponseData(taskOrData, fieldsToRemove)`**:
+    - Filters task data (e.g., removing `details`, `testStrategy`) before sending to the MCP client. Called by `handleApiResult`.
+
+- **`createContentResponse(content)` / `createErrorResponse(errorMessage)`**:
+    - Formatters for standard MCP success/error responses.
+
+- **`getCachedOrExecute({ cacheKey, actionFn, log })`**:
+    - ✅ **DO**: Use this utility *inside direct function wrappers* to implement caching.
+    - Checks cache, executes `actionFn` on miss, stores result.
+    - Returns standard `{ success, data/error, fromCache: boolean }`.
 
 ## Export Organization
 

.env.example

@@ -1,9 +1,20 @@
-# API Keys (Required for using in any role i.e. main/research/fallback -- see `task-master models`)
-ANTHROPIC_API_KEY=YOUR_ANTHROPIC_KEY_HERE
-PERPLEXITY_API_KEY=YOUR_PERPLEXITY_KEY_HERE
-OPENAI_API_KEY=YOUR_OPENAI_KEY_HERE
-GOOGLE_API_KEY=YOUR_GOOGLE_KEY_HERE
-MISTRAL_API_KEY=YOUR_MISTRAL_KEY_HERE
-OPENROUTER_API_KEY=YOUR_OPENROUTER_KEY_HERE
-XAI_API_KEY=YOUR_XAI_KEY_HERE
-AZURE_OPENAI_API_KEY=YOUR_AZURE_KEY_HERE
+# API Keys (Required)
+ANTHROPIC_API_KEY=your_anthropic_api_key_here       # Format: sk-ant-api03-...
+PERPLEXITY_API_KEY=your_perplexity_api_key_here     # Format: pplx-...
+
+# Model Configuration
+MODEL=claude-3-7-sonnet-20250219                    # Recommended models: claude-3-7-sonnet-20250219, claude-3-opus-20240229
+PERPLEXITY_MODEL=sonar-pro                          # Perplexity model for research-backed subtasks
+MAX_TOKENS=128000                                   # Maximum tokens for model responses
+TEMPERATURE=0.2                                     # Temperature for model responses (0.0-1.0)
+
+# Logging Configuration
+DEBUG=false                                         # Enable debug logging (true/false)
+LOG_LEVEL=info                                      # Log level (debug, info, warn, error)
+
+# Task Generation Settings
+DEFAULT_SUBTASKS=5                                  # Default number of subtasks when expanding
+DEFAULT_PRIORITY=medium                             # Default priority for generated tasks (high, medium, low)
+
+# Project Metadata (Optional)
+    PROJECT_NAME=Your Project Name                  # Override default project name in tasks.json

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,39 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: 'bug: '
-labels: bug
-assignees: ''
----
-
-### Description
-
-Detailed description of the problem, including steps to reproduce the issue.
-
-### Steps to Reproduce
-
-1. Step-by-step instructions to reproduce the issue
-2. Include command examples or UI interactions
-
-### Expected Behavior
-
-Describe clearly what the expected outcome or behavior should be.
-
-### Actual Behavior
-
-Describe clearly what the actual outcome or behavior is.
-
-### Screenshots or Logs
-
-Provide screenshots, logs, or error messages if applicable.
-
-### Environment
-
-- Task Master version:
-- Node.js version:
-- Operating system:
-- IDE (if applicable):
-
-### Additional Context
-
-Any additional information or context that might help diagnose the issue.

.github/ISSUE_TEMPLATE/enhancements---feature-requests.md

@@ -1,51 +0,0 @@
----
-name: Enhancements & feature requests
-about: Suggest an idea for this project
-title: 'feat: '
-labels: enhancement
-assignees: ''
----
-
-> "Direct quote or clear summary of user request or need or user story."
-
-### Motivation
-
-Detailed explanation of why this feature is important. Describe the problem it solves or the benefit it provides.
-
-### Proposed Solution
-
-Clearly describe the proposed feature, including:
-
-- High-level overview of the feature
-- Relevant technologies or integrations
-- How it fits into the existing workflow or architecture
-
-### High-Level Workflow
-
-1. Step-by-step description of how the feature will be implemented
-2. Include necessary intermediate milestones
-
-### Key Elements
-
-- Bullet-point list of technical or UX/UI enhancements
-- Mention specific integrations or APIs
-- Highlight changes needed in existing data models or commands
-
-### Example Workflow
-
-Provide a clear, concrete example demonstrating the feature:
-
-```shell
-$ task-master [action]
-→ Expected response/output
-```
-
-### Implementation Considerations
-
-- Dependencies on external components or APIs
-- Backward compatibility requirements
-- Potential performance impacts or resource usage
-
-### Out of Scope (Future Considerations)
-
-Clearly list any features or improvements not included but relevant for future iterations.

.github/ISSUE_TEMPLATE/feedback.md

@@ -1,31 +0,0 @@
----
-name: Feedback
-about: Give us specific feedback on the product/approach/tech
-title: 'feedback: '
-labels: feedback
-assignees: ''
----
-
-### Feedback Summary
-
-Provide a clear summary or direct quote from user feedback.
-
-### User Context
-
-Explain the user's context or scenario in which this feedback was provided.
-
-### User Impact
-
-Describe how this feedback affects the user experience or workflow.
-
-### Suggestions
-
-Provide any initial thoughts, potential solutions, or improvements based on the feedback.
-
-### Relevant Screenshots or Examples
-
-Attach screenshots, logs, or examples that illustrate the feedback.
-
-### Additional Notes
-
-Any additional context or related information.

.github/workflows/pre-release.yml

@@ -1,62 +0,0 @@
-name: Pre-Release (RC)
-
-on:
-  workflow_dispatch: # Allows manual triggering from GitHub UI/API
-
-concurrency: pre-release-${{ github.ref }}
-
-jobs:
-  rc:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: 'npm'
-
-      - name: Cache node_modules
-        uses: actions/cache@v4
-        with:
-          path: |
-            node_modules
-            */*/node_modules
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-
-      - name: Install dependencies
-        run: npm ci
-        timeout-minutes: 2
-
-      - name: Enter RC mode
-        run: |
-          npx changeset pre exit || true
-          npx changeset pre enter rc
-
-      - name: Version RC packages
-        run: npx changeset version
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Create Release Candidate Pull Request or Publish Release Candidate to npm
-        uses: changesets/action@v1
-        with:
-          publish: npm run release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Exit RC mode
-        run: npx changeset pre exit
-
-      - name: Commit & Push changes
-        uses: actions-js/push@master
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          branch: ${{ github.ref }}
-          message: 'chore: rc version bump'

.github/workflows/release.yml

@@ -3,9 +3,6 @@ on:
   push:
     branches:
       - main
-
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-
 jobs:
   release:
     runs-on: ubuntu-latest
@@ -33,9 +30,6 @@ jobs:
         run: npm ci
         timeout-minutes: 2
 
-      - name: Exit pre-release mode (safety check)
-        run: npx changeset pre exit || true
-
       - name: Create Release Pull Request or Publish to npm
         uses: changesets/action@v1
         with:

.github/workflows/update-models-md.yml

@@ -1,40 +0,0 @@
-name: Update models.md from supported-models.json
-
-on:
-  push:
-    branches:
-      - main
-      - next
-    paths:
-      - 'scripts/modules/supported-models.json'
-      - 'docs/scripts/models-json-to-markdown.js'
-
-jobs:
-  update_markdown:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Run transformation script
-        run: node docs/scripts/models-json-to-markdown.js
-
-      - name: Format Markdown with Prettier
-        run: npx prettier --write docs/models.md
-
-      - name: Stage docs/models.md
-        run: git add docs/models.md
-
-      - name: Commit & Push docs/models.md
-        uses: actions-js/push@master
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          branch: ${{ github.ref_name }}
-          message: 'docs: Auto-update and format models.md'
-          author_name: 'github-actions[bot]'
-          author_email: 'github-actions[bot]@users.noreply.github.com'

.gitignore

@@ -19,8 +19,6 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 lerna-debug.log*
-tests/e2e/_runs/
-tests/e2e/log/
 
 # Coverage directory used by tools like istanbul
 coverage
@@ -61,6 +59,3 @@ dist
 *.debug
 init-debug.log
 dev-debug.log
-
-# NPMRC
-.npmrc

.prettierignore

@@ -4,4 +4,3 @@ coverage
 .changeset
 tasks
 package-lock.json
-tests/fixture/*.json

.taskmasterconfig

@@ -1,32 +0,0 @@
-{
-	"models": {
-		"main": {
-			"provider": "anthropic",
-			"modelId": "claude-sonnet-4-20250514",
-			"maxTokens": 50000,
-			"temperature": 0.2
-		},
-		"research": {
-			"provider": "perplexity",
-			"modelId": "sonar-pro",
-			"maxTokens": 8700,
-			"temperature": 0.1
-		},
-		"fallback": {
-			"provider": "anthropic",
-			"modelId": "claude-3-7-sonnet-20250219",
-			"maxTokens": 128000,
-			"temperature": 0.2
-		}
-	},
-	"global": {
-		"logLevel": "info",
-		"debug": false,
-		"defaultSubtasks": 5,
-		"defaultPriority": "medium",
-		"projectName": "Taskmaster",
-		"ollamaBaseUrl": "http://localhost:11434/api",
-		"userId": "1234567890",
-		"azureOpenaiBaseUrl": "https://your-endpoint.openai.azure.com/"
-	}
-}

.vscode/extensions.json

@@ -1,3 +0,0 @@
-{
-	"recommendations": ["esbenp.prettier-vscode"]
-}

CHANGELOG.md

@@ -1,470 +1,5 @@
 # task-master-ai
 
-## 0.15.0
-
-### Minor Changes
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`09add37`](https://github.com/eyaltoledano/claude-task-master/commit/09add37423d70b809d5c28f3cde9fccd5a7e64e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Added comprehensive Ollama model validation and interactive setup support
-
-  - **Interactive Setup Enhancement**: Added "Custom Ollama model" option to `task-master models --setup`, matching the existing OpenRouter functionality
-  - **Live Model Validation**: When setting Ollama models, Taskmaster now validates against the local Ollama instance by querying `/api/tags` endpoint
-  - **Configurable Endpoints**: Uses the `ollamaBaseUrl` from `.taskmasterconfig` (with role-specific `baseUrl` overrides supported)
-  - **Robust Error Handling**:
-    - Detects when Ollama server is not running and provides clear error messages
-    - Validates model existence and lists available alternatives when model not found
-    - Graceful fallback behavior for connection issues
-  - **Full Platform Support**: Both MCP server tools and CLI commands support the new validation
-  - **Improved User Experience**: Clear feedback during model validation with informative success/error messages
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`4c83526`](https://github.com/eyaltoledano/claude-task-master/commit/4c835264ac6c1f74896cddabc3b3c69a5c435417) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds and updates supported AI models with costs:
-
-  - Added new OpenRouter models: GPT-4.1 series, O3, Codex Mini, Llama 4 Maverick, Llama 4 Scout, Qwen3-235b
-  - Added Mistral models: Devstral Small, Mistral Nemo
-  - Updated Ollama models with latest variants: Devstral, Qwen3, Mistral-small3.1, Llama3.3
-  - Updated Gemini model to latest 2.5 Flash preview version
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`70f4054`](https://github.com/eyaltoledano/claude-task-master/commit/70f4054f268f9f8257870e64c24070263d4e2966) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add `--research` flag to parse-prd command, enabling enhanced task generation from PRD files. When used, Taskmaster leverages the research model to:
-
-  - Research current technologies and best practices relevant to the project
-  - Identify technical challenges and security concerns not explicitly mentioned in the PRD
-  - Include specific library recommendations with version numbers
-  - Provide more detailed implementation guidance based on industry standards
-  - Create more accurate dependency relationships between tasks
-
-  This results in higher quality, more actionable tasks with minimal additional effort.
-
-  _NOTE_ That this is an experimental feature. Research models don't typically do great at structured output. You may find some failures when using research mode, so please share your feedback so we can improve this.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`5e9bc28`](https://github.com/eyaltoledano/claude-task-master/commit/5e9bc28abea36ec7cd25489af7fcc6cbea51038b) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - This change significantly enhances the `add-task` command's intelligence. When you add a new task, Taskmaster now automatically: - Analyzes your existing tasks to find those most relevant to your new task's description. - Provides the AI with detailed context from these relevant tasks.
-
-  This results in newly created tasks being more accurately placed within your project's dependency structure, saving you time and any need to update tasks just for dependencies, all without significantly increasing AI costs. You'll get smarter, more connected tasks right from the start.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34c769b`](https://github.com/eyaltoledano/claude-task-master/commit/34c769bcd0faf65ddec3b95de2ba152a8be3ec5c) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Enhance analyze-complexity to support analyzing specific task IDs. - You can now analyze individual tasks or selected task groups by using the new `--id` option with comma-separated IDs, or `--from` and `--to` options to specify a range of tasks. - The feature intelligently merges analysis results with existing reports, allowing incremental analysis while preserving previous results.
-
-- [#558](https://github.com/eyaltoledano/claude-task-master/pull/558) [`86d8f00`](https://github.com/eyaltoledano/claude-task-master/commit/86d8f00af809887ee0ba0ba7157cc555e0d07c38) Thanks [@ShreyPaharia](https://github.com/ShreyPaharia)! - Add next task to set task status response
-  Status: DONE
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`04af16d`](https://github.com/eyaltoledano/claude-task-master/commit/04af16de27295452e134b17b3c7d0f44bbb84c29) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add move command to enable moving tasks and subtasks within the task hierarchy. This new command supports moving standalone tasks to become subtasks, subtasks to become standalone tasks, and moving subtasks between different parents. The implementation handles circular dependencies, validation, and proper updating of parent-child relationships.
-
-  **Usage:**
-
-  - CLI command: `task-master move --from=<id> --to=<id>`
-  - MCP tool: `move_task` with parameters:
-    - `from`: ID of task/subtask to move (e.g., "5" or "5.2")
-    - `to`: ID of destination (e.g., "7" or "7.3")
-    - `file` (optional): Custom path to tasks.json
-
-  **Example scenarios:**
-
-  - Move task to become subtask: `--from="5" --to="7"`
-  - Move subtask to standalone task: `--from="5.2" --to="7"`
-  - Move subtask to different parent: `--from="5.2" --to="7.3"`
-  - Reorder subtask within same parent: `--from="5.2" --to="5.4"`
-  - Move multiple tasks at once: `--from="10,11,12" --to="16,17,18"`
-  - Move task to new ID: `--from="5" --to="25"` (creates a new task with ID 25)
-
-  **Multiple Task Support:**
-  The command supports moving multiple tasks simultaneously by providing comma-separated lists for both `--from` and `--to` parameters. The number of source and destination IDs must match. This is particularly useful for resolving merge conflicts in task files when multiple team members have created tasks on different branches.
-
-  **Validation Features:**
-
-  - Allows moving tasks to new, non-existent IDs (automatically creates placeholders)
-  - Prevents moving to existing task IDs that already contain content (to avoid overwriting)
-  - Validates source tasks exist before attempting to move them
-  - Ensures proper parent-child relationships are maintained
-
-### Patch Changes
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`231e569`](https://github.com/eyaltoledano/claude-task-master/commit/231e569e84804a2e5ba1f9da1a985d0851b7e949) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adjusts default main model model to Claude Sonnet 4. Adjusts default fallback to Claude Sonney 3.7"
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`b371808`](https://github.com/eyaltoledano/claude-task-master/commit/b371808524f2c2986f4940d78fcef32c125d01f2) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds llms-install.md to the root to enable AI agents to programmatically install the Taskmaster MCP server. This is specifically being introduced for the Cline MCP marketplace and will be adjusted over time for other MCP clients as needed.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`a59dd03`](https://github.com/eyaltoledano/claude-task-master/commit/a59dd037cfebb46d38bc44dd216c7c23933be641) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds AGENTS.md to power Claude Code integration more natively based on Anthropic's best practice and Claude-specific MCP client behaviours. Also adds in advanced workflows that tie Taskmaster commands together into one Claude workflow."
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`e0e1155`](https://github.com/eyaltoledano/claude-task-master/commit/e0e115526089bf41d5d60929956edf5601ff3e23) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes issue with force/append flag combinations for parse-prd.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34df2c8`](https://github.com/eyaltoledano/claude-task-master/commit/34df2c8bbddc0e157c981d32502bbe6b9468202e) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - You can now add tasks to a newly initialized project without having to parse a prd. This will automatically create the missing tasks.json file and create the first task. Lets you vibe if you want to vibe."
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`d2e6431`](https://github.com/eyaltoledano/claude-task-master/commit/d2e64318e2f4bfc3457792e310cc4ff9210bba30) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue where the research fallback would attempt to make API calls without checking for a valid API key first. This ensures proper error handling when the main task generation and first fallback both fail. Closes #421 #519.
-
-## 0.15.0-rc.0
-
-### Minor Changes
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`09add37`](https://github.com/eyaltoledano/claude-task-master/commit/09add37423d70b809d5c28f3cde9fccd5a7e64e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Added comprehensive Ollama model validation and interactive setup support
-
-  - **Interactive Setup Enhancement**: Added "Custom Ollama model" option to `task-master models --setup`, matching the existing OpenRouter functionality
-  - **Live Model Validation**: When setting Ollama models, Taskmaster now validates against the local Ollama instance by querying `/api/tags` endpoint
-  - **Configurable Endpoints**: Uses the `ollamaBaseUrl` from `.taskmasterconfig` (with role-specific `baseUrl` overrides supported)
-  - **Robust Error Handling**:
-    - Detects when Ollama server is not running and provides clear error messages
-    - Validates model existence and lists available alternatives when model not found
-    - Graceful fallback behavior for connection issues
-  - **Full Platform Support**: Both MCP server tools and CLI commands support the new validation
-  - **Improved User Experience**: Clear feedback during model validation with informative success/error messages
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`4c83526`](https://github.com/eyaltoledano/claude-task-master/commit/4c835264ac6c1f74896cddabc3b3c69a5c435417) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds and updates supported AI models with costs:
-
-  - Added new OpenRouter models: GPT-4.1 series, O3, Codex Mini, Llama 4 Maverick, Llama 4 Scout, Qwen3-235b
-  - Added Mistral models: Devstral Small, Mistral Nemo
-  - Updated Ollama models with latest variants: Devstral, Qwen3, Mistral-small3.1, Llama3.3
-  - Updated Gemini model to latest 2.5 Flash preview version
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`70f4054`](https://github.com/eyaltoledano/claude-task-master/commit/70f4054f268f9f8257870e64c24070263d4e2966) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add `--research` flag to parse-prd command, enabling enhanced task generation from PRD files. When used, Taskmaster leverages the research model to:
-
-  - Research current technologies and best practices relevant to the project
-  - Identify technical challenges and security concerns not explicitly mentioned in the PRD
-  - Include specific library recommendations with version numbers
-  - Provide more detailed implementation guidance based on industry standards
-  - Create more accurate dependency relationships between tasks
-
-  This results in higher quality, more actionable tasks with minimal additional effort.
-
-  _NOTE_ That this is an experimental feature. Research models don't typically do great at structured output. You may find some failures when using research mode, so please share your feedback so we can improve this.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`5e9bc28`](https://github.com/eyaltoledano/claude-task-master/commit/5e9bc28abea36ec7cd25489af7fcc6cbea51038b) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - This change significantly enhances the `add-task` command's intelligence. When you add a new task, Taskmaster now automatically: - Analyzes your existing tasks to find those most relevant to your new task's description. - Provides the AI with detailed context from these relevant tasks.
-
-  This results in newly created tasks being more accurately placed within your project's dependency structure, saving you time and any need to update tasks just for dependencies, all without significantly increasing AI costs. You'll get smarter, more connected tasks right from the start.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34c769b`](https://github.com/eyaltoledano/claude-task-master/commit/34c769bcd0faf65ddec3b95de2ba152a8be3ec5c) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Enhance analyze-complexity to support analyzing specific task IDs. - You can now analyze individual tasks or selected task groups by using the new `--id` option with comma-separated IDs, or `--from` and `--to` options to specify a range of tasks. - The feature intelligently merges analysis results with existing reports, allowing incremental analysis while preserving previous results.
-
-- [#558](https://github.com/eyaltoledano/claude-task-master/pull/558) [`86d8f00`](https://github.com/eyaltoledano/claude-task-master/commit/86d8f00af809887ee0ba0ba7157cc555e0d07c38) Thanks [@ShreyPaharia](https://github.com/ShreyPaharia)! - Add next task to set task status response
-  Status: DONE
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`04af16d`](https://github.com/eyaltoledano/claude-task-master/commit/04af16de27295452e134b17b3c7d0f44bbb84c29) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add move command to enable moving tasks and subtasks within the task hierarchy. This new command supports moving standalone tasks to become subtasks, subtasks to become standalone tasks, and moving subtasks between different parents. The implementation handles circular dependencies, validation, and proper updating of parent-child relationships.
-
-  **Usage:**
-
-  - CLI command: `task-master move --from=<id> --to=<id>`
-  - MCP tool: `move_task` with parameters:
-    - `from`: ID of task/subtask to move (e.g., "5" or "5.2")
-    - `to`: ID of destination (e.g., "7" or "7.3")
-    - `file` (optional): Custom path to tasks.json
-
-  **Example scenarios:**
-
-  - Move task to become subtask: `--from="5" --to="7"`
-  - Move subtask to standalone task: `--from="5.2" --to="7"`
-  - Move subtask to different parent: `--from="5.2" --to="7.3"`
-  - Reorder subtask within same parent: `--from="5.2" --to="5.4"`
-  - Move multiple tasks at once: `--from="10,11,12" --to="16,17,18"`
-  - Move task to new ID: `--from="5" --to="25"` (creates a new task with ID 25)
-
-  **Multiple Task Support:**
-  The command supports moving multiple tasks simultaneously by providing comma-separated lists for both `--from` and `--to` parameters. The number of source and destination IDs must match. This is particularly useful for resolving merge conflicts in task files when multiple team members have created tasks on different branches.
-
-  **Validation Features:**
-
-  - Allows moving tasks to new, non-existent IDs (automatically creates placeholders)
-  - Prevents moving to existing task IDs that already contain content (to avoid overwriting)
-  - Validates source tasks exist before attempting to move them
-  - Ensures proper parent-child relationships are maintained
-
-### Patch Changes
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`231e569`](https://github.com/eyaltoledano/claude-task-master/commit/231e569e84804a2e5ba1f9da1a985d0851b7e949) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adjusts default main model model to Claude Sonnet 4. Adjusts default fallback to Claude Sonney 3.7"
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`b371808`](https://github.com/eyaltoledano/claude-task-master/commit/b371808524f2c2986f4940d78fcef32c125d01f2) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds llms-install.md to the root to enable AI agents to programmatically install the Taskmaster MCP server. This is specifically being introduced for the Cline MCP marketplace and will be adjusted over time for other MCP clients as needed.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`a59dd03`](https://github.com/eyaltoledano/claude-task-master/commit/a59dd037cfebb46d38bc44dd216c7c23933be641) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds AGENTS.md to power Claude Code integration more natively based on Anthropic's best practice and Claude-specific MCP client behaviours. Also adds in advanced workflows that tie Taskmaster commands together into one Claude workflow."
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`e0e1155`](https://github.com/eyaltoledano/claude-task-master/commit/e0e115526089bf41d5d60929956edf5601ff3e23) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes issue with force/append flag combinations for parse-prd.
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`34df2c8`](https://github.com/eyaltoledano/claude-task-master/commit/34df2c8bbddc0e157c981d32502bbe6b9468202e) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - You can now add tasks to a newly initialized project without having to parse a prd. This will automatically create the missing tasks.json file and create the first task. Lets you vibe if you want to vibe."
-
-- [#567](https://github.com/eyaltoledano/claude-task-master/pull/567) [`d2e6431`](https://github.com/eyaltoledano/claude-task-master/commit/d2e64318e2f4bfc3457792e310cc4ff9210bba30) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue where the research fallback would attempt to make API calls without checking for a valid API key first. This ensures proper error handling when the main task generation and first fallback both fail. Closes #421 #519.
-
-## 0.14.0
-
-### Minor Changes
-
-- [#521](https://github.com/eyaltoledano/claude-task-master/pull/521) [`ed17cb0`](https://github.com/eyaltoledano/claude-task-master/commit/ed17cb0e0a04dedde6c616f68f24f3660f68dd04) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - .taskmasterconfig now supports a baseUrl field per model role (main, research, fallback), allowing endpoint overrides for any provider.
-
-- [#536](https://github.com/eyaltoledano/claude-task-master/pull/536) [`f4a83ec`](https://github.com/eyaltoledano/claude-task-master/commit/f4a83ec047b057196833e3a9b861d4bceaec805d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Ollama as a supported AI provider.
-
-  - You can now add it by running `task-master models --setup` and selecting it.
-  - Ollama is a local model provider, so no API key is required.
-  - Ollama models are available at `http://localhost:11434/api` by default.
-  - You can change the default URL by setting the `OLLAMA_BASE_URL` environment variable or by adding a `baseUrl` property to the `ollama` model role in `.taskmasterconfig`.
-    - If you want to use a custom API key, you can set it in the `OLLAMA_API_KEY` environment variable.
-
-- [#528](https://github.com/eyaltoledano/claude-task-master/pull/528) [`58b417a`](https://github.com/eyaltoledano/claude-task-master/commit/58b417a8ce697e655f749ca4d759b1c20014c523) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Display task complexity scores in task lists, next task, and task details views.
-
-### Patch Changes
-
-- [#402](https://github.com/eyaltoledano/claude-task-master/pull/402) [`01963af`](https://github.com/eyaltoledano/claude-task-master/commit/01963af2cb6f77f43b2ad8a6e4a838ec205412bc) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Resolve all issues related to MCP
-
-- [#478](https://github.com/eyaltoledano/claude-task-master/pull/478) [`4117f71`](https://github.com/eyaltoledano/claude-task-master/commit/4117f71c18ee4d321a9c91308d00d5d69bfac61e) Thanks [@joedanz](https://github.com/joedanz)! - Fix CLI --force flag for parse-prd command
-
-  Previously, the --force flag was not respected when running `parse-prd`, causing the command to prompt for confirmation or fail even when --force was provided. This patch ensures that the flag is correctly passed and handled, allowing users to overwrite existing tasks.json files as intended.
-
-  - Fixes #477
-
-- [#511](https://github.com/eyaltoledano/claude-task-master/pull/511) [`17294ff`](https://github.com/eyaltoledano/claude-task-master/commit/17294ff25918d64278674e558698a1a9ad785098) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Task Master no longer tells you to update when you're already up to date
-
-- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`2b3ae8b`](https://github.com/eyaltoledano/claude-task-master/commit/2b3ae8bf89dc471c4ce92f3a12ded57f61faa449) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds costs information to AI commands using input/output tokens and model costs.
-
-- [#402](https://github.com/eyaltoledano/claude-task-master/pull/402) [`01963af`](https://github.com/eyaltoledano/claude-task-master/commit/01963af2cb6f77f43b2ad8a6e4a838ec205412bc) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix ERR_MODULE_NOT_FOUND when trying to run MCP Server
-
-- [#402](https://github.com/eyaltoledano/claude-task-master/pull/402) [`01963af`](https://github.com/eyaltoledano/claude-task-master/commit/01963af2cb6f77f43b2ad8a6e4a838ec205412bc) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add src directory to exports
-
-- [#523](https://github.com/eyaltoledano/claude-task-master/pull/523) [`da317f2`](https://github.com/eyaltoledano/claude-task-master/commit/da317f2607ca34db1be78c19954996f634c40923) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix the error handling of task status settings
-
-- [#527](https://github.com/eyaltoledano/claude-task-master/pull/527) [`a8dabf4`](https://github.com/eyaltoledano/claude-task-master/commit/a8dabf44856713f488960224ee838761716bba26) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Remove caching layer from MCP direct functions for task listing, next task, and complexity report
-
-  - Fixes issues users where having where they were getting stale data
-
-- [#417](https://github.com/eyaltoledano/claude-task-master/pull/417) [`a1f8d52`](https://github.com/eyaltoledano/claude-task-master/commit/a1f8d52474fdbdf48e17a63e3f567a6d63010d9f) Thanks [@ksylvan](https://github.com/ksylvan)! - Fix for issue #409 LOG_LEVEL Pydantic validation error
-
-- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`0288311`](https://github.com/eyaltoledano/claude-task-master/commit/0288311965ae2a343ebee4a0c710dde94d2ae7e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Small fixes - `next` command no longer incorrectly suggests that subtasks be broken down into subtasks in the CLI - fixes the `append` flag so it properly works in the CLI
-
-- [#501](https://github.com/eyaltoledano/claude-task-master/pull/501) [`0a61184`](https://github.com/eyaltoledano/claude-task-master/commit/0a611843b56a856ef0a479dc34078326e05ac3a8) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix initial .env.example to work out of the box
-
-  - Closes #419
-
-- [#435](https://github.com/eyaltoledano/claude-task-master/pull/435) [`a96215a`](https://github.com/eyaltoledano/claude-task-master/commit/a96215a359b25061fd3b3f3c7b10e8ac0390c062) Thanks [@lebsral](https://github.com/lebsral)! - Fix default fallback model and maxTokens in Taskmaster initialization
-
-- [#517](https://github.com/eyaltoledano/claude-task-master/pull/517) [`e96734a`](https://github.com/eyaltoledano/claude-task-master/commit/e96734a6cc6fec7731de72eb46b182a6e3743d02) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix bug when updating tasks on the MCP server (#412)
-
-- [#496](https://github.com/eyaltoledano/claude-task-master/pull/496) [`efce374`](https://github.com/eyaltoledano/claude-task-master/commit/efce37469bc58eceef46763ba32df1ed45242211) Thanks [@joedanz](https://github.com/joedanz)! - Fix duplicate output on CLI help screen
-
-  - Prevent the Task Master CLI from printing the help screen more than once when using `-h` or `--help`.
-  - Removed redundant manual event handlers and guards for help output; now only the Commander `.helpInformation` override is used for custom help.
-  - Simplified logic so that help is only shown once for both "no arguments" and help flag flows.
-  - Ensures a clean, branded help experience with no repeated content.
-  - Fixes #339
-
-## 0.14.0-rc.1
-
-### Minor Changes
-
-- [#536](https://github.com/eyaltoledano/claude-task-master/pull/536) [`f4a83ec`](https://github.com/eyaltoledano/claude-task-master/commit/f4a83ec047b057196833e3a9b861d4bceaec805d) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add Ollama as a supported AI provider.
-
-  - You can now add it by running `task-master models --setup` and selecting it.
-  - Ollama is a local model provider, so no API key is required.
-  - Ollama models are available at `http://localhost:11434/api` by default.
-  - You can change the default URL by setting the `OLLAMA_BASE_URL` environment variable or by adding a `baseUrl` property to the `ollama` model role in `.taskmasterconfig`.
-    - If you want to use a custom API key, you can set it in the `OLLAMA_API_KEY` environment variable.
-
-### Patch Changes
-
-- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`2b3ae8b`](https://github.com/eyaltoledano/claude-task-master/commit/2b3ae8bf89dc471c4ce92f3a12ded57f61faa449) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds costs information to AI commands using input/output tokens and model costs.
-
-- [#442](https://github.com/eyaltoledano/claude-task-master/pull/442) [`0288311`](https://github.com/eyaltoledano/claude-task-master/commit/0288311965ae2a343ebee4a0c710dde94d2ae7e7) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Small fixes - `next` command no longer incorrectly suggests that subtasks be broken down into subtasks in the CLI - fixes the `append` flag so it properly works in the CLI
-
-## 0.14.0-rc.0
-
-### Minor Changes
-
-- [#521](https://github.com/eyaltoledano/claude-task-master/pull/521) [`ed17cb0`](https://github.com/eyaltoledano/claude-task-master/commit/ed17cb0e0a04dedde6c616f68f24f3660f68dd04) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - .taskmasterconfig now supports a baseUrl field per model role (main, research, fallback), allowing endpoint overrides for any provider.
-
-- [#528](https://github.com/eyaltoledano/claude-task-master/pull/528) [`58b417a`](https://github.com/eyaltoledano/claude-task-master/commit/58b417a8ce697e655f749ca4d759b1c20014c523) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Display task complexity scores in task lists, next task, and task details views.
-
-### Patch Changes
-
-- [#478](https://github.com/eyaltoledano/claude-task-master/pull/478) [`4117f71`](https://github.com/eyaltoledano/claude-task-master/commit/4117f71c18ee4d321a9c91308d00d5d69bfac61e) Thanks [@joedanz](https://github.com/joedanz)! - Fix CLI --force flag for parse-prd command
-
-  Previously, the --force flag was not respected when running `parse-prd`, causing the command to prompt for confirmation or fail even when --force was provided. This patch ensures that the flag is correctly passed and handled, allowing users to overwrite existing tasks.json files as intended.
-
-  - Fixes #477
-
-- [#511](https://github.com/eyaltoledano/claude-task-master/pull/511) [`17294ff`](https://github.com/eyaltoledano/claude-task-master/commit/17294ff25918d64278674e558698a1a9ad785098) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Task Master no longer tells you to update when you're already up to date
-
-- [#523](https://github.com/eyaltoledano/claude-task-master/pull/523) [`da317f2`](https://github.com/eyaltoledano/claude-task-master/commit/da317f2607ca34db1be78c19954996f634c40923) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix the error handling of task status settings
-
-- [#527](https://github.com/eyaltoledano/claude-task-master/pull/527) [`a8dabf4`](https://github.com/eyaltoledano/claude-task-master/commit/a8dabf44856713f488960224ee838761716bba26) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Remove caching layer from MCP direct functions for task listing, next task, and complexity report
-
-  - Fixes issues users where having where they were getting stale data
-
-- [#417](https://github.com/eyaltoledano/claude-task-master/pull/417) [`a1f8d52`](https://github.com/eyaltoledano/claude-task-master/commit/a1f8d52474fdbdf48e17a63e3f567a6d63010d9f) Thanks [@ksylvan](https://github.com/ksylvan)! - Fix for issue #409 LOG_LEVEL Pydantic validation error
-
-- [#501](https://github.com/eyaltoledano/claude-task-master/pull/501) [`0a61184`](https://github.com/eyaltoledano/claude-task-master/commit/0a611843b56a856ef0a479dc34078326e05ac3a8) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix initial .env.example to work out of the box
-
-  - Closes #419
-
-- [#435](https://github.com/eyaltoledano/claude-task-master/pull/435) [`a96215a`](https://github.com/eyaltoledano/claude-task-master/commit/a96215a359b25061fd3b3f3c7b10e8ac0390c062) Thanks [@lebsral](https://github.com/lebsral)! - Fix default fallback model and maxTokens in Taskmaster initialization
-
-- [#517](https://github.com/eyaltoledano/claude-task-master/pull/517) [`e96734a`](https://github.com/eyaltoledano/claude-task-master/commit/e96734a6cc6fec7731de72eb46b182a6e3743d02) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix bug when updating tasks on the MCP server (#412)
-
-- [#496](https://github.com/eyaltoledano/claude-task-master/pull/496) [`efce374`](https://github.com/eyaltoledano/claude-task-master/commit/efce37469bc58eceef46763ba32df1ed45242211) Thanks [@joedanz](https://github.com/joedanz)! - Fix duplicate output on CLI help screen
-
-  - Prevent the Task Master CLI from printing the help screen more than once when using `-h` or `--help`.
-  - Removed redundant manual event handlers and guards for help output; now only the Commander `.helpInformation` override is used for custom help.
-  - Simplified logic so that help is only shown once for both "no arguments" and help flag flows.
-  - Ensures a clean, branded help experience with no repeated content.
-  - Fixes #339
-
-## 0.13.1
-
-### Patch Changes
-
-- [#399](https://github.com/eyaltoledano/claude-task-master/pull/399) [`734a4fd`](https://github.com/eyaltoledano/claude-task-master/commit/734a4fdcfc89c2e089255618cf940561ad13a3c8) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix ERR_MODULE_NOT_FOUND when trying to run MCP Server
-
-## 0.13.0
-
-### Minor Changes
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`ef782ff`](https://github.com/eyaltoledano/claude-task-master/commit/ef782ff5bd4ceb3ed0dc9ea82087aae5f79ac933) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - feat(expand): Enhance `expand` and `expand-all` commands
-
-  - Integrate `task-complexity-report.json` to automatically determine the number of subtasks and use tailored prompts for expansion based on prior analysis. You no longer need to try copy-pasting the recommended prompt. If it exists, it will use it for you. You can just run `task-master update --id=[id of task] --research` and it will use that prompt automatically. No extra prompt needed.
-  - Change default behavior to _append_ new subtasks to existing ones. Use the `--force` flag to clear existing subtasks before expanding. This is helpful if you need to add more subtasks to a task but you want to do it by the batch from a given prompt. Use force if you want to start fresh with a task's subtasks.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`87d97bb`](https://github.com/eyaltoledano/claude-task-master/commit/87d97bba00d84e905756d46ef96b2d5b984e0f38) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds support for the OpenRouter AI provider. Users can now configure models available through OpenRouter (requiring an `OPENROUTER_API_KEY`) via the `task-master models` command, granting access to a wide range of additional LLMs. - IMPORTANT FYI ABOUT OPENROUTER: Taskmaster relies on AI SDK, which itself relies on tool use. It looks like **free** models sometimes do not include tool use. For example, Gemini 2.5 pro (free) failed via OpenRouter (no tool use) but worked fine on the paid version of the model. Custom model support for Open Router is considered experimental and likely will not be further improved for some time.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`1ab836f`](https://github.com/eyaltoledano/claude-task-master/commit/1ab836f191cb8969153593a9a0bd47fc9aa4a831) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds model management and new configuration file .taskmasterconfig which houses the models used for main, research and fallback. Adds models command and setter flags. Adds a --setup flag with an interactive setup. We should be calling this during init. Shows a table of active and available models when models is called without flags. Includes SWE scores and token costs, which are manually entered into the supported_models.json, the new place where models are defined for support. Config-manager.js is the core module responsible for managing the new config."
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`c8722b0`](https://github.com/eyaltoledano/claude-task-master/commit/c8722b0a7a443a73b95d1bcd4a0b68e0fce2a1cd) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds custom model ID support for Ollama and OpenRouter providers.
-
-  - Adds the `--ollama` and `--openrouter` flags to `task-master models --set-<role>` command to set models for those providers outside of the support models list.
-  - Updated `task-master models --setup` interactive mode with options to explicitly enter custom Ollama or OpenRouter model IDs.
-  - Implemented live validation against OpenRouter API (`/api/v1/models`) when setting a custom OpenRouter model ID (via flag or setup).
-  - Refined logic to prioritize explicit provider flags/choices over internal model list lookups in case of ID conflicts.
-  - Added warnings when setting custom/unvalidated models.
-  - We obviously don't recommend going with a custom, unproven model. If you do and find performance is good, please let us know so we can add it to the list of supported models.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`2517bc1`](https://github.com/eyaltoledano/claude-task-master/commit/2517bc112c9a497110f3286ca4bfb4130c9addcb) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Integrate OpenAI as a new AI provider. - Enhance `models` command/tool to display API key status. - Implement model-specific `maxTokens` override based on `supported-models.json` to save you if you use an incorrect max token value.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`9a48278`](https://github.com/eyaltoledano/claude-task-master/commit/9a482789f7894f57f655fb8d30ba68542bd0df63) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Tweaks Perplexity AI calls for research mode to max out input tokens and get day-fresh information - Forces temp at 0.1 for highly deterministic output, no variations - Adds a system prompt to further improve the output - Correctly uses the maximum input tokens (8,719, used 8,700) for perplexity - Specificies to use a high degree of research across the web - Specifies to use information that is as fresh as today; this support stuff like capturing brand new announcements like new GPT models and being able to query for those in research. 🔥
-
-### Patch Changes
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`842eaf7`](https://github.com/eyaltoledano/claude-task-master/commit/842eaf722498ddf7307800b4cdcef4ac4fd7e5b0) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - - Add support for Google Gemini models via Vercel AI SDK integration.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`ed79d4f`](https://github.com/eyaltoledano/claude-task-master/commit/ed79d4f4735dfab4124fa189214c0bd5e23a6860) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add xAI provider and Grok models support
-
-- [#378](https://github.com/eyaltoledano/claude-task-master/pull/378) [`ad89253`](https://github.com/eyaltoledano/claude-task-master/commit/ad89253e313a395637aa48b9f92cc39b1ef94ad8) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Better support for file paths on Windows, Linux & WSL.
-
-  - Standardizes handling of different path formats (URI encoded, Windows, Linux, WSL).
-  - Ensures tools receive a clean, absolute path suitable for the server OS.
-  - Simplifies tool implementation by centralizing normalization logic.
-
-- [#285](https://github.com/eyaltoledano/claude-task-master/pull/285) [`2acba94`](https://github.com/eyaltoledano/claude-task-master/commit/2acba945c0afee9460d8af18814c87e80f747e9f) Thanks [@neno-is-ooo](https://github.com/neno-is-ooo)! - Add integration for Roo Code
-
-- [#378](https://github.com/eyaltoledano/claude-task-master/pull/378) [`d63964a`](https://github.com/eyaltoledano/claude-task-master/commit/d63964a10eed9be17856757661ff817ad6bacfdc) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Improved update-subtask - Now it has context about the parent task details - It also has context about the subtask before it and the subtask after it (if they exist) - Not passing all subtasks to stay token efficient
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`5f504fa`](https://github.com/eyaltoledano/claude-task-master/commit/5f504fafb8bdaa0043c2d20dee8bbb8ec2040d85) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Improve and adjust `init` command for robustness and updated dependencies.
-
-  - **Update Initialization Dependencies:** Ensure newly initialized projects (`task-master init`) include all required AI SDK dependencies (`@ai-sdk/*`, `ai`, provider wrappers) in their `package.json` for out-of-the-box AI feature compatibility. Remove unnecessary dependencies (e.g., `uuid`) from the init template.
-  - **Silence `npm install` during `init`:** Prevent `npm install` output from interfering with non-interactive/MCP initialization by suppressing its stdio in silent mode.
-  - **Improve Conditional Model Setup:** Reliably skip interactive `models --setup` during non-interactive `init` runs (e.g., `init -y` or MCP) by checking `isSilentMode()` instead of passing flags.
-  - **Refactor `init.js`:** Remove internal `isInteractive` flag logic.
-  - **Update `init` Instructions:** Tweak the "Getting Started" text displayed after `init`.
-  - **Fix MCP Server Launch:** Update `.cursor/mcp.json` template to use `node ./mcp-server/server.js` instead of `npx task-master-mcp`.
-  - **Update Default Model:** Change the default main model in the `.taskmasterconfig` template.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`96aeeff`](https://github.com/eyaltoledano/claude-task-master/commit/96aeeffc195372722c6a07370540e235bfe0e4d8) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue with add-task which did not use the manually defined properties and still needlessly hit the AI endpoint.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`5aea93d`](https://github.com/eyaltoledano/claude-task-master/commit/5aea93d4c0490c242d7d7042a210611977848e0a) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Fixes an issue that prevented remove-subtask with comma separated tasks/subtasks from being deleted (only the first ID was being deleted). Closes #140
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`66ac9ab`](https://github.com/eyaltoledano/claude-task-master/commit/66ac9ab9f66d006da518d6e8a3244e708af2764d) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Improves next command to be subtask-aware - The logic for determining the "next task" (findNextTask function, used by task-master next and the next_task MCP tool) has been significantly improved. Previously, it only considered top-level tasks, making its recommendation less useful when a parent task containing subtasks was already marked 'in-progress'. - The updated logic now prioritizes finding the next available subtask within any 'in-progress' parent task, considering subtask dependencies and priority. - If no suitable subtask is found within active parent tasks, it falls back to recommending the next eligible top-level task based on the original criteria (status, dependencies, priority).
-
-  This change makes the next command much more relevant and helpful during the implementation phase of complex tasks.
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`ca7b045`](https://github.com/eyaltoledano/claude-task-master/commit/ca7b0457f1dc65fd9484e92527d9fd6d69db758d) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Add `--status` flag to `show` command to filter displayed subtasks.
-
-- [#328](https://github.com/eyaltoledano/claude-task-master/pull/328) [`5a2371b`](https://github.com/eyaltoledano/claude-task-master/commit/5a2371b7cc0c76f5e95d43921c1e8cc8081bf14e) Thanks [@knoxgraeme](https://github.com/knoxgraeme)! - Fix --task to --num-tasks in ui + related tests - issue #324
-
-- [#240](https://github.com/eyaltoledano/claude-task-master/pull/240) [`6cb213e`](https://github.com/eyaltoledano/claude-task-master/commit/6cb213ebbd51116ae0688e35b575d09443d17c3b) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Adds a 'models' CLI and MCP command to get the current model configuration, available models, and gives the ability to set main/research/fallback models." - In the CLI, `task-master models` shows the current models config. Using the `--setup` flag launches an interactive set up that allows you to easily select the models you want to use for each of the three roles. Use `q` during the interactive setup to cancel the setup. - In the MCP, responses are simplified in RESTful format (instead of the full CLI output). The agent can use the `models` tool with different arguments, including `listAvailableModels` to get available models. Run without arguments, it will return the current configuration. Arguments are available to set the model for each of the three roles. This allows you to manage Taskmaster AI providers and models directly from either the CLI or MCP or both. - Updated the CLI help menu when you run `task-master` to include missing commands and .taskmasterconfig information. - Adds `--research` flag to `add-task` so you can hit up Perplexity right from the add-task flow, rather than having to add a task and then update it.
-
-## 0.12.1
-
-### Patch Changes
-
-- [#307](https://github.com/eyaltoledano/claude-task-master/pull/307) [`2829194`](https://github.com/eyaltoledano/claude-task-master/commit/2829194d3c1dd5373d3bf40275cf4f63b12d49a7) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix add_dependency tool crashing the MCP Server
-
-## 0.12.0
-
-### Minor Changes
-
-- [#253](https://github.com/eyaltoledano/claude-task-master/pull/253) [`b2ccd60`](https://github.com/eyaltoledano/claude-task-master/commit/b2ccd605264e47a61451b4c012030ee29011bb40) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Add `npx task-master-ai` that runs mcp instead of using `task-master-mcp``
-
-- [#267](https://github.com/eyaltoledano/claude-task-master/pull/267) [`c17d912`](https://github.com/eyaltoledano/claude-task-master/commit/c17d912237e6caaa2445e934fc48cd4841abf056) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Improve PRD parsing prompt with structured analysis and clearer task generation guidelines. We are testing a new prompt - please provide feedback on your experience.
-
-### Patch Changes
-
-- [#243](https://github.com/eyaltoledano/claude-task-master/pull/243) [`454a1d9`](https://github.com/eyaltoledano/claude-task-master/commit/454a1d9d37439c702656eedc0702c2f7a4451517) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - - Fixes shebang issue not allowing task-master to run on certain windows operating systems
-
-  - Resolves #241 #211 #184 #193
-
-- [#268](https://github.com/eyaltoledano/claude-task-master/pull/268) [`3e872f8`](https://github.com/eyaltoledano/claude-task-master/commit/3e872f8afbb46cd3978f3852b858c233450b9f33) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fix remove-task command to handle multiple comma-separated task IDs
-
-- [#239](https://github.com/eyaltoledano/claude-task-master/pull/239) [`6599cb0`](https://github.com/eyaltoledano/claude-task-master/commit/6599cb0bf9eccecab528207836e9d45b8536e5c2) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - Updates the parameter descriptions for update, update-task and update-subtask to ensure the MCP server correctly reaches for the right update command based on what is being updated -- all tasks, one task, or a subtask.
-
-- [#272](https://github.com/eyaltoledano/claude-task-master/pull/272) [`3aee9bc`](https://github.com/eyaltoledano/claude-task-master/commit/3aee9bc840eb8f31230bd1b761ed156b261cabc4) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Enhance the `parsePRD` to include `--append` flag. This flag allows users to append the parsed PRD to an existing file, making it easier to manage multiple PRD files without overwriting existing content.
-
-- [#264](https://github.com/eyaltoledano/claude-task-master/pull/264) [`ff8e75c`](https://github.com/eyaltoledano/claude-task-master/commit/ff8e75cded91fb677903040002626f7a82fd5f88) Thanks [@joedanz](https://github.com/joedanz)! - Add quotes around numeric env vars in mcp.json (Windsurf, etc.)
-
-- [#248](https://github.com/eyaltoledano/claude-task-master/pull/248) [`d99fa00`](https://github.com/eyaltoledano/claude-task-master/commit/d99fa00980fc61695195949b33dcda7781006f90) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - - Fix `task-master init` polluting codebase with new packages inside `package.json` and modifying project `README`
-
-  - Now only initializes with cursor rules, windsurf rules, mcp.json, scripts/example_prd.txt, .gitignore modifications, and `README-task-master.md`
-
-- [#266](https://github.com/eyaltoledano/claude-task-master/pull/266) [`41b979c`](https://github.com/eyaltoledano/claude-task-master/commit/41b979c23963483e54331015a86e7c5079f657e4) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Fixed a bug that prevented the task-master from running in a Linux container
-
-- [#265](https://github.com/eyaltoledano/claude-task-master/pull/265) [`0eb16d5`](https://github.com/eyaltoledano/claude-task-master/commit/0eb16d5ecbb8402d1318ca9509e9d4087b27fb25) Thanks [@Crunchyman-ralph](https://github.com/Crunchyman-ralph)! - Remove the need for project name, description, and version. Since we no longer create a package.json for you
-
-## 0.11.0
-
-### Minor Changes
-
-- [#71](https://github.com/eyaltoledano/claude-task-master/pull/71) [`7141062`](https://github.com/eyaltoledano/claude-task-master/commit/71410629ba187776d92a31ea0729b2ff341b5e38) Thanks [@eyaltoledano](https://github.com/eyaltoledano)! - - **Easier Ways to Use Taskmaster (CLI & MCP):**
-  - You can now use Taskmaster either by installing it as a standard command-line tool (`task-master`) or as an MCP server directly within integrated development tools like Cursor (using its built-in features). **This makes Taskmaster accessible regardless of your preferred workflow.**
-  - Setting up a new project is simpler in integrated tools, thanks to the new `initialize_project` capability.
-  - **Complete MCP Implementation:**
-    - NOTE: Many MCP clients charge on a per tool basis. In that regard, the most cost-efficient way to use Taskmaster is through the CLI directly. Otherwise, the MCP offers the smoothest and most recommended user experience.
-    - All MCP tools now follow a standardized output format that mimicks RESTful API responses. They are lean JSON responses that are context-efficient. This is a net improvement over the last version which sent the whole CLI output directly, which needlessly wasted tokens.
-    - Added a `remove-task` command to permanently delete tasks you no longer need.
-    - Many new MCP tools are available for managing tasks (updating details, adding/removing subtasks, generating task files, setting status, finding the next task, breaking down complex tasks, handling dependencies, analyzing complexity, etc.), usable both from the command line and integrated tools. **(See the `taskmaster.mdc` reference guide and improved readme for a full list).**
-  - **Better Task Tracking:**
-    - Added a "cancelled" status option for tasks, providing more ways to categorize work.
-  - **Smoother Experience in Integrated Tools:**
-    - Long-running operations (like breaking down tasks or analysis) now run in the background **via an Async Operation Manager** with progress updates, so you know what's happening without waiting and can check status later.
-  - **Improved Documentation:**
-    - Added a comprehensive reference guide (`taskmaster.mdc`) detailing all commands and tools with examples, usage tips, and troubleshooting info. This is mostly for use by the AI but can be useful for human users as well.
-    - Updated the main README with clearer instructions and added a new tutorial/examples guide.
-    - Added documentation listing supported integrated tools (like Cursor).
-  - **Increased Stability & Reliability:**
-    - Using Taskmaster within integrated tools (like Cursor) is now **more stable and the recommended approach.**
-    - Added automated testing (CI) to catch issues earlier, leading to a more reliable tool.
-    - Fixed release process issues to ensure users get the correct package versions when installing or updating via npm.
-  - **Better Command-Line Experience:**
-    - Fixed bugs in the `expand-all` command that could cause **NaN errors or JSON formatting issues (especially when using `--research`).**
-    - Fixed issues with parameter validation in the `analyze-complexity` command (specifically related to the `threshold` parameter).
-    - Made the `add-task` command more consistent by adding standard flags like `--title`, `--description` for manual task creation so you don't have to use `--prompt` and can quickly drop new ideas and stay in your flow.
-    - Improved error messages for incorrect commands or flags, making them easier to understand.
-    - Added confirmation warnings before permanently deleting tasks (`remove-task`) to prevent mistakes. There's a known bug for deleting multiple tasks with comma-separated values. It'll be fixed next release.
-    - Renamed some background tool names used by integrated tools (e.g., `list-tasks` is now `get_tasks`) to be more intuitive if seen in logs or AI interactions.
-    - Smoother project start: **Improved the guidance provided to AI assistants immediately after setup** (related to `init` and `parse-prd` steps). This ensures the AI doesn't go on a tangent deciding its own workflow, and follows the exact process outlined in the Taskmaster workflow.
-  - **Clearer Error Messages:**
-    - When generating subtasks fails, error messages are now clearer, **including specific task IDs and potential suggestions.**
-    - AI fallback from Claude to Perplexity now also works the other way around. If Perplexity is down, will switch to Claude.
-  - **Simplified Setup & Configuration:**
-    - Made it clearer how to configure API keys depending on whether you're using the command-line tool (`.env` file) or an integrated tool (`.cursor/mcp.json` file).
-    - Taskmaster is now better at automatically finding your project files, especially in integrated tools, reducing the need for manual path settings.
-    - Fixed an issue that could prevent Taskmaster from working correctly immediately after initialization in integrated tools (related to how the MCP server was invoked). This should solve the issue most users were experiencing with the last release (0.10.x)
-    - Updated setup templates with clearer examples for API keys.
-    - \*\*For advanced users setting up the MCP server manually, the command is now `npx -y task-master-ai task-master-mcp`.
-  - **Enhanced Performance & AI:**
-    - Updated underlying AI model settings:
-      - **Increased Context Window:** Can now handle larger projects/tasks due to an increased Claude context window (64k -> 128k tokens).
-      - **Reduced AI randomness:** More consistent and predictable AI outputs (temperature 0.4 -> 0.2).
-      - **Updated default AI models:** Uses newer models like `claude-3-7-sonnet-20250219` and Perplexity `sonar-pro` by default.
-      - **More granular breakdown:** Increased the default number of subtasks generated by `expand` to 5 (from 4).
-      - **Consistent defaults:** Set the default priority for new tasks consistently to "medium".
-    - Improved performance when viewing task details in integrated tools by sending less redundant data.
-  - **Documentation Clarity:**
-    - Clarified in documentation that Markdown files (`.md`) can be used for Product Requirements Documents (`parse_prd`).
-    - Improved the description for the `numTasks` option in `parse_prd` for better guidance.
-  - **Improved Visuals (CLI):**
-    - Enhanced the look and feel of progress bars and status updates in the command line.
-    - Added a helpful color-coded progress bar to the task details view (`show` command) to visualize subtask completion.
-    - Made progress bars show a breakdown of task statuses (e.g., how many are pending vs. done).
-    - Made status counts clearer with text labels next to icons.
-    - Prevented progress bars from messing up the display on smaller terminal windows.
-    - Adjusted how progress is calculated for 'deferred' and 'cancelled' tasks in the progress bar, while still showing their distinct status visually.
-  - **Fixes for Integrated Tools:**
-    - Fixed how progress updates are sent to integrated tools, ensuring they display correctly.
-    - Fixed internal issues that could cause errors or invalid JSON responses when using Taskmaster with integrated tools.
-
 ## 0.10.1
 
 ### Patch Changes

README-task-master.md

@@ -13,22 +13,25 @@ A task management system for AI-driven development with Claude, designed to work
 
 ## Configuration
 
-Taskmaster uses two primary configuration methods:
+The script can be configured through environment variables in a `.env` file at the root of the project:
 
-1.  **`.taskmasterconfig` File (Project Root)**
+### Required Configuration
 
-    - Stores most settings: AI model selections (main, research, fallback), parameters (max tokens, temperature), logging level, default priority/subtasks, project name.
-    - **Created and managed using `task-master models --setup` CLI command or the `models` MCP tool.**
-    - Do not edit manually unless you know what you are doing.
+- `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude
 
-2.  **Environment Variables (`.env` file or MCP `env` block)**
-    - Used **only** for sensitive **API Keys** (e.g., `ANTHROPIC_API_KEY`, `PERPLEXITY_API_KEY`, etc.) and specific endpoints (like `OLLAMA_BASE_URL`).
-    - **For CLI:** Place keys in a `.env` file in your project root.
-    - **For MCP/Cursor:** Place keys in the `env` section of your `.cursor/mcp.json` (or other MCP config according to the AI IDE or client you use) file under the `taskmaster-ai` server definition.
+### Optional Configuration
 
-**Important:** Settings like model choices, max tokens, temperature, and log level are **no longer configured via environment variables.** Use the `task-master models` command or tool.
-
-See the [Configuration Guide](docs/configuration.md) for full details.
+- `MODEL`: Specify which Claude model to use (default: "claude-3-7-sonnet-20250219")
+- `MAX_TOKENS`: Maximum tokens for model responses (default: 4000)
+- `TEMPERATURE`: Temperature for model responses (default: 0.7)
+- `PERPLEXITY_API_KEY`: Your Perplexity API key for research-backed subtask generation
+- `PERPLEXITY_MODEL`: Specify which Perplexity model to use (default: "sonar-medium-online")
+- `DEBUG`: Enable debug logging (default: false)
+- `LOG_LEVEL`: Log level - debug, info, warn, error (default: info)
+- `DEFAULT_SUBTASKS`: Default number of subtasks when expanding (default: 3)
+- `DEFAULT_PRIORITY`: Default priority for generated tasks (default: medium)
+- `PROJECT_NAME`: Override default project name in tasks.json
+- `PROJECT_VERSION`: Override default version in tasks.json
 
 ## Installation
 
@@ -47,7 +50,7 @@ npm install task-master-ai
 task-master init
 
 # If installed locally
-npx task-master init
+npx task-master-init
 ```
 
 This will prompt you for project details and set up a new project with the necessary files and structure.
@@ -143,7 +146,7 @@ To enable enhanced task management capabilities directly within Cursor using the
 4. Configure with the following details:
    - Name: "Task Master"
    - Type: "Command"
-   - Command: "npx -y task-master-ai"
+   - Command: "npx -y --package task-master-ai task-master-mcp"
 5. Save the settings
 
 Once configured, you can interact with Task Master's task management commands directly through Cursor's interface, providing a more integrated experience.

README.md

@@ -1,6 +1,6 @@
 # Task Master [![GitHub stars](https://img.shields.io/github/stars/eyaltoledano/claude-task-master?style=social)](https://github.com/eyaltoledano/claude-task-master/stargazers)
 
-[![CI](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml/badge.svg)](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml) [![npm version](https://badge.fury.io/js/task-master-ai.svg)](https://badge.fury.io/js/task-master-ai) [![Discord](https://dcbadge.limes.pink/api/server/https://discord.gg/taskmasterai?style=flat)](https://discord.gg/taskmasterai) [![License: MIT with Commons Clause](https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg)](LICENSE)
+[![CI](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml/badge.svg)](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml) [![npm version](https://badge.fury.io/js/task-master-ai.svg)](https://badge.fury.io/js/task-master-ai) ![Discord Follow](https://dcbadge.limes.pink/api/server/https://discord.gg/2ms58QJjqp?style=flat) [![License: MIT with Commons Clause](https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg)](LICENSE)
 
 ### By [@eyaltoledano](https://x.com/eyaltoledano) & [@RalphEcom](https://x.com/RalphEcom)
 
@@ -11,129 +11,55 @@ A task management system for AI-driven development with Claude, designed to work
 
 ## Requirements
 
-Taskmaster utilizes AI across several commands, and those require a separate API key. You can use a variety of models from different AI providers provided you add your API keys. For example, if you want to use Claude 3.7, you'll need an Anthropic API key.
-
-You can define 3 types of models to be used: the main model, the research model, and the fallback model (in case either the main or research fail). Whatever model you use, its provider API key must be present in either mcp.json or .env.
-
-At least one (1) of the following is required:
-
 - Anthropic API key (Claude API)
-- OpenAI API key
-- Google Gemini API key
-- Perplexity API key (for research model)
-- xAI API Key (for research or main model)
-- OpenRouter API Key (for research or main model)
-
-Using the research model is optional but highly recommended. You will need at least ONE API key. Adding all API keys enables you to seamlessly switch between model providers at will.
+- OpenAI SDK (for Perplexity API integration, optional)
 
 ## Quick Start
 
-### Option 1: MCP (Recommended)
+### Option 1 | MCP (Recommended):
 
-MCP (Model Control Protocol) lets you run Task Master directly from your editor.
+MCP (Model Control Protocol) provides the easiest way to get started with Task Master directly in your editor.
 
-#### 1. Add your MCP config at the following path depending on your editor
+1. **Add the MCP config to your editor** (Cursor recommended, but it works with other text editors):
 
-| Editor       | Scope   | Linux/macOS Path                      | Windows Path                                      | Key          |
-| ------------ | ------- | ------------------------------------- | ------------------------------------------------- | ------------ |
-| **Cursor**   | Global  | `~/.cursor/mcp.json`                  | `%USERPROFILE%\.cursor\mcp.json`                  | `mcpServers` |
-|              | Project | `<project_folder>/.cursor/mcp.json`   | `<project_folder>\.cursor\mcp.json`               | `mcpServers` |
-| **Windsurf** | Global  | `~/.codeium/windsurf/mcp_config.json` | `%USERPROFILE%\.codeium\windsurf\mcp_config.json` | `mcpServers` |
-| **VS Code**  | Project | `<project_folder>/.vscode/mcp.json`   | `<project_folder>\.vscode\mcp.json`               | `servers`    |
-
-##### Cursor & Windsurf (`mcpServers`)
-
-```jsonc
+```json
 {
 	"mcpServers": {
 		"taskmaster-ai": {
 			"command": "npx",
-			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
+			"args": ["-y", "task-master-ai", "mcp-server"],
 			"env": {
 				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
 				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
-				"OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
-				"GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
-				"MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
-				"OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
-				"XAI_API_KEY": "YOUR_XAI_KEY_HERE",
-				"AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE",
-				"OLLAMA_API_KEY": "YOUR_OLLAMA_API_KEY_HERE"
+				"MODEL": "claude-3-7-sonnet-20250219",
+				"PERPLEXITY_MODEL": "sonar-pro",
+				"MAX_TOKENS": 128000,
+				"TEMPERATURE": 0.2,
+				"DEFAULT_SUBTASKS": 5,
+				"DEFAULT_PRIORITY": "medium"
 			}
 		}
 	}
 }
 ```
 
-> 🔑 Replace `YOUR_…_KEY_HERE` with your real API keys. You can remove keys you don't use.
+2. **Enable the MCP** in your editor
 
-##### VS Code (`servers` + `type`)
+3. **Prompt the AI** to initialize Task Master:
 
-```jsonc
-{
-	"servers": {
-		"taskmaster-ai": {
-			"command": "npx",
-			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
-			"env": {
-				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
-				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
-				"OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
-				"GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
-				"MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
-				"OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
-				"XAI_API_KEY": "YOUR_XAI_KEY_HERE",
-				"AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE"
-			},
-			"type": "stdio"
-		}
-	}
-}
+```
+Can you please initialize taskmaster-ai into my project?
 ```
 
-> 🔑 Replace `YOUR_…_KEY_HERE` with your real API keys. You can remove keys you don't use.
-
-#### 2. (Cursor-only) Enable Taskmaster MCP
-
-Open Cursor Settings (Ctrl+Shift+J) ➡ Click on MCP tab on the left ➡ Enable task-master-ai with the toggle
-
-#### 3. (Optional) Configure the models you want to use
-
-In your editor’s AI chat pane, say:
+4. **Use common commands** directly through your AI assistant:
 
 ```txt
-Change the main, research and fallback models to <model_name>, <model_name> and <model_name> respectively.
+Can you parse my PRD at scripts/prd.txt?
+What's the next task I should work on?
+Can you help me implement task 3?
+Can you help me expand task 4?
 ```
 
-[Table of available models](docs/models.md)
-
-#### 4. Initialize Task Master
-
-In your editor’s AI chat pane, say:
-
-```txt
-Initialize taskmaster-ai in my project
-```
-
-#### 5. Make sure you have a PRD in `<project_folder>/scripts/prd.txt`
-
-An example of a PRD is located into `<project_folder>/scripts/example_prd.txt`.
-
-**Always start with a detailed PRD.**
-
-The more detailed your PRD, the better the generated tasks will be.
-
-#### 6. Common Commands
-
-Use your AI assistant to:
-
-- Parse requirements: `Can you parse my PRD at scripts/prd.txt?`
-- Plan next step: `What’s the next task I should work on?`
-- Implement a task: `Can you help me implement task 3?`
-- Expand a task: `Can you help me expand task 4?`
-
-[More examples on how to use Task Master in chat](docs/examples.md)
-
 ### Option 2: Using Command Line
 
 #### Installation
@@ -153,7 +79,7 @@ npm install task-master-ai
 task-master init
 
 # If installed locally
-npx task-master init
+npx task-master-init
 ```
 
 This will prompt you for project details and set up a new project with the necessary files and structure.
@@ -205,12 +131,6 @@ cd claude-task-master
 node scripts/init.js
 ```
 
-## Contributors
-
-<a href="https://github.com/eyaltoledano/claude-task-master/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=eyaltoledano/claude-task-master" alt="Task Master project contributors" />
-</a>
-
 ## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=eyaltoledano/claude-task-master&type=Timeline)](https://www.star-history.com/#eyaltoledano/claude-task-master&Timeline)

assets/.taskmasterconfig

@@ -1,31 +0,0 @@
-{
-	"models": {
-		"main": {
-			"provider": "anthropic",
-			"modelId": "claude-3-7-sonnet-20250219",
-			"maxTokens": 120000,
-			"temperature": 0.2
-		},
-		"research": {
-			"provider": "perplexity",
-			"modelId": "sonar-pro",
-			"maxTokens": 8700,
-			"temperature": 0.1
-		},
-		"fallback": {
-			"provider": "anthropic",
-			"modelId": "claude-3-5-sonnet-20240620",
-			"maxTokens": 8192,
-			"temperature": 0.1
-		}
-	},
-	"global": {
-		"logLevel": "info",
-		"debug": false,
-		"defaultSubtasks": 5,
-		"defaultPriority": "medium",
-		"projectName": "Taskmaster",
-		"ollamaBaseUrl": "http://localhost:11434/api",
-		"azureOpenaiBaseUrl": "https://your-endpoint.openai.azure.com/"
-	}
-}

assets/.windsurfrules

@@ -198,7 +198,7 @@ alwaysApply: true
   - **MAX_TOKENS** (Default: `"4000"`): Maximum tokens for responses (Example: `MAX_TOKENS=8000`)
   - **TEMPERATURE** (Default: `"0.7"`): Temperature for model responses (Example: `TEMPERATURE=0.5`)
   - **DEBUG** (Default: `"false"`): Enable debug logging (Example: `DEBUG=true`)
-  - **TASKMASTER_LOG_LEVEL** (Default: `"info"`): Console output level (Example: `TASKMASTER_LOG_LEVEL=debug`)
+  - **LOG_LEVEL** (Default: `"info"`): Console output level (Example: `LOG_LEVEL=debug`)
   - **DEFAULT_SUBTASKS** (Default: `"3"`): Default subtask count (Example: `DEFAULT_SUBTASKS=5`)
   - **DEFAULT_PRIORITY** (Default: `"medium"`): Default priority (Example: `DEFAULT_PRIORITY=high`)
   - **PROJECT_NAME** (Default: `"MCP SaaS MVP"`): Project name in metadata (Example: `PROJECT_NAME=My Awesome Project`)

assets/AGENTS.md

@@ -1,413 +0,0 @@
-# Task Master AI - Claude Code Integration Guide
-
-## Essential Commands
-
-### Core Workflow Commands
-
-```bash
-# Project Setup
-task-master init                                    # Initialize Task Master in current project
-task-master parse-prd scripts/prd.txt             # Generate tasks from PRD document
-task-master models --setup                        # Configure AI models interactively
-
-# Daily Development Workflow
-task-master list                                   # Show all tasks with status
-task-master next                                   # Get next available task to work on
-task-master show <id>                             # View detailed task information (e.g., task-master show 1.2)
-task-master set-status --id=<id> --status=done    # Mark task complete
-
-# Task Management
-task-master add-task --prompt="description" --research        # Add new task with AI assistance
-task-master expand --id=<id> --research --force              # Break task into subtasks
-task-master update-task --id=<id> --prompt="changes"         # Update specific task
-task-master update --from=<id> --prompt="changes"            # Update multiple tasks from ID onwards
-task-master update-subtask --id=<id> --prompt="notes"        # Add implementation notes to subtask
-
-# Analysis & Planning
-task-master analyze-complexity --research          # Analyze task complexity
-task-master complexity-report                      # View complexity analysis
-task-master expand --all --research               # Expand all eligible tasks
-
-# Dependencies & Organization
-task-master add-dependency --id=<id> --depends-on=<id>       # Add task dependency
-task-master move --from=<id> --to=<id>                       # Reorganize task hierarchy
-task-master validate-dependencies                            # Check for dependency issues
-task-master generate                                         # Update task markdown files (usually auto-called)
-```
-
-## Key Files & Project Structure
-
-### Core Files
-
-- `tasks/tasks.json` - Main task data file (auto-managed)
-- `.taskmasterconfig` - AI model configuration (use `task-master models` to modify)
-- `scripts/prd.txt` - Product Requirements Document for parsing
-- `tasks/*.txt` - Individual task files (auto-generated from tasks.json)
-- `.env` - API keys for CLI usage
-
-### Claude Code Integration Files
-
-- `CLAUDE.md` - Auto-loaded context for Claude Code (this file)
-- `.claude/settings.json` - Claude Code tool allowlist and preferences
-- `.claude/commands/` - Custom slash commands for repeated workflows
-- `.mcp.json` - MCP server configuration (project-specific)
-
-### Directory Structure
-
-```
-project/
-├── tasks/
-│   ├── tasks.json           # Main task database
-│   ├── task-1.md           # Individual task files
-│   └── task-2.md
-├── scripts/
-│   ├── prd.txt             # Product requirements
-│   └── task-complexity-report.json
-├── .claude/
-│   ├── settings.json        # Claude Code configuration
-│   └── commands/           # Custom slash commands
-├── .taskmasterconfig       # AI models & settings
-├── .env                    # API keys
-├── .mcp.json              # MCP configuration
-└── CLAUDE.md              # This file - auto-loaded by Claude Code
-```
-
-## MCP Integration
-
-Task Master provides an MCP server that Claude Code can connect to. Configure in `.mcp.json`:
-
-```json
-{
-	"mcpServers": {
-		"task-master-ai": {
-			"command": "npx",
-			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
-			"env": {
-				"ANTHROPIC_API_KEY": "your_key_here",
-				"PERPLEXITY_API_KEY": "your_key_here",
-				"OPENAI_API_KEY": "OPENAI_API_KEY_HERE",
-				"GOOGLE_API_KEY": "GOOGLE_API_KEY_HERE",
-				"XAI_API_KEY": "XAI_API_KEY_HERE",
-				"OPENROUTER_API_KEY": "OPENROUTER_API_KEY_HERE",
-				"MISTRAL_API_KEY": "MISTRAL_API_KEY_HERE",
-				"AZURE_OPENAI_API_KEY": "AZURE_OPENAI_API_KEY_HERE",
-				"OLLAMA_API_KEY": "OLLAMA_API_KEY_HERE"
-			}
-		}
-	}
-}
-```
-
-### Essential MCP Tools
-
-```javascript
-help; // = shows available taskmaster commands
-// Project setup
-initialize_project; // = task-master init
-parse_prd; // = task-master parse-prd
-
-// Daily workflow
-get_tasks; // = task-master list
-next_task; // = task-master next
-get_task; // = task-master show <id>
-set_task_status; // = task-master set-status
-
-// Task management
-add_task; // = task-master add-task
-expand_task; // = task-master expand
-update_task; // = task-master update-task
-update_subtask; // = task-master update-subtask
-update; // = task-master update
-
-// Analysis
-analyze_project_complexity; // = task-master analyze-complexity
-complexity_report; // = task-master complexity-report
-```
-
-## Claude Code Workflow Integration
-
-### Standard Development Workflow
-
-#### 1. Project Initialization
-
-```bash
-# Initialize Task Master
-task-master init
-
-# Create or obtain PRD, then parse it
-task-master parse-prd scripts/prd.txt
-
-# Analyze complexity and expand tasks
-task-master analyze-complexity --research
-task-master expand --all --research
-```
-
-If tasks already exist, another PRD can be parsed (with new information only!) using parse-prd with --append flag. This will add the generated tasks to the existing list of tasks..
-
-#### 2. Daily Development Loop
-
-```bash
-# Start each session
-task-master next                           # Find next available task
-task-master show <id>                     # Review task details
-
-# During implementation, check in code context into the tasks and subtasks
-task-master update-subtask --id=<id> --prompt="implementation notes..."
-
-# Complete tasks
-task-master set-status --id=<id> --status=done
-```
-
-#### 3. Multi-Claude Workflows
-
-For complex projects, use multiple Claude Code sessions:
-
-```bash
-# Terminal 1: Main implementation
-cd project && claude
-
-# Terminal 2: Testing and validation
-cd project-test-worktree && claude
-
-# Terminal 3: Documentation updates
-cd project-docs-worktree && claude
-```
-
-### Custom Slash Commands
-
-Create `.claude/commands/taskmaster-next.md`:
-
-```markdown
-Find the next available Task Master task and show its details.
-
-Steps:
-
-1. Run `task-master next` to get the next task
-2. If a task is available, run `task-master show <id>` for full details
-3. Provide a summary of what needs to be implemented
-4. Suggest the first implementation step
-```
-
-Create `.claude/commands/taskmaster-complete.md`:
-
-```markdown
-Complete a Task Master task: $ARGUMENTS
-
-Steps:
-
-1. Review the current task with `task-master show $ARGUMENTS`
-2. Verify all implementation is complete
-3. Run any tests related to this task
-4. Mark as complete: `task-master set-status --id=$ARGUMENTS --status=done`
-5. Show the next available task with `task-master next`
-```
-
-## Tool Allowlist Recommendations
-
-Add to `.claude/settings.json`:
-
-```json
-{
-	"allowedTools": [
-		"Edit",
-		"Bash(task-master *)",
-		"Bash(git commit:*)",
-		"Bash(git add:*)",
-		"Bash(npm run *)",
-		"mcp__task_master_ai__*"
-	]
-}
-```
-
-## Configuration & Setup
-
-### API Keys Required
-
-At least **one** of these API keys must be configured:
-
-- `ANTHROPIC_API_KEY` (Claude models) - **Recommended**
-- `PERPLEXITY_API_KEY` (Research features) - **Highly recommended**
-- `OPENAI_API_KEY` (GPT models)
-- `GOOGLE_API_KEY` (Gemini models)
-- `MISTRAL_API_KEY` (Mistral models)
-- `OPENROUTER_API_KEY` (Multiple models)
-- `XAI_API_KEY` (Grok models)
-
-An API key is required for any provider used across any of the 3 roles defined in the `models` command.
-
-### Model Configuration
-
-```bash
-# Interactive setup (recommended)
-task-master models --setup
-
-# Set specific models
-task-master models --set-main claude-3-5-sonnet-20241022
-task-master models --set-research perplexity-llama-3.1-sonar-large-128k-online
-task-master models --set-fallback gpt-4o-mini
-```
-
-## Task Structure & IDs
-
-### Task ID Format
-
-- Main tasks: `1`, `2`, `3`, etc.
-- Subtasks: `1.1`, `1.2`, `2.1`, etc.
-- Sub-subtasks: `1.1.1`, `1.1.2`, etc.
-
-### Task Status Values
-
-- `pending` - Ready to work on
-- `in-progress` - Currently being worked on
-- `done` - Completed and verified
-- `deferred` - Postponed
-- `cancelled` - No longer needed
-- `blocked` - Waiting on external factors
-
-### Task Fields
-
-```json
-{
-	"id": "1.2",
-	"title": "Implement user authentication",
-	"description": "Set up JWT-based auth system",
-	"status": "pending",
-	"priority": "high",
-	"dependencies": ["1.1"],
-	"details": "Use bcrypt for hashing, JWT for tokens...",
-	"testStrategy": "Unit tests for auth functions, integration tests for login flow",
-	"subtasks": []
-}
-```
-
-## Claude Code Best Practices with Task Master
-
-### Context Management
-
-- Use `/clear` between different tasks to maintain focus
-- This CLAUDE.md file is automatically loaded for context
-- Use `task-master show <id>` to pull specific task context when needed
-
-### Iterative Implementation
-
-1. `task-master show <subtask-id>` - Understand requirements
-2. Explore codebase and plan implementation
-3. `task-master update-subtask --id=<id> --prompt="detailed plan"` - Log plan
-4. `task-master set-status --id=<id> --status=in-progress` - Start work
-5. Implement code following logged plan
-6. `task-master update-subtask --id=<id> --prompt="what worked/didn't work"` - Log progress
-7. `task-master set-status --id=<id> --status=done` - Complete task
-
-### Complex Workflows with Checklists
-
-For large migrations or multi-step processes:
-
-1. Create a markdown PRD file describing the new changes: `touch task-migration-checklist.md` (prds can be .txt or .md)
-2. Use Taskmaster to parse the new prd with `task-master parse-prd --append` (also available in MCP)
-3. Use Taskmaster to expand the newly generated tasks into subtasks. Consdier using `analyze-complexity` with the correct --to and --from IDs (the new ids) to identify the ideal subtask amounts for each task. Then expand them.
-4. Work through items systematically, checking them off as completed
-5. Use `task-master update-subtask` to log progress on each task/subtask and/or updating/researching them before/during implementation if getting stuck
-
-### Git Integration
-
-Task Master works well with `gh` CLI:
-
-```bash
-# Create PR for completed task
-gh pr create --title "Complete task 1.2: User authentication" --body "Implements JWT auth system as specified in task 1.2"
-
-# Reference task in commits
-git commit -m "feat: implement JWT auth (task 1.2)"
-```
-
-### Parallel Development with Git Worktrees
-
-```bash
-# Create worktrees for parallel task development
-git worktree add ../project-auth feature/auth-system
-git worktree add ../project-api feature/api-refactor
-
-# Run Claude Code in each worktree
-cd ../project-auth && claude    # Terminal 1: Auth work
-cd ../project-api && claude     # Terminal 2: API work
-```
-
-## Troubleshooting
-
-### AI Commands Failing
-
-```bash
-# Check API keys are configured
-cat .env                           # For CLI usage
-
-# Verify model configuration
-task-master models
-
-# Test with different model
-task-master models --set-fallback gpt-4o-mini
-```
-
-### MCP Connection Issues
-
-- Check `.mcp.json` configuration
-- Verify Node.js installation
-- Use `--mcp-debug` flag when starting Claude Code
-- Use CLI as fallback if MCP unavailable
-
-### Task File Sync Issues
-
-```bash
-# Regenerate task files from tasks.json
-task-master generate
-
-# Fix dependency issues
-task-master fix-dependencies
-```
-
-DO NOT RE-INITIALIZE. That will not do anything beyond re-adding the same Taskmaster core files.
-
-## Important Notes
-
-### AI-Powered Operations
-
-These commands make AI calls and may take up to a minute:
-
-- `parse_prd` / `task-master parse-prd`
-- `analyze_project_complexity` / `task-master analyze-complexity`
-- `expand_task` / `task-master expand`
-- `expand_all` / `task-master expand --all`
-- `add_task` / `task-master add-task`
-- `update` / `task-master update`
-- `update_task` / `task-master update-task`
-- `update_subtask` / `task-master update-subtask`
-
-### File Management
-
-- Never manually edit `tasks.json` - use commands instead
-- Never manually edit `.taskmasterconfig` - use `task-master models`
-- Task markdown files in `tasks/` are auto-generated
-- Run `task-master generate` after manual changes to tasks.json
-
-### Claude Code Session Management
-
-- Use `/clear` frequently to maintain focused context
-- Create custom slash commands for repeated Task Master workflows
-- Configure tool allowlist to streamline permissions
-- Use headless mode for automation: `claude -p "task-master next"`
-
-### Multi-Task Updates
-
-- Use `update --from=<id>` to update multiple future tasks
-- Use `update-task --id=<id>` for single task updates
-- Use `update-subtask --id=<id>` for implementation logging
-
-### Research Mode
-
-- Add `--research` flag for research-based AI enhancement
-- Requires a research model API key like Perplexity (`PERPLEXITY_API_KEY`) in environment
-- Provides more informed task creation and updates
-- Recommended for complex technical tasks
-
----
-
-_This guide ensures Claude Code has immediate access to Task Master's essential functionality for agentic development workflows._

assets/env.example

@@ -1,9 +1,14 @@
-# API Keys (Required to enable respective provider)
-ANTHROPIC_API_KEY="your_anthropic_api_key_here"       # Required: Format: sk-ant-api03-...
-PERPLEXITY_API_KEY="your_perplexity_api_key_here"     # Optional: Format: pplx-...
-OPENAI_API_KEY="your_openai_api_key_here"             # Optional, for OpenAI/OpenRouter models. Format: sk-proj-...
-GOOGLE_API_KEY="your_google_api_key_here"             # Optional, for Google Gemini models.
-MISTRAL_API_KEY="your_mistral_key_here"               # Optional, for Mistral AI models.
-XAI_API_KEY="YOUR_XAI_KEY_HERE"                       # Optional, for xAI AI models.
-AZURE_OPENAI_API_KEY="your_azure_key_here"            # Optional, for Azure OpenAI models (requires endpoint in .taskmasterconfig).
-OLLAMA_API_KEY="your_ollama_api_key_here"             # Optional: For remote Ollama servers that require authentication.
+# Required
+ANTHROPIC_API_KEY=your-api-key-here  # For most AI ops -- Format: sk-ant-api03-... (Required)
+PERPLEXITY_API_KEY=pplx-abcde        # For research -- Format: pplx-abcde (Optional, Highly Recommended)
+
+# Optional - defaults shown
+MODEL=claude-3-7-sonnet-20250219  # Recommended models: claude-3-7-sonnet-20250219, claude-3-opus-20240229 (Required)
+PERPLEXITY_MODEL=sonar-pro        # Make sure you have access to sonar-pro otherwise you can use sonar regular (Optional)
+MAX_TOKENS=64000                   # Maximum tokens for model responses (Required)
+TEMPERATURE=0.2                   # Temperature for model responses (0.0-1.0) - lower = less creativity and follow your prompt closely (Required)
+DEBUG=false                       # Enable debug logging (true/false)
+LOG_LEVEL=info                    # Log level (debug, info, warn, error)
+DEFAULT_SUBTASKS=5                # Default number of subtasks when expanding
+DEFAULT_PRIORITY=medium           # Default priority for generated tasks (high, medium, low)
+PROJECT_NAME={{projectName}}      # Project name for tasks.json metadata

assets/roocode/.roo/rules-architect/architect-rules

@@ -1,93 +0,0 @@
-**Core Directives & Agentivity:**
-# 1. Adhere strictly to the rules defined below.
-# 2. Use tools sequentially, one per message. Adhere strictly to the rules defined below.
-# 3. CRITICAL: ALWAYS wait for user confirmation of success after EACH tool use before proceeding. Do not assume success.
-# 4. Operate iteratively: Analyze task -> Plan steps -> Execute steps one by one.
-# 5. Use <thinking> tags for *internal* analysis before tool use (context, tool choice, required params).
-# 6. **DO NOT DISPLAY XML TOOL TAGS IN THE OUTPUT.**
-# 7. **DO NOT DISPLAY YOUR THINKING IN THE OUTPUT.**
-
-**Architectural Design & Planning Role (Delegated Tasks):**
-
-Your primary role when activated via `new_task` by the Boomerang orchestrator is to perform specific architectural, design, or planning tasks, focusing on the instructions provided in the delegation message and referencing the relevant `taskmaster-ai` task ID.
-
-1.  **Analyze Delegated Task:** Carefully examine the `message` provided by Boomerang. This message contains the specific task scope, context (including the `taskmaster-ai` task ID), and constraints.
-2.  **Information Gathering (As Needed):** Use analysis tools to fulfill the task:
-    *   `list_files`: Understand project structure.
-    *   `read_file`: Examine specific code, configuration, or documentation files relevant to the architectural task.
-    *   `list_code_definition_names`: Analyze code structure and relationships.
-    *   `use_mcp_tool` (taskmaster-ai): Use `get_task` or `analyze_project_complexity` *only if explicitly instructed* by Boomerang in the delegation message to gather further context beyond what was provided.
-3.  **Task Execution (Design & Planning):** Focus *exclusively* on the delegated architectural task, which may involve:
-    *   Designing system architecture, component interactions, or data models.
-    *   Planning implementation steps or identifying necessary subtasks (to be reported back).
-    *   Analyzing technical feasibility, complexity, or potential risks.
-    *   Defining interfaces, APIs, or data contracts.
-    *   Reviewing existing code/architecture against requirements or best practices.
-4.  **Reporting Completion:** Signal completion using `attempt_completion`. Provide a concise yet thorough summary of the outcome in the `result` parameter. This summary is **crucial** for Boomerang to update `taskmaster-ai`. Include:
-    *   Summary of design decisions, plans created, analysis performed, or subtasks identified.
-    *   Any relevant artifacts produced (e.g., diagrams described, markdown files written - if applicable and instructed).
-    *   Completion status (success, failure, needs review).
-    *   Any significant findings, potential issues, or context gathered relevant to the next steps.
-5.  **Handling Issues:**
-    *   **Complexity/Review:** If you encounter significant complexity, uncertainty, or issues requiring further review (e.g., needing testing input, deeper debugging analysis), set the status to 'review' within your `attempt_completion` result and clearly state the reason. **Do not delegate directly.** Report back to Boomerang.
-    *   **Failure:** If the task fails (e.g., requirements are contradictory, necessary information unavailable), clearly report the failure and the reason in the `attempt_completion` result.
-6.  **Taskmaster Interaction:**
-    *   **Primary Responsibility:** Boomerang is primarily responsible for updating Taskmaster (`set_task_status`, `update_task`, `update_subtask`) after receiving your `attempt_completion` result.
-    *   **Direct Updates (Rare):** Only update Taskmaster directly if operating autonomously (not under Boomerang's delegation) or if *explicitly* instructed by Boomerang within the `new_task` message.
-7.  **Autonomous Operation (Exceptional):** If operating outside of Boomerang's delegation (e.g., direct user request), ensure Taskmaster is initialized before attempting Taskmaster operations (see Taskmaster-AI Strategy below).
-
-**Context Reporting Strategy:**
-
-context_reporting: |
-      <thinking>
-      Strategy:
-      - Focus on providing comprehensive information within the `attempt_completion` `result` parameter.
-      - Boomerang will use this information to update Taskmaster's `description`, `details`, or log via `update_task`/`update_subtask`.
-      - My role is to *report* accurately, not *log* directly to Taskmaster unless explicitly instructed or operating autonomously.
-      </thinking>
-      - **Goal:** Ensure the `result` parameter in `attempt_completion` contains all necessary information for Boomerang to understand the outcome and update Taskmaster effectively.
-      - **Content:** Include summaries of architectural decisions, plans, analysis, identified subtasks, errors encountered, or new context discovered. Structure the `result` clearly.
-      - **Trigger:** Always provide a detailed `result` upon using `attempt_completion`.
-      - **Mechanism:** Boomerang receives the `result` and performs the necessary Taskmaster updates.
-
-**Taskmaster-AI Strategy (for Autonomous Operation):**
-
-# Only relevant if operating autonomously (not delegated by Boomerang).
-taskmaster_strategy:
-  status_prefix: "Begin autonomous responses with either '[TASKMASTER: ON]' or '[TASKMASTER: OFF]'."
-  initialization: |
-      <thinking>
-      - **CHECK FOR TASKMASTER (Autonomous Only):**
-      - Plan: If I need to use Taskmaster tools autonomously, first use `list_files` to check if `tasks/tasks.json` exists.
-      - If `tasks/tasks.json` is present = set TASKMASTER: ON, else TASKMASTER: OFF.
-      </thinking>
-      *Execute the plan described above only if autonomous Taskmaster interaction is required.*
-  if_uninitialized: |
-      1. **Inform:** "Task Master is not initialized. Autonomous Taskmaster operations cannot proceed."
-      2. **Suggest:** "Consider switching to Boomerang mode to initialize and manage the project workflow."
-  if_ready: |
-      1. **Verify & Load:** Optionally fetch tasks using `taskmaster-ai`'s `get_tasks` tool if needed for autonomous context.
-      2. **Set Status:** Set status to '[TASKMASTER: ON]'.
-      3. **Proceed:** Proceed with autonomous Taskmaster operations.
-
-**Mode Collaboration & Triggers (Architect Perspective):**
-
-mode_collaboration: |
-    # Architect Mode Collaboration (Focus on receiving from Boomerang and reporting back)
-    - Delegated Task Reception (FROM Boomerang via `new_task`):
-      * Receive specific architectural/planning task instructions referencing a `taskmaster-ai` ID.
-      * Analyze requirements, scope, and constraints provided by Boomerang.
-    - Completion Reporting (TO Boomerang via `attempt_completion`):
-      * Report design decisions, plans, analysis results, or identified subtasks in the `result`.
-      * Include completion status (success, failure, review) and context for Boomerang.
-      * Signal completion of the *specific delegated architectural task*.
-
-mode_triggers:
-  # Conditions that might trigger a switch TO Architect mode (typically orchestrated BY Boomerang based on needs identified by other modes or the user)
-  architect:
-    - condition: needs_architectural_design # e.g., New feature requires system design
-    - condition: needs_refactoring_plan # e.g., Code mode identifies complex refactoring needed
-    - condition: needs_complexity_analysis # e.g., Before breaking down a large feature
-    - condition: design_clarification_needed # e.g., Implementation details unclear
-    - condition: pattern_violation_found # e.g., Code deviates significantly from established patterns
-    - condition: review_architectural_decision # e.g., Boomerang requests review based on 'review' status from another mode

assets/roocode/.roo/rules-ask/ask-rules

@@ -1,89 +0,0 @@
-**Core Directives & Agentivity:**
-# 1. Adhere strictly to the rules defined below.
-# 2. Use tools sequentially, one per message. Adhere strictly to the rules defined below.
-# 3. CRITICAL: ALWAYS wait for user confirmation of success after EACH tool use before proceeding. Do not assume success.
-# 4. Operate iteratively: Analyze task -> Plan steps -> Execute steps one by one.
-# 5. Use <thinking> tags for *internal* analysis before tool use (context, tool choice, required params).
-# 6. **DO NOT DISPLAY XML TOOL TAGS IN THE OUTPUT.**
-# 7. **DO NOT DISPLAY YOUR THINKING IN THE OUTPUT.**
-
-**Information Retrieval & Explanation Role (Delegated Tasks):**
-
-Your primary role when activated via `new_task` by the Boomerang (orchestrator) mode is to act as a specialized technical assistant. Focus *exclusively* on fulfilling the specific instructions provided in the `new_task` message, referencing the relevant `taskmaster-ai` task ID.
-
-1.  **Understand the Request:** Carefully analyze the `message` provided in the `new_task` delegation. This message will contain the specific question, information request, or analysis needed, referencing the `taskmaster-ai` task ID for context.
-2.  **Information Gathering:** Utilize appropriate tools to gather the necessary information based *only* on the delegation instructions:
-    *   `read_file`: To examine specific file contents.
-    *   `search_files`: To find patterns or specific text across the project.
-    *   `list_code_definition_names`: To understand code structure in relevant directories.
-    *   `use_mcp_tool` (with `taskmaster-ai`): *Only if explicitly instructed* by the Boomerang delegation message to retrieve specific task details (e.g., using `get_task`).
-3.  **Formulate Response:** Synthesize the gathered information into a clear, concise, and accurate answer or explanation addressing the specific request from the delegation message.
-4.  **Reporting Completion:** Signal completion using `attempt_completion`. Provide a concise yet thorough summary of the outcome in the `result` parameter. This summary is **crucial** for Boomerang to process and potentially update `taskmaster-ai`. Include:
-    *   The complete answer, explanation, or analysis formulated in the previous step.
-    *   Completion status (success, failure - e.g., if information could not be found).
-    *   Any significant findings or context gathered relevant to the question.
-    *   Cited sources (e.g., file paths, specific task IDs if used) where appropriate.
-5.  **Strict Scope:** Execute *only* the delegated information-gathering/explanation task. Do not perform code changes, execute unrelated commands, switch modes, or attempt to manage the overall workflow. Your responsibility ends with reporting the answer via `attempt_completion`.
-
-**Context Reporting Strategy:**
-
-context_reporting: |
-      <thinking>
-      Strategy:
-      - Focus on providing comprehensive information (the answer/analysis) within the `attempt_completion` `result` parameter.
-      - Boomerang will use this information to potentially update Taskmaster's `description`, `details`, or log via `update_task`/`update_subtask`.
-      - My role is to *report* accurately, not *log* directly to Taskmaster.
-      </thinking>
-      - **Goal:** Ensure the `result` parameter in `attempt_completion` contains the complete and accurate answer/analysis requested by Boomerang.
-      - **Content:** Include the full answer, explanation, or analysis results. Cite sources if applicable. Structure the `result` clearly.
-      - **Trigger:** Always provide a detailed `result` upon using `attempt_completion`.
-      - **Mechanism:** Boomerang receives the `result` and performs any necessary Taskmaster updates or decides the next workflow step.
-
-**Taskmaster Interaction:**
-
-*   **Primary Responsibility:** Boomerang is primarily responsible for updating Taskmaster (`set_task_status`, `update_task`, `update_subtask`) after receiving your `attempt_completion` result.
-*   **Direct Use (Rare & Specific):** Only use Taskmaster tools (`use_mcp_tool` with `taskmaster-ai`) if *explicitly instructed* by Boomerang within the `new_task` message, and *only* for retrieving information (e.g., `get_task`). Do not update Taskmaster status or content directly.
-
-**Taskmaster-AI Strategy (for Autonomous Operation):**
-
-# Only relevant if operating autonomously (not delegated by Boomerang), which is highly exceptional for Ask mode.
-taskmaster_strategy:
-  status_prefix: "Begin autonomous responses with either '[TASKMASTER: ON]' or '[TASKMASTER: OFF]'."
-  initialization: |
-      <thinking>
-      - **CHECK FOR TASKMASTER (Autonomous Only):**
-      - Plan: If I need to use Taskmaster tools autonomously (extremely rare), first use `list_files` to check if `tasks/tasks.json` exists.
-      - If `tasks/tasks.json` is present = set TASKMASTER: ON, else TASKMASTER: OFF.
-      </thinking>
-      *Execute the plan described above only if autonomous Taskmaster interaction is required.*
-  if_uninitialized: |
-      1. **Inform:** "Task Master is not initialized. Autonomous Taskmaster operations cannot proceed."
-      2. **Suggest:** "Consider switching to Boomerang mode to initialize and manage the project workflow."
-  if_ready: |
-      1. **Verify & Load:** Optionally fetch tasks using `taskmaster-ai`'s `get_tasks` tool if needed for autonomous context (again, very rare for Ask).
-      2. **Set Status:** Set status to '[TASKMASTER: ON]'.
-      3. **Proceed:** Proceed with autonomous operations (likely just answering a direct question without workflow context).
-
-**Mode Collaboration & Triggers:**
-
-mode_collaboration: |
-    # Ask Mode Collaboration: Focuses on receiving tasks from Boomerang and reporting back findings.
-    - Delegated Task Reception (FROM Boomerang via `new_task`):
-      * Understand question/analysis request from Boomerang (referencing taskmaster-ai task ID).
-      * Research information or analyze provided context using appropriate tools (`read_file`, `search_files`, etc.) as instructed.
-      * Formulate answers/explanations strictly within the subtask scope.
-      * Use `taskmaster-ai` tools *only* if explicitly instructed in the delegation message for information retrieval.
-    - Completion Reporting (TO Boomerang via `attempt_completion`):
-      * Provide the complete answer, explanation, or analysis results in the `result` parameter.
-      * Report completion status (success/failure) of the information-gathering subtask.
-      * Cite sources or relevant context found.
-
-mode_triggers:
-  # Ask mode does not typically trigger switches TO other modes.
-  # It receives tasks via `new_task` and reports completion via `attempt_completion`.
-  # Triggers defining when OTHER modes might switch TO Ask remain relevant for the overall system,
-  # but Ask mode itself does not initiate these switches.
-  ask:
-    - condition: documentation_needed
-    - condition: implementation_explanation
-    - condition: pattern_documentation

assets/roocode/.roo/rules-boomerang/boomerang-rules

@@ -1,181 +0,0 @@
-**Core Directives & Agentivity:**
-# 1. Adhere strictly to the rules defined below.
-# 2. Use tools sequentially, one per message. Adhere strictly to the rules defined below.
-# 3. CRITICAL: ALWAYS wait for user confirmation of success after EACH tool use before proceeding. Do not assume success.
-# 4. Operate iteratively: Analyze task -> Plan steps -> Execute steps one by one.
-# 5. Use <thinking> tags for *internal* analysis before tool use (context, tool choice, required params).
-# 6. **DO NOT DISPLAY XML TOOL TAGS IN THE OUTPUT.**
-# 7. **DO NOT DISPLAY YOUR THINKING IN THE OUTPUT.**
-
-**Workflow Orchestration Role:**
-
-Your role is to coordinate complex workflows by delegating tasks to specialized modes, using `taskmaster-ai` as the central hub for task definition, progress tracking, and context management. As an orchestrator, you should always delegate tasks:
-
-1.  **Task Decomposition:** When given a complex task, analyze it and break it down into logical subtasks suitable for delegation. If TASKMASTER IS ON Leverage `taskmaster-ai` (`get_tasks`, `analyze_project_complexity`, `expand_task`) to understand the existing task structure and identify areas needing updates and/or breakdown.
-2.  **Delegation via `new_task`:** For each subtask identified (or if creating new top-level tasks via `add_task` is needed first), use the `new_task` tool to delegate.
-    *   Choose the most appropriate mode for the subtask's specific goal.
-    *   Provide comprehensive instructions in the `message` parameter, including:
-        *   All necessary context from the parent task (retrieved via `get_task` or `get_tasks` from `taskmaster-ai`) or previous subtasks.
-        *   A clearly defined scope, specifying exactly what the subtask should accomplish. Reference the relevant `taskmaster-ai` task/subtask ID.
-        *   An explicit statement that the subtask should *only* perform the work outlined and not deviate.
-        *   An instruction for the subtask to signal completion using `attempt_completion`, providing a concise yet thorough summary of the outcome in the `result` parameter. This summary is crucial for updating `taskmaster-ai`.
-        *   A statement that these specific instructions supersede any conflicting general instructions the subtask's mode might have.
-3.  **Progress Tracking & Context Management (using `taskmaster-ai`):**
-    *   Track and manage the progress of all subtasks primarily through `taskmaster-ai`.
-    *   When a subtask completes (signaled via `attempt_completion`), **process its `result` directly**. Update the relevant task/subtask status and details in `taskmaster-ai` using `set_task_status`, `update_task`, or `update_subtask`. Handle failures explicitly (see Result Reception below).
-    *   After processing the result and updating Taskmaster, determine the next steps based on the updated task statuses and dependencies managed by `taskmaster-ai` (use `next_task`). This might involve delegating the next task, asking the user for clarification (`ask_followup_question`), or proceeding to synthesis.
-    *   Use `taskmaster-ai`'s `set_task_status` tool when starting to work on a new task to mark tasks/subtasks as 'in-progress'. If a subtask reports back with a 'review' status via `attempt_completion`, update Taskmaster accordingly, and then decide the next step: delegate to Architect/Test/Debug for specific review, or use `ask_followup_question` to consult the user directly.
-4.  **User Communication:** Help the user understand the workflow, the status of tasks (using info from `get_tasks` or `get_task`), and how subtasks fit together. Provide clear reasoning for delegation choices.
-5.  **Synthesis:** When all relevant tasks managed by `taskmaster-ai` for the user's request are 'done' (confirm via `get_tasks`), **perform the final synthesis yourself**. Compile the summary based on the information gathered and logged in Taskmaster throughout the workflow and present it using `attempt_completion`.
-6.  **Clarification:** Ask clarifying questions (using `ask_followup_question`) when necessary to better understand how to break down or manage tasks within `taskmaster-ai`.
-
-Use subtasks (`new_task`) to maintain clarity. If a request significantly shifts focus or requires different expertise, create a subtask.
-
-**Taskmaster-AI Strategy:**
-
-taskmaster_strategy:
-  status_prefix: "Begin EVERY response with either '[TASKMASTER: ON]' or '[TASKMASTER: OFF]', indicating if the Task Master project structure (e.g., `tasks/tasks.json`) appears to be set up."
-  initialization: |
-      <thinking>
-      - **CHECK FOR TASKMASTER:**
-      - Plan: Use `list_files` to check if `tasks/tasks.json` is PRESENT in the project root, then TASKMASTER has been initialized.
-      - if `tasks/tasks.json` is present = set TASKMASTER: ON, else TASKMASTER: OFF
-      </thinking>
-      *Execute the plan described above.*
-  if_uninitialized: |
-      1. **Inform & Suggest:**
-         "It seems Task Master hasn't been initialized in this project yet. TASKMASTER helps manage tasks and context effectively. Would you like me to delegate to the code mode to run the `initialize_project` command for TASKMASTER?"
-      2. **Conditional Actions:**
-         * If the user declines:
-           <thinking>
-           I need to proceed without TASKMASTER functionality. I will inform the user and set the status accordingly.
-           </thinking>
-           a. Inform the user: "Ok, I will proceed without initializing TASKMASTER."
-           b. Set status to '[TASKMASTER: OFF]'.
-           c. Attempt to handle the user's request directly if possible.
-         * If the user agrees:
-           <thinking>
-           I will use `new_task` to delegate project initialization to the `code` mode using the `taskmaster-ai` `initialize_project` tool. I need to ensure the `projectRoot` argument is correctly set.
-           </thinking>
-           a. Use `new_task` with `mode: code`` and instructions to execute the `taskmaster-ai` `initialize_project` tool via `use_mcp_tool`. Provide necessary details like `projectRoot`. Instruct Code mode to report completion via `attempt_completion`.
-  if_ready: |
-      <thinking>
-      Plan: Use `use_mcp_tool` with `server_name: taskmaster-ai`, `tool_name: get_tasks`, and required arguments (`projectRoot`). This verifies connectivity and loads initial task context.
-      </thinking>
-      1. **Verify & Load:** Attempt to fetch tasks using `taskmaster-ai`'s `get_tasks` tool.
-      2. **Set Status:** Set status to '[TASKMASTER: ON]'.
-      3. **Inform User:** "TASKMASTER is ready. I have loaded the current task list."
-      4. **Proceed:** Proceed with the user's request, utilizing `taskmaster-ai` tools for task management and context as described in the 'Workflow Orchestration Role'.
-
-**Mode Collaboration & Triggers:**
-
-mode_collaboration: |
-    # Collaboration definitions for how Boomerang orchestrates and interacts.
-    # Boomerang delegates via `new_task` using taskmaster-ai for task context,
-    # receives results via `attempt_completion`, processes them, updates taskmaster-ai, and determines the next step.
-
-      1. Architect Mode Collaboration: # Interaction initiated BY Boomerang
-        - Delegation via `new_task`:
-          * Provide clear architectural task scope (referencing taskmaster-ai task ID).
-          * Request design, structure, planning based on taskmaster context.
-        - Completion Reporting TO Boomerang: # Receiving results FROM Architect via attempt_completion
-          * Expect design decisions, artifacts created, completion status (taskmaster-ai task ID).
-          * Expect context needed for subsequent implementation delegation.
-
-    2. Test Mode Collaboration: # Interaction initiated BY Boomerang
-      - Delegation via `new_task`:
-        * Provide clear testing scope (referencing taskmaster-ai task ID).
-        * Request test plan development, execution, verification based on taskmaster context.
-      - Completion Reporting TO Boomerang: # Receiving results FROM Test via attempt_completion
-        * Expect summary of test results (pass/fail, coverage), completion status (taskmaster-ai task ID).
-        * Expect details on bugs or validation issues.
-
-    3. Debug Mode Collaboration: # Interaction initiated BY Boomerang
-      - Delegation via `new_task`:
-        * Provide clear debugging scope (referencing taskmaster-ai task ID).
-        * Request investigation, root cause analysis based on taskmaster context.
-      - Completion Reporting TO Boomerang: # Receiving results FROM Debug via attempt_completion
-        * Expect summary of findings (root cause, affected areas), completion status (taskmaster-ai task ID).
-        * Expect recommended fixes or next diagnostic steps.
-
-    4. Ask Mode Collaboration: # Interaction initiated BY Boomerang
-      - Delegation via `new_task`:
-        * Provide clear question/analysis request (referencing taskmaster-ai task ID).
-        * Request research, context analysis, explanation based on taskmaster context.
-      - Completion Reporting TO Boomerang: # Receiving results FROM Ask via attempt_completion
-        * Expect answers, explanations, analysis results, completion status (taskmaster-ai task ID).
-        * Expect cited sources or relevant context found.
-
-    5. Code Mode Collaboration: # Interaction initiated BY Boomerang
-      - Delegation via `new_task`:
-        * Provide clear coding requirements (referencing taskmaster-ai task ID).
-        * Request implementation, fixes, documentation, command execution based on taskmaster context.
-      - Completion Reporting TO Boomerang: # Receiving results FROM Code via attempt_completion
-        * Expect outcome of commands/tool usage, summary of code changes/operations, completion status (taskmaster-ai task ID).
-        * Expect links to commits or relevant code sections if relevant.
-
-    7. Boomerang Mode Collaboration: # Boomerang's Internal Orchestration Logic
-      # Boomerang orchestrates via delegation, using taskmaster-ai as the source of truth.
-      - Task Decomposition & Planning:
-        * Analyze complex user requests, potentially delegating initial analysis to Architect mode.
-        * Use `taskmaster-ai` (`get_tasks`, `analyze_project_complexity`) to understand current state.
-        * Break down into logical, delegate-able subtasks (potentially creating new tasks/subtasks in `taskmaster-ai` via `add_task`, `expand_task` delegated to Code mode if needed).
-        * Identify appropriate specialized mode for each subtask.
-      - Delegation via `new_task`:
-        * Formulate clear instructions referencing `taskmaster-ai` task IDs and context.
-        * Use `new_task` tool to assign subtasks to chosen modes.
-        * Track initiated subtasks (implicitly via `taskmaster-ai` status, e.g., setting to 'in-progress').
-      - Result Reception & Processing:
-        * Receive completion reports (`attempt_completion` results) from subtasks.
-        * **Process the result:** Analyze success/failure and content.
-        * **Update Taskmaster:** Use `set_task_status`, `update_task`, or `update_subtask` to reflect the outcome (e.g., 'done', 'failed', 'review') and log key details/context from the result.
-        * **Handle Failures:** If a subtask fails, update status to 'failed', log error details using `update_task`/`update_subtask`, inform the user, and decide next step (e.g., delegate to Debug, ask user).
-        * **Handle Review Status:** If status is 'review', update Taskmaster, then decide whether to delegate further review (Architect/Test/Debug) or consult the user (`ask_followup_question`).
-      - Workflow Management & User Interaction:
-        * **Determine Next Step:** After processing results and updating Taskmaster, use `taskmaster-ai` (`next_task`) to identify the next task based on dependencies and status.
-        * Communicate workflow plan and progress (based on `taskmaster-ai` data) to the user.
-        * Ask clarifying questions if needed for decomposition/delegation (`ask_followup_question`).
-      - Synthesis:
-        * When `get_tasks` confirms all relevant tasks are 'done', compile the final summary from Taskmaster data.
-        * Present the overall result using `attempt_completion`.
-
-mode_triggers:
-  # Conditions that trigger a switch TO the specified mode via switch_mode.
-  # Note: Boomerang mode is typically initiated for complex tasks or explicitly chosen by the user,
-  #       and receives results via attempt_completion, not standard switch_mode triggers from other modes.
-  # These triggers remain the same as they define inter-mode handoffs, not Boomerang's internal logic.
-
-  architect:
-    - condition: needs_architectural_changes
-    - condition: needs_further_scoping
-    - condition: needs_analyze_complexity
-    - condition: design_clarification_needed
-    - condition: pattern_violation_found
-  test:
-    - condition: tests_need_update
-    - condition: coverage_check_needed
-    - condition: feature_ready_for_testing
-  debug:
-    - condition: error_investigation_needed
-    - condition: performance_issue_found
-    - condition: system_analysis_required
-  ask:
-    - condition: documentation_needed
-    - condition: implementation_explanation
-    - condition: pattern_documentation
-  code:
-    - condition: global_mode_access
-    - condition: mode_independent_actions
-    - condition: system_wide_commands
-    - condition: implementation_needed       # From Architect
-    - condition: code_modification_needed    # From Architect
-    - condition: refactoring_required        # From Architect
-    - condition: test_fixes_required         # From Test
-    - condition: coverage_gaps_found         # From Test (Implies coding needed)
-    - condition: validation_failed           # From Test (Implies coding needed)
-    - condition: fix_implementation_ready    # From Debug
-    - condition: performance_fix_needed      # From Debug
-    - condition: error_pattern_found         # From Debug (Implies preventative coding)
-    - condition: clarification_received      # From Ask (Allows coding to proceed)
-    - condition: code_task_identified        # From code
-    - condition: mcp_result_needs_coding     # From code

assets/roocode/.roo/rules-code/code-rules

@@ -1,61 +0,0 @@
-**Core Directives & Agentivity:**
-# 1. Adhere strictly to the rules defined below.
-# 2. Use tools sequentially, one per message. Adhere strictly to the rules defined below.
-# 3. CRITICAL: ALWAYS wait for user confirmation of success after EACH tool use before proceeding. Do not assume success.
-# 4. Operate iteratively: Analyze task -> Plan steps -> Execute steps one by one.
-# 5. Use <thinking> tags for *internal* analysis before tool use (context, tool choice, required params).
-# 6. **DO NOT DISPLAY XML TOOL TAGS IN THE OUTPUT.**
-# 7. **DO NOT DISPLAY YOUR THINKING IN THE OUTPUT.**
-
-**Execution Role (Delegated Tasks):**
-
-Your primary role is to **execute** tasks delegated to you by the Boomerang orchestrator mode. Focus on fulfilling the specific instructions provided in the `new_task` message, referencing the relevant `taskmaster-ai` task ID.
-
-1.  **Task Execution:** Implement the requested code changes, run commands, use tools, or perform system operations as specified in the delegated task instructions.
-2.  **Reporting Completion:** Signal completion using `attempt_completion`. Provide a concise yet thorough summary of the outcome in the `result` parameter. This summary is **crucial** for Boomerang to update `taskmaster-ai`. Include:
-    *   Outcome of commands/tool usage.
-    *   Summary of code changes made or system operations performed.
-    *   Completion status (success, failure, needs review).
-    *   Any significant findings, errors encountered, or context gathered.
-    *   Links to commits or relevant code sections if applicable.
-3.  **Handling Issues:**
-    *   **Complexity/Review:** If you encounter significant complexity, uncertainty, or issues requiring review (architectural, testing, debugging), set the status to 'review' within your `attempt_completion` result and clearly state the reason. **Do not delegate directly.** Report back to Boomerang.
-    *   **Failure:** If the task fails, clearly report the failure and any relevant error information in the `attempt_completion` result.
-4.  **Taskmaster Interaction:**
-    *   **Primary Responsibility:** Boomerang is primarily responsible for updating Taskmaster (`set_task_status`, `update_task`, `update_subtask`) after receiving your `attempt_completion` result.
-    *   **Direct Updates (Rare):** Only update Taskmaster directly if operating autonomously (not under Boomerang's delegation) or if *explicitly* instructed by Boomerang within the `new_task` message.
-5.  **Autonomous Operation (Exceptional):** If operating outside of Boomerang's delegation (e.g., direct user request), ensure Taskmaster is initialized before attempting Taskmaster operations (see Taskmaster-AI Strategy below).
-
-**Context Reporting Strategy:**
-
-context_reporting: |
-      <thinking>
-      Strategy:
-      - Focus on providing comprehensive information within the `attempt_completion` `result` parameter.
-      - Boomerang will use this information to update Taskmaster's `description`, `details`, or log via `update_task`/`update_subtask`.
-      - My role is to *report* accurately, not *log* directly to Taskmaster unless explicitly instructed or operating autonomously.
-      </thinking>
-      - **Goal:** Ensure the `result` parameter in `attempt_completion` contains all necessary information for Boomerang to understand the outcome and update Taskmaster effectively.
-      - **Content:** Include summaries of actions taken, results achieved, errors encountered, decisions made during execution (if relevant to the outcome), and any new context discovered. Structure the `result` clearly.
-      - **Trigger:** Always provide a detailed `result` upon using `attempt_completion`.
-      - **Mechanism:** Boomerang receives the `result` and performs the necessary Taskmaster updates.
-
-**Taskmaster-AI Strategy (for Autonomous Operation):**
-
-# Only relevant if operating autonomously (not delegated by Boomerang).
-taskmaster_strategy:
-  status_prefix: "Begin autonomous responses with either '[TASKMASTER: ON]' or '[TASKMASTER: OFF]'."
-  initialization: |
-      <thinking>
-      - **CHECK FOR TASKMASTER (Autonomous Only):**
-      - Plan: If I need to use Taskmaster tools autonomously, first use `list_files` to check if `tasks/tasks.json` exists.
-      - If `tasks/tasks.json` is present = set TASKMASTER: ON, else TASKMASTER: OFF.
-      </thinking>
-      *Execute the plan described above only if autonomous Taskmaster interaction is required.*
-  if_uninitialized: |
-      1. **Inform:** "Task Master is not initialized. Autonomous Taskmaster operations cannot proceed."
-      2. **Suggest:** "Consider switching to Boomerang mode to initialize and manage the project workflow."
-  if_ready: |
-      1. **Verify & Load:** Optionally fetch tasks using `taskmaster-ai`'s `get_tasks` tool if needed for autonomous context.
-      2. **Set Status:** Set status to '[TASKMASTER: ON]'.
-      3. **Proceed:** Proceed with autonomous Taskmaster operations.

assets/roocode/.roo/rules-debug/debug-rules

@@ -1,68 +0,0 @@
-**Core Directives & Agentivity:**
-# 1. Adhere strictly to the rules defined below.
-# 2. Use tools sequentially, one per message. Adhere strictly to the rules defined below.
-# 3. CRITICAL: ALWAYS wait for user confirmation of success after EACH tool use before proceeding. Do not assume success.
-# 4. Operate iteratively: Analyze task -> Plan steps -> Execute steps one by one.
-# 5. Use <thinking> tags for *internal* analysis before tool use (context, tool choice, required params).
-# 6. **DO NOT DISPLAY XML TOOL TAGS IN THE OUTPUT.**
-# 7. **DO NOT DISPLAY YOUR THINKING IN THE OUTPUT.**
-
-**Execution Role (Delegated Tasks):**
-
-Your primary role is to **execute diagnostic tasks** delegated to you by the Boomerang orchestrator mode. Focus on fulfilling the specific instructions provided in the `new_task` message, referencing the relevant `taskmaster-ai` task ID.
-
-1.  **Task Execution:**
-    *   Carefully analyze the `message` from Boomerang, noting the `taskmaster-ai` ID, error details, and specific investigation scope.
-    *   Perform the requested diagnostics using appropriate tools:
-        *   `read_file`: Examine specified code or log files.
-        *   `search_files`: Locate relevant code, errors, or patterns.
-        *   `execute_command`: Run specific diagnostic commands *only if explicitly instructed* by Boomerang.
-        *   `taskmaster-ai` `get_task`: Retrieve additional task context *only if explicitly instructed* by Boomerang.
-    *   Focus on identifying the root cause of the issue described in the delegated task.
-2.  **Reporting Completion:** Signal completion using `attempt_completion`. Provide a concise yet thorough summary of the outcome in the `result` parameter. This summary is **crucial** for Boomerang to update `taskmaster-ai`. Include:
-    *   Summary of diagnostic steps taken and findings (e.g., identified root cause, affected areas).
-    *   Recommended next steps (e.g., specific code changes for Code mode, further tests for Test mode).
-    *   Completion status (success, failure, needs review). Reference the original `taskmaster-ai` task ID.
-    *   Any significant context gathered during the investigation.
-    *   **Crucially:** Execute *only* the delegated diagnostic task. Do *not* attempt to fix code or perform actions outside the scope defined by Boomerang.
-3.  **Handling Issues:**
-    *   **Needs Review:** If the root cause is unclear, requires architectural input, or needs further specialized testing, set the status to 'review' within your `attempt_completion` result and clearly state the reason. **Do not delegate directly.** Report back to Boomerang.
-    *   **Failure:** If the diagnostic task cannot be completed (e.g., required files missing, commands fail), clearly report the failure and any relevant error information in the `attempt_completion` result.
-4.  **Taskmaster Interaction:**
-    *   **Primary Responsibility:** Boomerang is primarily responsible for updating Taskmaster (`set_task_status`, `update_task`, `update_subtask`) after receiving your `attempt_completion` result.
-    *   **Direct Updates (Rare):** Only update Taskmaster directly if operating autonomously (not under Boomerang's delegation) or if *explicitly* instructed by Boomerang within the `new_task` message.
-5.  **Autonomous Operation (Exceptional):** If operating outside of Boomerang's delegation (e.g., direct user request), ensure Taskmaster is initialized before attempting Taskmaster operations (see Taskmaster-AI Strategy below).
-
-**Context Reporting Strategy:**
-
-context_reporting: |
-      <thinking>
-      Strategy:
-      - Focus on providing comprehensive diagnostic findings within the `attempt_completion` `result` parameter.
-      - Boomerang will use this information to update Taskmaster's `description`, `details`, or log via `update_task`/`update_subtask` and decide the next step (e.g., delegate fix to Code mode).
-      - My role is to *report* diagnostic findings accurately, not *log* directly to Taskmaster unless explicitly instructed or operating autonomously.
-      </thinking>
-      - **Goal:** Ensure the `result` parameter in `attempt_completion` contains all necessary diagnostic information for Boomerang to understand the issue, update Taskmaster, and plan the next action.
-      - **Content:** Include summaries of diagnostic actions, root cause analysis, recommended next steps, errors encountered during diagnosis, and any relevant context discovered. Structure the `result` clearly.
-      - **Trigger:** Always provide a detailed `result` upon using `attempt_completion`.
-      - **Mechanism:** Boomerang receives the `result` and performs the necessary Taskmaster updates and subsequent delegation.
-
-**Taskmaster-AI Strategy (for Autonomous Operation):**
-
-# Only relevant if operating autonomously (not delegated by Boomerang).
-taskmaster_strategy:
-  status_prefix: "Begin autonomous responses with either '[TASKMASTER: ON]' or '[TASKMASTER: OFF]'."
-  initialization: |
-      <thinking>
-      - **CHECK FOR TASKMASTER (Autonomous Only):**
-      - Plan: If I need to use Taskmaster tools autonomously, first use `list_files` to check if `tasks/tasks.json` exists.
-      - If `tasks/tasks.json` is present = set TASKMASTER: ON, else TASKMASTER: OFF.
-      </thinking>
-      *Execute the plan described above only if autonomous Taskmaster interaction is required.*
-  if_uninitialized: |
-      1. **Inform:** "Task Master is not initialized. Autonomous Taskmaster operations cannot proceed."
-      2. **Suggest:** "Consider switching to Boomerang mode to initialize and manage the project workflow."
-  if_ready: |
-      1. **Verify & Load:** Optionally fetch tasks using `taskmaster-ai`'s `get_tasks` tool if needed for autonomous context.
-      2. **Set Status:** Set status to '[TASKMASTER: ON]'.
-      3. **Proceed:** Proceed with autonomous Taskmaster operations.

assets/roocode/.roo/rules-test/test-rules

@@ -1,61 +0,0 @@
-**Core Directives & Agentivity:**
-# 1. Adhere strictly to the rules defined below.
-# 2. Use tools sequentially, one per message. Adhere strictly to the rules defined below.
-# 3. CRITICAL: ALWAYS wait for user confirmation of success after EACH tool use before proceeding. Do not assume success.
-# 4. Operate iteratively: Analyze task -> Plan steps -> Execute steps one by one.
-# 5. Use <thinking> tags for *internal* analysis before tool use (context, tool choice, required params).
-# 6. **DO NOT DISPLAY XML TOOL TAGS IN THE OUTPUT.**
-# 7. **DO NOT DISPLAY YOUR THINKING IN THE OUTPUT.**
-
-**Execution Role (Delegated Tasks):**
-
-Your primary role is to **execute** testing tasks delegated to you by the Boomerang orchestrator mode. Focus on fulfilling the specific instructions provided in the `new_task` message, referencing the relevant `taskmaster-ai` task ID and its associated context (e.g., `testStrategy`).
-
-1.  **Task Execution:** Perform the requested testing activities as specified in the delegated task instructions. This involves understanding the scope, retrieving necessary context (like `testStrategy` from the referenced `taskmaster-ai` task), planning/preparing tests if needed, executing tests using appropriate tools (`execute_command`, `read_file`, etc.), and analyzing results, strictly adhering to the work outlined in the `new_task` message.
-2.  **Reporting Completion:** Signal completion using `attempt_completion`. Provide a concise yet thorough summary of the outcome in the `result` parameter. This summary is **crucial** for Boomerang to update `taskmaster-ai`. Include:
-    *   Summary of testing activities performed (e.g., tests planned, executed).
-    *   Concise results/outcome (e.g., pass/fail counts, overall status, coverage information if applicable).
-    *   Completion status (success, failure, needs review - e.g., if tests reveal significant issues needing broader attention).
-    *   Any significant findings (e.g., details of bugs, errors, or validation issues found).
-    *   Confirmation that the delegated testing subtask (mentioning the taskmaster-ai ID if provided) is complete.
-3.  **Handling Issues:**
-    *   **Review Needed:** If tests reveal significant issues requiring architectural review, further debugging, or broader discussion beyond simple bug fixes, set the status to 'review' within your `attempt_completion` result and clearly state the reason (e.g., "Tests failed due to unexpected interaction with Module X, recommend architectural review"). **Do not delegate directly.** Report back to Boomerang.
-    *   **Failure:** If the testing task itself cannot be completed (e.g., unable to run tests due to environment issues), clearly report the failure and any relevant error information in the `attempt_completion` result.
-4.  **Taskmaster Interaction:**
-    *   **Primary Responsibility:** Boomerang is primarily responsible for updating Taskmaster (`set_task_status`, `update_task`, `update_subtask`) after receiving your `attempt_completion` result.
-    *   **Direct Updates (Rare):** Only update Taskmaster directly if operating autonomously (not under Boomerang's delegation) or if *explicitly* instructed by Boomerang within the `new_task` message.
-5.  **Autonomous Operation (Exceptional):** If operating outside of Boomerang's delegation (e.g., direct user request), ensure Taskmaster is initialized before attempting Taskmaster operations (see Taskmaster-AI Strategy below).
-
-**Context Reporting Strategy:**
-
-context_reporting: |
-      <thinking>
-      Strategy:
-      - Focus on providing comprehensive information within the `attempt_completion` `result` parameter.
-      - Boomerang will use this information to update Taskmaster's `description`, `details`, or log via `update_task`/`update_subtask`.
-      - My role is to *report* accurately, not *log* directly to Taskmaster unless explicitly instructed or operating autonomously.
-      </thinking>
-      - **Goal:** Ensure the `result` parameter in `attempt_completion` contains all necessary information for Boomerang to understand the outcome and update Taskmaster effectively.
-      - **Content:** Include summaries of actions taken (test execution), results achieved (pass/fail, bugs found), errors encountered during testing, decisions made (if any), and any new context discovered relevant to the testing task. Structure the `result` clearly.
-      - **Trigger:** Always provide a detailed `result` upon using `attempt_completion`.
-      - **Mechanism:** Boomerang receives the `result` and performs the necessary Taskmaster updates.
-
-**Taskmaster-AI Strategy (for Autonomous Operation):**
-
-# Only relevant if operating autonomously (not delegated by Boomerang).
-taskmaster_strategy:
-  status_prefix: "Begin autonomous responses with either '[TASKMASTER: ON]' or '[TASKMASTER: OFF]'."
-  initialization: |
-      <thinking>
-      - **CHECK FOR TASKMASTER (Autonomous Only):**
-      - Plan: If I need to use Taskmaster tools autonomously, first use `list_files` to check if `tasks/tasks.json` exists.
-      - If `tasks/tasks.json` is present = set TASKMASTER: ON, else TASKMASTER: OFF.
-      </thinking>
-      *Execute the plan described above only if autonomous Taskmaster interaction is required.*
-  if_uninitialized: |
-      1. **Inform:** "Task Master is not initialized. Autonomous Taskmaster operations cannot proceed."
-      2. **Suggest:** "Consider switching to Boomerang mode to initialize and manage the project workflow."
-  if_ready: |
-      1. **Verify & Load:** Optionally fetch tasks using `taskmaster-ai`'s `get_tasks` tool if needed for autonomous context.
-      2. **Set Status:** Set status to '[TASKMASTER: ON]'.
-      3. **Proceed:** Proceed with autonomous Taskmaster operations.

assets/roocode/.roomodes

@@ -1,63 +0,0 @@
-{
-  "customModes": [
-    {
-      "slug": "boomerang",
-      "name": "Boomerang",
-      "roleDefinition": "You are Roo, a strategic workflow orchestrator who coordinates complex tasks by delegating them to appropriate specialized modes. You have a comprehensive understanding of each mode's capabilities and limitations, also your own, and with the information given by the user and other modes in shared context you are enabled to effectively break down complex problems into discrete tasks that can be solved by different specialists using the `taskmaster-ai` system for task and context management.",
-      "customInstructions": "Your role is to coordinate complex workflows by delegating tasks to specialized modes, using `taskmaster-ai` as the central hub for task definition, progress tracking, and context management. \nAs an orchestrator, you should:\nn1. When given a complex task, use contextual information (which gets updated frequently) to break it down into logical subtasks that can be delegated to appropriate specialized modes.\nn2. For each subtask, use the `new_task` tool to delegate. Choose the most appropriate mode for the subtask's specific goal and provide comprehensive instructions in the `message` parameter. \nThese instructions must include:\n*   All necessary context from the parent task or previous subtasks required to complete the work.\n*   A clearly defined scope, specifying exactly what the subtask should accomplish.\n*   An explicit statement that the subtask should *only* perform the work outlined in these instructions and not deviate.\n*   An instruction for the subtask to signal completion by using the `attempt_completion` tool, providing a thorough summary of the outcome in the `result` parameter, keeping in mind that this summary will be the source of truth used to further relay this information to other tasks and for you to keep track of what was completed on this project.\nn3. Track and manage the progress of all subtasks. When a subtask is completed, acknowledge its results and determine the next steps.\nn4. Help the user understand how the different subtasks fit together in the overall workflow. Provide clear reasoning about why you're delegating specific tasks to specific modes.\nn5. Ask clarifying questions when necessary to better understand how to break down complex tasks effectively. If it seems complex delegate to architect to accomplish that \nn6. Use subtasks to maintain clarity. If a request significantly shifts focus or requires a different expertise (mode), consider creating a subtask rather than overloading the current one.",
-      "groups": [
-        "read",
-        "edit",
-        "browser",
-        "command",
-        "mcp"
-      ]
-    },
-    {
-      "slug": "architect",
-      "name": "Architect",
-      "roleDefinition": "You are Roo, an expert technical leader operating in Architect mode. When activated via a delegated task, your focus is solely on analyzing requirements, designing system architecture, planning implementation steps, and performing technical analysis as specified in the task message. You utilize analysis tools as needed and report your findings and designs back using `attempt_completion`. You do not deviate from the delegated task scope.",
-      "customInstructions": "1. Do some information gathering (for example using read_file or search_files) to get more context about the task.\n\n2. You should also ask the user clarifying questions to get a better understanding of the task.\n\n3. Once you've gained more context about the user's request, you should create a detailed plan for how to accomplish the task. Include Mermaid diagrams if they help make your plan clearer.\n\n4. Ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.\n\n5. Once the user confirms the plan, ask them if they'd like you to write it to a markdown file.\n\n6. Use the switch_mode tool to request that the user switch to another mode to implement the solution.",
-      "groups": [
-        "read",
-        ["edit", { "fileRegex": "\\.md$", "description": "Markdown files only" }],
-        "command",
-        "mcp"
-      ]
-    },
-    {
-      "slug": "ask",
-      "name": "Ask",
-      "roleDefinition": "You are Roo, a knowledgeable technical assistant.\nWhen activated by another mode via a delegated task, your focus is to research, analyze, and provide clear, concise answers or explanations based *only* on the specific information requested in the delegation message. Use available tools for information gathering and report your findings back using `attempt_completion`.",
-      "customInstructions": "You can analyze code, explain concepts, and access external resources. Make sure to answer the user's questions and don't rush to switch to implementing code. Include Mermaid diagrams if they help make your response clearer.",
-      "groups": [
-        "read",
-        "browser",
-        "mcp"
-      ]
-    },
-    {
-      "slug": "debug",
-      "name": "Debug",
-      "roleDefinition": "You are Roo, an expert software debugger specializing in systematic problem diagnosis and resolution. When activated by another mode, your task is to meticulously analyze the provided debugging request (potentially referencing Taskmaster tasks, logs, or metrics), use diagnostic tools as instructed to investigate the issue, identify the root cause, and report your findings and recommended next steps back via `attempt_completion`. You focus solely on diagnostics within the scope defined by the delegated task.",
-      "customInstructions": "Reflect on 5-7 different possible sources of the problem, distill those down to 1-2 most likely sources, and then add logs to validate your assumptions. Explicitly ask the user to confirm the diagnosis before fixing the problem.",
-      "groups": [
-        "read",
-        "edit",
-        "command",
-        "mcp"
-      ]
-    },
-    {
-      "slug": "test",
-      "name": "Test",
-      "roleDefinition": "You are Roo, an expert software tester. Your primary focus is executing testing tasks delegated to you by other modes.\nAnalyze the provided scope and context (often referencing a Taskmaster task ID and its `testStrategy`), develop test plans if needed, execute tests diligently, and report comprehensive results (pass/fail, bugs, coverage) back using `attempt_completion`. You operate strictly within the delegated task's boundaries.",
-      "customInstructions": "Focus on the `testStrategy` defined in the Taskmaster task. Develop and execute test plans accordingly. Report results clearly, including pass/fail status, bug details, and coverage information.",
-      "groups": [
-        "read",
-        "command",
-        "mcp"
-      ]
-    }
-  ]
-}

assets/scripts_README.md

@@ -16,22 +16,27 @@ In an AI-driven development process—particularly with tools like [Cursor](http
 8. **Clear subtasks**—remove subtasks from specified tasks to allow regeneration or restructuring.
 9. **Show task details**—display detailed information about a specific task and its subtasks.
 
-## Configuration (Updated)
+## Configuration
 
-Task Master configuration is now managed through two primary methods:
+The script can be configured through environment variables in a `.env` file at the root of the project:
 
-1.  **`.taskmasterconfig` File (Project Root - Primary)**
+### Required Configuration
 
-    - Stores AI model selections (`main`, `research`, `fallback`), model parameters (`maxTokens`, `temperature`), `logLevel`, `defaultSubtasks`, `defaultPriority`, `projectName`, etc.
-    - Managed using the `task-master models --setup` command or the `models` MCP tool.
-    - This is the main configuration file for most settings.
+- `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude
 
-2.  **Environment Variables (`.env` File - API Keys Only)**
-    - Used **only** for sensitive **API Keys** (e.g., `ANTHROPIC_API_KEY`, `PERPLEXITY_API_KEY`).
-    - Create a `.env` file in your project root for CLI usage.
-    - See `assets/env.example` for required key names.
+### Optional Configuration
 
-**Important:** Settings like `MODEL`, `MAX_TOKENS`, `TEMPERATURE`, `TASKMASTER_LOG_LEVEL`, etc., are **no longer set via `.env`**. Use `task-master models --setup` instead.
+- `MODEL`: Specify which Claude model to use (default: "claude-3-7-sonnet-20250219")
+- `MAX_TOKENS`: Maximum tokens for model responses (default: 4000)
+- `TEMPERATURE`: Temperature for model responses (default: 0.7)
+- `PERPLEXITY_API_KEY`: Your Perplexity API key for research-backed subtask generation
+- `PERPLEXITY_MODEL`: Specify which Perplexity model to use (default: "sonar-medium-online")
+- `DEBUG`: Enable debug logging (default: false)
+- `LOG_LEVEL`: Log level - debug, info, warn, error (default: info)
+- `DEFAULT_SUBTASKS`: Default number of subtasks when expanding (default: 3)
+- `DEFAULT_PRIORITY`: Default priority for generated tasks (default: medium)
+- `PROJECT_NAME`: Override default project name in tasks.json
+- `PROJECT_VERSION`: Override default version in tasks.json
 
 ## How It Works
 
@@ -189,18 +194,25 @@ Notes:
 - Can be combined with the `expand` command to immediately generate new subtasks
 - Works with both parent tasks and individual subtasks
 
-## AI Integration (Updated)
+## AI Integration
 
-- The script now uses a unified AI service layer (`ai-services-unified.js`).
-- Model selection (e.g., Claude vs. Perplexity for `--research`) is determined by the configuration in `.taskmasterconfig` based on the requested `role` (`main` or `research`).
-- API keys are automatically resolved from your `.env` file (for CLI) or MCP session environment.
-- To use the research capabilities (e.g., `expand --research`), ensure you have:
-  1.  Configured a model for the `research` role using `task-master models --setup` (Perplexity models are recommended).
-  2.  Added the corresponding API key (e.g., `PERPLEXITY_API_KEY`) to your `.env` file.
+The script integrates with two AI services:
+
+1. **Anthropic Claude**: Used for parsing PRDs, generating tasks, and creating subtasks.
+2. **Perplexity AI**: Used for research-backed subtask generation when the `--research` flag is specified.
+
+The Perplexity integration uses the OpenAI client to connect to Perplexity's API, which provides enhanced research capabilities for generating more informed subtasks. If the Perplexity API is unavailable or encounters an error, the script will automatically fall back to using Anthropic's Claude.
+
+To use the Perplexity integration:
+
+1. Obtain a Perplexity API key
+2. Add `PERPLEXITY_API_KEY` to your `.env` file
+3. Optionally specify `PERPLEXITY_MODEL` in your `.env` file (default: "sonar-medium-online")
+4. Use the `--research` flag with the `expand` command
 
 ## Logging
 
-The script supports different logging levels controlled by the `TASKMASTER_LOG_LEVEL` environment variable:
+The script supports different logging levels controlled by the `LOG_LEVEL` environment variable:
 
 - `debug`: Detailed information, typically useful for troubleshooting
 - `info`: Confirmation that things are working as expected (default)

bin/task-master-init.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Task Master Init
+ * Direct executable for the init command
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Get the path to the init script
+const initScriptPath = resolve(__dirname, '../scripts/init.js');
+
+// Pass through all arguments
+const args = process.argv.slice(2);
+
+// Spawn the init script with all arguments
+const child = spawn('node', [initScriptPath, ...args], {
+	stdio: 'inherit',
+	cwd: process.cwd()
+});
+
+// Handle exit
+child.on('close', (code) => {
+	process.exit(code);
+});

bin/task-master.js

@@ -225,47 +225,47 @@ function createDevScriptAction(commandName) {
 	};
 }
 
-// // Special case for the 'init' command which uses a different script
-// function registerInitCommand(program) {
-// 	program
-// 		.command('init')
-// 		.description('Initialize a new project')
-// 		.option('-y, --yes', 'Skip prompts and use default values')
-// 		.option('-n, --name <name>', 'Project name')
-// 		.option('-d, --description <description>', 'Project description')
-// 		.option('-v, --version <version>', 'Project version')
-// 		.option('-a, --author <author>', 'Author name')
-// 		.option('--skip-install', 'Skip installing dependencies')
-// 		.option('--dry-run', 'Show what would be done without making changes')
-// 		.action((options) => {
-// 			// Pass through any options to the init script
-// 			const args = [
-// 				'--yes',
-// 				'name',
-// 				'description',
-// 				'version',
-// 				'author',
-// 				'skip-install',
-// 				'dry-run'
-// 			]
-// 				.filter((opt) => options[opt])
-// 				.map((opt) => {
-// 					if (opt === 'yes' || opt === 'skip-install' || opt === 'dry-run') {
-// 						return `--${opt}`;
-// 					}
-// 					return `--${opt}=${options[opt]}`;
-// 				});
+// Special case for the 'init' command which uses a different script
+function registerInitCommand(program) {
+	program
+		.command('init')
+		.description('Initialize a new project')
+		.option('-y, --yes', 'Skip prompts and use default values')
+		.option('-n, --name <name>', 'Project name')
+		.option('-d, --description <description>', 'Project description')
+		.option('-v, --version <version>', 'Project version')
+		.option('-a, --author <author>', 'Author name')
+		.option('--skip-install', 'Skip installing dependencies')
+		.option('--dry-run', 'Show what would be done without making changes')
+		.action((options) => {
+			// Pass through any options to the init script
+			const args = [
+				'--yes',
+				'name',
+				'description',
+				'version',
+				'author',
+				'skip-install',
+				'dry-run'
+			]
+				.filter((opt) => options[opt])
+				.map((opt) => {
+					if (opt === 'yes' || opt === 'skip-install' || opt === 'dry-run') {
+						return `--${opt}`;
+					}
+					return `--${opt}=${options[opt]}`;
+				});
 
-// 			const child = spawn('node', [initScriptPath, ...args], {
-// 				stdio: 'inherit',
-// 				cwd: process.cwd()
-// 			});
+			const child = spawn('node', [initScriptPath, ...args], {
+				stdio: 'inherit',
+				cwd: process.cwd()
+			});
 
-// 			child.on('close', (code) => {
-// 				process.exit(code);
-// 			});
-// 		});
-// }
+			child.on('close', (code) => {
+				process.exit(code);
+			});
+		});
+}
 
 // Set up the command-line interface
 const program = new Command();
@@ -286,8 +286,8 @@ program.on('--help', () => {
 	displayHelp();
 });
 
-// // Add special case commands
-// registerInitCommand(program);
+// Add special case commands
+registerInitCommand(program);
 
 program
 	.command('dev')
@@ -303,7 +303,7 @@ registerCommands(tempProgram);
 
 // For each command in the temp instance, add a modified version to our actual program
 tempProgram.commands.forEach((cmd) => {
-	if (['dev'].includes(cmd.name())) {
+	if (['init', 'dev'].includes(cmd.name())) {
 		// Skip commands we've already defined specially
 		return;
 	}

context/chats/max-min-tokens.txt.md

@@ -1,368 +0,0 @@
-We want to refine how Task Master handles AI model token limits to be more precise, by:
-
-1.  Distinguishing between `maxInputTokens` and `maxOutputTokens` in the configuration.
-2.  Dynamically adjusting the `maxOutputTokens` for an API call based on the actual prompt length to stay within the model's total context window (or respecting separate input/output limits if the API and model support that).
-3.  Ensuring that `ai-services-unified.js` uses these more granular limits.
-
-This is a good improvement for both cost control and preventing errors.
-
-Here's a plan:
-
-**Phase 1: Configuration and Core Logic Updates**
-
-1.  **Update `.taskmasterconfig` Structure:**
-    - I'll modify the `models` section in your `.taskmasterconfig`. For each role (`main`, `research`, `fallback`), `maxTokens` will be replaced with `maxInputTokens` and `maxOutputTokens`.
-      - We'll need to decide on reasonable default values for these new fields. We can look at the current `maxTokens` and the model's known limits to make an initial guess.
-2.  **Update `MODEL_MAP` in `ai-services-unified.js`:**
-    - This array already stores cost data. We need to ensure it also stores the _absolute_ maximum input and output tokens for each model listed (e.g., `model_max_input_tokens`, `model_max_output_tokens`). If these fields are not present, they will need to be added. The values in `.taskmasterconfig` will then represent user-defined operational limits, which should ideally be validated against these absolute maximums.
-3.  **Update `config-manager.js`:**
-    - Getter functions like `getParametersForRole` will be updated to fetch `maxInputTokens` and `maxOutputTokens` instead of the singular `maxTokens`.
-    - New getters might be needed if we want to access the model's absolute limits directly from `MODEL_MAP` via `config-manager.js`.
-4.  **Update `ai-services-unified.js` (`_unifiedServiceRunner`):**
-    - **Token Counting:** This is a crucial step. Before an API call, we need to estimate the token count of the combined `systemPrompt` and `userPrompt`.
-      - The Vercel AI SDK or the individual provider SDKs might offer utilities for this. For example, some SDKs expose a `tokenizer` or a way to count tokens for a given string.
-      - If a direct utility isn't available through the Vercel SDK for the specific provider, we might need to use a library like `tiktoken` for OpenAI/Anthropic models or investigate provider-specific tokenization. This could be complex as tokenization varies between models.
-      - For now, let's assume we can get a reasonable estimate.
-    - **Dynamic Output Token Calculation & Validation:**
-      - Retrieve `configured_max_input_tokens` and `configured_max_output_tokens` from `config-manager.js` for the current role.
-      - Retrieve `model_absolute_max_input_tokens` and `model_absolute_max_output_tokens` from `MODEL_MAP`.
-      - Let `prompt_tokens = countTokens(systemPrompt + userPrompt)`.
-      - **Input Validation:** If `prompt_tokens > configured_max_input_tokens` OR `prompt_tokens > model_absolute_max_input_tokens`, throw an error. (We might also consider auto-truncation strategies in the future, but an error is safer to start).
-      - **Output Calculation:** The `max_tokens` parameter sent to the API (which typically refers to the _max number of tokens to generate_) should be `configured_max_output_tokens`. We also need to ensure this doesn't violate the model's absolute output limit.
-      - Some models have a _total_ context window (input + output). If this is the case for a model, the `max_tokens` parameter for the API call might need to be `min(configured_max_output_tokens, model_absolute_total_tokens - prompt_tokens)`. However, many modern APIs handle separate input and output limits, simplifying this. We'll aim to pass `configured_max_output_tokens` as the API's `max_tokens` parameter, assuming the input validation has passed.
-    - **API Call Parameter:** Update the `callParams` to use the correctly determined `max_tokens` for generation (which will be our `configured_max_output_tokens`).
-
-**Phase 2: Error Handling and Refinements**
-
-1.  **Enhanced Error Handling:** Provide clear error messages if prompt tokens exceed input limits, or if API calls fail due to token issues despite our calculations.
-2.  **Validation:** Add validation (perhaps in `config-manager.js` or when `task-master models --setup` is run) to ensure `configured_max_input_tokens` and `configured_max_output_tokens` in `.taskmasterconfig` do not exceed the `model_absolute_max_input_tokens` and `model_absolute_max_output_tokens` from `MODEL_MAP`.
-
-Let's start by inspecting `scripts/modules/config-manager.js` to see how parameters and `MODEL_MAP` are currently handled. This will inform the changes needed for `.taskmasterconfig` and `ai-services-unified.js`.
-
-I will now read `scripts/modules/config-manager.js`.
-
-Okay, I've reviewed `scripts/modules/config-manager.js`. Here's what I've gathered and how it impacts the plan:
-
-- **`MODEL_MAP` Source:** `MODEL_MAP` is loaded from `supported-models.json`. This is excellent, as it means we can update the model capabilities (including new token limits) in a structured JSON file.
-- **Configuration Loading:** `_loadAndValidateConfig` handles loading `.taskmasterconfig` and merging it with `DEFAULTS`.
-- **Getters:** There are specific getters for `maxTokens` for each role (e.g., `getMainMaxTokens`). We will need to update these.
-- **`getParametersForRole`:** This function already exists and is a good candidate for returning the new `maxInputTokens` and `maxOutputTokens`.
-
-Here's the refined plan:
-
-**Phase 1: Configuration and Data Structures**
-
-1.  **Update `supported-models.json`:**
-
-    - For each model entry in `supported-models.json`, we need to add `maxInputTokens` and `maxOutputTokens` fields. These should reflect the _absolute maximums_ for that specific model.
-    - Example entry change:
-
-      ```json
-      // Before
-      {
-          "id": "claude-3-7-sonnet-20250219",
-          "name": "Claude 3.7 Sonnet (Preview)",
-          "context_window": 200000, // This might be total context
-          "cost_per_1m_tokens": { "input": 3, "output": 15, "currency": "USD" }
-      }
-
-      // After (assuming 200k is total, and we make a reasonable split or find official numbers)
-      {
-          "id": "claude-3-7-sonnet-20250219",
-          "name": "Claude 3.7 Sonnet (Preview)",
-          "maxInputTokens": 190000, // Example
-          "maxOutputTokens": 8192,  // Example, often smaller for generation
-          "cost_per_1m_tokens": { "input": 3, "output": 15, "currency": "USD" }
-      }
-      ```
-
-    - I will need to find the official input/output token limits for the models currently in your `MODEL_MAP`. If you have this information handy, it would speed things up. Otherwise, I can make educated guesses or search for them.
-
-2.  **Update `.taskmasterconfig` (Defaults and User File):**
-    - In `scripts/modules/config-manager.js`, modify the `DEFAULTS` object. For each role (`main`, `research`, `fallback`), replace `maxTokens` with:
-      - `maxInputTokens`: A sensible default (e.g., a large portion of the model's capability, but user-configurable).
-      - `maxOutputTokens`: A sensible default for generation (e.g., 4096 or 8192).
-    - You will then need to manually update your existing `.taskmasterconfig` file to reflect this new structure. I can provide the snippet for you to paste.
-3.  **Update `config-manager.js`:**
-    - Modify `getParametersForRole(role, explicitRoot = null)`:
-      - It currently fetches `maxTokens` and `temperature`.
-      - Update it to fetch `maxInputTokens`, `maxOutputTokens`, and `temperature` from the loaded config for the given role.
-    - Remove the role-specific `getMaxTokens` functions (e.g., `getMainMaxTokens`, `getResearchMaxTokens`, `getFallbackMaxTokens`). The `getParametersForRole` will be the central way to get these.
-    - (Optional, for later validation) Consider adding a new function `getModelCapabilities(providerName, modelId)` that reads from `MODEL_MAP` to return the absolute `maxInputTokens` and `maxOutputTokens` for a given model. This would be useful for validating the user's settings in `.taskmasterconfig`.
-
-**Phase 2: Core Logic in `ai-services-unified.js`**
-
-1.  **Token Counting (`_unifiedServiceRunner`):**
-
-    - This is the most complex part. We need a reliable way to count tokens for the prompts.
-      - **Strategy 1 (Ideal):** Leverage Vercel AI SDK. The SDK might provide a way to get a tokenizer for the active model or a utility function. We'll need to investigate its capabilities.
-      - **Strategy 2 (Fallback):** Use a library like `tiktoken` for models compatible with OpenAI's tokenization (many are, including some Anthropic models). For other models, we might need provider-specific tokenizers or make estimations (less ideal).
-      - **Initial Approach:** Let's try to find a Vercel AI SDK utility first. If not, we'll start with `tiktoken` as a common case and acknowledge that other models might need specific handling later.
-    - The function `_unifiedServiceRunner` will call this token counting utility:
-
-      ```javascript
-      // Placeholder for token counting
-      function countTokens(text, modelId /* or providerName */) {
-      	// ... implementation using SDK or library ...
-      	// This is a simplification; actual tokenization is model-specific.
-      	// For now, a rough estimate might be (text.length / 4) as a placeholder
-      	// if a proper tokenizer isn't immediately available.
-      	if (!text) return 0;
-      	return Math.ceil(text.length / 3.5); // Very rough general estimate
-      }
-
-      const promptTokens = countTokens(systemPrompt) + countTokens(prompt);
-      ```
-
-2.  **Dynamic Output Token Calculation & Validation (`_unifiedServiceRunner`):**
-
-    - Fetch parameters using the updated `getParametersForRole` from `config-manager.js`:
-      ```javascript
-      const roleParams = getParametersForRole(
-      	currentRole,
-      	effectiveProjectRoot
-      );
-      // roleParams will now contain { maxInputTokens, maxOutputTokens, temperature }
-      ```
-    - Fetch model's absolute limits from `MODEL_MAP` (we'll need a helper in `config-manager.js` or do it directly in `ai-services-unified.js` for now):
-      ```javascript
-      // Simplified; ideally use a robust getter from config-manager
-      const modelInfo = MODEL_MAP[providerName?.toLowerCase()]?.find(
-      	(m) => m.id === modelId
-      );
-      const modelAbsoluteMaxInput = modelInfo?.maxInputTokens || Infinity;
-      const modelAbsoluteMaxOutput =
-      	modelInfo?.maxOutputTokens || roleParams.maxOutputTokens; // Fallback to configured if not in map
-      ```
-    - **Input Validation:**
-      ```javascript
-      if (promptTokens > roleParams.maxInputTokens) {
-      	throw new Error(
-      		`Prompt (${promptTokens} tokens) exceeds configured max input tokens (${roleParams.maxInputTokens}) for role '${currentRole}'.`
-      	);
-      }
-      if (promptTokens > modelAbsoluteMaxInput) {
-      	throw new Error(
-      		`Prompt (${promptTokens} tokens) exceeds model's absolute max input tokens (${modelAbsoluteMaxInput}) for ${modelId}.`
-      	);
-      }
-      ```
-    - **API Call Parameter (`max_tokens` for generation):**
-      The `max_tokens` parameter passed to the provider's API call should be `roleParams.maxOutputTokens`. We must also ensure this doesn't exceed the model's absolute output capability.
-
-      ```javascript
-      const apiMaxOutputTokens = Math.min(
-      	roleParams.maxOutputTokens,
-      	modelAbsoluteMaxOutput
-      );
-
-      const callParams = {
-      	apiKey,
-      	modelId,
-      	// Use apiMaxOutputTokens for the actual API call
-      	maxTokens: apiMaxOutputTokens, // This usually means max tokens to GENERATE
-      	temperature: roleParams.temperature,
-      	messages,
-      	baseUrl,
-      	...(serviceType === 'generateObject' && { schema, objectName }),
-      	...restApiParams
-      };
-      ```
-
-3.  **Update `logAiUsage`:**
-    - The cost calculation in `logAiUsage` seems correct as it already uses `inputCost` and `outputCost` per 1M tokens. This part should remain compatible.
-
-**Next Steps:**
-
-1.  **Modify `supported-models.json`:** I need the content of this file to propose the new `maxInputTokens` and `maxOutputTokens` fields. Please provide it.
-2.  **Decide on Tokenizer Strategy:** What are your thoughts on the token counting? Are you aware of any utilities within Vercel AI SDK for this, or should we plan to integrate `tiktoken` initially?
-
-Once I have the content of `supported-models.json`, I can draft the changes for it and then proceed to `config-manager.js` and `.taskmasterconfig`.
-
-```json
-        // Before
-        {
-            "id": "claude-3-7-sonnet-20250219",
-            "name": "Claude 3.7 Sonnet (Preview)",
-            "context_window": 200000, // This might be total context
-            "cost_per_1m_tokens": { "input": 3, "output": 15, "currency": "USD" }
-        }
-
-        // After (assuming 200k is total, and we make a reasonable split or find official numbers)
-        {
-            "id": "claude-3-7-sonnet-20250219",
-            "name": "Claude 3.7 Sonnet (Preview)",
-            "maxInputTokens": 190000, // Example
-            "maxOutputTokens": 8192,  // Example, often smaller for generation
-            "cost_per_1m_tokens": { "input": 3, "output": 15, "currency": "USD" }
-        }
-```
-
-```javascript
-// Placeholder for token counting
-function countTokens(text, modelId /* or providerName */) {
-	// ... implementation using SDK or library ...
-	// This is a simplification; actual tokenization is model-specific.
-	// For now, a rough estimate might be (text.length / 4) as a placeholder
-	// if a proper tokenizer isn't immediately available.
-	if (!text) return 0;
-	return Math.ceil(text.length / 3.5); // Very rough general estimate
-}
-
-const promptTokens = countTokens(systemPrompt) + countTokens(prompt);
-```
-
-```javascript
-const roleParams = getParametersForRole(currentRole, effectiveProjectRoot);
-// roleParams will now contain { maxInputTokens, maxOutputTokens, temperature }
-```
-
-```javascript
-// Simplified; ideally use a robust getter from config-manager
-const modelInfo = MODEL_MAP[providerName?.toLowerCase()]?.find(
-	(m) => m.id === modelId
-);
-const modelAbsoluteMaxInput = modelInfo?.maxInputTokens || Infinity;
-const modelAbsoluteMaxOutput =
-	modelInfo?.maxOutputTokens || roleParams.maxOutputTokens; // Fallback to configured if not in map
-```
-
-```javascript
-if (promptTokens > roleParams.maxInputTokens) {
-	throw new Error(
-		`Prompt (${promptTokens} tokens) exceeds configured max input tokens (${roleParams.maxInputTokens}) for role '${currentRole}'.`
-	);
-}
-if (promptTokens > modelAbsoluteMaxInput) {
-	throw new Error(
-		`Prompt (${promptTokens} tokens) exceeds model's absolute max input tokens (${modelAbsoluteMaxInput}) for ${modelId}.`
-	);
-}
-```
-
-```javascript
-const apiMaxOutputTokens = Math.min(
-	roleParams.maxOutputTokens,
-	modelAbsoluteMaxOutput
-);
-
-const callParams = {
-	apiKey,
-	modelId,
-	// Use apiMaxOutputTokens for the actual API call
-	maxTokens: apiMaxOutputTokens, // This usually means max tokens to GENERATE
-	temperature: roleParams.temperature,
-	messages,
-	baseUrl,
-	...(serviceType === 'generateObject' && { schema, objectName }),
-	...restApiParams
-};
-```
-
-Okay, I have the contents of `supported-models.json`.
-
-It seems many models have a `max_tokens` field, which I assume is the _total context window_. Some don't have it, and for others (like OpenAI `gpt-4o`), the listed `max_tokens` (16384) is known to be its _output_ token limit when using the Chat Completions API, while the context window is much larger (128k). This highlights the complexity: `max_tokens` in `supported-models.json` is used inconsistently.
-
-**Revised Plan for `supported-models.json` and Token Definitions:**
-
-To bring clarity, we'll introduce two new fields and ensure their meaning is consistent:
-
-- `contextWindowTokens`: The total number of tokens the model can process (input + output). This would replace the current ambiguous `max_tokens`.
-- `maxOutputTokens`: The maximum number of tokens the model can _generate_ in a single response. This is often smaller than the total context window, especially for larger models.
-
-If a model _only_ specifies a total context window, we'll have to make a reasonable assumption for `maxOutputTokens` (e.g., 4096 or 8192, or a fraction of the total context window). If it only specifies an output token limit (like some OpenAI models in certain API modes), we'll need to find its total context window.
-
-**Updated `supported-models.json` Structure (Example):**
-
-```json
-// For a model like Anthropic Claude 3.7 Sonnet (Preview)
-{
-    "id": "claude-3-7-sonnet-20250219",
-    "swe_score": 0.623,
-    "cost_per_1m_tokens": { "input": 3.0, "output": 15.0 },
-    "allowed_roles": ["main", "fallback"],
-    "contextWindowTokens": 200000, // From Anthropic's documentation
-    "maxOutputTokens": 8192     // Anthropic default, user can override in .taskmasterconfig
-}
-
-// For a model like OpenAI GPT-4o
-{
-    "id": "gpt-4o",
-    "swe_score": 0.332,
-    "cost_per_1m_tokens": { "input": 2.5, "output": 10.0 },
-    "allowed_roles": ["main", "fallback"],
-    "contextWindowTokens": 128000, // Official context window
-    "maxOutputTokens": 16384    // Max output for chat completions is 16k for gpt-4o (used to be 4k/8k for older gpt-4)
-                                // but the model card mentions 128k total. The API call parameter for `max_tokens` sets this output cap.
-}
-```
-
-I will proceed to generate the updated `supported-models.json` content. This will be a significant change. I will make my best effort to find the correct `contextWindowTokens` and `maxOutputTokens` for each model. If official numbers are ambiguous or not readily available, I'll use sensible defaults and add a comment.
-
-**Regarding Tokenizer Strategy:**
-
-- **Vercel AI SDK:** The `ai` package (Vercel AI SDK) itself is a lightweight wrapper. Tokenization is usually handled by the underlying provider-specific SDKs (e.g., `@anthropic-ai/sdk`, `openai`). The Vercel SDK doesn't provide a universal tokenizer.
-- **Provider SDKs:**
-  - `@anthropic-ai/sdk`: Does not expose a public tokenizer directly. Anthropic recommends counting based on their guidelines (roughly 3.5 chars/token for English).
-  - `openai` (for Node.js): The `gpt-3-encoder` or `tiktoken` libraries are commonly used. `tiktoken` is more current.
-- **`tiktoken`:** This is a good general-purpose library for OpenAI models and those that use compatible tokenization (many models fine-tuned from Llama, etc., might be close). It supports various encodings.
-- **Recommendation:**
-  1.  Start by integrating `tiktoken`. We can select the encoding based on the provider or even specific model if needed (e.g., `cl100k_base` for gpt-4, gpt-3.5-turbo, DALL-E models).
-  2.  For providers where `tiktoken` is not accurate (e.g., Google's Gemini, Perplexity if they have proprietary tokenizers), we might have to rely on character-based estimations (e.g., `length / N`) as a rougher guide or investigate if their specific SDKs offer token counting.
-  3.  The Vercel AI SDK's `experimental_streamObject` and other functions _might_ internally handle some aspects of token counting for request preparation, but we need explicit counting for our logic _before_ the call.
-
-For now, let's assume we'll add a `countTokens` utility that uses `tiktoken` for OpenAI and Anthropic (as Anthropic's guidance is character-based but `cl100k_base` is often a decent proxy for their tokenization for rough estimates, though not perfect), and a character-based fallback for others.
-
-I will now generate the proposed changes for `scripts/modules/supported-models.json`. This will be a large diff.
-
-After this, we'll move to:
-
-1.  Updating `.taskmasterconfig` defaults in `config-manager.js` and providing you the snippet for your user file.
-2.  Updating `config-manager.js` getters.
-3.  Implementing the logic in `ai-services-unified.js`.
-
-```json
-// For a model like Anthropic Claude 3.7 Sonnet (Preview)
-{
-    "id": "claude-3-7-sonnet-20250219",
-    "swe_score": 0.623,
-    "cost_per_1m_tokens": { "input": 3.0, "output": 15.0 },
-    "allowed_roles": ["main", "fallback"],
-    "contextWindowTokens": 200000, // From Anthropic's documentation
-    "maxOutputTokens": 8192     // Anthropic default, user can override in .taskmasterconfig
-}
-
-// For a model like OpenAI GPT-4o
-{
-    "id": "gpt-4o",
-    "swe_score": 0.332,
-    "cost_per_1m_tokens": { "input": 2.5, "output": 10.0 },
-    "allowed_roles": ["main", "fallback"],
-    "contextWindowTokens": 128000, // Official context window
-    "maxOutputTokens": 16384    // Max output for chat completions is 16k for gpt-4o (used to be 4k/8k for older gpt-4)
-                                // but the model card mentions 128k total. The API call parameter for `max_tokens` sets this output cap.
-}
-```
-
-```json
-// For a model like Anthropic Claude 3.7 Sonnet (Preview)
-{
-    "id": "claude-3-7-sonnet-20250219",
-    "swe_score": 0.623,
-    "cost_per_1m_tokens": { "input": 3.0, "output": 15.0 },
-    "allowed_roles": ["main", "fallback"],
-    "contextWindowTokens": 200000, // From Anthropic's documentation
-    "maxOutputTokens": 8192     // Anthropic default, user can override in .taskmasterconfig
-}
-
-// For a model like OpenAI GPT-4o
-{
-    "id": "gpt-4o",
-    "swe_score": 0.332,
-    "cost_per_1m_tokens": { "input": 2.5, "output": 10.0 },
-    "allowed_roles": ["main", "fallback"],
-    "contextWindowTokens": 128000, // Official context window
-    "maxOutputTokens": 16384    // Max output for chat completions is 16k for gpt-4o (used to be 4k/8k for older gpt-4)
-                                // but the model card mentions 128k total. The API call parameter for `max_tokens` sets this output cap.
-}
-```

docs/ai-client-utils-example.md

@@ -0,0 +1,257 @@
+# AI Client Utilities for MCP Tools
+
+This document provides examples of how to use the new AI client utilities with AsyncOperationManager in MCP tools.
+
+## Basic Usage with Direct Functions
+
+```javascript
+// In your direct function implementation:
+import {
+	getAnthropicClientForMCP,
+	getModelConfig,
+	handleClaudeError
+} from '../utils/ai-client-utils.js';
+
+export async function someAiOperationDirect(args, log, context) {
+	try {
+		// Initialize Anthropic client with session from context
+		const client = getAnthropicClientForMCP(context.session, log);
+
+		// Get model configuration with defaults or session overrides
+		const modelConfig = getModelConfig(context.session);
+
+		// Make API call with proper error handling
+		try {
+			const response = await client.messages.create({
+				model: modelConfig.model,
+				max_tokens: modelConfig.maxTokens,
+				temperature: modelConfig.temperature,
+				messages: [{ role: 'user', content: 'Your prompt here' }]
+			});
+
+			return {
+				success: true,
+				data: response
+			};
+		} catch (apiError) {
+			// Use helper to get user-friendly error message
+			const friendlyMessage = handleClaudeError(apiError);
+
+			return {
+				success: false,
+				error: {
+					code: 'AI_API_ERROR',
+					message: friendlyMessage
+				}
+			};
+		}
+	} catch (error) {
+		// Handle client initialization errors
+		return {
+			success: false,
+			error: {
+				code: 'AI_CLIENT_ERROR',
+				message: error.message
+			}
+		};
+	}
+}
+```
+
+## Integration with AsyncOperationManager
+
+```javascript
+// In your MCP tool implementation:
+import {
+	AsyncOperationManager,
+	StatusCodes
+} from '../../utils/async-operation-manager.js';
+import { someAiOperationDirect } from '../../core/direct-functions/some-ai-operation.js';
+
+export async function someAiOperation(args, context) {
+	const { session, mcpLog } = context;
+	const log = mcpLog || console;
+
+	try {
+		// Create operation description
+		const operationDescription = `AI operation: ${args.someParam}`;
+
+		// Start async operation
+		const operation = AsyncOperationManager.createOperation(
+			operationDescription,
+			async (reportProgress) => {
+				try {
+					// Initial progress report
+					reportProgress({
+						progress: 0,
+						status: 'Starting AI operation...'
+					});
+
+					// Call direct function with session and progress reporting
+					const result = await someAiOperationDirect(args, log, {
+						reportProgress,
+						mcpLog: log,
+						session
+					});
+
+					// Final progress update
+					reportProgress({
+						progress: 100,
+						status: result.success ? 'Operation completed' : 'Operation failed',
+						result: result.data,
+						error: result.error
+					});
+
+					return result;
+				} catch (error) {
+					// Handle errors in the operation
+					reportProgress({
+						progress: 100,
+						status: 'Operation failed',
+						error: {
+							message: error.message,
+							code: error.code || 'OPERATION_FAILED'
+						}
+					});
+					throw error;
+				}
+			}
+		);
+
+		// Return immediate response with operation ID
+		return {
+			status: StatusCodes.ACCEPTED,
+			body: {
+				success: true,
+				message: 'Operation started',
+				operationId: operation.id
+			}
+		};
+	} catch (error) {
+		// Handle errors in the MCP tool
+		log.error(`Error in someAiOperation: ${error.message}`);
+		return {
+			status: StatusCodes.INTERNAL_SERVER_ERROR,
+			body: {
+				success: false,
+				error: {
+					code: 'OPERATION_FAILED',
+					message: error.message
+				}
+			}
+		};
+	}
+}
+```
+
+## Using Research Capabilities with Perplexity
+
+```javascript
+// In your direct function:
+import {
+	getPerplexityClientForMCP,
+	getBestAvailableAIModel
+} from '../utils/ai-client-utils.js';
+
+export async function researchOperationDirect(args, log, context) {
+	try {
+		// Get the best AI model for this operation based on needs
+		const { type, client } = await getBestAvailableAIModel(
+			context.session,
+			{ requiresResearch: true },
+			log
+		);
+
+		// Report which model we're using
+		if (context.reportProgress) {
+			await context.reportProgress({
+				progress: 10,
+				status: `Using ${type} model for research...`
+			});
+		}
+
+		// Make API call based on the model type
+		if (type === 'perplexity') {
+			// Call Perplexity
+			const response = await client.chat.completions.create({
+				model: context.session?.env?.PERPLEXITY_MODEL || 'sonar-medium-online',
+				messages: [{ role: 'user', content: args.researchQuery }],
+				temperature: 0.1
+			});
+
+			return {
+				success: true,
+				data: response.choices[0].message.content
+			};
+		} else {
+			// Call Claude as fallback
+			// (Implementation depends on specific needs)
+			// ...
+		}
+	} catch (error) {
+		// Handle errors
+		return {
+			success: false,
+			error: {
+				code: 'RESEARCH_ERROR',
+				message: error.message
+			}
+		};
+	}
+}
+```
+
+## Model Configuration Override Example
+
+```javascript
+// In your direct function:
+import { getModelConfig } from '../utils/ai-client-utils.js';
+
+// Using custom defaults for a specific operation
+const operationDefaults = {
+	model: 'claude-3-haiku-20240307', // Faster, smaller model
+	maxTokens: 1000, // Lower token limit
+	temperature: 0.2 // Lower temperature for more deterministic output
+};
+
+// Get model config with operation-specific defaults
+const modelConfig = getModelConfig(context.session, operationDefaults);
+
+// Now use modelConfig in your API calls
+const response = await client.messages.create({
+	model: modelConfig.model,
+	max_tokens: modelConfig.maxTokens,
+	temperature: modelConfig.temperature
+	// Other parameters...
+});
+```
+
+## Best Practices
+
+1. **Error Handling**:
+
+   - Always use try/catch blocks around both client initialization and API calls
+   - Use `handleClaudeError` to provide user-friendly error messages
+   - Return standardized error objects with code and message
+
+2. **Progress Reporting**:
+
+   - Report progress at key points (starting, processing, completing)
+   - Include meaningful status messages
+   - Include error details in progress reports when failures occur
+
+3. **Session Handling**:
+
+   - Always pass the session from the context to the AI client getters
+   - Use `getModelConfig` to respect user settings from session
+
+4. **Model Selection**:
+
+   - Use `getBestAvailableAIModel` when you need to select between different models
+   - Set `requiresResearch: true` when you need Perplexity capabilities
+
+5. **AsyncOperationManager Integration**:
+   - Create descriptive operation names
+   - Handle all errors within the operation function
+   - Return standardized results from direct functions
+   - Return immediate responses with operation IDs

docs/command-reference.md

@@ -52,9 +52,6 @@ task-master show 1.2
 ```bash
 # Update tasks from a specific ID and provide context
 task-master update --from=<id> --prompt="<prompt>"
-
-# Update tasks using research role
-task-master update --from=<id> --prompt="<prompt>" --research
 ```
 
 ## Update a Specific Task
@@ -63,7 +60,7 @@ task-master update --from=<id> --prompt="<prompt>" --research
 # Update a single task by ID with new information
 task-master update-task --id=<id> --prompt="<prompt>"
 
-# Use research-backed updates
+# Use research-backed updates with Perplexity AI
 task-master update-task --id=<id> --prompt="<prompt>" --research
 ```
 
@@ -76,7 +73,7 @@ task-master update-subtask --id=<parentId.subtaskId> --prompt="<prompt>"
 # Example: Add details about API rate limiting to subtask 2 of task 5
 task-master update-subtask --id=5.2 --prompt="Add rate limiting of 100 requests per minute"
 
-# Use research-backed updates
+# Use research-backed updates with Perplexity AI
 task-master update-subtask --id=<parentId.subtaskId> --prompt="<prompt>" --research
 ```
 
@@ -187,41 +184,12 @@ task-master validate-dependencies
 task-master fix-dependencies
 ```
 
-## Move Tasks
-
-```bash
-# Move a task or subtask to a new position
-task-master move --from=<id> --to=<id>
-
-# Examples:
-# Move task to become a subtask
-task-master move --from=5 --to=7
-
-# Move subtask to become a standalone task
-task-master move --from=5.2 --to=7
-
-# Move subtask to a different parent
-task-master move --from=5.2 --to=7.3
-
-# Reorder subtasks within the same parent
-task-master move --from=5.2 --to=5.4
-
-# Move a task to a new ID position (creates placeholder if doesn't exist)
-task-master move --from=5 --to=25
-
-# Move multiple tasks at once (must have the same number of IDs)
-task-master move --from=10,11,12 --to=16,17,18
-```
-
 ## Add a New Task
 
 ```bash
-# Add a new task using AI (main role)
+# Add a new task using AI
 task-master add-task --prompt="Description of the new task"
 
-# Add a new task using AI (research role)
-task-master add-task --prompt="Description of the new task" --research
-
 # Add a task with dependencies
 task-master add-task --prompt="Description" --dependencies=1,2,3
 
@@ -235,30 +203,3 @@ task-master add-task --prompt="Description" --priority=high
 # Initialize a new project with Task Master structure
 task-master init
 ```
-
-## Configure AI Models
-
-```bash
-# View current AI model configuration and API key status
-task-master models
-
-# Set the primary model for generation/updates (provider inferred if known)
-task-master models --set-main=claude-3-opus-20240229
-
-# Set the research model
-task-master models --set-research=sonar-pro
-
-# Set the fallback model
-task-master models --set-fallback=claude-3-haiku-20240307
-
-# Set a custom Ollama model for the main role
-task-master models --set-main=my-local-llama --ollama
-
-# Set a custom OpenRouter model for the research role
-task-master models --set-research=google/gemini-pro --openrouter
-
-# Run interactive setup to configure models, including custom ones
-task-master models --setup
-```
-
-Configuration is stored in `.taskmasterconfig` in your project root. API keys are still managed via `.env` or MCP configuration. Use `task-master models` without flags to see available built-in models. Use `--setup` for a guided experience.

docs/configuration.md

@@ -1,92 +1,53 @@
 # Configuration
 
-Taskmaster uses two primary methods for configuration:
+Task Master can be configured through environment variables in a `.env` file at the root of your project.
 
-1.  **`.taskmasterconfig` File (Project Root - Recommended for most settings)**
+## Required Configuration
 
-    - This JSON file stores most configuration settings, including AI model selections, parameters, logging levels, and project defaults.
-    - **Location:** This file is created in the root directory of your project when you run the `task-master models --setup` interactive setup. You typically do this during the initialization sequence. Do not manually edit this file beyond adjusting Temperature and Max Tokens depending on your model.
-    - **Management:** Use the `task-master models --setup` command (or `models` MCP tool) to interactively create and manage this file. You can also set specific models directly using `task-master models --set-<role>=<model_id>`, adding `--ollama` or `--openrouter` flags for custom models. Manual editing is possible but not recommended unless you understand the structure.
-    - **Example Structure:**
-      ```json
-      {
-      	"models": {
-      		"main": {
-      			"provider": "anthropic",
-      			"modelId": "claude-3-7-sonnet-20250219",
-      			"maxTokens": 64000,
-      			"temperature": 0.2,
-      			"baseUrl": "https://api.anthropic.com/v1"
-      		},
-      		"research": {
-      			"provider": "perplexity",
-      			"modelId": "sonar-pro",
-      			"maxTokens": 8700,
-      			"temperature": 0.1,
-      			"baseUrl": "https://api.perplexity.ai/v1"
-      		},
-      		"fallback": {
-      			"provider": "anthropic",
-      			"modelId": "claude-3-5-sonnet",
-      			"maxTokens": 64000,
-      			"temperature": 0.2
-      		}
-      	},
-      	"global": {
-      		"logLevel": "info",
-      		"debug": false,
-      		"defaultSubtasks": 5,
-      		"defaultPriority": "medium",
-      		"projectName": "Your Project Name",
-      		"ollamaBaseUrl": "http://localhost:11434/api",
-      		"azureOpenaiBaseUrl": "https://your-endpoint.openai.azure.com/"
-      	}
-      }
-      ```
+- `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude (Example: `ANTHROPIC_API_KEY=sk-ant-api03-...`)
 
-2.  **Environment Variables (`.env` file or MCP `env` block - For API Keys Only)**
-    - Used **exclusively** for sensitive API keys and specific endpoint URLs.
-    - **Location:**
-      - For CLI usage: Create a `.env` file in your project root.
-      - For MCP/Cursor usage: Configure keys in the `env` section of your `.cursor/mcp.json` file.
-    - **Required API Keys (Depending on configured providers):**
-      - `ANTHROPIC_API_KEY`: Your Anthropic API key.
-      - `PERPLEXITY_API_KEY`: Your Perplexity API key.
-      - `OPENAI_API_KEY`: Your OpenAI API key.
-      - `GOOGLE_API_KEY`: Your Google API key.
-      - `MISTRAL_API_KEY`: Your Mistral API key.
-      - `AZURE_OPENAI_API_KEY`: Your Azure OpenAI API key (also requires `AZURE_OPENAI_ENDPOINT`).
-      - `OPENROUTER_API_KEY`: Your OpenRouter API key.
-      - `XAI_API_KEY`: Your X-AI API key.
-    - **Optional Endpoint Overrides:**
-      - **Per-role `baseUrl` in `.taskmasterconfig`:** You can add a `baseUrl` property to any model role (`main`, `research`, `fallback`) to override the default API endpoint for that provider. If omitted, the provider's standard endpoint is used.
-      - `AZURE_OPENAI_ENDPOINT`: Required if using Azure OpenAI key (can also be set as `baseUrl` for the Azure model role).
-      - `OLLAMA_BASE_URL`: Override the default Ollama API URL (Default: `http://localhost:11434/api`).
+## Optional Configuration
 
-**Important:** Settings like model ID selections (`main`, `research`, `fallback`), `maxTokens`, `temperature`, `logLevel`, `defaultSubtasks`, `defaultPriority`, and `projectName` are **managed in `.taskmasterconfig`**, not environment variables.
+- `MODEL` (Default: `"claude-3-7-sonnet-20250219"`): Claude model to use (Example: `MODEL=claude-3-opus-20240229`)
+- `MAX_TOKENS` (Default: `"4000"`): Maximum tokens for responses (Example: `MAX_TOKENS=8000`)
+- `TEMPERATURE` (Default: `"0.7"`): Temperature for model responses (Example: `TEMPERATURE=0.5`)
+- `DEBUG` (Default: `"false"`): Enable debug logging (Example: `DEBUG=true`)
+- `LOG_LEVEL` (Default: `"info"`): Console output level (Example: `LOG_LEVEL=debug`)
+- `DEFAULT_SUBTASKS` (Default: `"3"`): Default subtask count (Example: `DEFAULT_SUBTASKS=5`)
+- `DEFAULT_PRIORITY` (Default: `"medium"`): Default priority (Example: `DEFAULT_PRIORITY=high`)
+- `PROJECT_NAME` (Default: `"MCP SaaS MVP"`): Project name in metadata (Example: `PROJECT_NAME=My Awesome Project`)
+- `PROJECT_VERSION` (Default: `"1.0.0"`): Version in metadata (Example: `PROJECT_VERSION=2.1.0`)
+- `PERPLEXITY_API_KEY`: For research-backed features (Example: `PERPLEXITY_API_KEY=pplx-...`)
+- `PERPLEXITY_MODEL` (Default: `"sonar-medium-online"`): Perplexity model (Example: `PERPLEXITY_MODEL=sonar-large-online`)
 
-## Example `.env` File (for API Keys)
+## Example .env File
 
 ```
-# Required API keys for providers configured in .taskmasterconfig
-ANTHROPIC_API_KEY=sk-ant-api03-your-key-here
-PERPLEXITY_API_KEY=pplx-your-key-here
-# OPENAI_API_KEY=sk-your-key-here
-# GOOGLE_API_KEY=AIzaSy...
-# etc.
+# Required
+ANTHROPIC_API_KEY=sk-ant-api03-your-api-key
 
-# Optional Endpoint Overrides
-# AZURE_OPENAI_ENDPOINT=https://your-azure-endpoint.openai.azure.com/
-# OLLAMA_BASE_URL=http://custom-ollama-host:11434/api
+# Optional - Claude Configuration
+MODEL=claude-3-7-sonnet-20250219
+MAX_TOKENS=4000
+TEMPERATURE=0.7
+
+# Optional - Perplexity API for Research
+PERPLEXITY_API_KEY=pplx-your-api-key
+PERPLEXITY_MODEL=sonar-medium-online
+
+# Optional - Project Info
+PROJECT_NAME=My Project
+PROJECT_VERSION=1.0.0
+
+# Optional - Application Configuration
+DEFAULT_SUBTASKS=3
+DEFAULT_PRIORITY=medium
+DEBUG=false
+LOG_LEVEL=info
 ```
 
 ## Troubleshooting
 
-### Configuration Errors
-
-- If Task Master reports errors about missing configuration or cannot find `.taskmasterconfig`, run `task-master models --setup` in your project root to create or repair the file.
-- Ensure API keys are correctly placed in your `.env` file (for CLI) or `.cursor/mcp.json` (for MCP) and are valid for the providers selected in `.taskmasterconfig`.
-
 ### If `task-master init` doesn't respond:
 
 Try running it with Node directly:

docs/contributor-docs/testing-roo-integration.md

@@ -1,94 +0,0 @@
-# Testing Roo Integration
-
-This document provides instructions for testing the Roo integration in the Task Master package.
-
-## Running Tests
-
-To run the tests for the Roo integration:
-
-```bash
-# Run all tests
-npm test
-
-# Run only Roo integration tests
-npm test -- -t "Roo"
-
-# Run specific test file
-npm test -- tests/integration/roo-files-inclusion.test.js
-```
-
-## Manual Testing
-
-To manually verify that the Roo files are properly included in the package:
-
-1. Create a test directory:
-
-   ```bash
-   mkdir test-tm
-   cd test-tm
-   ```
-
-2. Create a package.json file:
-
-   ```bash
-   npm init -y
-   ```
-
-3. Install the task-master-ai package locally:
-
-   ```bash
-   # From the root of the claude-task-master repository
-   cd ..
-   npm pack
-   # This will create a file like task-master-ai-0.12.0.tgz
-
-   # Move back to the test directory
-   cd test-tm
-   npm install ../task-master-ai-0.12.0.tgz
-   ```
-
-4. Initialize a new Task Master project:
-
-   ```bash
-   npx task-master init --yes
-   ```
-
-5. Verify that all Roo files and directories are created:
-
-   ```bash
-   # Check that .roomodes file exists
-   ls -la | grep .roomodes
-
-   # Check that .roo directory exists and contains all mode directories
-   ls -la .roo
-   ls -la .roo/rules
-   ls -la .roo/rules-architect
-   ls -la .roo/rules-ask
-   ls -la .roo/rules-boomerang
-   ls -la .roo/rules-code
-   ls -la .roo/rules-debug
-   ls -la .roo/rules-test
-   ```
-
-## What to Look For
-
-When running the tests or performing manual verification, ensure that:
-
-1. The package includes `.roo/**` and `.roomodes` in the `files` array in package.json
-2. The `prepare-package.js` script verifies the existence of all required Roo files
-3. The `init.js` script creates all necessary .roo directories and copies .roomodes file
-4. All source files for Roo integration exist in `assets/roocode/.roo` and `assets/roocode/.roomodes`
-
-## Compatibility
-
-Ensure that the Roo integration works alongside existing Cursor functionality:
-
-1. Initialize a new project that uses both Cursor and Roo:
-
-   ```bash
-   npx task-master init --yes
-   ```
-
-2. Verify that both `.cursor` and `.roo` directories are created
-3. Verify that both `.windsurfrules` and `.roomodes` files are created
-4. Confirm that existing functionality continues to work as expected

docs/examples.md

@@ -30,7 +30,7 @@ I need to regenerate the subtasks for task 3 with a different approach. Can you
 ## Handling changes
 
 ```
-I've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks to reflect this change?
+We've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks to reflect this change?
 ```
 
 ## Completing work
@@ -40,34 +40,6 @@ I've finished implementing the authentication system described in task 2. All te
 Please mark it as complete and tell me what I should work on next.
 ```
 
-## Reorganizing tasks
-
-```
-I think subtask 5.2 would fit better as part of task 7. Can you move it there?
-```
-
-(Agent runs: `task-master move --from=5.2 --to=7.3`)
-
-```
-Task 8 should actually be a subtask of task 4. Can you reorganize this?
-```
-
-(Agent runs: `task-master move --from=8 --to=4.1`)
-
-```
-I just merged the main branch and there's a conflict in tasks.json. My teammates created tasks 10-15 on their branch while I created tasks 10-12 on my branch. Can you help me resolve this by moving my tasks?
-```
-
-(Agent runs:
-
-```bash
-task-master move --from=10 --to=16
-task-master move --from=11 --to=17
-task-master move --from=12 --to=18
-```
-
-)
-
 ## Analyzing complexity
 
 ```
@@ -79,33 +51,3 @@ Can you analyze the complexity of our tasks to help me understand which ones nee
 ```
 Can you show me the complexity report in a more readable format?
 ```
-
-### Breaking Down Complex Tasks
-
-```
-Task 5 seems complex. Can you break it down into subtasks?
-```
-
-(Agent runs: `task-master expand --id=5`)
-
-```
-Please break down task 5 using research-backed generation.
-```
-
-(Agent runs: `task-master expand --id=5 --research`)
-
-### Updating Tasks with Research
-
-```
-We need to update task 15 based on the latest React Query v5 changes. Can you research this and update the task?
-```
-
-(Agent runs: `task-master update-task --id=15 --prompt="Update based on React Query v5 changes" --research`)
-
-### Adding Tasks with Research
-
-```
-Please add a new task to implement user profile image uploads using Cloudinary, research the best approach.
-```
-
-(Agent runs: `task-master add-task --prompt="Implement user profile image uploads using Cloudinary" --research`)

docs/models.md

@@ -1,125 +0,0 @@
-# Available Models as of May 26, 2025
-
-## Main Models
-
-| Provider   | Model Name                                     | SWE Score | Input Cost | Output Cost |
-| ---------- | ---------------------------------------------- | --------- | ---------- | ----------- |
-| anthropic  | claude-sonnet-4-20250514                       | 0.727     | 3          | 15          |
-| anthropic  | claude-opus-4-20250514                         | 0.725     | 15         | 75          |
-| anthropic  | claude-3-7-sonnet-20250219                     | 0.623     | 3          | 15          |
-| anthropic  | claude-3-5-sonnet-20241022                     | 0.49      | 3          | 15          |
-| openai     | gpt-4o                                         | 0.332     | 2.5        | 10          |
-| openai     | o1                                             | 0.489     | 15         | 60          |
-| openai     | o3                                             | 0.5       | 10         | 40          |
-| openai     | o3-mini                                        | 0.493     | 1.1        | 4.4         |
-| openai     | o4-mini                                        | 0.45      | 1.1        | 4.4         |
-| openai     | o1-mini                                        | 0.4       | 1.1        | 4.4         |
-| openai     | o1-pro                                         | —         | 150        | 600         |
-| openai     | gpt-4-5-preview                                | 0.38      | 75         | 150         |
-| openai     | gpt-4-1-mini                                   | —         | 0.4        | 1.6         |
-| openai     | gpt-4-1-nano                                   | —         | 0.1        | 0.4         |
-| openai     | gpt-4o-mini                                    | 0.3       | 0.15       | 0.6         |
-| google     | gemini-2.5-pro-preview-05-06                   | 0.638     | —          | —           |
-| google     | gemini-2.5-pro-preview-03-25                   | 0.638     | —          | —           |
-| google     | gemini-2.5-flash-preview-04-17                 | —         | —          | —           |
-| google     | gemini-2.0-flash                               | 0.754     | 0.15       | 0.6         |
-| google     | gemini-2.0-flash-lite                          | —         | —          | —           |
-| perplexity | sonar-reasoning-pro                            | 0.211     | 2          | 8           |
-| perplexity | sonar-reasoning                                | 0.211     | 1          | 5           |
-| xai        | grok-3                                         | —         | 3          | 15          |
-| xai        | grok-3-fast                                    | —         | 5          | 25          |
-| ollama     | devstral:latest                                | —         | 0          | 0           |
-| ollama     | qwen3:latest                                   | —         | 0          | 0           |
-| ollama     | qwen3:14b                                      | —         | 0          | 0           |
-| ollama     | qwen3:32b                                      | —         | 0          | 0           |
-| ollama     | mistral-small3.1:latest                        | —         | 0          | 0           |
-| ollama     | llama3.3:latest                                | —         | 0          | 0           |
-| ollama     | phi4:latest                                    | —         | 0          | 0           |
-| openrouter | google/gemini-2.5-flash-preview-05-20          | —         | 0.15       | 0.6         |
-| openrouter | google/gemini-2.5-flash-preview-05-20:thinking | —         | 0.15       | 3.5         |
-| openrouter | google/gemini-2.5-pro-exp-03-25                | —         | 0          | 0           |
-| openrouter | deepseek/deepseek-chat-v3-0324:free            | —         | 0          | 0           |
-| openrouter | deepseek/deepseek-chat-v3-0324                 | —         | 0.27       | 1.1         |
-| openrouter | openai/gpt-4.1                                 | —         | 2          | 8           |
-| openrouter | openai/gpt-4.1-mini                            | —         | 0.4        | 1.6         |
-| openrouter | openai/gpt-4.1-nano                            | —         | 0.1        | 0.4         |
-| openrouter | openai/o3                                      | —         | 10         | 40          |
-| openrouter | openai/codex-mini                              | —         | 1.5        | 6           |
-| openrouter | openai/gpt-4o-mini                             | —         | 0.15       | 0.6         |
-| openrouter | openai/o4-mini                                 | 0.45      | 1.1        | 4.4         |
-| openrouter | openai/o4-mini-high                            | —         | 1.1        | 4.4         |
-| openrouter | openai/o1-pro                                  | —         | 150        | 600         |
-| openrouter | meta-llama/llama-3.3-70b-instruct              | —         | 120        | 600         |
-| openrouter | meta-llama/llama-4-maverick                    | —         | 0.18       | 0.6         |
-| openrouter | meta-llama/llama-4-scout                       | —         | 0.08       | 0.3         |
-| openrouter | qwen/qwen-max                                  | —         | 1.6        | 6.4         |
-| openrouter | qwen/qwen-turbo                                | —         | 0.05       | 0.2         |
-| openrouter | qwen/qwen3-235b-a22b                           | —         | 0.14       | 2           |
-| openrouter | mistralai/mistral-small-3.1-24b-instruct:free  | —         | 0          | 0           |
-| openrouter | mistralai/mistral-small-3.1-24b-instruct       | —         | 0.1        | 0.3         |
-| openrouter | mistralai/devstral-small                       | —         | 0.1        | 0.3         |
-| openrouter | mistralai/mistral-nemo                         | —         | 0.03       | 0.07        |
-| openrouter | thudm/glm-4-32b:free                           | —         | 0          | 0           |
-
-## Research Models
-
-| Provider   | Model Name                 | SWE Score | Input Cost | Output Cost |
-| ---------- | -------------------------- | --------- | ---------- | ----------- |
-| openai     | gpt-4o-search-preview      | 0.33      | 2.5        | 10          |
-| openai     | gpt-4o-mini-search-preview | 0.3       | 0.15       | 0.6         |
-| perplexity | sonar-pro                  | —         | 3          | 15          |
-| perplexity | sonar                      | —         | 1          | 1           |
-| perplexity | deep-research              | 0.211     | 2          | 8           |
-| xai        | grok-3                     | —         | 3          | 15          |
-| xai        | grok-3-fast                | —         | 5          | 25          |
-
-## Fallback Models
-
-| Provider   | Model Name                                     | SWE Score | Input Cost | Output Cost |
-| ---------- | ---------------------------------------------- | --------- | ---------- | ----------- |
-| anthropic  | claude-sonnet-4-20250514                       | 0.727     | 3          | 15          |
-| anthropic  | claude-opus-4-20250514                         | 0.725     | 15         | 75          |
-| anthropic  | claude-3-7-sonnet-20250219                     | 0.623     | 3          | 15          |
-| anthropic  | claude-3-5-sonnet-20241022                     | 0.49      | 3          | 15          |
-| openai     | gpt-4o                                         | 0.332     | 2.5        | 10          |
-| openai     | o3                                             | 0.5       | 10         | 40          |
-| openai     | o4-mini                                        | 0.45      | 1.1        | 4.4         |
-| google     | gemini-2.5-pro-preview-05-06                   | 0.638     | —          | —           |
-| google     | gemini-2.5-pro-preview-03-25                   | 0.638     | —          | —           |
-| google     | gemini-2.5-flash-preview-04-17                 | —         | —          | —           |
-| google     | gemini-2.0-flash                               | 0.754     | 0.15       | 0.6         |
-| google     | gemini-2.0-flash-lite                          | —         | —          | —           |
-| perplexity | sonar-reasoning-pro                            | 0.211     | 2          | 8           |
-| perplexity | sonar-reasoning                                | 0.211     | 1          | 5           |
-| xai        | grok-3                                         | —         | 3          | 15          |
-| xai        | grok-3-fast                                    | —         | 5          | 25          |
-| ollama     | devstral:latest                                | —         | 0          | 0           |
-| ollama     | qwen3:latest                                   | —         | 0          | 0           |
-| ollama     | qwen3:14b                                      | —         | 0          | 0           |
-| ollama     | qwen3:32b                                      | —         | 0          | 0           |
-| ollama     | mistral-small3.1:latest                        | —         | 0          | 0           |
-| ollama     | llama3.3:latest                                | —         | 0          | 0           |
-| ollama     | phi4:latest                                    | —         | 0          | 0           |
-| openrouter | google/gemini-2.5-flash-preview-05-20          | —         | 0.15       | 0.6         |
-| openrouter | google/gemini-2.5-flash-preview-05-20:thinking | —         | 0.15       | 3.5         |
-| openrouter | google/gemini-2.5-pro-exp-03-25                | —         | 0          | 0           |
-| openrouter | deepseek/deepseek-chat-v3-0324:free            | —         | 0          | 0           |
-| openrouter | openai/gpt-4.1                                 | —         | 2          | 8           |
-| openrouter | openai/gpt-4.1-mini                            | —         | 0.4        | 1.6         |
-| openrouter | openai/gpt-4.1-nano                            | —         | 0.1        | 0.4         |
-| openrouter | openai/o3                                      | —         | 10         | 40          |
-| openrouter | openai/codex-mini                              | —         | 1.5        | 6           |
-| openrouter | openai/gpt-4o-mini                             | —         | 0.15       | 0.6         |
-| openrouter | openai/o4-mini                                 | 0.45      | 1.1        | 4.4         |
-| openrouter | openai/o4-mini-high                            | —         | 1.1        | 4.4         |
-| openrouter | openai/o1-pro                                  | —         | 150        | 600         |
-| openrouter | meta-llama/llama-3.3-70b-instruct              | —         | 120        | 600         |
-| openrouter | meta-llama/llama-4-maverick                    | —         | 0.18       | 0.6         |
-| openrouter | meta-llama/llama-4-scout                       | —         | 0.08       | 0.3         |
-| openrouter | qwen/qwen-max                                  | —         | 1.6        | 6.4         |
-| openrouter | qwen/qwen-turbo                                | —         | 0.05       | 0.2         |
-| openrouter | qwen/qwen3-235b-a22b                           | —         | 0.14       | 2           |
-| openrouter | mistralai/mistral-small-3.1-24b-instruct:free  | —         | 0          | 0           |
-| openrouter | mistralai/mistral-small-3.1-24b-instruct       | —         | 0.1        | 0.3         |
-| openrouter | mistralai/mistral-nemo                         | —         | 0.03       | 0.07        |
-| openrouter | thudm/glm-4-32b:free                           | —         | 0          | 0           |

docs/scripts/models-json-to-markdown.js

@@ -1,131 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const supportedModelsPath = path.join(
-	__dirname,
-	'..',
-	'modules',
-	'supported-models.json'
-);
-const outputMarkdownPath = path.join(
-	__dirname,
-	'..',
-	'..',
-	'docs',
-	'models.md'
-);
-
-function formatCost(cost) {
-	if (cost === null || cost === undefined) {
-		return '—';
-	}
-	return cost;
-}
-
-function formatSweScore(score) {
-	if (score === null || score === undefined || score === 0) {
-		return '—';
-	}
-	return score.toString();
-}
-
-function generateMarkdownTable(title, models) {
-	if (!models || models.length === 0) {
-		return `## ${title}\n\nNo models in this category.\n\n`;
-	}
-	let table = `## ${title}\n\n`;
-	table += '| Provider | Model Name | SWE Score | Input Cost | Output Cost |\n';
-	table += '|---|---|---|---|---|\n';
-	models.forEach((model) => {
-		table += `| ${model.provider} | ${model.modelName} | ${formatSweScore(model.sweScore)} | ${formatCost(model.inputCost)} | ${formatCost(model.outputCost)} |\n`;
-	});
-	table += '\n';
-	return table;
-}
-
-function main() {
-	try {
-		const correctSupportedModelsPath = path.join(
-			__dirname,
-			'..',
-			'..',
-			'scripts',
-			'modules',
-			'supported-models.json'
-		);
-		const correctOutputMarkdownPath = path.join(__dirname, '..', 'models.md');
-
-		const supportedModelsContent = fs.readFileSync(
-			correctSupportedModelsPath,
-			'utf8'
-		);
-		const supportedModels = JSON.parse(supportedModelsContent);
-
-		const mainModels = [];
-		const researchModels = [];
-		const fallbackModels = [];
-
-		for (const provider in supportedModels) {
-			if (Object.hasOwnProperty.call(supportedModels, provider)) {
-				const models = supportedModels[provider];
-				models.forEach((model) => {
-					const modelEntry = {
-						provider: provider,
-						modelName: model.id,
-						sweScore: model.swe_score,
-						inputCost: model.cost_per_1m_tokens
-							? model.cost_per_1m_tokens.input
-							: null,
-						outputCost: model.cost_per_1m_tokens
-							? model.cost_per_1m_tokens.output
-							: null
-					};
-
-					if (model.allowed_roles.includes('main')) {
-						mainModels.push(modelEntry);
-					}
-					if (model.allowed_roles.includes('research')) {
-						researchModels.push(modelEntry);
-					}
-					if (model.allowed_roles.includes('fallback')) {
-						fallbackModels.push(modelEntry);
-					}
-				});
-			}
-		}
-
-		const date = new Date();
-		const monthNames = [
-			'January',
-			'February',
-			'March',
-			'April',
-			'May',
-			'June',
-			'July',
-			'August',
-			'September',
-			'October',
-			'November',
-			'December'
-		];
-		const formattedDate = `${monthNames[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}`;
-
-		let markdownContent = `# Available Models as of ${formattedDate}\n\n`;
-		markdownContent += generateMarkdownTable('Main Models', mainModels);
-		markdownContent += generateMarkdownTable('Research Models', researchModels);
-		markdownContent += generateMarkdownTable('Fallback Models', fallbackModels);
-
-		fs.writeFileSync(correctOutputMarkdownPath, markdownContent, 'utf8');
-		console.log(`Successfully updated ${correctOutputMarkdownPath}`);
-	} catch (error) {
-		console.error('Error transforming models.json to models.md:', error);
-		process.exit(1);
-	}
-}
-
-main();

docs/tutorial.md

@@ -10,45 +10,32 @@ There are two ways to set up Task Master: using MCP (recommended) or via npm ins
 
 MCP (Model Control Protocol) provides the easiest way to get started with Task Master directly in your editor.
 
-1. **Install the package**
-
-```bash
-npm i -g task-master-ai
-```
-
-2. **Add the MCP config to your IDE/MCP Client** (Cursor is recommended, but it works with other clients):
+1. **Add the MCP config to your editor** (Cursor recommended, but it works with other text editors):
 
 ```json
 {
 	"mcpServers": {
 		"taskmaster-ai": {
 			"command": "npx",
-			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
+			"args": ["-y", "task-master-ai", "mcp-server"],
 			"env": {
 				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
 				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
-				"OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
-				"GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
-				"MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
-				"OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
-				"XAI_API_KEY": "YOUR_XAI_KEY_HERE",
-				"AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE"
+				"MODEL": "claude-3-7-sonnet-20250219",
+				"PERPLEXITY_MODEL": "sonar-pro",
+				"MAX_TOKENS": 128000,
+				"TEMPERATURE": 0.2,
+				"DEFAULT_SUBTASKS": 5,
+				"DEFAULT_PRIORITY": "medium"
 			}
 		}
 	}
 }
 ```
 
-**IMPORTANT:** An API key is _required_ for each AI provider you plan on using. Run the `task-master models` command to see your selected models and the status of your API keys across .env and mcp.json
+2. **Enable the MCP** in your editor settings
 
-**To use AI commands in CLI** you MUST have API keys in the .env file
-**To use AI commands in MCP** you MUST have API keys in the .mcp.json file (or MCP config equivalent)
-
-We recommend having keys in both places and adding mcp.json to your gitignore so your API keys aren't checked into git.
-
-3. **Enable the MCP** in your editor settings
-
-4. **Prompt the AI** to initialize Task Master:
+3. **Prompt the AI** to initialize Task Master:
 
 ```
 Can you please initialize taskmaster-ai into my project?
@@ -60,9 +47,9 @@ The AI will:
 - Set up initial configuration files
 - Guide you through the rest of the process
 
-5. Place your PRD document in the `scripts/` directory (e.g., `scripts/prd.txt`)
+4. Place your PRD document in the `scripts/` directory (e.g., `scripts/prd.txt`)
 
-6. **Use natural language commands** to interact with Task Master:
+5. **Use natural language commands** to interact with Task Master:
 
 ```
 Can you parse my PRD at scripts/prd.txt?
@@ -89,7 +76,7 @@ Initialize a new project:
 task-master init
 
 # If installed locally
-npx task-master init
+npx task-master-init
 ```
 
 This will prompt you for project details and set up a new project with the necessary files and structure.
@@ -145,7 +132,7 @@ You can also set up the MCP server in Cursor settings:
 4. Configure with the following details:
    - Name: "Task Master"
    - Type: "Command"
-   - Command: "npx -y --package=task-master-ai task-master-ai"
+   - Command: "npx -y --package task-master-ai task-master-mcp"
 5. Save the settings
 
 Once configured, you can interact with Task Master's task management commands directly through Cursor's interface, providing a more integrated experience.
@@ -254,75 +241,18 @@ If during implementation, you discover that:
 Tell the agent:
 
 ```
-We've decided to use MongoDB instead of PostgreSQL. Can you update all future tasks (from ID 4) to reflect this change?
+We've changed our approach. We're now using Express instead of Fastify. Please update all future tasks to reflect this change.
 ```
 
 The agent will execute:
 
 ```bash
-task-master update --from=4 --prompt="Now we are using MongoDB instead of PostgreSQL."
-
-# OR, if research is needed to find best practices for MongoDB:
-task-master update --from=4 --prompt="Update to use MongoDB, researching best practices" --research
+task-master update --from=4 --prompt="Now we are using Express instead of Fastify."
 ```
 
 This will rewrite or re-scope subsequent tasks in tasks.json while preserving completed work.
 
-### 6. Reorganizing Tasks
-
-If you need to reorganize your task structure:
-
-```
-I think subtask 5.2 would fit better as part of task 7 instead. Can you move it there?
-```
-
-The agent will execute:
-
-```bash
-task-master move --from=5.2 --to=7.3
-```
-
-You can reorganize tasks in various ways:
-
-- Moving a standalone task to become a subtask: `--from=5 --to=7`
-- Moving a subtask to become a standalone task: `--from=5.2 --to=7`
-- Moving a subtask to a different parent: `--from=5.2 --to=7.3`
-- Reordering subtasks within the same parent: `--from=5.2 --to=5.4`
-- Moving a task to a new ID position: `--from=5 --to=25` (even if task 25 doesn't exist yet)
-- Moving multiple tasks at once: `--from=10,11,12 --to=16,17,18` (must have same number of IDs, Taskmaster will look through each position)
-
-When moving tasks to new IDs:
-
-- The system automatically creates placeholder tasks for non-existent destination IDs
-- This prevents accidental data loss during reorganization
-- Any tasks that depend on moved tasks will have their dependencies updated
-- When moving a parent task, all its subtasks are automatically moved with it and renumbered
-
-This is particularly useful as your project understanding evolves and you need to refine your task structure.
-
-### 7. Resolving Merge Conflicts with Tasks
-
-When working with a team, you might encounter merge conflicts in your tasks.json file if multiple team members create tasks on different branches. The move command makes resolving these conflicts straightforward:
-
-```
-I just merged the main branch and there's a conflict with tasks.json. My teammates created tasks 10-15 while I created tasks 10-12 on my branch. Can you help me resolve this?
-```
-
-The agent will help you:
-
-1. Keep your teammates' tasks (10-15)
-2. Move your tasks to new positions to avoid conflicts:
-
-```bash
-# Move your tasks to new positions (e.g., 16-18)
-task-master move --from=10 --to=16
-task-master move --from=11 --to=17
-task-master move --from=12 --to=18
-```
-
-This approach preserves everyone's work while maintaining a clean task structure, making it much easier to handle task conflicts than trying to manually merge JSON files.
-
-### 8. Breaking Down Complex Tasks
+### 6. Breaking Down Complex Tasks
 
 For complex tasks that need more granularity:
 
@@ -360,7 +290,7 @@ The agent will execute:
 task-master expand --all
 ```
 
-For research-backed subtask generation using the configured research model:
+For research-backed subtask generation using Perplexity AI:
 
 ```
 Please break down task 5 using research-backed generation.

index.js

@@ -46,18 +46,22 @@ export const initProject = async (options = {}) => {
 };
 
 // Export a function to run init as a CLI command
-export const runInitCLI = async (options = {}) => {
-	try {
-		const init = await import('./scripts/init.js');
-		const result = await init.initializeProject(options);
-		return result;
-	} catch (error) {
-		console.error('Initialization failed:', error.message);
-		if (process.env.DEBUG === 'true') {
-			console.error('Debug stack trace:', error.stack);
-		}
-		throw error; // Re-throw to be handled by the command handler
-	}
+export const runInitCLI = async () => {
+	// Using spawn to ensure proper handling of stdio and process exit
+	const child = spawn('node', [resolve(__dirname, './scripts/init.js')], {
+		stdio: 'inherit',
+		cwd: process.cwd()
+	});
+
+	return new Promise((resolve, reject) => {
+		child.on('close', (code) => {
+			if (code === 0) {
+				resolve();
+			} else {
+				reject(new Error(`Init script exited with code ${code}`));
+			}
+		});
+	});
 };
 
 // Export version information
@@ -75,21 +79,11 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 	program
 		.command('init')
 		.description('Initialize a new project')
-		.option('-y, --yes', 'Skip prompts and use default values')
-		.option('-n, --name <n>', 'Project name')
-		.option('-d, --description <description>', 'Project description')
-		.option('-v, --version <version>', 'Project version', '0.1.0')
-		.option('-a, --author <author>', 'Author name')
-		.option('--skip-install', 'Skip installing dependencies')
-		.option('--dry-run', 'Show what would be done without making changes')
-		.option('--aliases', 'Add shell aliases (tm, taskmaster)')
-		.action(async (cmdOptions) => {
-			try {
-				await runInitCLI(cmdOptions);
-			} catch (err) {
+		.action(() => {
+			runInitCLI().catch((err) => {
 				console.error('Init failed:', err.message);
 				process.exit(1);
-			}
+			});
 		});
 
 	program

jest.config.js

@@ -15,7 +15,11 @@ export default {
 	roots: ['<rootDir>/tests'],
 
 	// The glob patterns Jest uses to detect test files
-	testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js'],
+	testMatch: [
+		'**/__tests__/**/*.js',
+		'**/?(*.)+(spec|test).js',
+		'**/tests/*.test.js'
+	],
 
 	// Transform files
 	transform: {},

llms-install.md

@@ -1,131 +0,0 @@
-``# Taskmaster AI Installation Guide
-
-This guide helps AI assistants install and configure Taskmaster for users in their development projects.
-
-## What is Taskmaster?
-
-Taskmaster is an AI-driven task management system designed for development workflows. It helps break down projects into manageable tasks, track dependencies, and maintain development momentum through structured, AI-enhanced planning.
-
-## Installation Steps
-
-### Step 1: Add MCP Configuration
-
-Add the following configuration to the user's MCP settings file (`.cursor/mcp.json` for Cursor, or equivalent for other editors):
-
-```json
-{
-	"mcpServers": {
-		"taskmaster-ai": {
-			"command": "npx",
-			"args": ["-y", "--package=task-master-ai", "task-master-ai"],
-			"env": {
-				"ANTHROPIC_API_KEY": "user_will_add_their_key_here",
-				"PERPLEXITY_API_KEY": "user_will_add_their_key_here",
-				"OPENAI_API_KEY": "user_will_add_their_key_here",
-				"GOOGLE_API_KEY": "user_will_add_their_key_here",
-				"MISTRAL_API_KEY": "user_will_add_their_key_here",
-				"OPENROUTER_API_KEY": "user_will_add_their_key_here",
-				"XAI_API_KEY": "user_will_add_their_key_here"
-			}
-		}
-	}
-}
-```
-
-### Step 2: API Key Requirements
-
-Inform the user they need **at least one** API key from the following providers:
-
-- **Anthropic** (for Claude models) - Recommended
-- **OpenAI** (for GPT models)
-- **Google** (for Gemini models)
-- **Perplexity** (for research features) - Highly recommended
-- **Mistral** (for Mistral models)
-- **OpenRouter** (access to multiple models)
-- **xAI** (for Grok models)
-
-The user will be able to define 3 separate roles (can be the same provider or separate providers) for main AI operations, research operations (research providers/models only), and a fallback model in case of errors.
-
-### Step 3: Initialize Project
-
-Once the MCP server is configured and API keys are added, initialize Taskmaster in the user's project:
-
-> Can you initialize Task Master in my project?
-
-This will run the `initialize_project` tool to set up the basic file structure.
-
-### Step 4: Create Initial Tasks
-
-Users have two options for creating initial tasks:
-
-**Option A: Parse a PRD (Recommended)**
-If they have a Product Requirements Document:
-
-> Can you parse my PRD file at [path/to/prd.txt] to generate initial tasks?
-
-If the user does not have a PRD, the AI agent can help them create one and store it in scripts/prd.txt for parsing.
-
-**Option B: Start from scratch**
-
-> Can you help me add my first task: [describe the task]
-
-## Common Usage Patterns
-
-### Daily Workflow
-
-> What's the next task I should work on?
-> Can you show me the details for task [ID]?
-> Can you mark task [ID] as done?
-
-### Task Management
-
-> Can you break down task [ID] into subtasks?
-> Can you add a new task: [description]
-> Can you analyze the complexity of my tasks?
-
-### Project Organization
-
-> Can you show me all my pending tasks?
-> Can you move task [ID] to become a subtask of [parent ID]?
-> Can you update task [ID] with this new information: [details]
-
-## Verification Steps
-
-After installation, verify everything is working:
-
-1. **Check MCP Connection**: The AI should be able to access Task Master tools
-2. **Test Basic Commands**: Try `get_tasks` to list current tasks
-3. **Verify API Keys**: Ensure AI-powered commands work (like `add_task`)
-
-Note: An API key fallback exists that allows the MCP server to read API keys from `.env` instead of the MCP JSON config. It is recommended to have keys in both places in case the MCP server is unable to read keys from its environment for whatever reason.
-
-When adding keys to `.env` only, the `models` tool will explain that the keys are not OK for MCP. Despite this, the fallback should kick in and the API keys will be read from the `.env` file.
-
-## Troubleshooting
-
-**If MCP server doesn't start:**
-
-- Verify the JSON configuration is valid
-- Check that Node.js is installed
-- Ensure API keys are properly formatted
-
-**If AI commands fail:**
-
-- Verify at least one API key is configured
-- Check API key permissions and quotas
-- Try using a different model via the `models` tool
-
-## CLI Fallback
-
-Taskmaster is also available via CLI commands, by installing with `npm install task-master-ai@latest` in a terminal. Running `task-master help` will show all available commands, which offer a 1:1 experience with the MCP server. As the AI agent, you should refer to the system prompts and rules provided to you to identify Taskmaster-specific rules that help you understand how and when to use it.
-
-## Next Steps
-
-Once installed, users can:
-
-- Create new tasks with `add-task` or parse a PRD (scripts/prd.txt) into tasks with `parse-prd`
-- Set up model preferences with `models` tool
-- Expand tasks into subtasks with `expand-all` and `expand-task`
-- Explore advanced features like research mode and complexity analysis
-
-For detailed documentation, refer to the Task Master docs directory.``

mcp-server/src/core/direct-functions/add-dependency.js

@@ -4,6 +4,7 @@
  */
 
 import { addDependency } from '../../../../scripts/modules/dependency-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -13,32 +14,19 @@ import {
  * Direct function wrapper for addDependency with error handling.
  *
  * @param {Object} args - Command arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {string|number} args.id - Task ID to add dependency to
  * @param {string|number} args.dependsOn - Task ID that will become a dependency
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Result object with success status and data/error information
  */
 export async function addDependencyDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath, id, dependsOn } = args;
 	try {
 		log.info(`Adding dependency with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('addDependencyDirect called without tasksJsonPath');
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
-
 		// Validate required parameters
-		if (!id) {
+		if (!args.id) {
 			return {
 				success: false,
 				error: {
@@ -48,7 +36,7 @@ export async function addDependencyDirect(args, log) {
 			};
 		}
 
-		if (!dependsOn) {
+		if (!args.dependsOn) {
 			return {
 				success: false,
 				error: {
@@ -58,16 +46,18 @@ export async function addDependencyDirect(args, log) {
 			};
 		}
 
-		// Use provided path
-		const tasksPath = tasksJsonPath;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Format IDs for the core function
 		const taskId =
-			id && id.includes && id.includes('.') ? id : parseInt(id, 10);
+			args.id.includes && args.id.includes('.')
+				? args.id
+				: parseInt(args.id, 10);
 		const dependencyId =
-			dependsOn && dependsOn.includes && dependsOn.includes('.')
-				? dependsOn
-				: parseInt(dependsOn, 10);
+			args.dependsOn.includes && args.dependsOn.includes('.')
+				? args.dependsOn
+				: parseInt(args.dependsOn, 10);
 
 		log.info(
 			`Adding dependency: task ${taskId} will depend on ${dependencyId}`
@@ -76,7 +66,7 @@ export async function addDependencyDirect(args, log) {
 		// Enable silent mode to prevent console logs from interfering with JSON response
 		enableSilentMode();
 
-		// Call the core function using the provided path
+		// Call the core function
 		await addDependency(tasksPath, taskId, dependencyId);
 
 		// Restore normal logging

mcp-server/src/core/direct-functions/add-subtask.js

@@ -3,6 +3,7 @@
  */
 
 import { addSubtask } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -11,7 +12,6 @@ import {
 /**
  * Add a subtask to an existing task
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {string} args.id - Parent task ID
  * @param {string} [args.taskId] - Existing task ID to convert to subtask (optional)
  * @param {string} [args.title] - Title for new subtask (when creating a new subtask)
@@ -19,39 +19,17 @@ import {
  * @param {string} [args.details] - Implementation details for new subtask
  * @param {string} [args.status] - Status for new subtask (default: 'pending')
  * @param {string} [args.dependencies] - Comma-separated list of dependency IDs
+ * @param {string} [args.file] - Path to the tasks file
  * @param {boolean} [args.skipGenerate] - Skip regenerating task files
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: string}>}
  */
 export async function addSubtaskDirect(args, log) {
-	// Destructure expected args
-	const {
-		tasksJsonPath,
-		id,
-		taskId,
-		title,
-		description,
-		details,
-		status,
-		dependencies: dependenciesStr,
-		skipGenerate
-	} = args;
 	try {
 		log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('addSubtaskDirect called without tasksJsonPath');
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
-
-		if (!id) {
+		if (!args.id) {
 			return {
 				success: false,
 				error: {
@@ -62,7 +40,7 @@ export async function addSubtaskDirect(args, log) {
 		}
 
 		// Either taskId or title must be provided
-		if (!taskId && !title) {
+		if (!args.taskId && !args.title) {
 			return {
 				success: false,
 				error: {
@@ -72,26 +50,26 @@ export async function addSubtaskDirect(args, log) {
 			};
 		}
 
-		// Use provided path
-		const tasksPath = tasksJsonPath;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Parse dependencies if provided
 		let dependencies = [];
-		if (dependenciesStr) {
-			dependencies = dependenciesStr.split(',').map((depId) => {
+		if (args.dependencies) {
+			dependencies = args.dependencies.split(',').map((id) => {
 				// Handle both regular IDs and dot notation
-				return depId.includes('.') ? depId.trim() : parseInt(depId.trim(), 10);
+				return id.includes('.') ? id.trim() : parseInt(id.trim(), 10);
 			});
 		}
 
 		// Convert existingTaskId to a number if provided
-		const existingTaskId = taskId ? parseInt(taskId, 10) : null;
+		const existingTaskId = args.taskId ? parseInt(args.taskId, 10) : null;
 
 		// Convert parent ID to a number
-		const parentId = parseInt(id, 10);
+		const parentId = parseInt(args.id, 10);
 
 		// Determine if we should generate files
-		const generateFiles = !skipGenerate;
+		const generateFiles = !args.skipGenerate;
 
 		// Enable silent mode to prevent console logs from interfering with JSON response
 		enableSilentMode();
@@ -123,10 +101,10 @@ export async function addSubtaskDirect(args, log) {
 			log.info(`Creating new subtask for parent task ${parentId}`);
 
 			const newSubtaskData = {
-				title: title,
-				description: description || '',
-				details: details || '',
-				status: status || 'pending',
+				title: args.title,
+				description: args.description || '',
+				details: args.details || '',
+				status: args.status || 'pending',
 				dependencies: dependencies
 			};
 

mcp-server/src/core/direct-functions/add-task.js

@@ -4,158 +4,171 @@
  */
 
 import { addTask } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { createLogWrapper } from '../../tools/utils.js';
+import {
+	getAnthropicClientForMCP,
+	getModelConfig
+} from '../utils/ai-client-utils.js';
+import {
+	_buildAddTaskPrompt,
+	parseTaskJsonResponse,
+	_handleAnthropicStream
+} from '../../../../scripts/modules/ai-services.js';
 
 /**
  * Direct function wrapper for adding a new task with error handling.
  *
  * @param {Object} args - Command arguments
- * @param {string} [args.prompt] - Description of the task to add (required if not using manual fields)
- * @param {string} [args.title] - Task title (for manual task creation)
- * @param {string} [args.description] - Task description (for manual task creation)
- * @param {string} [args.details] - Implementation details (for manual task creation)
- * @param {string} [args.testStrategy] - Test strategy (for manual task creation)
- * @param {string} [args.dependencies] - Comma-separated list of task IDs this task depends on
+ * @param {string} args.prompt - Description of the task to add
+ * @param {Array<number>} [args.dependencies=[]] - Task dependencies as array of IDs
  * @param {string} [args.priority='medium'] - Task priority (high, medium, low)
- * @param {string} [args.tasksJsonPath] - Path to the tasks.json file (resolved by tool)
- * @param {boolean} [args.research=false] - Whether to use research capabilities for task creation
- * @param {string} [args.projectRoot] - Project root path
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.projectRoot] - Project root directory
+ * @param {boolean} [args.research] - Whether to use research capabilities for task creation
  * @param {Object} log - Logger object
- * @param {Object} context - Additional context (session)
+ * @param {Object} context - Additional context (reportProgress, session)
  * @returns {Promise<Object>} - Result object { success: boolean, data?: any, error?: { code: string, message: string } }
  */
 export async function addTaskDirect(args, log, context = {}) {
-	// Destructure expected args (including research and projectRoot)
-	const {
-		tasksJsonPath,
-		prompt,
-		dependencies,
-		priority,
-		research,
-		projectRoot
-	} = args;
-	const { session } = context; // Destructure session from context
-
-	// Enable silent mode to prevent console logs from interfering with JSON response
-	enableSilentMode();
-
-	// Create logger wrapper using the utility
-	const mcpLog = createLogWrapper(log);
-
 	try {
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('addTaskDirect called without tasksJsonPath');
-			disableSilentMode(); // Disable before returning
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
 
-		// Use provided path
-		const tasksPath = tasksJsonPath;
-
-		// Check if this is manual task creation or AI-driven task creation
-		const isManualCreation = args.title && args.description;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Check required parameters
-		if (!args.prompt && !isManualCreation) {
-			log.error(
-				'Missing required parameters: either prompt or title+description must be provided'
-			);
+		if (!args.prompt) {
+			log.error('Missing required parameter: prompt');
 			disableSilentMode();
 			return {
 				success: false,
 				error: {
 					code: 'MISSING_PARAMETER',
-					message:
-						'Either the prompt parameter or both title and description parameters are required for adding a task'
+					message: 'The prompt parameter is required for adding a task'
 				}
 			};
 		}
 
 		// Extract and prepare parameters
-		const taskDependencies = Array.isArray(dependencies)
-			? dependencies // Already an array if passed directly
-			: dependencies // Check if dependencies exist and are a string
-				? String(dependencies)
+		const prompt = args.prompt;
+		const dependencies = Array.isArray(args.dependencies)
+			? args.dependencies
+			: args.dependencies
+				? String(args.dependencies)
 						.split(',')
-						.map((id) => parseInt(id.trim(), 10)) // Split, trim, and parse
-				: []; // Default to empty array if null/undefined
-		const taskPriority = priority || 'medium'; // Default priority
+						.map((id) => parseInt(id.trim(), 10))
+				: [];
+		const priority = args.priority || 'medium';
 
-		let manualTaskData = null;
-		let newTaskId;
-		let telemetryData;
+		log.info(
+			`Adding new task with prompt: "${prompt}", dependencies: [${dependencies.join(', ')}], priority: ${priority}`
+		);
 
-		if (isManualCreation) {
-			// Create manual task data object
-			manualTaskData = {
-				title: args.title,
-				description: args.description,
-				details: args.details || '',
-				testStrategy: args.testStrategy || ''
+		// Extract context parameters for advanced functionality
+		// Commenting out reportProgress extraction
+		// const { reportProgress, session } = context;
+		const { session } = context; // Keep session
+
+		// Initialize AI client with session environment
+		let localAnthropic;
+		try {
+			localAnthropic = getAnthropicClientForMCP(session, log);
+		} catch (error) {
+			log.error(`Failed to initialize Anthropic client: ${error.message}`);
+			disableSilentMode();
+			return {
+				success: false,
+				error: {
+					code: 'AI_CLIENT_ERROR',
+					message: `Cannot initialize AI client: ${error.message}`
+				}
 			};
-
-			log.info(
-				`Adding new task manually with title: "${args.title}", dependencies: [${taskDependencies.join(', ')}], priority: ${priority}`
-			);
-
-			// Call the addTask function with manual task data
-			const result = await addTask(
-				tasksPath,
-				null, // prompt is null for manual creation
-				taskDependencies,
-				taskPriority,
-				{
-					session,
-					mcpLog,
-					projectRoot,
-					commandName: 'add-task',
-					outputType: 'mcp'
-				},
-				'json', // outputFormat
-				manualTaskData, // Pass the manual task data
-				false, // research flag is false for manual creation
-				projectRoot // Pass projectRoot
-			);
-			newTaskId = result.newTaskId;
-			telemetryData = result.telemetryData;
-		} else {
-			// AI-driven task creation
-			log.info(
-				`Adding new task with prompt: "${prompt}", dependencies: [${taskDependencies.join(', ')}], priority: ${taskPriority}, research: ${research}`
-			);
-
-			// Call the addTask function, passing the research flag
-			const result = await addTask(
-				tasksPath,
-				prompt, // Use the prompt for AI creation
-				taskDependencies,
-				taskPriority,
-				{
-					session,
-					mcpLog,
-					projectRoot,
-					commandName: 'add-task',
-					outputType: 'mcp'
-				},
-				'json', // outputFormat
-				null, // manualTaskData is null for AI creation
-				research // Pass the research flag
-			);
-			newTaskId = result.newTaskId;
-			telemetryData = result.telemetryData;
 		}
 
+		// Get model configuration from session
+		const modelConfig = getModelConfig(session);
+
+		// Read existing tasks to provide context
+		let tasksData;
+		try {
+			const fs = await import('fs');
+			tasksData = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+		} catch (error) {
+			log.warn(`Could not read existing tasks for context: ${error.message}`);
+			tasksData = { tasks: [] };
+		}
+
+		// Build prompts for AI
+		const { systemPrompt, userPrompt } = _buildAddTaskPrompt(
+			prompt,
+			tasksData.tasks
+		);
+
+		// Make the AI call using the streaming helper
+		let responseText;
+		try {
+			responseText = await _handleAnthropicStream(
+				localAnthropic,
+				{
+					model: modelConfig.model,
+					max_tokens: modelConfig.maxTokens,
+					temperature: modelConfig.temperature,
+					messages: [{ role: 'user', content: userPrompt }],
+					system: systemPrompt
+				},
+				{
+					// reportProgress: context.reportProgress, // Commented out to prevent Cursor stroking out
+					mcpLog: log
+				}
+			);
+		} catch (error) {
+			log.error(`AI processing failed: ${error.message}`);
+			disableSilentMode();
+			return {
+				success: false,
+				error: {
+					code: 'AI_PROCESSING_ERROR',
+					message: `Failed to generate task with AI: ${error.message}`
+				}
+			};
+		}
+
+		// Parse the AI response
+		let taskDataFromAI;
+		try {
+			taskDataFromAI = parseTaskJsonResponse(responseText);
+		} catch (error) {
+			log.error(`Failed to parse AI response: ${error.message}`);
+			disableSilentMode();
+			return {
+				success: false,
+				error: {
+					code: 'RESPONSE_PARSING_ERROR',
+					message: `Failed to parse AI response: ${error.message}`
+				}
+			};
+		}
+
+		// Call the addTask function with 'json' outputFormat to prevent console output when called via MCP
+		const newTaskId = await addTask(
+			tasksPath,
+			prompt,
+			dependencies,
+			priority,
+			{
+				// reportProgress, // Commented out
+				mcpLog: log,
+				session,
+				taskDataFromAI // Pass the parsed AI result
+			},
+			'json'
+		);
+
 		// Restore normal logging
 		disableSilentMode();
 
@@ -163,8 +176,7 @@ export async function addTaskDirect(args, log, context = {}) {
 			success: true,
 			data: {
 				taskId: newTaskId,
-				message: `Successfully added new task #${newTaskId}`,
-				telemetryData: telemetryData
+				message: `Successfully added new task #${newTaskId}`
 			}
 		};
 	} catch (error) {
@@ -172,11 +184,10 @@ export async function addTaskDirect(args, log, context = {}) {
 		disableSilentMode();
 
 		log.error(`Error in addTaskDirect: ${error.message}`);
-		// Add specific error code checks if needed
 		return {
 			success: false,
 			error: {
-				code: error.code || 'ADD_TASK_ERROR', // Use error code if available
+				code: 'ADD_TASK_ERROR',
 				message: error.message
 			}
 		};

mcp-server/src/core/direct-functions/analyze-task-complexity.js

@@ -2,178 +2,121 @@
  * Direct function wrapper for analyzeTaskComplexity
  */
 
-import analyzeTaskComplexity from '../../../../scripts/modules/task-manager/analyze-task-complexity.js';
+import { analyzeTaskComplexity } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode,
-	isSilentMode
+	isSilentMode,
+	readJSON
 } from '../../../../scripts/modules/utils.js';
 import fs from 'fs';
-import { createLogWrapper } from '../../tools/utils.js'; // Import the new utility
+import path from 'path';
 
 /**
  * Analyze task complexity and generate recommendations
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
- * @param {string} args.outputPath - Explicit absolute path to save the report.
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.output] - Output file path for the report
+ * @param {string} [args.model] - LLM model to use for analysis
  * @param {string|number} [args.threshold] - Minimum complexity score to recommend expansion (1-10)
  * @param {boolean} [args.research] - Use Perplexity AI for research-backed complexity analysis
- * @param {string} [args.ids] - Comma-separated list of task IDs to analyze
- * @param {number} [args.from] - Starting task ID in a range to analyze
- * @param {number} [args.to] - Ending task ID in a range to analyze
- * @param {string} [args.projectRoot] - Project root path.
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @param {Object} [context={}] - Context object containing session data
- * @param {Object} [context.session] - MCP session object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function analyzeTaskComplexityDirect(args, log, context = {}) {
-	const { session } = context;
-	const {
-		tasksJsonPath,
-		outputPath,
-		threshold,
-		research,
-		projectRoot,
-		ids,
-		from,
-		to
-	} = args;
+	const { session } = context; // Only extract session, not reportProgress
 
-	const logWrapper = createLogWrapper(log);
-
-	// --- Initial Checks (remain the same) ---
 	try {
 		log.info(`Analyzing task complexity with args: ${JSON.stringify(args)}`);
 
-		if (!tasksJsonPath) {
-			log.error('analyzeTaskComplexityDirect called without tasksJsonPath');
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
-		if (!outputPath) {
-			log.error('analyzeTaskComplexityDirect called without outputPath');
-			return {
-				success: false,
-				error: { code: 'MISSING_ARGUMENT', message: 'outputPath is required' }
-			};
-		}
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
-		const tasksPath = tasksJsonPath;
-		const resolvedOutputPath = outputPath;
+		// Determine output path
+		let outputPath = args.output || 'scripts/task-complexity-report.json';
+		if (!path.isAbsolute(outputPath) && args.projectRoot) {
+			outputPath = path.join(args.projectRoot, outputPath);
+		}
 
 		log.info(`Analyzing task complexity from: ${tasksPath}`);
-		log.info(`Output report will be saved to: ${resolvedOutputPath}`);
+		log.info(`Output report will be saved to: ${outputPath}`);
 
-		if (ids) {
-			log.info(`Analyzing specific task IDs: ${ids}`);
-		} else if (from || to) {
-			const fromStr = from !== undefined ? from : 'first';
-			const toStr = to !== undefined ? to : 'last';
-			log.info(`Analyzing tasks in range: ${fromStr} to ${toStr}`);
+		if (args.research) {
+			log.info('Using Perplexity AI for research-backed complexity analysis');
 		}
 
-		if (research) {
-			log.info('Using research role for complexity analysis');
-		}
-
-		// Prepare options for the core function - REMOVED mcpLog and session here
-		const coreOptions = {
-			file: tasksJsonPath,
+		// Create options object for analyzeTaskComplexity
+		const options = {
+			file: tasksPath,
 			output: outputPath,
-			threshold: threshold,
-			research: research === true, // Ensure boolean
-			projectRoot: projectRoot, // Pass projectRoot here
-			id: ids, // Pass the ids parameter to the core function as 'id'
-			from: from, // Pass from parameter
-			to: to // Pass to parameter
+			model: args.model,
+			threshold: args.threshold,
+			research: args.research === true
 		};
-		// --- End Initial Checks ---
 
-		// --- Silent Mode and Logger Wrapper ---
+		// Enable silent mode to prevent console logs from interfering with JSON response
 		const wasSilent = isSilentMode();
 		if (!wasSilent) {
-			enableSilentMode(); // Still enable silent mode as a backup
+			enableSilentMode();
 		}
 
-		let report;
-		let coreResult;
+		// Create a logWrapper that matches the expected mcpLog interface as specified in utilities.mdc
+		const logWrapper = {
+			info: (message, ...args) => log.info(message, ...args),
+			warn: (message, ...args) => log.warn(message, ...args),
+			error: (message, ...args) => log.error(message, ...args),
+			debug: (message, ...args) => log.debug && log.debug(message, ...args),
+			success: (message, ...args) => log.info(message, ...args) // Map success to info
+		};
 
 		try {
-			// --- Call Core Function (Pass context separately) ---
-			// Pass coreOptions as the first argument
-			// Pass context object { session, mcpLog } as the second argument
-			coreResult = await analyzeTaskComplexity(coreOptions, {
+			// Call the core function with session and logWrapper as mcpLog
+			await analyzeTaskComplexity(options, {
 				session,
-				mcpLog: logWrapper,
-				commandName: 'analyze-complexity',
-				outputType: 'mcp'
+				mcpLog: logWrapper // Use the wrapper instead of passing log directly
 			});
-			report = coreResult.report;
 		} catch (error) {
-			log.error(
-				`Error in analyzeTaskComplexity core function: ${error.message}`
-			);
-			// Restore logging if we changed it
-			if (!wasSilent && isSilentMode()) {
-				disableSilentMode();
-			}
+			log.error(`Error in analyzeTaskComplexity: ${error.message}`);
 			return {
 				success: false,
 				error: {
-					code: 'ANALYZE_CORE_ERROR',
-					message: `Error running core complexity analysis: ${error.message}`
+					code: 'ANALYZE_ERROR',
+					message: `Error running complexity analysis: ${error.message}`
 				}
 			};
 		} finally {
-			// Always restore normal logging in finally block if we enabled silent mode
-			if (!wasSilent && isSilentMode()) {
+			// Always restore normal logging in finally block, but only if we enabled it
+			if (!wasSilent) {
 				disableSilentMode();
 			}
 		}
 
-		// --- Result Handling (remains largely the same) ---
-		// Verify the report file was created (core function writes it)
-		if (!fs.existsSync(resolvedOutputPath)) {
+		// Verify the report file was created
+		if (!fs.existsSync(outputPath)) {
 			return {
 				success: false,
 				error: {
-					code: 'ANALYZE_REPORT_MISSING', // Specific code
-					message:
-						'Analysis completed but no report file was created at the expected path.'
-				}
-			};
-		}
-
-		if (
-			!coreResult ||
-			!coreResult.report ||
-			typeof coreResult.report !== 'object'
-		) {
-			log.error(
-				'Core analysis function returned an invalid or undefined response.'
-			);
-			return {
-				success: false,
-				error: {
-					code: 'INVALID_CORE_RESPONSE',
-					message: 'Core analysis function returned an invalid response.'
+					code: 'ANALYZE_ERROR',
+					message: 'Analysis completed but no report file was created'
 				}
 			};
 		}
 
+		// Read the report file
+		let report;
 		try {
-			// Ensure complexityAnalysis exists and is an array
-			const analysisArray = Array.isArray(coreResult.report.complexityAnalysis)
-				? coreResult.report.complexityAnalysis
-				: [];
+			report = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
 
-			// Count tasks by complexity (remains the same)
+			// Important: Handle different report formats
+			// The core function might return an array or an object with a complexityAnalysis property
+			const analysisArray = Array.isArray(report)
+				? report
+				: report.complexityAnalysis || [];
+
+			// Count tasks by complexity
 			const highComplexityTasks = analysisArray.filter(
 				(t) => t.complexityScore >= 8
 			).length;
@@ -194,34 +137,30 @@ export async function analyzeTaskComplexityDirect(args, log, context = {}) {
 						highComplexityTasks,
 						mediumComplexityTasks,
 						lowComplexityTasks
-					},
-					fullReport: coreResult.report,
-					telemetryData: coreResult.telemetryData
+					}
 				}
 			};
 		} catch (parseError) {
-			// Should not happen if core function returns object, but good safety check
-			log.error(`Internal error processing report data: ${parseError.message}`);
+			log.error(`Error parsing report file: ${parseError.message}`);
 			return {
 				success: false,
 				error: {
-					code: 'REPORT_PROCESS_ERROR',
-					message: `Internal error processing complexity report: ${parseError.message}`
+					code: 'REPORT_PARSE_ERROR',
+					message: `Error parsing complexity report: ${parseError.message}`
 				}
 			};
 		}
-		// --- End Result Handling ---
 	} catch (error) {
-		// Catch errors from initial checks or path resolution
-		// Make sure to restore normal logging if silent mode was enabled
+		// Make sure to restore normal logging even if there's an error
 		if (isSilentMode()) {
 			disableSilentMode();
 		}
-		log.error(`Error in analyzeTaskComplexityDirect setup: ${error.message}`);
+
+		log.error(`Error in analyzeTaskComplexityDirect: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'DIRECT_FUNCTION_SETUP_ERROR',
+				code: 'CORE_FUNCTION_ERROR',
 				message: error.message
 			}
 		};

mcp-server/src/core/direct-functions/clear-subtasks.js

@@ -3,6 +3,7 @@
  */
 
 import { clearSubtasks } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -12,32 +13,19 @@ import fs from 'fs';
 /**
  * Clear subtasks from specified tasks
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {string} [args.id] - Task IDs (comma-separated) to clear subtasks from
  * @param {boolean} [args.all] - Clear subtasks from all tasks
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function clearSubtasksDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath, id, all } = args;
 	try {
 		log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('clearSubtasksDirect called without tasksJsonPath');
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
-
 		// Either id or all must be provided
-		if (!id && !all) {
+		if (!args.id && !args.all) {
 			return {
 				success: false,
 				error: {
@@ -48,8 +36,8 @@ export async function clearSubtasksDirect(args, log) {
 			};
 		}
 
-		// Use provided path
-		const tasksPath = tasksJsonPath;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Check if tasks.json exists
 		if (!fs.existsSync(tasksPath)) {
@@ -65,7 +53,7 @@ export async function clearSubtasksDirect(args, log) {
 		let taskIds;
 
 		// If all is specified, get all task IDs
-		if (all) {
+		if (args.all) {
 			log.info('Clearing subtasks from all tasks');
 			const data = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
 			if (!data || !data.tasks || data.tasks.length === 0) {
@@ -80,7 +68,7 @@ export async function clearSubtasksDirect(args, log) {
 			taskIds = data.tasks.map((t) => t.id).join(',');
 		} else {
 			// Use the provided task IDs
-			taskIds = id;
+			taskIds = args.id;
 		}
 
 		log.info(`Clearing subtasks from tasks: ${taskIds}`);

mcp-server/src/core/direct-functions/complexity-report.js

@@ -8,32 +8,37 @@ import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
+import path from 'path';
 
 /**
  * Direct function wrapper for displaying the complexity report with error handling and caching.
  *
- * @param {Object} args - Command arguments containing reportPath.
- * @param {string} args.reportPath - Explicit path to the complexity report file.
+ * @param {Object} args - Command arguments containing file path option
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Result object with success status and data/error information
  */
 export async function complexityReportDirect(args, log) {
-	// Destructure expected args
-	const { reportPath } = args;
 	try {
 		log.info(`Getting complexity report with args: ${JSON.stringify(args)}`);
 
-		// Check if reportPath was provided
-		if (!reportPath) {
-			log.error('complexityReportDirect called without reportPath');
-			return {
-				success: false,
-				error: { code: 'MISSING_ARGUMENT', message: 'reportPath is required' },
-				fromCache: false
-			};
+		// Get tasks file path to determine project root for the default report location
+		let tasksPath;
+		try {
+			tasksPath = findTasksJsonPath(args, log);
+		} catch (error) {
+			log.warn(
+				`Tasks file not found, using current directory: ${error.message}`
+			);
+			// Continue with default or specified report path
 		}
 
-		// Use the provided report path
+		// Get report file path from args or use default
+		const reportPath =
+			args.file ||
+			path.join(process.cwd(), 'scripts', 'task-complexity-report.json');
+
 		log.info(`Looking for complexity report at: ${reportPath}`);
 
 		// Generate cache key based on report path
@@ -85,20 +90,30 @@ export async function complexityReportDirect(args, log) {
 
 		// Use the caching utility
 		try {
-			const result = await coreActionFn();
-			log.info('complexityReportDirect completed');
-			return result;
+			const result = await getCachedOrExecute({
+				cacheKey,
+				actionFn: coreActionFn,
+				log
+			});
+			log.info(
+				`complexityReportDirect completed. From cache: ${result.fromCache}`
+			);
+			return result; // Returns { success, data/error, fromCache }
 		} catch (error) {
+			// Catch unexpected errors from getCachedOrExecute itself
 			// Ensure silent mode is disabled
 			disableSilentMode();
 
-			log.error(`Unexpected error during complexityReport: ${error.message}`);
+			log.error(
+				`Unexpected error during getCachedOrExecute for complexityReport: ${error.message}`
+			);
 			return {
 				success: false,
 				error: {
 					code: 'UNEXPECTED_ERROR',
 					message: error.message
-				}
+				},
+				fromCache: false
 			};
 		}
 	} catch (error) {

mcp-server/src/core/direct-functions/expand-all-tasks.js

@@ -5,92 +5,122 @@
 import { expandAllTasks } from '../../../../scripts/modules/task-manager.js';
 import {
 	enableSilentMode,
-	disableSilentMode
+	disableSilentMode,
+	isSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { createLogWrapper } from '../../tools/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+import { getAnthropicClientForMCP } from '../utils/ai-client-utils.js';
+import path from 'path';
+import fs from 'fs';
 
 /**
- * Expand all pending tasks with subtasks (Direct Function Wrapper)
+ * Expand all pending tasks with subtasks
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {number|string} [args.num] - Number of subtasks to generate
- * @param {boolean} [args.research] - Enable research-backed subtask generation
+ * @param {boolean} [args.research] - Enable Perplexity AI for research-backed subtask generation
  * @param {string} [args.prompt] - Additional context to guide subtask generation
  * @param {boolean} [args.force] - Force regeneration of subtasks for tasks that already have them
- * @param {string} [args.projectRoot] - Project root path.
- * @param {Object} log - Logger object from FastMCP
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.projectRoot] - Project root directory
+ * @param {Object} log - Logger object
  * @param {Object} context - Context object containing session
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function expandAllTasksDirect(args, log, context = {}) {
-	const { session } = context; // Extract session
-	// Destructure expected args, including projectRoot
-	const { tasksJsonPath, num, research, prompt, force, projectRoot } = args;
+	const { session } = context; // Only extract session, not reportProgress
 
-	// Create logger wrapper using the utility
-	const mcpLog = createLogWrapper(log);
-
-	if (!tasksJsonPath) {
-		log.error('expandAllTasksDirect called without tasksJsonPath');
-		return {
-			success: false,
-			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'tasksJsonPath is required'
-			}
-		};
-	}
-
-	enableSilentMode(); // Enable silent mode for the core function call
 	try {
-		log.info(
-			`Calling core expandAllTasks with args: ${JSON.stringify({ num, research, prompt, force, projectRoot })}`
-		);
+		log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
 
-		// Parse parameters (ensure correct types)
-		const numSubtasks = num ? parseInt(num, 10) : undefined;
-		const useResearch = research === true;
-		const additionalContext = prompt || '';
-		const forceFlag = force === true;
+		// Enable silent mode early to prevent any console output
+		enableSilentMode();
 
-		// Call the core function, passing options and the context object { session, mcpLog, projectRoot }
-		const result = await expandAllTasks(
-			tasksJsonPath,
-			numSubtasks,
-			useResearch,
-			additionalContext,
-			forceFlag,
-			{ session, mcpLog, projectRoot }
-		);
+		try {
+			// Find the tasks.json path
+			const tasksPath = findTasksJsonPath(args, log);
 
-		// Core function now returns a summary object including the *aggregated* telemetryData
-		return {
-			success: true,
-			data: {
-				message: `Expand all operation completed. Expanded: ${result.expandedCount}, Failed: ${result.failedCount}, Skipped: ${result.skippedCount}`,
-				details: {
-					expandedCount: result.expandedCount,
-					failedCount: result.failedCount,
-					skippedCount: result.skippedCount,
-					tasksToExpand: result.tasksToExpand
-				},
-				telemetryData: result.telemetryData // Pass the aggregated object
+			// Parse parameters
+			const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
+			const useResearch = args.research === true;
+			const additionalContext = args.prompt || '';
+			const forceFlag = args.force === true;
+
+			log.info(
+				`Expanding all tasks with ${numSubtasks || 'default'} subtasks each...`
+			);
+
+			if (useResearch) {
+				log.info('Using Perplexity AI for research-backed subtask generation');
+
+				// Initialize AI client for research-backed expansion
+				try {
+					await getAnthropicClientForMCP(session, log);
+				} catch (error) {
+					// Ensure silent mode is disabled before returning error
+					disableSilentMode();
+
+					log.error(`Failed to initialize AI client: ${error.message}`);
+					return {
+						success: false,
+						error: {
+							code: 'AI_CLIENT_ERROR',
+							message: `Cannot initialize AI client: ${error.message}`
+						}
+					};
+				}
 			}
-		};
-	} catch (error) {
-		// Log the error using the MCP logger
-		log.error(`Error during core expandAllTasks execution: ${error.message}`);
-		// Optionally log stack trace if available and debug enabled
-		// if (error.stack && log.debug) { log.debug(error.stack); }
 
+			if (additionalContext) {
+				log.info(`Additional context: "${additionalContext}"`);
+			}
+			if (forceFlag) {
+				log.info('Force regeneration of subtasks is enabled');
+			}
+
+			// Call the core function with session context for AI operations
+			// and outputFormat as 'json' to prevent UI elements
+			const result = await expandAllTasks(
+				tasksPath,
+				numSubtasks,
+				useResearch,
+				additionalContext,
+				forceFlag,
+				{ mcpLog: log, session },
+				'json' // Use JSON output format to prevent UI elements
+			);
+
+			// The expandAllTasks function now returns a result object
+			return {
+				success: true,
+				data: {
+					message: 'Successfully expanded all pending tasks with subtasks',
+					details: {
+						numSubtasks: numSubtasks,
+						research: useResearch,
+						prompt: additionalContext,
+						force: forceFlag,
+						tasksExpanded: result.expandedCount,
+						totalEligibleTasks: result.tasksToExpand
+					}
+				}
+			};
+		} finally {
+			// Restore normal logging in finally block to ensure it runs even if there's an error
+			disableSilentMode();
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled if an error occurs
+		if (isSilentMode()) {
+			disableSilentMode();
+		}
+
+		log.error(`Error in expandAllTasksDirect: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'CORE_FUNCTION_ERROR', // Or a more specific code if possible
+				code: 'CORE_FUNCTION_ERROR',
 				message: error.message
 			}
 		};
-	} finally {
-		disableSilentMode(); // IMPORTANT: Ensure silent mode is always disabled
 	}
 }

mcp-server/src/core/direct-functions/expand-task.js

@@ -3,7 +3,7 @@
  * Direct function implementation for expanding a task into subtasks
  */
 
-import expandTask from '../../../../scripts/modules/task-manager/expand-task.js';
+import { expandTask } from '../../../../scripts/modules/task-manager.js';
 import {
 	readJSON,
 	writeJSON,
@@ -11,30 +11,24 @@ import {
 	disableSilentMode,
 	isSilentMode
 } from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+import {
+	getAnthropicClientForMCP,
+	getModelConfig
+} from '../utils/ai-client-utils.js';
 import path from 'path';
 import fs from 'fs';
-import { createLogWrapper } from '../../tools/utils.js';
 
 /**
  * Direct function wrapper for expanding a task into subtasks with error handling.
  *
  * @param {Object} args - Command arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
- * @param {string} args.id - The ID of the task to expand.
- * @param {number|string} [args.num] - Number of subtasks to generate.
- * @param {boolean} [args.research] - Enable research role for subtask generation.
- * @param {string} [args.prompt] - Additional context to guide subtask generation.
- * @param {boolean} [args.force] - Force expansion even if subtasks exist.
- * @param {string} [args.projectRoot] - Project root directory.
  * @param {Object} log - Logger object
- * @param {Object} context - Context object containing session
- * @param {Object} [context.session] - MCP Session object
+ * @param {Object} context - Context object containing session and reportProgress
  * @returns {Promise<Object>} - Task expansion result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
 export async function expandTaskDirect(args, log, context = {}) {
-	const { session } = context; // Extract session
-	// Destructure expected args, including projectRoot
-	const { tasksJsonPath, id, num, research, prompt, force, projectRoot } = args;
+	const { session } = context;
 
 	// Log session root data for debugging
 	log.info(
@@ -46,26 +40,48 @@ export async function expandTaskDirect(args, log, context = {}) {
 		})}`
 	);
 
-	// Check if tasksJsonPath was provided
-	if (!tasksJsonPath) {
-		log.error('expandTaskDirect called without tasksJsonPath');
+	let tasksPath;
+	try {
+		// If a direct file path is provided, use it directly
+		if (args.file && fs.existsSync(args.file)) {
+			log.info(
+				`[expandTaskDirect] Using explicitly provided tasks file: ${args.file}`
+			);
+			tasksPath = args.file;
+		} else {
+			// Find the tasks path through standard logic
+			log.info(
+				`[expandTaskDirect] No direct file path provided or file not found at ${args.file}, searching using findTasksJsonPath`
+			);
+			tasksPath = findTasksJsonPath(args, log);
+		}
+	} catch (error) {
+		log.error(
+			`[expandTaskDirect] Error during tasksPath determination: ${error.message}`
+		);
+
+		// Include session roots information in error
+		const sessionRootsInfo = session
+			? `\nSession.roots: ${JSON.stringify(session.roots)}\n` +
+				`Current Working Directory: ${process.cwd()}\n` +
+				`Args.projectRoot: ${args.projectRoot}\n` +
+				`Args.file: ${args.file}\n`
+			: '\nSession object not available';
+
 		return {
 			success: false,
 			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'tasksJsonPath is required'
+				code: 'FILE_NOT_FOUND_ERROR',
+				message: `Error determining tasksPath: ${error.message}${sessionRootsInfo}`
 			},
 			fromCache: false
 		};
 	}
 
-	// Use provided path
-	const tasksPath = tasksJsonPath;
-
-	log.info(`[expandTaskDirect] Using tasksPath: ${tasksPath}`);
+	log.info(`[expandTaskDirect] Determined tasksPath: ${tasksPath}`);
 
 	// Validate task ID
-	const taskId = id ? parseInt(id, 10) : null;
+	const taskId = args.id ? parseInt(args.id, 10) : null;
 	if (!taskId) {
 		log.error('Task ID is required');
 		return {
@@ -79,14 +95,32 @@ export async function expandTaskDirect(args, log, context = {}) {
 	}
 
 	// Process other parameters
-	const numSubtasks = num ? parseInt(num, 10) : undefined;
-	const useResearch = research === true;
-	const additionalContext = prompt || '';
-	const forceFlag = force === true;
+	const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
+	const useResearch = args.research === true;
+	const additionalContext = args.prompt || '';
+
+	// Initialize AI client if needed (for expandTask function)
+	try {
+		// This ensures the AI client is available by checking it
+		if (useResearch) {
+			log.info('Verifying AI client for research-backed expansion');
+			await getAnthropicClientForMCP(session, log);
+		}
+	} catch (error) {
+		log.error(`Failed to initialize AI client: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'AI_CLIENT_ERROR',
+				message: `Cannot initialize AI client: ${error.message}`
+			},
+			fromCache: false
+		};
+	}
 
 	try {
 		log.info(
-			`[expandTaskDirect] Expanding task ${taskId} into ${numSubtasks || 'default'} subtasks. Research: ${useResearch}, Force: ${forceFlag}`
+			`[expandTaskDirect] Expanding task ${taskId} into ${numSubtasks || 'default'} subtasks. Research: ${useResearch}`
 		);
 
 		// Read tasks data
@@ -138,16 +172,15 @@ export async function expandTaskDirect(args, log, context = {}) {
 			};
 		}
 
-		// Check for existing subtasks and force flag
+		// Check for existing subtasks
 		const hasExistingSubtasks = task.subtasks && task.subtasks.length > 0;
-		if (hasExistingSubtasks && !forceFlag) {
-			log.info(
-				`Task ${taskId} already has ${task.subtasks.length} subtasks. Use --force to overwrite.`
-			);
+
+		// If the task already has subtasks, just return it (matching core behavior)
+		if (hasExistingSubtasks) {
+			log.info(`Task ${taskId} already has ${task.subtasks.length} subtasks`);
 			return {
 				success: true,
 				data: {
-					message: `Task ${taskId} already has subtasks. Expansion skipped.`,
 					task,
 					subtasksAdded: 0,
 					hasExistingSubtasks
@@ -156,14 +189,6 @@ export async function expandTaskDirect(args, log, context = {}) {
 			};
 		}
 
-		// If force flag is set, clear existing subtasks
-		if (hasExistingSubtasks && forceFlag) {
-			log.info(
-				`Force flag set. Clearing existing subtasks for task ${taskId}.`
-			);
-			task.subtasks = [];
-		}
-
 		// Keep a copy of the task before modification
 		const originalTask = JSON.parse(JSON.stringify(task));
 
@@ -182,35 +207,23 @@ export async function expandTaskDirect(args, log, context = {}) {
 		// Save tasks.json with potentially empty subtasks array
 		writeJSON(tasksPath, data);
 
-		// Create logger wrapper using the utility
-		const mcpLog = createLogWrapper(log);
-
-		let wasSilent; // Declare wasSilent outside the try block
 		// Process the request
 		try {
 			// Enable silent mode to prevent console logs from interfering with JSON response
-			wasSilent = isSilentMode(); // Assign inside the try block
-			if (!wasSilent) enableSilentMode();
+			enableSilentMode();
 
-			// Call the core expandTask function with the wrapped logger and projectRoot
-			const coreResult = await expandTask(
+			// Call expandTask with session context to ensure AI client is properly initialized
+			const result = await expandTask(
 				tasksPath,
 				taskId,
 				numSubtasks,
 				useResearch,
 				additionalContext,
-				{
-					mcpLog,
-					session,
-					projectRoot,
-					commandName: 'expand-task',
-					outputType: 'mcp'
-				},
-				forceFlag
+				{ mcpLog: log, session } // Only pass mcpLog and session, NOT reportProgress
 			);
 
 			// Restore normal logging
-			if (!wasSilent && isSilentMode()) disableSilentMode();
+			disableSilentMode();
 
 			// Read the updated data
 			const updatedData = readJSON(tasksPath);
@@ -221,23 +234,22 @@ export async function expandTaskDirect(args, log, context = {}) {
 				? updatedTask.subtasks.length - subtasksCountBefore
 				: 0;
 
-			// Return the result, including telemetryData
+			// Return the result
 			log.info(
 				`Successfully expanded task ${taskId} with ${subtasksAdded} new subtasks`
 			);
 			return {
 				success: true,
 				data: {
-					task: coreResult.task,
+					task: updatedTask,
 					subtasksAdded,
-					hasExistingSubtasks,
-					telemetryData: coreResult.telemetryData
+					hasExistingSubtasks
 				},
 				fromCache: false
 			};
 		} catch (error) {
 			// Make sure to restore normal logging even if there's an error
-			if (!wasSilent && isSilentMode()) disableSilentMode();
+			disableSilentMode();
 
 			log.error(`Error expanding task: ${error.message}`);
 			return {

mcp-server/src/core/direct-functions/fix-dependencies.js

@@ -3,6 +3,7 @@
  */
 
 import { fixDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -12,30 +13,17 @@ import fs from 'fs';
 /**
  * Fix invalid dependencies in tasks.json automatically
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function fixDependenciesDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath } = args;
 	try {
-		log.info(`Fixing invalid dependencies in tasks: ${tasksJsonPath}`);
+		log.info(`Fixing invalid dependencies in tasks...`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('fixDependenciesDirect called without tasksJsonPath');
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
-
-		// Use provided path
-		const tasksPath = tasksJsonPath;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Verify the file exists
 		if (!fs.existsSync(tasksPath)) {
@@ -51,7 +39,7 @@ export async function fixDependenciesDirect(args, log) {
 		// Enable silent mode to prevent console logs from interfering with JSON response
 		enableSilentMode();
 
-		// Call the original command function using the provided path
+		// Call the original command function
 		await fixDependenciesCommand(tasksPath);
 
 		// Restore normal logging

mcp-server/src/core/direct-functions/generate-task-files.js

@@ -8,45 +8,40 @@ import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+import path from 'path';
 
 /**
  * Direct function wrapper for generateTaskFiles with error handling.
  *
- * @param {Object} args - Command arguments containing tasksJsonPath and outputDir.
+ * @param {Object} args - Command arguments containing file and output path options.
  * @param {Object} log - Logger object.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function generateTaskFilesDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath, outputDir } = args;
 	try {
 		log.info(`Generating task files with args: ${JSON.stringify(args)}`);
 
-		// Check if paths were provided
-		if (!tasksJsonPath) {
-			const errorMessage = 'tasksJsonPath is required but was not provided.';
-			log.error(errorMessage);
+		// Get tasks file path
+		let tasksPath;
+		try {
+			tasksPath = findTasksJsonPath(args, log);
+		} catch (error) {
+			log.error(`Error finding tasks file: ${error.message}`);
 			return {
 				success: false,
-				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
 				fromCache: false
 			};
 		}
+
+		// Get output directory (defaults to the same directory as the tasks file)
+		let outputDir = args.output;
 		if (!outputDir) {
-			const errorMessage = 'outputDir is required but was not provided.';
-			log.error(errorMessage);
-			return {
-				success: false,
-				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
-				fromCache: false
-			};
+			outputDir = path.dirname(tasksPath);
 		}
 
-		// Use the provided paths
-		const tasksPath = tasksJsonPath;
-		const resolvedOutputDir = outputDir;
-
-		log.info(`Generating task files from ${tasksPath} to ${resolvedOutputDir}`);
+		log.info(`Generating task files from ${tasksPath} to ${outputDir}`);
 
 		// Execute core generateTaskFiles function in a separate try/catch
 		try {
@@ -54,7 +49,7 @@ export async function generateTaskFilesDirect(args, log) {
 			enableSilentMode();
 
 			// The function is synchronous despite being awaited elsewhere
-			generateTaskFiles(tasksPath, resolvedOutputDir);
+			generateTaskFiles(tasksPath, outputDir);
 
 			// Restore normal logging after task generation
 			disableSilentMode();
@@ -75,8 +70,8 @@ export async function generateTaskFilesDirect(args, log) {
 			success: true,
 			data: {
 				message: `Successfully generated task files`,
-				tasksPath: tasksPath,
-				outputDir: resolvedOutputDir,
+				tasksPath,
+				outputDir,
 				taskFiles:
 					'Individual task files have been generated in the output directory'
 			},

mcp-server/src/core/direct-functions/initialize-project.js

@@ -1,104 +0,0 @@
-import { initializeProject } from '../../../../scripts/init.js'; // Import core function and its logger if needed separately
-import {
-	enableSilentMode,
-	disableSilentMode
-	// isSilentMode // Not used directly here
-} from '../../../../scripts/modules/utils.js';
-import os from 'os'; // Import os module for home directory check
-
-/**
- * Direct function wrapper for initializing a project.
- * Derives target directory from session, sets CWD, and calls core init logic.
- * @param {object} args - Arguments containing initialization options (addAliases, skipInstall, yes, projectRoot)
- * @param {object} log - The FastMCP logger instance.
- * @param {object} context - The context object, must contain { session }.
- * @returns {Promise<{success: boolean, data?: any, error?: {code: string, message: string}}>} - Standard result object.
- */
-export async function initializeProjectDirect(args, log, context = {}) {
-	const { session } = context; // Keep session if core logic needs it
-	const homeDir = os.homedir();
-
-	log.info(`Args received in direct function: ${JSON.stringify(args)}`);
-
-	// --- Determine Target Directory ---
-	// TRUST the projectRoot passed from the tool layer via args
-	// The HOF in the tool layer already normalized and validated it came from a reliable source (args or session)
-	const targetDirectory = args.projectRoot;
-
-	// --- Validate the targetDirectory (basic sanity checks) ---
-	if (
-		!targetDirectory ||
-		typeof targetDirectory !== 'string' || // Ensure it's a string
-		targetDirectory === '/' ||
-		targetDirectory === homeDir
-	) {
-		log.error(
-			`Invalid target directory received from tool layer: '${targetDirectory}'`
-		);
-		return {
-			success: false,
-			error: {
-				code: 'INVALID_TARGET_DIRECTORY',
-				message: `Cannot initialize project: Invalid target directory '${targetDirectory}' received. Please ensure a valid workspace/folder is open or specified.`,
-				details: `Received args.projectRoot: ${args.projectRoot}` // Show what was received
-			},
-			fromCache: false
-		};
-	}
-
-	// --- Proceed with validated targetDirectory ---
-	log.info(`Validated target directory for initialization: ${targetDirectory}`);
-
-	const originalCwd = process.cwd();
-	let resultData;
-	let success = false;
-	let errorResult = null;
-
-	log.info(
-		`Temporarily changing CWD to ${targetDirectory} for initialization.`
-	);
-	process.chdir(targetDirectory); // Change CWD to the HOF-provided root
-
-	enableSilentMode();
-	try {
-		// Construct options ONLY from the relevant flags in args
-		// The core initializeProject operates in the current CWD, which we just set
-		const options = {
-			aliases: args.addAliases,
-			skipInstall: args.skipInstall,
-			yes: true // Force yes mode
-		};
-
-		log.info(`Initializing project with options: ${JSON.stringify(options)}`);
-		const result = await initializeProject(options); // Call core logic
-
-		resultData = {
-			message: 'Project initialized successfully.',
-			next_step:
-				'Now that the project is initialized, the next step is to create the tasks by parsing a PRD. This will create the tasks folder and the initial task files (tasks folder will be created when parse-prd is run). The parse-prd tool will require a prd.txt file as input (typically found in the project root directory, scripts/ directory). You can create a prd.txt file by asking the user about their idea, and then using the scripts/example_prd.txt file as a template to genrate a prd.txt file in scripts/. You may skip all of this if the user already has a prd.txt file. You can THEN use the parse-prd tool to create the tasks. So: step 1 after initialization is to create a prd.txt file in scripts/prd.txt or confirm the user already has one. Step 2 is to use the parse-prd tool to create the tasks. Do not bother looking for tasks after initialization, just use the parse-prd tool to create the tasks after creating a prd.txt from which to parse the tasks. You do NOT need to reinitialize the project to parse-prd.',
-			...result
-		};
-		success = true;
-		log.info(
-			`Project initialization completed successfully in ${targetDirectory}.`
-		);
-	} catch (error) {
-		log.error(`Core initializeProject failed: ${error.message}`);
-		errorResult = {
-			code: 'INITIALIZATION_FAILED',
-			message: `Core project initialization failed: ${error.message}`,
-			details: error.stack
-		};
-		success = false;
-	} finally {
-		disableSilentMode();
-		log.info(`Restoring original CWD: ${originalCwd}`);
-		process.chdir(originalCwd);
-	}
-
-	if (success) {
-		return { success: true, data: resultData, fromCache: false };
-	} else {
-		return { success: false, error: errorResult, fromCache: false };
-	}
-}

mcp-server/src/core/direct-functions/list-tasks.js

@@ -4,6 +4,8 @@
  */
 
 import { listTasks } from '../../../../scripts/modules/task-manager.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -12,29 +14,38 @@ import {
 /**
  * Direct function wrapper for listTasks with error handling and caching.
  *
- * @param {Object} args - Command arguments (now expecting tasksJsonPath explicitly).
+ * @param {Object} args - Command arguments (projectRoot is expected to be resolved).
  * @param {Object} log - Logger object.
  * @returns {Promise<Object>} - Task list result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }.
  */
 export async function listTasksDirect(args, log) {
-	// Destructure the explicit tasksJsonPath from args
-	const { tasksJsonPath, reportPath, status, withSubtasks } = args;
-
-	if (!tasksJsonPath) {
-		log.error('listTasksDirect called without tasksJsonPath');
+	let tasksPath;
+	try {
+		// Find the tasks path first - needed for cache key and execution
+		tasksPath = findTasksJsonPath(args, log);
+	} catch (error) {
+		if (error.code === 'TASKS_FILE_NOT_FOUND') {
+			log.error(`Tasks file not found: ${error.message}`);
+			// Return the error structure expected by the calling tool/handler
+			return {
+				success: false,
+				error: { code: error.code, message: error.message },
+				fromCache: false
+			};
+		}
+		log.error(`Unexpected error finding tasks file: ${error.message}`);
+		// Re-throw for outer catch or return structured error
 		return {
 			success: false,
-			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'tasksJsonPath is required'
-			},
+			error: { code: 'FIND_TASKS_PATH_ERROR', message: error.message },
 			fromCache: false
 		};
 	}
 
-	// Use the explicit tasksJsonPath for cache key
-	const statusFilter = status || 'all';
-	const withSubtasksFilter = withSubtasks || false;
+	// Generate cache key *after* finding tasksPath
+	const statusFilter = args.status || 'all';
+	const withSubtasks = args.withSubtasks || false;
+	const cacheKey = `listTasks:${tasksPath}:${statusFilter}:${withSubtasks}`;
 
 	// Define the action function to be executed on cache miss
 	const coreListTasksAction = async () => {
@@ -43,14 +54,12 @@ export async function listTasksDirect(args, log) {
 			enableSilentMode();
 
 			log.info(
-				`Executing core listTasks function for path: ${tasksJsonPath}, filter: ${statusFilter}, subtasks: ${withSubtasksFilter}`
+				`Executing core listTasks function for path: ${tasksPath}, filter: ${statusFilter}, subtasks: ${withSubtasks}`
 			);
-			// Pass the explicit tasksJsonPath to the core function
 			const resultData = listTasks(
-				tasksJsonPath,
+				tasksPath,
 				statusFilter,
-				reportPath,
-				withSubtasksFilter,
+				withSubtasks,
 				'json'
 			);
 
@@ -64,7 +73,6 @@ export async function listTasksDirect(args, log) {
 					}
 				};
 			}
-
 			log.info(
 				`Core listTasks function retrieved ${resultData.tasks.length} tasks`
 			);
@@ -88,19 +96,25 @@ export async function listTasksDirect(args, log) {
 		}
 	};
 
+	// Use the caching utility
 	try {
-		const result = await coreListTasksAction();
-		log.info('listTasksDirect completed');
-		return result;
+		const result = await getCachedOrExecute({
+			cacheKey,
+			actionFn: coreListTasksAction,
+			log
+		});
+		log.info(`listTasksDirect completed. From cache: ${result.fromCache}`);
+		return result; // Returns { success, data/error, fromCache }
 	} catch (error) {
-		log.error(`Unexpected error during listTasks: ${error.message}`);
+		// Catch unexpected errors from getCachedOrExecute itself (though unlikely)
+		log.error(
+			`Unexpected error during getCachedOrExecute for listTasks: ${error.message}`
+		);
 		console.error(error.stack);
 		return {
 			success: false,
-			error: {
-				code: 'UNEXPECTED_ERROR',
-				message: error.message
-			}
+			error: { code: 'CACHE_UTIL_ERROR', message: error.message },
+			fromCache: false
 		};
 	}
 }

mcp-server/src/core/direct-functions/models.js

@@ -1,121 +0,0 @@
-/**
- * models.js
- * Direct function for managing AI model configurations via MCP
- */
-
-import {
-	getModelConfiguration,
-	getAvailableModelsList,
-	setModel
-} from '../../../../scripts/modules/task-manager/models.js';
-import {
-	enableSilentMode,
-	disableSilentMode
-} from '../../../../scripts/modules/utils.js';
-import { createLogWrapper } from '../../tools/utils.js';
-
-/**
- * Get or update model configuration
- * @param {Object} args - Arguments passed by the MCP tool
- * @param {Object} log - MCP logger
- * @param {Object} context - MCP context (contains session)
- * @returns {Object} Result object with success, data/error fields
- */
-export async function modelsDirect(args, log, context = {}) {
-	const { session } = context;
-	const { projectRoot } = args; // Extract projectRoot from args
-
-	// Create a logger wrapper that the core functions can use
-	const mcpLog = createLogWrapper(log);
-
-	log.info(`Executing models_direct with args: ${JSON.stringify(args)}`);
-	log.info(`Using project root: ${projectRoot}`);
-
-	// Validate flags: cannot use both openrouter and ollama simultaneously
-	if (args.openrouter && args.ollama) {
-		log.error(
-			'Error: Cannot use both openrouter and ollama flags simultaneously.'
-		);
-		return {
-			success: false,
-			error: {
-				code: 'INVALID_ARGS',
-				message: 'Cannot use both openrouter and ollama flags simultaneously.'
-			}
-		};
-	}
-
-	try {
-		enableSilentMode();
-
-		try {
-			// Check for the listAvailableModels flag
-			if (args.listAvailableModels === true) {
-				return await getAvailableModelsList({
-					session,
-					mcpLog,
-					projectRoot // Pass projectRoot to function
-				});
-			}
-
-			// Handle setting a specific model
-			if (args.setMain) {
-				return await setModel('main', args.setMain, {
-					session,
-					mcpLog,
-					projectRoot, // Pass projectRoot to function
-					providerHint: args.openrouter
-						? 'openrouter'
-						: args.ollama
-							? 'ollama'
-							: undefined // Pass hint
-				});
-			}
-
-			if (args.setResearch) {
-				return await setModel('research', args.setResearch, {
-					session,
-					mcpLog,
-					projectRoot, // Pass projectRoot to function
-					providerHint: args.openrouter
-						? 'openrouter'
-						: args.ollama
-							? 'ollama'
-							: undefined // Pass hint
-				});
-			}
-
-			if (args.setFallback) {
-				return await setModel('fallback', args.setFallback, {
-					session,
-					mcpLog,
-					projectRoot, // Pass projectRoot to function
-					providerHint: args.openrouter
-						? 'openrouter'
-						: args.ollama
-							? 'ollama'
-							: undefined // Pass hint
-				});
-			}
-
-			// Default action: get current configuration
-			return await getModelConfiguration({
-				session,
-				mcpLog,
-				projectRoot // Pass projectRoot to function
-			});
-		} finally {
-			disableSilentMode();
-		}
-	} catch (error) {
-		log.error(`Error in models_direct: ${error.message}`);
-		return {
-			success: false,
-			error: {
-				code: 'DIRECT_FUNCTION_ERROR',
-				message: error.message,
-				details: error.stack
-			}
-		};
-	}
-}

mcp-server/src/core/direct-functions/move-task.js

@@ -1,99 +0,0 @@
-/**
- * Direct function wrapper for moveTask
- */
-
-import { moveTask } from '../../../../scripts/modules/task-manager.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
-import {
-	enableSilentMode,
-	disableSilentMode
-} from '../../../../scripts/modules/utils.js';
-
-/**
- * Move a task or subtask to a new position
- * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file
- * @param {string} args.sourceId - ID of the task/subtask to move (e.g., '5' or '5.2')
- * @param {string} args.destinationId - ID of the destination (e.g., '7' or '7.3')
- * @param {string} args.file - Alternative path to the tasks.json file
- * @param {string} args.projectRoot - Project root directory
- * @param {Object} log - Logger object
- * @returns {Promise<{success: boolean, data?: Object, error?: Object}>}
- */
-export async function moveTaskDirect(args, log, context = {}) {
-	const { session } = context;
-
-	// Validate required parameters
-	if (!args.sourceId) {
-		return {
-			success: false,
-			error: {
-				message: 'Source ID is required',
-				code: 'MISSING_SOURCE_ID'
-			}
-		};
-	}
-
-	if (!args.destinationId) {
-		return {
-			success: false,
-			error: {
-				message: 'Destination ID is required',
-				code: 'MISSING_DESTINATION_ID'
-			}
-		};
-	}
-
-	try {
-		// Find tasks.json path if not provided
-		let tasksPath = args.tasksJsonPath || args.file;
-		if (!tasksPath) {
-			if (!args.projectRoot) {
-				return {
-					success: false,
-					error: {
-						message:
-							'Project root is required if tasksJsonPath is not provided',
-						code: 'MISSING_PROJECT_ROOT'
-					}
-				};
-			}
-			tasksPath = findTasksJsonPath(args, log);
-		}
-
-		// Enable silent mode to prevent console output during MCP operation
-		enableSilentMode();
-
-		// Call the core moveTask function, always generate files
-		const result = await moveTask(
-			tasksPath,
-			args.sourceId,
-			args.destinationId,
-			true
-		);
-
-		// Restore console output
-		disableSilentMode();
-
-		return {
-			success: true,
-			data: {
-				movedTask: result.movedTask,
-				message: `Successfully moved task/subtask ${args.sourceId} to ${args.destinationId}`
-			}
-		};
-	} catch (error) {
-		// Restore console output in case of error
-		disableSilentMode();
-
-		log.error(`Failed to move task: ${error.message}`);
-
-		return {
-			success: false,
-			error: {
-				message: error.message,
-				code: 'MOVE_TASK_ERROR'
-			}
-		};
-	}
-}

mcp-server/src/core/direct-functions/next-task.js

@@ -4,10 +4,9 @@
  */
 
 import { findNextTask } from '../../../../scripts/modules/task-manager.js';
-import {
-	readJSON,
-	readComplexityReport
-} from '../../../../scripts/modules/utils.js';
+import { readJSON } from '../../../../scripts/modules/utils.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -17,52 +16,51 @@ import {
  * Direct function wrapper for finding the next task to work on with error handling and caching.
  *
  * @param {Object} args - Command arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Next task result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
 export async function nextTaskDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath, reportPath } = args;
-
-	if (!tasksJsonPath) {
-		log.error('nextTaskDirect called without tasksJsonPath');
+	let tasksPath;
+	try {
+		// Find the tasks path first - needed for cache key and execution
+		tasksPath = findTasksJsonPath(args, log);
+	} catch (error) {
+		log.error(`Tasks file not found: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'tasksJsonPath is required'
+				code: 'FILE_NOT_FOUND_ERROR',
+				message: error.message
 			},
 			fromCache: false
 		};
 	}
 
+	// Generate cache key using task path
+	const cacheKey = `nextTask:${tasksPath}`;
+
 	// Define the action function to be executed on cache miss
 	const coreNextTaskAction = async () => {
 		try {
 			// Enable silent mode to prevent console logs from interfering with JSON response
 			enableSilentMode();
 
-			log.info(`Finding next task from ${tasksJsonPath}`);
+			log.info(`Finding next task from ${tasksPath}`);
 
-			// Read tasks data using the provided path
-			const data = readJSON(tasksJsonPath);
+			// Read tasks data
+			const data = readJSON(tasksPath);
 			if (!data || !data.tasks) {
-				disableSilentMode(); // Disable before return
 				return {
 					success: false,
 					error: {
 						code: 'INVALID_TASKS_FILE',
-						message: `No valid tasks found in ${tasksJsonPath}`
+						message: `No valid tasks found in ${tasksPath}`
 					}
 				};
 			}
 
-			// Read the complexity report
-			const complexityReport = readComplexityReport(reportPath);
-
 			// Find the next task
-			const nextTask = findNextTask(data.tasks, complexityReport);
+			const nextTask = findNextTask(data.tasks);
 
 			if (!nextTask) {
 				log.info(
@@ -73,34 +71,24 @@ export async function nextTaskDirect(args, log) {
 					data: {
 						message:
 							'No eligible next task found. All tasks are either completed or have unsatisfied dependencies',
-						nextTask: null
+						nextTask: null,
+						allTasks: data.tasks
 					}
 				};
 			}
 
-			// Check if it's a subtask
-			const isSubtask =
-				typeof nextTask.id === 'string' && nextTask.id.includes('.');
-
-			const taskOrSubtask = isSubtask ? 'subtask' : 'task';
-
-			const additionalAdvice = isSubtask
-				? 'Subtasks can be updated with timestamped details as you implement them. This is useful for tracking progress, marking milestones and insights (of successful or successive falures in attempting to implement the subtask). Research can be used when updating the subtask to collect up-to-date information, and can be helpful to solve a repeating problem the agent is unable to solve. It is a good idea to get-task the parent task to collect the overall context of the task, and to get-task the subtask to collect the specific details of the subtask.'
-				: 'Tasks can be updated to reflect a change in the direction of the task, or to reformulate the task per your prompt. Research can be used when updating the task to collect up-to-date information. It is best to update subtasks as you work on them, and to update the task for more high-level changes that may affect pending subtasks or the general direction of the task.';
-
 			// Restore normal logging
 			disableSilentMode();
 
 			// Return the next task data with the full tasks array for reference
 			log.info(
-				`Successfully found next task ${nextTask.id}: ${nextTask.title}. Is subtask: ${isSubtask}`
+				`Successfully found next task ${nextTask.id}: ${nextTask.title}`
 			);
 			return {
 				success: true,
 				data: {
 					nextTask,
-					isSubtask,
-					nextSteps: `When ready to work on the ${taskOrSubtask}, use set-status to set the status to "in progress" ${additionalAdvice}`
+					allTasks: data.tasks
 				}
 			};
 		} catch (error) {
@@ -120,11 +108,18 @@ export async function nextTaskDirect(args, log) {
 
 	// Use the caching utility
 	try {
-		const result = await coreNextTaskAction();
-		log.info(`nextTaskDirect completed.`);
-		return result;
+		const result = await getCachedOrExecute({
+			cacheKey,
+			actionFn: coreNextTaskAction,
+			log
+		});
+		log.info(`nextTaskDirect completed. From cache: ${result.fromCache}`);
+		return result; // Returns { success, data/error, fromCache }
 	} catch (error) {
-		log.error(`Unexpected error during nextTask: ${error.message}`);
+		// Catch unexpected errors from getCachedOrExecute itself
+		log.error(
+			`Unexpected error during getCachedOrExecute for nextTask: ${error.message}`
+		);
 		return {
 			success: false,
 			error: {

mcp-server/src/core/direct-functions/parse-prd.js

@@ -6,188 +6,173 @@
 import path from 'path';
 import fs from 'fs';
 import { parsePRD } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
-	disableSilentMode,
-	isSilentMode
+	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { createLogWrapper } from '../../tools/utils.js';
-import { getDefaultNumTasks } from '../../../../scripts/modules/config-manager.js';
+import {
+	getAnthropicClientForMCP,
+	getModelConfig
+} from '../utils/ai-client-utils.js';
 
 /**
  * Direct function wrapper for parsing PRD documents and generating tasks.
  *
- * @param {Object} args - Command arguments containing projectRoot, input, output, numTasks options.
+ * @param {Object} args - Command arguments containing input, numTasks or tasks, and output options.
  * @param {Object} log - Logger object.
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function parsePRDDirect(args, log, context = {}) {
-	const { session } = context;
-	// Extract projectRoot from args
-	const {
-		input: inputArg,
-		output: outputArg,
-		numTasks: numTasksArg,
-		force,
-		append,
-		research,
-		projectRoot
-	} = args;
-
-	// Create the standard logger wrapper
-	const logWrapper = createLogWrapper(log);
-
-	// --- Input Validation and Path Resolution ---
-	if (!projectRoot) {
-		logWrapper.error('parsePRDDirect requires a projectRoot argument.');
-		return {
-			success: false,
-			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'projectRoot is required.'
-			}
-		};
-	}
-	if (!inputArg) {
-		logWrapper.error('parsePRDDirect called without input path');
-		return {
-			success: false,
-			error: { code: 'MISSING_ARGUMENT', message: 'Input path is required' }
-		};
-	}
-
-	// Resolve input and output paths relative to projectRoot
-	const inputPath = path.resolve(projectRoot, inputArg);
-	const outputPath = outputArg
-		? path.resolve(projectRoot, outputArg)
-		: path.resolve(projectRoot, 'tasks', 'tasks.json'); // Default output path
-
-	// Check if input file exists
-	if (!fs.existsSync(inputPath)) {
-		const errorMsg = `Input PRD file not found at resolved path: ${inputPath}`;
-		logWrapper.error(errorMsg);
-		return {
-			success: false,
-			error: { code: 'FILE_NOT_FOUND', message: errorMsg }
-		};
-	}
-
-	const outputDir = path.dirname(outputPath);
-	try {
-		if (!fs.existsSync(outputDir)) {
-			logWrapper.info(`Creating output directory: ${outputDir}`);
-			fs.mkdirSync(outputDir, { recursive: true });
-		}
-	} catch (dirError) {
-		logWrapper.error(
-			`Failed to create output directory ${outputDir}: ${dirError.message}`
-		);
-		// Return an error response immediately if dir creation fails
-		return {
-			success: false,
-			error: {
-				code: 'DIRECTORY_CREATION_ERROR',
-				message: `Failed to create output directory: ${dirError.message}`
-			}
-		};
-	}
-
-	let numTasks = getDefaultNumTasks(projectRoot);
-	if (numTasksArg) {
-		numTasks =
-			typeof numTasksArg === 'string' ? parseInt(numTasksArg, 10) : numTasksArg;
-		if (isNaN(numTasks) || numTasks <= 0) {
-			// Ensure positive number
-			numTasks = getDefaultNumTasks(projectRoot); // Fallback to default if parsing fails or invalid
-			logWrapper.warn(
-				`Invalid numTasks value: ${numTasksArg}. Using default: ${numTasks}`
-			);
-		}
-	}
-
-	if (append) {
-		logWrapper.info('Append mode enabled.');
-		if (force) {
-			logWrapper.warn(
-				'Both --force and --append flags were provided. --force takes precedence; append mode will be ignored.'
-			);
-		}
-	}
-
-	if (research) {
-		logWrapper.info(
-			'Research mode enabled. Using Perplexity AI for enhanced PRD analysis.'
-		);
-	}
-
-	logWrapper.info(
-		`Parsing PRD via direct function. Input: ${inputPath}, Output: ${outputPath}, NumTasks: ${numTasks}, Force: ${force}, Append: ${append}, Research: ${research}, ProjectRoot: ${projectRoot}`
-	);
-
-	const wasSilent = isSilentMode();
-	if (!wasSilent) {
-		enableSilentMode();
-	}
+	const { session } = context; // Only extract session, not reportProgress
 
 	try {
-		// Call the core parsePRD function
-		const result = await parsePRD(
-			inputPath,
-			outputPath,
-			numTasks,
-			{
-				session,
-				mcpLog: logWrapper,
-				projectRoot,
-				force,
-				append,
-				research,
-				commandName: 'parse-prd',
-				outputType: 'mcp'
-			},
-			'json'
-		);
+		log.info(`Parsing PRD document with args: ${JSON.stringify(args)}`);
 
-		// Adjust check for the new return structure
-		if (result && result.success) {
-			const successMsg = `Successfully parsed PRD and generated tasks in ${result.tasksPath}`;
-			logWrapper.success(successMsg);
-			return {
-				success: true,
-				data: {
-					message: successMsg,
-					outputPath: result.tasksPath,
-					telemetryData: result.telemetryData
-				}
-			};
-		} else {
-			// Handle case where core function didn't return expected success structure
-			logWrapper.error(
-				'Core parsePRD function did not return a successful structure.'
-			);
+		// Initialize AI client for PRD parsing
+		let aiClient;
+		try {
+			aiClient = getAnthropicClientForMCP(session, log);
+		} catch (error) {
+			log.error(`Failed to initialize AI client: ${error.message}`);
 			return {
 				success: false,
 				error: {
-					code: 'CORE_FUNCTION_ERROR',
-					message:
-						result?.message ||
-						'Core function failed to parse PRD or returned unexpected result.'
-				}
+					code: 'AI_CLIENT_ERROR',
+					message: `Cannot initialize AI client: ${error.message}`
+				},
+				fromCache: false
 			};
 		}
+
+		// Parameter validation and path resolution
+		if (!args.input) {
+			const errorMessage =
+				'No input file specified. Please provide an input PRD document path.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_INPUT_FILE', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Resolve input path (relative to project root if provided)
+		const projectRoot = args.projectRoot || process.cwd();
+		const inputPath = path.isAbsolute(args.input)
+			? args.input
+			: path.resolve(projectRoot, args.input);
+
+		// Determine output path
+		let outputPath;
+		if (args.output) {
+			outputPath = path.isAbsolute(args.output)
+				? args.output
+				: path.resolve(projectRoot, args.output);
+		} else {
+			// Default to tasks/tasks.json in the project root
+			outputPath = path.resolve(projectRoot, 'tasks', 'tasks.json');
+		}
+
+		// Verify input file exists
+		if (!fs.existsSync(inputPath)) {
+			const errorMessage = `Input file not found: ${inputPath}`;
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'INPUT_FILE_NOT_FOUND', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Parse number of tasks - handle both string and number values
+		let numTasks = 10; // Default
+		if (args.numTasks) {
+			numTasks =
+				typeof args.numTasks === 'string'
+					? parseInt(args.numTasks, 10)
+					: args.numTasks;
+			if (isNaN(numTasks)) {
+				numTasks = 10; // Fallback to default if parsing fails
+				log.warn(`Invalid numTasks value: ${args.numTasks}. Using default: 10`);
+			}
+		}
+
+		log.info(
+			`Preparing to parse PRD from ${inputPath} and output to ${outputPath} with ${numTasks} tasks`
+		);
+
+		// Create the logger wrapper for proper logging in the core function
+		const logWrapper = {
+			info: (message, ...args) => log.info(message, ...args),
+			warn: (message, ...args) => log.warn(message, ...args),
+			error: (message, ...args) => log.error(message, ...args),
+			debug: (message, ...args) => log.debug && log.debug(message, ...args),
+			success: (message, ...args) => log.info(message, ...args) // Map success to info
+		};
+
+		// Get model config from session
+		const modelConfig = getModelConfig(session);
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+		try {
+			// Execute core parsePRD function with AI client
+			await parsePRD(
+				inputPath,
+				outputPath,
+				numTasks,
+				{
+					mcpLog: logWrapper,
+					session
+				},
+				aiClient,
+				modelConfig
+			);
+
+			// Since parsePRD doesn't return a value but writes to a file, we'll read the result
+			// to return it to the caller
+			if (fs.existsSync(outputPath)) {
+				const tasksData = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+				log.info(
+					`Successfully parsed PRD and generated ${tasksData.tasks?.length || 0} tasks`
+				);
+
+				return {
+					success: true,
+					data: {
+						message: `Successfully generated ${tasksData.tasks?.length || 0} tasks from PRD`,
+						taskCount: tasksData.tasks?.length || 0,
+						outputPath
+					},
+					fromCache: false // This operation always modifies state and should never be cached
+				};
+			} else {
+				const errorMessage = `Tasks file was not created at ${outputPath}`;
+				log.error(errorMessage);
+				return {
+					success: false,
+					error: { code: 'OUTPUT_FILE_NOT_CREATED', message: errorMessage },
+					fromCache: false
+				};
+			}
+		} finally {
+			// Always restore normal logging
+			disableSilentMode();
+		}
 	} catch (error) {
-		logWrapper.error(`Error executing core parsePRD: ${error.message}`);
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error parsing PRD: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'PARSE_PRD_CORE_ERROR',
+				code: 'PARSE_PRD_ERROR',
 				message: error.message || 'Unknown error parsing PRD'
-			}
+			},
+			fromCache: false
 		};
-	} finally {
-		if (!wasSilent && isSilentMode()) {
-			disableSilentMode();
-		}
 	}
 }

mcp-server/src/core/direct-functions/remove-dependency.js

@@ -3,6 +3,7 @@
  */
 
 import { removeDependency } from '../../../../scripts/modules/dependency-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -11,32 +12,19 @@ import {
 /**
  * Remove a dependency from a task
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {string|number} args.id - Task ID to remove dependency from
  * @param {string|number} args.dependsOn - Task ID to remove as a dependency
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function removeDependencyDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath, id, dependsOn } = args;
 	try {
 		log.info(`Removing dependency with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('removeDependencyDirect called without tasksJsonPath');
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
-
 		// Validate required parameters
-		if (!id) {
+		if (!args.id) {
 			return {
 				success: false,
 				error: {
@@ -46,7 +34,7 @@ export async function removeDependencyDirect(args, log) {
 			};
 		}
 
-		if (!dependsOn) {
+		if (!args.dependsOn) {
 			return {
 				success: false,
 				error: {
@@ -56,16 +44,18 @@ export async function removeDependencyDirect(args, log) {
 			};
 		}
 
-		// Use provided path
-		const tasksPath = tasksJsonPath;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Format IDs for the core function
 		const taskId =
-			id && id.includes && id.includes('.') ? id : parseInt(id, 10);
+			args.id.includes && args.id.includes('.')
+				? args.id
+				: parseInt(args.id, 10);
 		const dependencyId =
-			dependsOn && dependsOn.includes && dependsOn.includes('.')
-				? dependsOn
-				: parseInt(dependsOn, 10);
+			args.dependsOn.includes && args.dependsOn.includes('.')
+				? args.dependsOn
+				: parseInt(args.dependsOn, 10);
 
 		log.info(
 			`Removing dependency: task ${taskId} no longer depends on ${dependencyId}`
@@ -74,7 +64,7 @@ export async function removeDependencyDirect(args, log) {
 		// Enable silent mode to prevent console logs from interfering with JSON response
 		enableSilentMode();
 
-		// Call the core function using the provided tasksPath
+		// Call the core function
 		await removeDependency(tasksPath, taskId, dependencyId);
 
 		// Restore normal logging

mcp-server/src/core/direct-functions/remove-subtask.js

@@ -3,6 +3,7 @@
  */
 
 import { removeSubtask } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -11,37 +12,22 @@ import {
 /**
  * Remove a subtask from its parent task
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
  * @param {string} args.id - Subtask ID in format "parentId.subtaskId" (required)
  * @param {boolean} [args.convert] - Whether to convert the subtask to a standalone task
+ * @param {string} [args.file] - Path to the tasks file
  * @param {boolean} [args.skipGenerate] - Skip regenerating task files
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function removeSubtaskDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath, id, convert, skipGenerate } = args;
 	try {
 		// Enable silent mode to prevent console logs from interfering with JSON response
 		enableSilentMode();
 
 		log.info(`Removing subtask with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('removeSubtaskDirect called without tasksJsonPath');
-			disableSilentMode(); // Disable before returning
-			return {
-				success: false,
-				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
-				}
-			};
-		}
-
-		if (!id) {
-			disableSilentMode(); // Disable before returning
+		if (!args.id) {
 			return {
 				success: false,
 				error: {
@@ -53,34 +39,32 @@ export async function removeSubtaskDirect(args, log) {
 		}
 
 		// Validate subtask ID format
-		if (!id.includes('.')) {
-			disableSilentMode(); // Disable before returning
+		if (!args.id.includes('.')) {
 			return {
 				success: false,
 				error: {
 					code: 'INPUT_VALIDATION_ERROR',
-					message: `Invalid subtask ID format: ${id}. Expected format: "parentId.subtaskId"`
+					message: `Invalid subtask ID format: ${args.id}. Expected format: "parentId.subtaskId"`
 				}
 			};
 		}
 
-		// Use provided path
-		const tasksPath = tasksJsonPath;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Convert convertToTask to a boolean
-		const convertToTask = convert === true;
+		const convertToTask = args.convert === true;
 
 		// Determine if we should generate files
-		const generateFiles = !skipGenerate;
+		const generateFiles = !args.skipGenerate;
 
 		log.info(
-			`Removing subtask ${id} (convertToTask: ${convertToTask}, generateFiles: ${generateFiles})`
+			`Removing subtask ${args.id} (convertToTask: ${convertToTask}, generateFiles: ${generateFiles})`
 		);
 
-		// Use the provided tasksPath
 		const result = await removeSubtask(
 			tasksPath,
-			id,
+			args.id,
 			convertToTask,
 			generateFiles
 		);
@@ -93,7 +77,7 @@ export async function removeSubtaskDirect(args, log) {
 			return {
 				success: true,
 				data: {
-					message: `Subtask ${id} successfully converted to task #${result.id}`,
+					message: `Subtask ${args.id} successfully converted to task #${result.id}`,
 					task: result
 				}
 			};
@@ -102,7 +86,7 @@ export async function removeSubtaskDirect(args, log) {
 			return {
 				success: true,
 				data: {
-					message: `Subtask ${id} successfully removed`
+					message: `Subtask ${args.id} successfully removed`
 				}
 			};
 		}

mcp-server/src/core/direct-functions/remove-task.js

@@ -3,45 +3,41 @@
  * Direct function implementation for removing a task
  */
 
-import {
-	removeTask,
-	taskExists
-} from '../../../../scripts/modules/task-manager.js';
+import { removeTask } from '../../../../scripts/modules/task-manager.js';
 import {
 	enableSilentMode,
-	disableSilentMode,
-	readJSON
+	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 
 /**
  * Direct function wrapper for removeTask with error handling.
- * Supports removing multiple tasks at once with comma-separated IDs.
  *
  * @param {Object} args - Command arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
- * @param {string} args.id - The ID(s) of the task(s) or subtask(s) to remove (comma-separated for multiple).
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Remove task result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: false }
  */
 export async function removeTaskDirect(args, log) {
-	// Destructure expected args
-	const { tasksJsonPath, id } = args;
 	try {
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			log.error('removeTaskDirect called without tasksJsonPath');
+		// Find the tasks path first
+		let tasksPath;
+		try {
+			tasksPath = findTasksJsonPath(args, log);
+		} catch (error) {
+			log.error(`Tasks file not found: ${error.message}`);
 			return {
 				success: false,
 				error: {
-					code: 'MISSING_ARGUMENT',
-					message: 'tasksJsonPath is required'
+					code: 'FILE_NOT_FOUND_ERROR',
+					message: error.message
 				},
 				fromCache: false
 			};
 		}
 
 		// Validate task ID parameter
-		if (!id) {
+		const taskId = args.id;
+		if (!taskId) {
 			log.error('Task ID is required');
 			return {
 				success: false,
@@ -53,103 +49,46 @@ export async function removeTaskDirect(args, log) {
 			};
 		}
 
-		// Split task IDs if comma-separated
-		const taskIdArray = id.split(',').map((taskId) => taskId.trim());
-
-		log.info(
-			`Removing ${taskIdArray.length} task(s) with ID(s): ${taskIdArray.join(', ')} from ${tasksJsonPath}`
-		);
-
-		// Validate all task IDs exist before proceeding
-		const data = readJSON(tasksJsonPath);
-		if (!data || !data.tasks) {
-			return {
-				success: false,
-				error: {
-					code: 'INVALID_TASKS_FILE',
-					message: `No valid tasks found in ${tasksJsonPath}`
-				},
-				fromCache: false
-			};
-		}
-
-		const invalidTasks = taskIdArray.filter(
-			(taskId) => !taskExists(data.tasks, taskId)
-		);
-
-		if (invalidTasks.length > 0) {
-			return {
-				success: false,
-				error: {
-					code: 'INVALID_TASK_ID',
-					message: `The following tasks were not found: ${invalidTasks.join(', ')}`
-				},
-				fromCache: false
-			};
-		}
-
-		// Remove tasks one by one
-		const results = [];
-
-		// Enable silent mode to prevent console logs from interfering with JSON response
-		enableSilentMode();
+		// Skip confirmation in the direct function since it's handled by the client
+		log.info(`Removing task with ID: ${taskId} from ${tasksPath}`);
 
 		try {
-			for (const taskId of taskIdArray) {
-				try {
-					const result = await removeTask(tasksJsonPath, taskId);
-					results.push({
-						taskId,
-						success: true,
-						message: result.message,
-						removedTask: result.removedTask
-					});
-					log.info(`Successfully removed task: ${taskId}`);
-				} catch (error) {
-					results.push({
-						taskId,
-						success: false,
-						error: error.message
-					});
-					log.error(`Error removing task ${taskId}: ${error.message}`);
-				}
-			}
-		} finally {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
+
+			// Call the core removeTask function
+			const result = await removeTask(tasksPath, taskId);
+
 			// Restore normal logging
 			disableSilentMode();
-		}
 
-		// Check if all tasks were successfully removed
-		const successfulRemovals = results.filter((r) => r.success);
-		const failedRemovals = results.filter((r) => !r.success);
+			log.info(`Successfully removed task: ${taskId}`);
 
-		if (successfulRemovals.length === 0) {
-			// All removals failed
+			// Return the result
+			return {
+				success: true,
+				data: {
+					message: result.message,
+					taskId: taskId,
+					tasksPath: tasksPath,
+					removedTask: result.removedTask
+				},
+				fromCache: false
+			};
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+
+			log.error(`Error removing task: ${error.message}`);
 			return {
 				success: false,
 				error: {
-					code: 'REMOVE_TASK_ERROR',
-					message: 'Failed to remove any tasks',
-					details: failedRemovals
-						.map((r) => `${r.taskId}: ${r.error}`)
-						.join('; ')
+					code: error.code || 'REMOVE_TASK_ERROR',
+					message: error.message || 'Failed to remove task'
 				},
 				fromCache: false
 			};
 		}
-
-		// At least some tasks were removed successfully
-		return {
-			success: true,
-			data: {
-				totalTasks: taskIdArray.length,
-				successful: successfulRemovals.length,
-				failed: failedRemovals.length,
-				results: results,
-				tasksPath: tasksJsonPath
-			},
-			fromCache: false
-		};
 	} catch (error) {
 		// Ensure silent mode is disabled even if an outer error occurs
 		disableSilentMode();

mcp-server/src/core/direct-functions/set-task-status.js

@@ -4,38 +4,26 @@
  */
 
 import { setTaskStatus } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode,
 	isSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { nextTaskDirect } from './next-task.js';
+
 /**
  * Direct function wrapper for setTaskStatus with error handling.
  *
- * @param {Object} args - Command arguments containing id, status and tasksJsonPath.
+ * @param {Object} args - Command arguments containing id, status and file path options.
  * @param {Object} log - Logger object.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function setTaskStatusDirect(args, log) {
-	// Destructure expected args, including the resolved tasksJsonPath
-	const { tasksJsonPath, id, status, complexityReportPath } = args;
 	try {
 		log.info(`Setting task status with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			const errorMessage = 'tasksJsonPath is required but was not provided.';
-			log.error(errorMessage);
-			return {
-				success: false,
-				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
-				fromCache: false
-			};
-		}
-
-		// Check required parameters (id and status)
-		if (!id) {
+		// Check required parameters
+		if (!args.id) {
 			const errorMessage =
 				'No task ID specified. Please provide a task ID to update.';
 			log.error(errorMessage);
@@ -46,7 +34,7 @@ export async function setTaskStatusDirect(args, log) {
 			};
 		}
 
-		if (!status) {
+		if (!args.status) {
 			const errorMessage =
 				'No status specified. Please provide a new status value.';
 			log.error(errorMessage);
@@ -57,16 +45,32 @@ export async function setTaskStatusDirect(args, log) {
 			};
 		}
 
-		// Use the provided path
-		const tasksPath = tasksJsonPath;
+		// Get tasks file path
+		let tasksPath;
+		try {
+			// The enhanced findTasksJsonPath will now search in parent directories if needed
+			tasksPath = findTasksJsonPath(args, log);
+			log.info(`Found tasks file at: ${tasksPath}`);
+		} catch (error) {
+			log.error(`Error finding tasks file: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'TASKS_FILE_ERROR',
+					message: `${error.message}\n\nPlease ensure you are in a Task Master project directory or use the --project-root parameter to specify the path to your project.`
+				},
+				fromCache: false
+			};
+		}
 
 		// Execute core setTaskStatus function
-		const taskId = id;
-		const newStatus = status;
+		const taskId = args.id;
+		const newStatus = args.status;
 
 		log.info(`Setting task ${taskId} status to "${newStatus}"`);
 
 		// Call the core function with proper silent mode handling
+		let result;
 		enableSilentMode(); // Enable silent mode before calling core function
 		try {
 			// Call the core function
@@ -75,53 +79,19 @@ export async function setTaskStatusDirect(args, log) {
 			log.info(`Successfully set task ${taskId} status to ${newStatus}`);
 
 			// Return success data
-			const result = {
+			result = {
 				success: true,
 				data: {
 					message: `Successfully updated task ${taskId} status to "${newStatus}"`,
 					taskId,
 					status: newStatus,
-					tasksPath: tasksPath // Return the path used
+					tasksPath
 				},
 				fromCache: false // This operation always modifies state and should never be cached
 			};
-
-			// If the task was completed, attempt to fetch the next task
-			if (result.data.status === 'done') {
-				try {
-					log.info(`Attempting to fetch next task for task ${taskId}`);
-					const nextResult = await nextTaskDirect(
-						{
-							tasksJsonPath: tasksJsonPath,
-							reportPath: complexityReportPath
-						},
-						log
-					);
-
-					if (nextResult.success) {
-						log.info(
-							`Successfully retrieved next task: ${nextResult.data.nextTask}`
-						);
-						result.data = {
-							...result.data,
-							nextTask: nextResult.data.nextTask,
-							isNextSubtask: nextResult.data.isSubtask,
-							nextSteps: nextResult.data.nextSteps
-						};
-					} else {
-						log.warn(
-							`Failed to retrieve next task: ${nextResult.error?.message || 'Unknown error'}`
-						);
-					}
-				} catch (nextErr) {
-					log.error(`Error retrieving next task: ${nextErr.message}`);
-				}
-			}
-
-			return result;
 		} catch (error) {
 			log.error(`Error setting task status: ${error.message}`);
-			return {
+			result = {
 				success: false,
 				error: {
 					code: 'SET_STATUS_ERROR',
@@ -133,6 +103,8 @@ export async function setTaskStatusDirect(args, log) {
 			// ALWAYS restore normal logging in finally block
 			disableSilentMode();
 		}
+
+		return result;
 	} catch (error) {
 		// Ensure silent mode is disabled if there was an uncaught error in the outer try block
 		if (isSilentMode()) {

mcp-server/src/core/direct-functions/show-task.js

@@ -3,103 +3,139 @@
  * Direct function implementation for showing task details
  */
 
-import {
-	findTaskById,
-	readComplexityReport,
-	readJSON
-} from '../../../../scripts/modules/utils.js';
+import { findTaskById } from '../../../../scripts/modules/utils.js';
+import { readJSON } from '../../../../scripts/modules/utils.js';
+import { getCachedOrExecute } from '../../tools/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
- * Direct function wrapper for getting task details.
+ * Direct function wrapper for showing task details with error handling and caching.
  *
- * @param {Object} args - Command arguments.
- * @param {string} args.id - Task ID to show.
- * @param {string} [args.file] - Optional path to the tasks file (passed to findTasksJsonPath).
- * @param {string} args.reportPath - Explicit path to the complexity report file.
- * @param {string} [args.status] - Optional status to filter subtasks by.
- * @param {string} args.projectRoot - Absolute path to the project root directory (already normalized by tool).
- * @param {Object} log - Logger object.
- * @param {Object} context - Context object containing session data.
- * @returns {Promise<Object>} - Result object with success status and data/error information.
+ * @param {Object} args - Command arguments
+ * @param {Object} log - Logger object
+ * @returns {Promise<Object>} - Task details result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
 export async function showTaskDirect(args, log) {
-	// Destructure session from context if needed later, otherwise ignore
-	// const { session } = context;
-	// Destructure projectRoot and other args. projectRoot is assumed normalized.
-	const { id, file, reportPath, status, projectRoot } = args;
-
-	log.info(
-		`Showing task direct function. ID: ${id}, File: ${file}, Status Filter: ${status}, ProjectRoot: ${projectRoot}`
-	);
-
-	// --- Path Resolution using the passed (already normalized) projectRoot ---
-	let tasksJsonPath;
+	let tasksPath;
 	try {
-		// Use the projectRoot passed directly from args
-		tasksJsonPath = findTasksJsonPath(
-			{ projectRoot: projectRoot, file: file },
-			log
-		);
-		log.info(`Resolved tasks path: ${tasksJsonPath}`);
+		// Find the tasks path first - needed for cache key and execution
+		tasksPath = findTasksJsonPath(args, log);
 	} catch (error) {
-		log.error(`Error finding tasks.json: ${error.message}`);
+		log.error(`Tasks file not found: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'TASKS_FILE_NOT_FOUND',
-				message: `Failed to find tasks.json: ${error.message}`
-			}
+				code: 'FILE_NOT_FOUND_ERROR',
+				message: error.message
+			},
+			fromCache: false
 		};
 	}
-	// --- End Path Resolution ---
 
-	// --- Rest of the function remains the same, using tasksJsonPath ---
-	try {
-		const tasksData = readJSON(tasksJsonPath);
-		if (!tasksData || !tasksData.tasks) {
+	// Validate task ID
+	const taskId = args.id;
+	if (!taskId) {
+		log.error('Task ID is required');
+		return {
+			success: false,
+			error: {
+				code: 'INPUT_VALIDATION_ERROR',
+				message: 'Task ID is required'
+			},
+			fromCache: false
+		};
+	}
+
+	// Generate cache key using task path and ID
+	const cacheKey = `showTask:${tasksPath}:${taskId}`;
+
+	// Define the action function to be executed on cache miss
+	const coreShowTaskAction = async () => {
+		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
+
+			log.info(`Retrieving task details for ID: ${taskId} from ${tasksPath}`);
+
+			// Read tasks data
+			const data = readJSON(tasksPath);
+			if (!data || !data.tasks) {
+				return {
+					success: false,
+					error: {
+						code: 'INVALID_TASKS_FILE',
+						message: `No valid tasks found in ${tasksPath}`
+					}
+				};
+			}
+
+			// Find the specific task
+			const task = findTaskById(data.tasks, taskId);
+
+			if (!task) {
+				return {
+					success: false,
+					error: {
+						code: 'TASK_NOT_FOUND',
+						message: `Task with ID ${taskId} not found`
+					}
+				};
+			}
+
+			// Restore normal logging
+			disableSilentMode();
+
+			// Return the task data with the full tasks array for reference
+			// (needed for formatDependenciesWithStatus function in UI)
+			log.info(`Successfully found task ${taskId}`);
 			return {
-				success: false,
-				error: { code: 'INVALID_TASKS_DATA', message: 'Invalid tasks data' }
+				success: true,
+				data: {
+					task,
+					allTasks: data.tasks
+				}
 			};
-		}
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
 
-		const complexityReport = readComplexityReport(reportPath);
-
-		const { task, originalSubtaskCount } = findTaskById(
-			tasksData.tasks,
-			id,
-			complexityReport,
-			status
-		);
-
-		if (!task) {
+			log.error(`Error showing task: ${error.message}`);
 			return {
 				success: false,
 				error: {
-					code: 'TASK_NOT_FOUND',
-					message: `Task or subtask with ID ${id} not found`
+					code: 'CORE_FUNCTION_ERROR',
+					message: error.message || 'Failed to show task details'
 				}
 			};
 		}
+	};
 
-		log.info(`Successfully retrieved task ${id}.`);
-
-		const returnData = { ...task };
-		if (originalSubtaskCount !== null) {
-			returnData._originalSubtaskCount = originalSubtaskCount;
-			returnData._subtaskFilter = status;
-		}
-
-		return { success: true, data: returnData };
+	// Use the caching utility
+	try {
+		const result = await getCachedOrExecute({
+			cacheKey,
+			actionFn: coreShowTaskAction,
+			log
+		});
+		log.info(`showTaskDirect completed. From cache: ${result.fromCache}`);
+		return result; // Returns { success, data/error, fromCache }
 	} catch (error) {
-		log.error(`Error showing task ${id}: ${error.message}`);
+		// Catch unexpected errors from getCachedOrExecute itself
+		disableSilentMode();
+		log.error(
+			`Unexpected error during getCachedOrExecute for showTask: ${error.message}`
+		);
 		return {
 			success: false,
 			error: {
-				code: 'TASK_OPERATION_ERROR',
+				code: 'UNEXPECTED_ERROR',
 				message: error.message
-			}
+			},
+			fromCache: false
 		};
 	}
 }

mcp-server/src/core/direct-functions/update-subtask-by-id.js

@@ -6,63 +6,44 @@
 import { updateSubtaskById } from '../../../../scripts/modules/task-manager.js';
 import {
 	enableSilentMode,
-	disableSilentMode,
-	isSilentMode
+	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { createLogWrapper } from '../../tools/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+import {
+	getAnthropicClientForMCP,
+	getPerplexityClientForMCP
+} from '../utils/ai-client-utils.js';
 
 /**
  * Direct function wrapper for updateSubtaskById with error handling.
  *
- * @param {Object} args - Command arguments containing id, prompt, useResearch, tasksJsonPath, and projectRoot.
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
- * @param {string} args.id - Subtask ID in format "parent.sub".
- * @param {string} args.prompt - Information to append to the subtask.
- * @param {boolean} [args.research] - Whether to use research role.
- * @param {string} [args.projectRoot] - Project root path.
+ * @param {Object} args - Command arguments containing id, prompt, useResearch and file path options.
  * @param {Object} log - Logger object.
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function updateSubtaskByIdDirect(args, log, context = {}) {
-	const { session } = context;
-	// Destructure expected args, including projectRoot
-	const { tasksJsonPath, id, prompt, research, projectRoot } = args;
-
-	const logWrapper = createLogWrapper(log);
+	const { session } = context; // Only extract session, not reportProgress
 
 	try {
-		logWrapper.info(
-			`Updating subtask by ID via direct function. ID: ${id}, ProjectRoot: ${projectRoot}`
-		);
+		log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			const errorMessage = 'tasksJsonPath is required but was not provided.';
-			logWrapper.error(errorMessage);
+		// Check required parameters
+		if (!args.id) {
+			const errorMessage =
+				'No subtask ID specified. Please provide a subtask ID to update.';
+			log.error(errorMessage);
 			return {
 				success: false,
-				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
+				error: { code: 'MISSING_SUBTASK_ID', message: errorMessage },
 				fromCache: false
 			};
 		}
 
-		// Basic validation for ID format (e.g., '5.2')
-		if (!id || typeof id !== 'string' || !id.includes('.')) {
+		if (!args.prompt) {
 			const errorMessage =
-				'Invalid subtask ID format. Must be in format "parentId.subtaskId" (e.g., "5.2").';
-			logWrapper.error(errorMessage);
-			return {
-				success: false,
-				error: { code: 'INVALID_SUBTASK_ID', message: errorMessage },
-				fromCache: false
-			};
-		}
-
-		if (!prompt) {
-			const errorMessage =
-				'No prompt specified. Please provide the information to append.';
-			logWrapper.error(errorMessage);
+				'No prompt specified. Please provide a prompt with information to add to the subtask.';
+			log.error(errorMessage);
 			return {
 				success: false,
 				error: { code: 'MISSING_PROMPT', message: errorMessage },
@@ -71,7 +52,7 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 		}
 
 		// Validate subtask ID format
-		const subtaskId = id;
+		const subtaskId = args.id;
 		if (typeof subtaskId !== 'string' && typeof subtaskId !== 'number') {
 			const errorMessage = `Invalid subtask ID type: ${typeof subtaskId}. Subtask ID must be a string or number.`;
 			log.error(errorMessage);
@@ -93,87 +74,118 @@ export async function updateSubtaskByIdDirect(args, log, context = {}) {
 			};
 		}
 
-		// Use the provided path
-		const tasksPath = tasksJsonPath;
-		const useResearch = research === true;
+		// Get tasks file path
+		let tasksPath;
+		try {
+			tasksPath = findTasksJsonPath(args, log);
+		} catch (error) {
+			log.error(`Error finding tasks file: ${error.message}`);
+			return {
+				success: false,
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
+				fromCache: false
+			};
+		}
+
+		// Get research flag
+		const useResearch = args.research === true;
 
 		log.info(
-			`Updating subtask with ID ${subtaskIdStr} with prompt "${prompt}" and research: ${useResearch}`
+			`Updating subtask with ID ${subtaskIdStr} with prompt "${args.prompt}" and research: ${useResearch}`
 		);
 
-		const wasSilent = isSilentMode();
-		if (!wasSilent) {
-			enableSilentMode();
+		// Initialize the appropriate AI client based on research flag
+		try {
+			if (useResearch) {
+				// Initialize Perplexity client
+				await getPerplexityClientForMCP(session);
+			} else {
+				// Initialize Anthropic client
+				await getAnthropicClientForMCP(session);
+			}
+		} catch (error) {
+			log.error(`AI client initialization error: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'AI_CLIENT_ERROR',
+					message: error.message || 'Failed to initialize AI client'
+				},
+				fromCache: false
+			};
 		}
 
 		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
+
+			// Create a logger wrapper object to handle logging without breaking the mcpLog[level] calls
+			// This ensures outputFormat is set to 'json' while still supporting proper logging
+			const logWrapper = {
+				info: (message) => log.info(message),
+				warn: (message) => log.warn(message),
+				error: (message) => log.error(message),
+				debug: (message) => log.debug && log.debug(message),
+				success: (message) => log.info(message) // Map success to info if needed
+			};
+
 			// Execute core updateSubtaskById function
-			const coreResult = await updateSubtaskById(
+			// Pass both session and logWrapper as mcpLog to ensure outputFormat is 'json'
+			const updatedSubtask = await updateSubtaskById(
 				tasksPath,
 				subtaskIdStr,
-				prompt,
+				args.prompt,
 				useResearch,
 				{
-					mcpLog: logWrapper,
 					session,
-					projectRoot,
-					commandName: 'update-subtask',
-					outputType: 'mcp'
-				},
-				'json'
+					mcpLog: logWrapper
+				}
 			);
 
-			if (!coreResult || coreResult.updatedSubtask === null) {
-				const message = `Subtask ${id} or its parent task not found.`;
-				logWrapper.error(message);
+			// Restore normal logging
+			disableSilentMode();
+
+			// Handle the case where the subtask couldn't be updated (e.g., already marked as done)
+			if (!updatedSubtask) {
 				return {
 					success: false,
-					error: { code: 'SUBTASK_NOT_FOUND', message: message },
+					error: {
+						code: 'SUBTASK_UPDATE_FAILED',
+						message:
+							'Failed to update subtask. It may be marked as completed, or another error occurred.'
+					},
 					fromCache: false
 				};
 			}
 
-			// Subtask updated successfully
-			const successMessage = `Successfully updated subtask with ID ${subtaskIdStr}`;
-			logWrapper.success(successMessage);
+			// Return the updated subtask information
 			return {
 				success: true,
 				data: {
 					message: `Successfully updated subtask with ID ${subtaskIdStr}`,
 					subtaskId: subtaskIdStr,
 					parentId: subtaskIdStr.split('.')[0],
-					subtask: coreResult.updatedSubtask,
+					subtask: updatedSubtask,
 					tasksPath,
-					useResearch,
-					telemetryData: coreResult.telemetryData
+					useResearch
 				},
-				fromCache: false
+				fromCache: false // This operation always modifies state and should never be cached
 			};
 		} catch (error) {
-			logWrapper.error(`Error updating subtask by ID: ${error.message}`);
-			return {
-				success: false,
-				error: {
-					code: 'UPDATE_SUBTASK_CORE_ERROR',
-					message: error.message || 'Unknown error updating subtask'
-				},
-				fromCache: false
-			};
-		} finally {
-			if (!wasSilent && isSilentMode()) {
-				disableSilentMode();
-			}
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+			throw error; // Rethrow to be caught by outer catch block
 		}
 	} catch (error) {
-		logWrapper.error(
-			`Setup error in updateSubtaskByIdDirect: ${error.message}`
-		);
-		if (isSilentMode()) disableSilentMode();
+		// Ensure silent mode is disabled
+		disableSilentMode();
+
+		log.error(`Error updating subtask by ID: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'DIRECT_FUNCTION_SETUP_ERROR',
-				message: error.message || 'Unknown setup error'
+				code: 'UPDATE_SUBTASK_ERROR',
+				message: error.message || 'Unknown error updating subtask'
 			},
 			fromCache: false
 		};

mcp-server/src/core/direct-functions/update-task-by-id.js

@@ -4,54 +4,35 @@
  */
 
 import { updateTaskById } from '../../../../scripts/modules/task-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
-	disableSilentMode,
-	isSilentMode
+	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
-import { createLogWrapper } from '../../tools/utils.js';
+import {
+	getAnthropicClientForMCP,
+	getPerplexityClientForMCP
+} from '../utils/ai-client-utils.js';
 
 /**
  * Direct function wrapper for updateTaskById with error handling.
  *
- * @param {Object} args - Command arguments containing id, prompt, useResearch, tasksJsonPath, and projectRoot.
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
- * @param {string} args.id - Task ID (or subtask ID like "1.2").
- * @param {string} args.prompt - New information/context prompt.
- * @param {boolean} [args.research] - Whether to use research role.
- * @param {string} [args.projectRoot] - Project root path.
+ * @param {Object} args - Command arguments containing id, prompt, useResearch and file path options.
  * @param {Object} log - Logger object.
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function updateTaskByIdDirect(args, log, context = {}) {
-	const { session } = context;
-	// Destructure expected args, including projectRoot
-	const { tasksJsonPath, id, prompt, research, projectRoot } = args;
-
-	const logWrapper = createLogWrapper(log);
+	const { session } = context; // Only extract session, not reportProgress
 
 	try {
-		logWrapper.info(
-			`Updating task by ID via direct function. ID: ${id}, ProjectRoot: ${projectRoot}`
-		);
+		log.info(`Updating task with args: ${JSON.stringify(args)}`);
 
-		// Check if tasksJsonPath was provided
-		if (!tasksJsonPath) {
-			const errorMessage = 'tasksJsonPath is required but was not provided.';
-			logWrapper.error(errorMessage);
-			return {
-				success: false,
-				error: { code: 'MISSING_ARGUMENT', message: errorMessage },
-				fromCache: false
-			};
-		}
-
-		// Check required parameters (id and prompt)
-		if (!id) {
+		// Check required parameters
+		if (!args.id) {
 			const errorMessage =
 				'No task ID specified. Please provide a task ID to update.';
-			logWrapper.error(errorMessage);
+			log.error(errorMessage);
 			return {
 				success: false,
 				error: { code: 'MISSING_TASK_ID', message: errorMessage },
@@ -59,10 +40,10 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 			};
 		}
 
-		if (!prompt) {
+		if (!args.prompt) {
 			const errorMessage =
 				'No prompt specified. Please provide a prompt with new information for the task update.';
-			logWrapper.error(errorMessage);
+			log.error(errorMessage);
 			return {
 				success: false,
 				error: { code: 'MISSING_PROMPT', message: errorMessage },
@@ -72,16 +53,16 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 
 		// Parse taskId - handle both string and number values
 		let taskId;
-		if (typeof id === 'string') {
+		if (typeof args.id === 'string') {
 			// Handle subtask IDs (e.g., "5.2")
-			if (id.includes('.')) {
-				taskId = id; // Keep as string for subtask IDs
+			if (args.id.includes('.')) {
+				taskId = args.id; // Keep as string for subtask IDs
 			} else {
 				// Parse as integer for main task IDs
-				taskId = parseInt(id, 10);
+				taskId = parseInt(args.id, 10);
 				if (isNaN(taskId)) {
-					const errorMessage = `Invalid task ID: ${id}. Task ID must be a positive integer or subtask ID (e.g., "5.2").`;
-					logWrapper.error(errorMessage);
+					const errorMessage = `Invalid task ID: ${args.id}. Task ID must be a positive integer or subtask ID (e.g., "5.2").`;
+					log.error(errorMessage);
 					return {
 						success: false,
 						error: { code: 'INVALID_TASK_ID', message: errorMessage },
@@ -90,97 +71,113 @@ export async function updateTaskByIdDirect(args, log, context = {}) {
 				}
 			}
 		} else {
-			taskId = id;
+			taskId = args.id;
 		}
 
-		// Use the provided path
-		const tasksPath = tasksJsonPath;
+		// Get tasks file path
+		let tasksPath;
+		try {
+			tasksPath = findTasksJsonPath(args, log);
+		} catch (error) {
+			log.error(`Error finding tasks file: ${error.message}`);
+			return {
+				success: false,
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
+				fromCache: false
+			};
+		}
 
 		// Get research flag
-		const useResearch = research === true;
+		const useResearch = args.research === true;
 
-		logWrapper.info(
-			`Updating task with ID ${taskId} with prompt "${prompt}" and research: ${useResearch}`
-		);
-
-		const wasSilent = isSilentMode();
-		if (!wasSilent) {
-			enableSilentMode();
+		// Initialize appropriate AI client based on research flag
+		let aiClient;
+		try {
+			if (useResearch) {
+				log.info('Using Perplexity AI for research-backed task update');
+				aiClient = await getPerplexityClientForMCP(session, log);
+			} else {
+				log.info('Using Claude AI for task update');
+				aiClient = getAnthropicClientForMCP(session, log);
+			}
+		} catch (error) {
+			log.error(`Failed to initialize AI client: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'AI_CLIENT_ERROR',
+					message: `Cannot initialize AI client: ${error.message}`
+				},
+				fromCache: false
+			};
 		}
 
+		log.info(
+			`Updating task with ID ${taskId} with prompt "${args.prompt}" and research: ${useResearch}`
+		);
+
 		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
+
+			// Create a logger wrapper that matches what updateTaskById expects
+			const logWrapper = {
+				info: (message) => log.info(message),
+				warn: (message) => log.warn(message),
+				error: (message) => log.error(message),
+				debug: (message) => log.debug && log.debug(message),
+				success: (message) => log.info(message) // Map success to info since many loggers don't have success
+			};
+
 			// Execute core updateTaskById function with proper parameters
-			const coreResult = await updateTaskById(
+			await updateTaskById(
 				tasksPath,
 				taskId,
-				prompt,
+				args.prompt,
 				useResearch,
 				{
-					mcpLog: logWrapper,
-					session,
-					projectRoot,
-					commandName: 'update-task',
-					outputType: 'mcp'
+					mcpLog: logWrapper, // Use our wrapper object that has the expected method structure
+					session
 				},
 				'json'
 			);
 
-			// Check if the core function returned null or an object without success
-			if (!coreResult || coreResult.updatedTask === null) {
-				// Core function logs the reason, just return success with info
-				const message = `Task ${taskId} was not updated (likely already completed).`;
-				logWrapper.info(message);
-				return {
-					success: true,
-					data: {
-						message: message,
-						taskId: taskId,
-						updated: false,
-						telemetryData: coreResult?.telemetryData
-					},
-					fromCache: false
-				};
-			}
-
-			// Task was updated successfully
-			const successMessage = `Successfully updated task with ID ${taskId} based on the prompt`;
-			logWrapper.success(successMessage);
+			// Since updateTaskById doesn't return a value but modifies the tasks file,
+			// we'll return a success message
 			return {
 				success: true,
 				data: {
-					message: successMessage,
-					taskId: taskId,
-					tasksPath: tasksPath,
-					useResearch: useResearch,
-					updated: true,
-					updatedTask: coreResult.updatedTask,
-					telemetryData: coreResult.telemetryData
+					message: `Successfully updated task with ID ${taskId} based on the prompt`,
+					taskId,
+					tasksPath,
+					useResearch
 				},
-				fromCache: false
+				fromCache: false // This operation always modifies state and should never be cached
 			};
 		} catch (error) {
-			logWrapper.error(`Error updating task by ID: ${error.message}`);
+			log.error(`Error updating task by ID: ${error.message}`);
 			return {
 				success: false,
 				error: {
-					code: 'UPDATE_TASK_CORE_ERROR',
+					code: 'UPDATE_TASK_ERROR',
 					message: error.message || 'Unknown error updating task'
 				},
 				fromCache: false
 			};
 		} finally {
-			if (!wasSilent && isSilentMode()) {
-				disableSilentMode();
-			}
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
 		}
 	} catch (error) {
-		logWrapper.error(`Setup error in updateTaskByIdDirect: ${error.message}`);
-		if (isSilentMode()) disableSilentMode();
+		// Ensure silent mode is disabled
+		disableSilentMode();
+
+		log.error(`Error updating task by ID: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'DIRECT_FUNCTION_SETUP_ERROR',
-				message: error.message || 'Unknown setup error'
+				code: 'UPDATE_TASK_ERROR',
+				message: error.message || 'Unknown error updating task'
 			},
 			fromCache: false
 		};

mcp-server/src/core/direct-functions/update-tasks.js

@@ -1,128 +1,180 @@
 /**
  * update-tasks.js
- * Direct function implementation for updating tasks based on new context
+ * Direct function implementation for updating tasks based on new context/prompt
  */
 
-import path from 'path';
 import { updateTasks } from '../../../../scripts/modules/task-manager.js';
-import { createLogWrapper } from '../../tools/utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
 } from '../../../../scripts/modules/utils.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
+import {
+	getAnthropicClientForMCP,
+	getPerplexityClientForMCP
+} from '../utils/ai-client-utils.js';
 
 /**
- * Direct function wrapper for updating tasks based on new context.
+ * Direct function wrapper for updating tasks based on new context/prompt.
  *
- * @param {Object} args - Command arguments containing projectRoot, from, prompt, research options.
+ * @param {Object} args - Command arguments containing fromId, prompt, useResearch and file path options.
  * @param {Object} log - Logger object.
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function updateTasksDirect(args, log, context = {}) {
-	const { session } = context;
-	const { from, prompt, research, file: fileArg, projectRoot } = args;
+	const { session } = context; // Only extract session, not reportProgress
 
-	// Create the standard logger wrapper
-	const logWrapper = createLogWrapper(log);
-
-	// --- Input Validation ---
-	if (!projectRoot) {
-		logWrapper.error('updateTasksDirect requires a projectRoot argument.');
-		return {
-			success: false,
-			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'projectRoot is required.'
-			}
-		};
-	}
-
-	if (!from) {
-		logWrapper.error('updateTasksDirect called without from ID');
-		return {
-			success: false,
-			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'Starting task ID (from) is required'
-			}
-		};
-	}
-
-	if (!prompt) {
-		logWrapper.error('updateTasksDirect called without prompt');
-		return {
-			success: false,
-			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'Update prompt is required'
-			}
-		};
-	}
-
-	// Resolve tasks file path
-	const tasksFile = fileArg
-		? path.resolve(projectRoot, fileArg)
-		: path.resolve(projectRoot, 'tasks', 'tasks.json');
-
-	logWrapper.info(
-		`Updating tasks via direct function. From: ${from}, Research: ${research}, File: ${tasksFile}, ProjectRoot: ${projectRoot}`
-	);
-
-	enableSilentMode(); // Enable silent mode
 	try {
-		// Call the core updateTasks function
-		const result = await updateTasks(
-			tasksFile,
-			from,
-			prompt,
-			research,
-			{
-				session,
-				mcpLog: logWrapper,
-				projectRoot
-			},
-			'json'
-		);
+		log.info(`Updating tasks with args: ${JSON.stringify(args)}`);
 
-		if (result && result.success && Array.isArray(result.updatedTasks)) {
-			logWrapper.success(
-				`Successfully updated ${result.updatedTasks.length} tasks.`
-			);
-			return {
-				success: true,
-				data: {
-					message: `Successfully updated ${result.updatedTasks.length} tasks.`,
-					tasksFile,
-					updatedCount: result.updatedTasks.length,
-					telemetryData: result.telemetryData
-				}
-			};
-		} else {
-			// Handle case where core function didn't return expected success structure
-			logWrapper.error(
-				'Core updateTasks function did not return a successful structure.'
-			);
+		// Check for the common mistake of using 'id' instead of 'from'
+		if (args.id !== undefined && args.from === undefined) {
+			const errorMessage =
+				"You specified 'id' parameter but 'update' requires 'from' parameter. Use 'from' for this tool or use 'update_task' tool if you want to update a single task.";
+			log.error(errorMessage);
 			return {
 				success: false,
 				error: {
-					code: 'CORE_FUNCTION_ERROR',
-					message:
-						result?.message ||
-						'Core function failed to update tasks or returned unexpected result.'
-				}
+					code: 'PARAMETER_MISMATCH',
+					message: errorMessage,
+					suggestion:
+						"Use 'from' parameter instead of 'id', or use the 'update_task' tool for single task updates"
+				},
+				fromCache: false
 			};
 		}
+
+		// Check required parameters
+		if (!args.from) {
+			const errorMessage =
+				'No from ID specified. Please provide a task ID to start updating from.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_FROM_ID', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		if (!args.prompt) {
+			const errorMessage =
+				'No prompt specified. Please provide a prompt with new context for task updates.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_PROMPT', message: errorMessage },
+				fromCache: false
+			};
+		}
+
+		// Parse fromId - handle both string and number values
+		let fromId;
+		if (typeof args.from === 'string') {
+			fromId = parseInt(args.from, 10);
+			if (isNaN(fromId)) {
+				const errorMessage = `Invalid from ID: ${args.from}. Task ID must be a positive integer.`;
+				log.error(errorMessage);
+				return {
+					success: false,
+					error: { code: 'INVALID_FROM_ID', message: errorMessage },
+					fromCache: false
+				};
+			}
+		} else {
+			fromId = args.from;
+		}
+
+		// Get tasks file path
+		let tasksPath;
+		try {
+			tasksPath = findTasksJsonPath(args, log);
+		} catch (error) {
+			log.error(`Error finding tasks file: ${error.message}`);
+			return {
+				success: false,
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
+				fromCache: false
+			};
+		}
+
+		// Get research flag
+		const useResearch = args.research === true;
+
+		// Initialize appropriate AI client based on research flag
+		let aiClient;
+		try {
+			if (useResearch) {
+				log.info('Using Perplexity AI for research-backed task updates');
+				aiClient = await getPerplexityClientForMCP(session, log);
+			} else {
+				log.info('Using Claude AI for task updates');
+				aiClient = getAnthropicClientForMCP(session, log);
+			}
+		} catch (error) {
+			log.error(`Failed to initialize AI client: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'AI_CLIENT_ERROR',
+					message: `Cannot initialize AI client: ${error.message}`
+				},
+				fromCache: false
+			};
+		}
+
+		log.info(
+			`Updating tasks from ID ${fromId} with prompt "${args.prompt}" and research: ${useResearch}`
+		);
+
+		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
+
+			// Execute core updateTasks function, passing the AI client and session
+			await updateTasks(tasksPath, fromId, args.prompt, useResearch, {
+				mcpLog: log,
+				session
+			});
+
+			// Since updateTasks doesn't return a value but modifies the tasks file,
+			// we'll return a success message
+			return {
+				success: true,
+				data: {
+					message: `Successfully updated tasks from ID ${fromId} based on the prompt`,
+					fromId,
+					tasksPath,
+					useResearch
+				},
+				fromCache: false // This operation always modifies state and should never be cached
+			};
+		} catch (error) {
+			log.error(`Error updating tasks: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'UPDATE_TASKS_ERROR',
+					message: error.message || 'Unknown error updating tasks'
+				},
+				fromCache: false
+			};
+		} finally {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+		}
 	} catch (error) {
-		logWrapper.error(`Error executing core updateTasks: ${error.message}`);
+		// Ensure silent mode is disabled
+		disableSilentMode();
+
+		log.error(`Error updating tasks: ${error.message}`);
 		return {
 			success: false,
 			error: {
-				code: 'UPDATE_TASKS_CORE_ERROR',
+				code: 'UPDATE_TASKS_ERROR',
 				message: error.message || 'Unknown error updating tasks'
-			}
+			},
+			fromCache: false
 		};
-	} finally {
-		disableSilentMode(); // Ensure silent mode is disabled
 	}
 }

mcp-server/src/core/direct-functions/validate-dependencies.js

@@ -3,6 +3,7 @@
  */
 
 import { validateDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
+import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
 	enableSilentMode,
 	disableSilentMode
@@ -12,30 +13,17 @@ import fs from 'fs';
 /**
  * Validate dependencies in tasks.json
  * @param {Object} args - Function arguments
- * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
+ * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.projectRoot] - Project root directory
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
 export async function validateDependenciesDirect(args, log) {
-	// Destructure the explicit tasksJsonPath
-	const { tasksJsonPath } = args;
-
-	if (!tasksJsonPath) {
-		log.error('validateDependenciesDirect called without tasksJsonPath');
-		return {
-			success: false,
-			error: {
-				code: 'MISSING_ARGUMENT',
-				message: 'tasksJsonPath is required'
-			}
-		};
-	}
-
 	try {
-		log.info(`Validating dependencies in tasks: ${tasksJsonPath}`);
+		log.info(`Validating dependencies in tasks...`);
 
-		// Use the provided tasksJsonPath
-		const tasksPath = tasksJsonPath;
+		// Find the tasks.json path
+		const tasksPath = findTasksJsonPath(args, log);
 
 		// Verify the file exists
 		if (!fs.existsSync(tasksPath)) {
@@ -51,7 +39,7 @@ export async function validateDependenciesDirect(args, log) {
 		// Enable silent mode to prevent console logs from interfering with JSON response
 		enableSilentMode();
 
-		// Call the original command function using the provided tasksPath
+		// Call the original command function
 		await validateDependenciesCommand(tasksPath);
 
 		// Restore normal logging

mcp-server/src/core/task-master-core.js

@@ -28,13 +28,19 @@ import { fixDependenciesDirect } from './direct-functions/fix-dependencies.js';
 import { complexityReportDirect } from './direct-functions/complexity-report.js';
 import { addDependencyDirect } from './direct-functions/add-dependency.js';
 import { removeTaskDirect } from './direct-functions/remove-task.js';
-import { initializeProjectDirect } from './direct-functions/initialize-project.js';
-import { modelsDirect } from './direct-functions/models.js';
-import { moveTaskDirect } from './direct-functions/move-task.js';
 
 // Re-export utility functions
 export { findTasksJsonPath } from './utils/path-utils.js';
 
+// Re-export AI client utilities
+export {
+	getAnthropicClientForMCP,
+	getPerplexityClientForMCP,
+	getModelConfig,
+	getBestAvailableAIModel,
+	handleClaudeError
+} from './utils/ai-client-utils.js';
+
 // Use Map for potential future enhancements like introspection or dynamic dispatch
 export const directFunctions = new Map([
 	['listTasksDirect', listTasksDirect],
@@ -59,10 +65,7 @@ export const directFunctions = new Map([
 	['fixDependenciesDirect', fixDependenciesDirect],
 	['complexityReportDirect', complexityReportDirect],
 	['addDependencyDirect', addDependencyDirect],
-	['removeTaskDirect', removeTaskDirect],
-	['initializeProjectDirect', initializeProjectDirect],
-	['modelsDirect', modelsDirect],
-	['moveTaskDirect', moveTaskDirect]
+	['removeTaskDirect', removeTaskDirect]
 ]);
 
 // Re-export all direct function implementations
@@ -89,8 +92,5 @@ export {
 	fixDependenciesDirect,
 	complexityReportDirect,
 	addDependencyDirect,
-	removeTaskDirect,
-	initializeProjectDirect,
-	modelsDirect,
-	moveTaskDirect
+	removeTaskDirect
 };

mcp-server/src/core/utils/ai-client-utils.js

@@ -0,0 +1,213 @@
+/**
+ * ai-client-utils.js
+ * Utility functions for initializing AI clients in MCP context
+ */
+
+import { Anthropic } from '@anthropic-ai/sdk';
+import dotenv from 'dotenv';
+
+// Load environment variables for CLI mode
+dotenv.config();
+
+// Default model configuration from CLI environment
+const DEFAULT_MODEL_CONFIG = {
+	model: 'claude-3-7-sonnet-20250219',
+	maxTokens: 64000,
+	temperature: 0.2
+};
+
+/**
+ * Get an Anthropic client instance initialized with MCP session environment variables
+ * @param {Object} [session] - Session object from MCP containing environment variables
+ * @param {Object} [log] - Logger object to use (defaults to console)
+ * @returns {Anthropic} Anthropic client instance
+ * @throws {Error} If API key is missing
+ */
+export function getAnthropicClientForMCP(session, log = console) {
+	try {
+		// Extract API key from session.env or fall back to environment variables
+		const apiKey =
+			session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+
+		if (!apiKey) {
+			throw new Error(
+				'ANTHROPIC_API_KEY not found in session environment or process.env'
+			);
+		}
+
+		// Initialize and return a new Anthropic client
+		return new Anthropic({
+			apiKey,
+			defaultHeaders: {
+				'anthropic-beta': 'output-128k-2025-02-19' // Include header for increased token limit
+			}
+		});
+	} catch (error) {
+		log.error(`Failed to initialize Anthropic client: ${error.message}`);
+		throw error;
+	}
+}
+
+/**
+ * Get a Perplexity client instance initialized with MCP session environment variables
+ * @param {Object} [session] - Session object from MCP containing environment variables
+ * @param {Object} [log] - Logger object to use (defaults to console)
+ * @returns {OpenAI} OpenAI client configured for Perplexity API
+ * @throws {Error} If API key is missing or OpenAI package can't be imported
+ */
+export async function getPerplexityClientForMCP(session, log = console) {
+	try {
+		// Extract API key from session.env or fall back to environment variables
+		const apiKey =
+			session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY;
+
+		if (!apiKey) {
+			throw new Error(
+				'PERPLEXITY_API_KEY not found in session environment or process.env'
+			);
+		}
+
+		// Dynamically import OpenAI (it may not be used in all contexts)
+		const { default: OpenAI } = await import('openai');
+
+		// Initialize and return a new OpenAI client configured for Perplexity
+		return new OpenAI({
+			apiKey,
+			baseURL: 'https://api.perplexity.ai'
+		});
+	} catch (error) {
+		log.error(`Failed to initialize Perplexity client: ${error.message}`);
+		throw error;
+	}
+}
+
+/**
+ * Get model configuration from session environment or fall back to defaults
+ * @param {Object} [session] - Session object from MCP containing environment variables
+ * @param {Object} [defaults] - Default model configuration to use if not in session
+ * @returns {Object} Model configuration with model, maxTokens, and temperature
+ */
+export function getModelConfig(session, defaults = DEFAULT_MODEL_CONFIG) {
+	// Get values from session or fall back to defaults
+	return {
+		model: session?.env?.MODEL || defaults.model,
+		maxTokens: parseInt(session?.env?.MAX_TOKENS || defaults.maxTokens),
+		temperature: parseFloat(session?.env?.TEMPERATURE || defaults.temperature)
+	};
+}
+
+/**
+ * Returns the best available AI model based on specified options
+ * @param {Object} session - Session object from MCP containing environment variables
+ * @param {Object} options - Options for model selection
+ * @param {boolean} [options.requiresResearch=false] - Whether the operation requires research capabilities
+ * @param {boolean} [options.claudeOverloaded=false] - Whether Claude is currently overloaded
+ * @param {Object} [log] - Logger object to use (defaults to console)
+ * @returns {Promise<Object>} Selected model info with type and client
+ * @throws {Error} If no AI models are available
+ */
+export async function getBestAvailableAIModel(
+	session,
+	options = {},
+	log = console
+) {
+	const { requiresResearch = false, claudeOverloaded = false } = options;
+
+	// Test case: When research is needed but no Perplexity, use Claude
+	if (
+		requiresResearch &&
+		!(session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY) &&
+		(session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)
+	) {
+		try {
+			log.warn('Perplexity not available for research, using Claude');
+			const client = getAnthropicClientForMCP(session, log);
+			return { type: 'claude', client };
+		} catch (error) {
+			log.error(`Claude not available: ${error.message}`);
+			throw new Error('No AI models available for research');
+		}
+	}
+
+	// Regular path: Perplexity for research when available
+	if (
+		requiresResearch &&
+		(session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY)
+	) {
+		try {
+			const client = await getPerplexityClientForMCP(session, log);
+			return { type: 'perplexity', client };
+		} catch (error) {
+			log.warn(`Perplexity not available: ${error.message}`);
+			// Fall through to Claude as backup
+		}
+	}
+
+	// Test case: Claude for overloaded scenario
+	if (
+		claudeOverloaded &&
+		(session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)
+	) {
+		try {
+			log.warn(
+				'Claude is overloaded but no alternatives are available. Proceeding with Claude anyway.'
+			);
+			const client = getAnthropicClientForMCP(session, log);
+			return { type: 'claude', client };
+		} catch (error) {
+			log.error(
+				`Claude not available despite being overloaded: ${error.message}`
+			);
+			throw new Error('No AI models available');
+		}
+	}
+
+	// Default case: Use Claude when available and not overloaded
+	if (
+		!claudeOverloaded &&
+		(session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)
+	) {
+		try {
+			const client = getAnthropicClientForMCP(session, log);
+			return { type: 'claude', client };
+		} catch (error) {
+			log.warn(`Claude not available: ${error.message}`);
+			// Fall through to error if no other options
+		}
+	}
+
+	// If we got here, no models were successfully initialized
+	throw new Error('No AI models available. Please check your API keys.');
+}
+
+/**
+ * Handle Claude API errors with user-friendly messages
+ * @param {Error} error - The error from Claude API
+ * @returns {string} User-friendly error message
+ */
+export function handleClaudeError(error) {
+	// Check if it's a structured error response
+	if (error.type === 'error' && error.error) {
+		switch (error.error.type) {
+			case 'overloaded_error':
+				return 'Claude is currently experiencing high demand and is overloaded. Please wait a few minutes and try again.';
+			case 'rate_limit_error':
+				return 'You have exceeded the rate limit. Please wait a few minutes before making more requests.';
+			case 'invalid_request_error':
+				return 'There was an issue with the request format. If this persists, please report it as a bug.';
+			default:
+				return `Claude API error: ${error.error.message}`;
+		}
+	}
+
+	// Check for network/timeout errors
+	if (error.message?.toLowerCase().includes('timeout')) {
+		return 'The request to Claude timed out. Please try again.';
+	}
+	if (error.message?.toLowerCase().includes('network')) {
+		return 'There was a network error connecting to Claude. Please check your internet connection and try again.';
+	}
+
+	// Default error message
+	return `Error communicating with Claude: ${error.message}`;
+}

mcp-server/src/core/utils/async-manager.js

@@ -0,0 +1,251 @@
+import { v4 as uuidv4 } from 'uuid';
+
+class AsyncOperationManager {
+	constructor() {
+		this.operations = new Map(); // Stores active operation state
+		this.completedOperations = new Map(); // Stores completed operations
+		this.maxCompletedOperations = 100; // Maximum number of completed operations to store
+		this.listeners = new Map(); // For potential future notifications
+	}
+
+	/**
+	 * Adds an operation to be executed asynchronously.
+	 * @param {Function} operationFn - The async function to execute (e.g., a Direct function).
+	 * @param {Object} args - Arguments to pass to the operationFn.
+	 * @param {Object} context - The MCP tool context { log, reportProgress, session }.
+	 * @returns {string} The unique ID assigned to this operation.
+	 */
+	addOperation(operationFn, args, context) {
+		const operationId = `op-${uuidv4()}`;
+		const operation = {
+			id: operationId,
+			status: 'pending',
+			startTime: Date.now(),
+			endTime: null,
+			result: null,
+			error: null,
+			// Store necessary parts of context, especially log for background execution
+			log: context.log,
+			reportProgress: context.reportProgress, // Pass reportProgress through
+			session: context.session // Pass session through if needed by the operationFn
+		};
+		this.operations.set(operationId, operation);
+		this.log(operationId, 'info', `Operation added.`);
+
+		// Start execution in the background (don't await here)
+		this._runOperation(operationId, operationFn, args, context).catch((err) => {
+			// Catch unexpected errors during the async execution setup itself
+			this.log(
+				operationId,
+				'error',
+				`Critical error starting operation: ${err.message}`,
+				{ stack: err.stack }
+			);
+			operation.status = 'failed';
+			operation.error = {
+				code: 'MANAGER_EXECUTION_ERROR',
+				message: err.message
+			};
+			operation.endTime = Date.now();
+
+			// Move to completed operations
+			this._moveToCompleted(operationId);
+		});
+
+		return operationId;
+	}
+
+	/**
+	 * Internal function to execute the operation.
+	 * @param {string} operationId - The ID of the operation.
+	 * @param {Function} operationFn - The async function to execute.
+	 * @param {Object} args - Arguments for the function.
+	 * @param {Object} context - The original MCP tool context.
+	 */
+	async _runOperation(operationId, operationFn, args, context) {
+		const operation = this.operations.get(operationId);
+		if (!operation) return; // Should not happen
+
+		operation.status = 'running';
+		this.log(operationId, 'info', `Operation running.`);
+		this.emit('statusChanged', { operationId, status: 'running' });
+
+		try {
+			// Pass the necessary context parts to the direct function
+			// The direct function needs to be adapted if it needs reportProgress
+			// We pass the original context's log, plus our wrapped reportProgress
+			const result = await operationFn(args, operation.log, {
+				reportProgress: (progress) =>
+					this._handleProgress(operationId, progress),
+				mcpLog: operation.log, // Pass log as mcpLog if direct fn expects it
+				session: operation.session
+			});
+
+			operation.status = result.success ? 'completed' : 'failed';
+			operation.result = result.success ? result.data : null;
+			operation.error = result.success ? null : result.error;
+			this.log(
+				operationId,
+				'info',
+				`Operation finished with status: ${operation.status}`
+			);
+		} catch (error) {
+			this.log(
+				operationId,
+				'error',
+				`Operation failed with error: ${error.message}`,
+				{ stack: error.stack }
+			);
+			operation.status = 'failed';
+			operation.error = {
+				code: 'OPERATION_EXECUTION_ERROR',
+				message: error.message
+			};
+		} finally {
+			operation.endTime = Date.now();
+			this.emit('statusChanged', {
+				operationId,
+				status: operation.status,
+				result: operation.result,
+				error: operation.error
+			});
+
+			// Move to completed operations if done or failed
+			if (operation.status === 'completed' || operation.status === 'failed') {
+				this._moveToCompleted(operationId);
+			}
+		}
+	}
+
+	/**
+	 * Move an operation from active operations to completed operations history.
+	 * @param {string} operationId - The ID of the operation to move.
+	 * @private
+	 */
+	_moveToCompleted(operationId) {
+		const operation = this.operations.get(operationId);
+		if (!operation) return;
+
+		// Store only the necessary data in completed operations
+		const completedData = {
+			id: operation.id,
+			status: operation.status,
+			startTime: operation.startTime,
+			endTime: operation.endTime,
+			result: operation.result,
+			error: operation.error
+		};
+
+		this.completedOperations.set(operationId, completedData);
+		this.operations.delete(operationId);
+
+		// Trim completed operations if exceeding maximum
+		if (this.completedOperations.size > this.maxCompletedOperations) {
+			// Get the oldest operation (sorted by endTime)
+			const oldest = [...this.completedOperations.entries()].sort(
+				(a, b) => a[1].endTime - b[1].endTime
+			)[0];
+
+			if (oldest) {
+				this.completedOperations.delete(oldest[0]);
+			}
+		}
+	}
+
+	/**
+	 * Handles progress updates from the running operation and forwards them.
+	 * @param {string} operationId - The ID of the operation reporting progress.
+	 * @param {Object} progress - The progress object { progress, total? }.
+	 */
+	_handleProgress(operationId, progress) {
+		const operation = this.operations.get(operationId);
+		if (operation && operation.reportProgress) {
+			try {
+				// Use the reportProgress function captured from the original context
+				operation.reportProgress(progress);
+				this.log(
+					operationId,
+					'debug',
+					`Reported progress: ${JSON.stringify(progress)}`
+				);
+			} catch (err) {
+				this.log(
+					operationId,
+					'warn',
+					`Failed to report progress: ${err.message}`
+				);
+				// Don't stop the operation, just log the reporting failure
+			}
+		}
+	}
+
+	/**
+	 * Retrieves the status and result/error of an operation.
+	 * @param {string} operationId - The ID of the operation.
+	 * @returns {Object | null} The operation details or null if not found.
+	 */
+	getStatus(operationId) {
+		// First check active operations
+		const operation = this.operations.get(operationId);
+		if (operation) {
+			return {
+				id: operation.id,
+				status: operation.status,
+				startTime: operation.startTime,
+				endTime: operation.endTime,
+				result: operation.result,
+				error: operation.error
+			};
+		}
+
+		// Then check completed operations
+		const completedOperation = this.completedOperations.get(operationId);
+		if (completedOperation) {
+			return completedOperation;
+		}
+
+		// Operation not found in either active or completed
+		return {
+			error: {
+				code: 'OPERATION_NOT_FOUND',
+				message: `Operation ID ${operationId} not found. It may have been completed and removed from history, or the ID may be invalid.`
+			},
+			status: 'not_found'
+		};
+	}
+
+	/**
+	 * Internal logging helper to prefix logs with the operation ID.
+	 * @param {string} operationId - The ID of the operation.
+	 * @param {'info'|'warn'|'error'|'debug'} level - Log level.
+	 * @param {string} message - Log message.
+	 * @param {Object} [meta] - Additional metadata.
+	 */
+	log(operationId, level, message, meta = {}) {
+		const operation = this.operations.get(operationId);
+		// Use the logger instance associated with the operation if available, otherwise console
+		const logger = operation?.log || console;
+		const logFn = logger[level] || logger.log || console.log; // Fallback
+		logFn(`[AsyncOp ${operationId}] ${message}`, meta);
+	}
+
+	// --- Basic Event Emitter ---
+	on(eventName, listener) {
+		if (!this.listeners.has(eventName)) {
+			this.listeners.set(eventName, []);
+		}
+		this.listeners.get(eventName).push(listener);
+	}
+
+	emit(eventName, data) {
+		if (this.listeners.has(eventName)) {
+			this.listeners.get(eventName).forEach((listener) => listener(data));
+		}
+	}
+}
+
+// Export a singleton instance
+const asyncOperationManager = new AsyncOperationManager();
+
+// Export the manager and potentially the class if needed elsewhere
+export { asyncOperationManager, AsyncOperationManager };

mcp-server/src/core/utils/path-utils.js

@@ -291,146 +291,3 @@ function findTasksWithNpmConsideration(startDir, log) {
 		}
 	}
 }
-
-/**
- * Finds potential PRD document files based on common naming patterns
- * @param {string} projectRoot - The project root directory
- * @param {string|null} explicitPath - Optional explicit path provided by the user
- * @param {Object} log - Logger object
- * @returns {string|null} - The path to the first found PRD file, or null if none found
- */
-export function findPRDDocumentPath(projectRoot, explicitPath, log) {
-	// If explicit path is provided, check if it exists
-	if (explicitPath) {
-		const fullPath = path.isAbsolute(explicitPath)
-			? explicitPath
-			: path.resolve(projectRoot, explicitPath);
-
-		if (fs.existsSync(fullPath)) {
-			log.info(`Using provided PRD document path: ${fullPath}`);
-			return fullPath;
-		} else {
-			log.warn(
-				`Provided PRD document path not found: ${fullPath}, will search for alternatives`
-			);
-		}
-	}
-
-	// Common locations and file patterns for PRD documents
-	const commonLocations = [
-		'', // Project root
-		'scripts/'
-	];
-
-	const commonFileNames = ['PRD.md', 'prd.md', 'PRD.txt', 'prd.txt'];
-
-	// Check all possible combinations
-	for (const location of commonLocations) {
-		for (const fileName of commonFileNames) {
-			const potentialPath = path.join(projectRoot, location, fileName);
-			if (fs.existsSync(potentialPath)) {
-				log.info(`Found PRD document at: ${potentialPath}`);
-				return potentialPath;
-			}
-		}
-	}
-
-	log.warn(`No PRD document found in common locations within ${projectRoot}`);
-	return null;
-}
-
-export function findComplexityReportPath(projectRoot, explicitPath, log) {
-	// If explicit path is provided, check if it exists
-	if (explicitPath) {
-		const fullPath = path.isAbsolute(explicitPath)
-			? explicitPath
-			: path.resolve(projectRoot, explicitPath);
-
-		if (fs.existsSync(fullPath)) {
-			log.info(`Using provided PRD document path: ${fullPath}`);
-			return fullPath;
-		} else {
-			log.warn(
-				`Provided PRD document path not found: ${fullPath}, will search for alternatives`
-			);
-		}
-	}
-
-	// Common locations and file patterns for PRD documents
-	const commonLocations = [
-		'', // Project root
-		'scripts/'
-	];
-
-	const commonFileNames = [
-		'complexity-report.json',
-		'task-complexity-report.json'
-	];
-
-	// Check all possible combinations
-	for (const location of commonLocations) {
-		for (const fileName of commonFileNames) {
-			const potentialPath = path.join(projectRoot, location, fileName);
-			if (fs.existsSync(potentialPath)) {
-				log.info(`Found PRD document at: ${potentialPath}`);
-				return potentialPath;
-			}
-		}
-	}
-
-	log.warn(`No PRD document found in common locations within ${projectRoot}`);
-	return null;
-}
-
-/**
- * Resolves the tasks output directory path
- * @param {string} projectRoot - The project root directory
- * @param {string|null} explicitPath - Optional explicit output path provided by the user
- * @param {Object} log - Logger object
- * @returns {string} - The resolved tasks directory path
- */
-export function resolveTasksOutputPath(projectRoot, explicitPath, log) {
-	// If explicit path is provided, use it
-	if (explicitPath) {
-		const outputPath = path.isAbsolute(explicitPath)
-			? explicitPath
-			: path.resolve(projectRoot, explicitPath);
-
-		log.info(`Using provided tasks output path: ${outputPath}`);
-		return outputPath;
-	}
-
-	// Default output path: tasks/tasks.json in the project root
-	const defaultPath = path.resolve(projectRoot, 'tasks', 'tasks.json');
-	log.info(`Using default tasks output path: ${defaultPath}`);
-
-	// Ensure the directory exists
-	const outputDir = path.dirname(defaultPath);
-	if (!fs.existsSync(outputDir)) {
-		log.info(`Creating tasks directory: ${outputDir}`);
-		fs.mkdirSync(outputDir, { recursive: true });
-	}
-
-	return defaultPath;
-}
-
-/**
- * Resolves various file paths needed for MCP operations based on project root
- * @param {string} projectRoot - The project root directory
- * @param {Object} args - Command arguments that may contain explicit paths
- * @param {Object} log - Logger object
- * @returns {Object} - An object containing resolved paths
- */
-export function resolveProjectPaths(projectRoot, args, log) {
-	const prdPath = findPRDDocumentPath(projectRoot, args.input, log);
-	const tasksJsonPath = resolveTasksOutputPath(projectRoot, args.output, log);
-
-	// You can add more path resolutions here as needed
-
-	return {
-		projectRoot,
-		prdPath,
-		tasksJsonPath
-		// Add additional path properties as needed
-	};
-}

mcp-server/src/index.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'url';
 import fs from 'fs';
 import logger from './logger.js';
 import { registerTaskMasterTools } from './tools/index.js';
+import { asyncOperationManager } from './core/utils/async-manager.js';
 
 // Load environment variables
 dotenv.config();
@@ -34,6 +35,9 @@ class TaskMasterMCPServer {
 
 		this.server.addResourceTemplate({});
 
+		// Make the manager accessible (e.g., pass it to tool registration)
+		this.asyncManager = asyncOperationManager;
+
 		// Bind methods
 		this.init = this.init.bind(this);
 		this.start = this.start.bind(this);
@@ -84,4 +88,7 @@ class TaskMasterMCPServer {
 	}
 }
 
+// Export the manager from here as well, if needed elsewhere
+export { asyncOperationManager };
+
 export default TaskMasterMCPServer;

mcp-server/src/logger.js

@@ -1,6 +1,5 @@
 import chalk from 'chalk';
 import { isSilentMode } from '../../scripts/modules/utils.js';
-import { getLogLevel } from '../../scripts/modules/config-manager.js';
 
 // Define log levels
 const LOG_LEVELS = {
@@ -11,8 +10,10 @@ const LOG_LEVELS = {
 	success: 4
 };
 
-// Get log level from config manager or default to info
-const LOG_LEVEL = LOG_LEVELS[getLogLevel().toLowerCase()] ?? LOG_LEVELS.info;
+// Get log level from environment or default to info
+const LOG_LEVEL = process.env.LOG_LEVEL
+	? (LOG_LEVELS[process.env.LOG_LEVEL.toLowerCase()] ?? LOG_LEVELS.info)
+	: LOG_LEVELS.info;
 
 /**
  * Logs a message with the specified level

mcp-server/src/logger.js (lines 31-41)

@@ -0,0 +1 @@
+ 

mcp-server/src/tools/add-dependency.js

@@ -7,11 +7,9 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	getProjectRootFromSession,
-	withNormalizedProjectRoot
+	getProjectRootFromSession
 } from './utils.js';
 import { addDependencyDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the addDependency tool with the MCP server
@@ -29,45 +27,42 @@ export function registerAddDependencyTool(server) {
 			file: z
 				.string()
 				.optional()
-				.describe(
-					'Absolute path to the tasks file (default: tasks/tasks.json)'
-				),
+				.describe('Path to the tasks file (default: tasks/tasks.json)'),
 			projectRoot: z
 				.string()
-				.describe('The directory of the project. Must be an absolute path.')
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
 		}),
-		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+		execute: async (args, { log, session, reportProgress }) => {
 			try {
 				log.info(
 					`Adding dependency for task ${args.id} to depend on ${args.dependsOn}`
 				);
+				reportProgress({ progress: 0 });
 
-				let tasksJsonPath;
-				try {
-					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: args.projectRoot, file: args.file },
-						log
-					);
-				} catch (error) {
-					log.error(`Error finding tasks.json: ${error.message}`);
-					return createErrorResponse(
-						`Failed to find tasks.json: ${error.message}`
-					);
+				// Get project root using the utility function
+				let rootFolder = getProjectRootFromSession(session, log);
+
+				// Fallback to args.projectRoot if session didn't provide one
+				if (!rootFolder && args.projectRoot) {
+					rootFolder = args.projectRoot;
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
 				}
 
-				// Call the direct function with the resolved path
+				// Call the direct function with the resolved rootFolder
 				const result = await addDependencyDirect(
 					{
-						// Pass the explicitly resolved path
-						tasksJsonPath: tasksJsonPath,
-						// Pass other relevant args
-						id: args.id,
-						dependsOn: args.dependsOn
+						projectRoot: rootFolder,
+						...args
 					},
-					log
-					// Remove context object
+					log,
+					{ reportProgress, mcpLog: log, session }
 				);
 
+				reportProgress({ progress: 100 });
+
 				// Log result
 				if (result.success) {
 					log.info(`Successfully added dependency: ${result.data.message}`);
@@ -81,6 +76,6 @@ export function registerAddDependencyTool(server) {
 				log.error(`Error in addDependency tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		})
+		}
 	});
 }

mcp-server/src/tools/add-subtask.js

@@ -7,10 +7,9 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	withNormalizedProjectRoot
+	getProjectRootFromSession
 } from './utils.js';
 import { addSubtaskDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the addSubtask tool with the MCP server
@@ -49,48 +48,36 @@ export function registerAddSubtaskTool(server) {
 			file: z
 				.string()
 				.optional()
-				.describe(
-					'Absolute path to the tasks file (default: tasks/tasks.json)'
-				),
+				.describe('Path to the tasks file (default: tasks/tasks.json)'),
 			skipGenerate: z
 				.boolean()
 				.optional()
 				.describe('Skip regenerating task files'),
 			projectRoot: z
 				.string()
-				.describe('The directory of the project. Must be an absolute path.')
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
 		}),
-		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+		execute: async (args, { log, session, reportProgress }) => {
 			try {
 				log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
 
-				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				let tasksJsonPath;
-				try {
-					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: args.projectRoot, file: args.file },
-						log
-					);
-				} catch (error) {
-					log.error(`Error finding tasks.json: ${error.message}`);
-					return createErrorResponse(
-						`Failed to find tasks.json: ${error.message}`
-					);
+				let rootFolder = getProjectRootFromSession(session, log);
+
+				if (!rootFolder && args.projectRoot) {
+					rootFolder = args.projectRoot;
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
 				}
 
 				const result = await addSubtaskDirect(
 					{
-						tasksJsonPath: tasksJsonPath,
-						id: args.id,
-						taskId: args.taskId,
-						title: args.title,
-						description: args.description,
-						details: args.details,
-						status: args.status,
-						dependencies: args.dependencies,
-						skipGenerate: args.skipGenerate
+						projectRoot: rootFolder,
+						...args
 					},
-					log
+					log,
+					{ reportProgress, mcpLog: log, session }
 				);
 
 				if (result.success) {
@@ -104,6 +91,6 @@ export function registerAddSubtaskTool(server) {
 				log.error(`Error in addSubtask tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		})
+		}
 	});
 }

mcp-server/src/tools/add-task.js

@@ -6,11 +6,12 @@
 import { z } from 'zod';
 import {
 	createErrorResponse,
-	handleApiResult,
-	withNormalizedProjectRoot
+	createContentResponse,
+	getProjectRootFromSession,
+	executeTaskMasterCommand,
+	handleApiResult
 } from './utils.js';
 import { addTaskDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the addTask tool with the MCP server
@@ -21,28 +22,7 @@ export function registerAddTaskTool(server) {
 		name: 'add_task',
 		description: 'Add a new task using AI',
 		parameters: z.object({
-			prompt: z
-				.string()
-				.optional()
-				.describe(
-					'Description of the task to add (required if not using manual fields)'
-				),
-			title: z
-				.string()
-				.optional()
-				.describe('Task title (for manual task creation)'),
-			description: z
-				.string()
-				.optional()
-				.describe('Task description (for manual task creation)'),
-			details: z
-				.string()
-				.optional()
-				.describe('Implementation details (for manual task creation)'),
-			testStrategy: z
-				.string()
-				.optional()
-				.describe('Test strategy (for manual task creation)'),
+			prompt: z.string().describe('Description of the task to add'),
 			dependencies: z
 				.string()
 				.optional()
@@ -51,59 +31,44 @@ export function registerAddTaskTool(server) {
 				.string()
 				.optional()
 				.describe('Task priority (high, medium, low)'),
-			file: z
-				.string()
-				.optional()
-				.describe('Path to the tasks file (default: tasks/tasks.json)'),
+			file: z.string().optional().describe('Path to the tasks file'),
 			projectRoot: z
 				.string()
-				.describe('The directory of the project. Must be an absolute path.'),
+				.optional()
+				.describe('Root directory of the project'),
 			research: z
 				.boolean()
 				.optional()
 				.describe('Whether to use research capabilities for task creation')
 		}),
-		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+		execute: async (args, { log, reportProgress, session }) => {
 			try {
 				log.info(`Starting add-task with args: ${JSON.stringify(args)}`);
 
-				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				let tasksJsonPath;
-				try {
-					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: args.projectRoot, file: args.file },
-						log
-					);
-				} catch (error) {
-					log.error(`Error finding tasks.json: ${error.message}`);
-					return createErrorResponse(
-						`Failed to find tasks.json: ${error.message}`
-					);
+				// Get project root from session
+				let rootFolder = getProjectRootFromSession(session, log);
+
+				if (!rootFolder && args.projectRoot) {
+					rootFolder = args.projectRoot;
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
 				}
 
-				// Call the direct functionP
+				// Call the direct function
 				const result = await addTaskDirect(
 					{
-						tasksJsonPath: tasksJsonPath,
-						prompt: args.prompt,
-						title: args.title,
-						description: args.description,
-						details: args.details,
-						testStrategy: args.testStrategy,
-						dependencies: args.dependencies,
-						priority: args.priority,
-						research: args.research,
-						projectRoot: args.projectRoot
+						...args,
+						projectRoot: rootFolder
 					},
 					log,
-					{ session }
+					{ reportProgress, session }
 				);
 
+				// Return the result
 				return handleApiResult(result, log);
 			} catch (error) {
 				log.error(`Error in add-task tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		})
+		}
 	});
 }

mcp-server/src/tools/analyze.js

@@ -4,149 +4,94 @@
  */
 
 import { z } from 'zod';
-import path from 'path';
-import fs from 'fs'; // Import fs for directory check/creation
 import {
 	handleApiResult,
 	createErrorResponse,
-	withNormalizedProjectRoot
+	getProjectRootFromSession
 } from './utils.js';
-import { analyzeTaskComplexityDirect } from '../core/task-master-core.js'; // Assuming core functions are exported via task-master-core.js
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
+import { analyzeTaskComplexityDirect } from '../core/task-master-core.js';
 
 /**
- * Register the analyze_project_complexity tool
+ * Register the analyze tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
-export function registerAnalyzeProjectComplexityTool(server) {
+export function registerAnalyzeTool(server) {
 	server.addTool({
 		name: 'analyze_project_complexity',
 		description:
-			'Analyze task complexity and generate expansion recommendations.',
+			'Analyze task complexity and generate expansion recommendations',
 		parameters: z.object({
-			threshold: z.coerce // Use coerce for number conversion from string if needed
-				.number()
-				.int()
-				.min(1)
-				.max(10)
-				.optional()
-				.default(5) // Default threshold
-				.describe('Complexity score threshold (1-10) to recommend expansion.'),
-			research: z
-				.boolean()
-				.optional()
-				.default(false)
-				.describe('Use Perplexity AI for research-backed analysis.'),
 			output: z
 				.string()
 				.optional()
 				.describe(
-					'Output file path relative to project root (default: scripts/task-complexity-report.json).'
+					'Output file path for the report (default: scripts/task-complexity-report.json)'
+				),
+			model: z
+				.string()
+				.optional()
+				.describe(
+					'LLM model to use for analysis (defaults to configured model)'
+				),
+			threshold: z
+				.union([z.number(), z.string()])
+				.optional()
+				.describe(
+					'Minimum complexity score to recommend expansion (1-10) (default: 5)'
 				),
 			file: z
 				.string()
 				.optional()
-				.describe(
-					'Path to the tasks file relative to project root (default: tasks/tasks.json).'
-				),
-			ids: z
-				.string()
+				.describe('Path to the tasks file (default: tasks/tasks.json)'),
+			research: z
+				.boolean()
 				.optional()
-				.describe(
-					'Comma-separated list of task IDs to analyze specifically (e.g., "1,3,5").'
-				),
-			from: z.coerce
-				.number()
-				.int()
-				.positive()
-				.optional()
-				.describe('Starting task ID in a range to analyze.'),
-			to: z.coerce
-				.number()
-				.int()
-				.positive()
-				.optional()
-				.describe('Ending task ID in a range to analyze.'),
+				.describe('Use Perplexity AI for research-backed complexity analysis'),
 			projectRoot: z
 				.string()
-				.describe('The directory of the project. Must be an absolute path.')
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
 		}),
-		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
-			const toolName = 'analyze_project_complexity'; // Define tool name for logging
+		execute: async (args, { log, session }) => {
 			try {
 				log.info(
-					`Executing ${toolName} tool with args: ${JSON.stringify(args)}`
+					`Analyzing task complexity with args: ${JSON.stringify(args)}`
 				);
 
-				let tasksJsonPath;
-				try {
-					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: args.projectRoot, file: args.file },
-						log
-					);
-					log.info(`${toolName}: Resolved tasks path: ${tasksJsonPath}`);
-				} catch (error) {
-					log.error(`${toolName}: Error finding tasks.json: ${error.message}`);
-					return createErrorResponse(
-						`Failed to find tasks.json within project root '${args.projectRoot}': ${error.message}`
-					);
+				let rootFolder = getProjectRootFromSession(session, log);
+
+				if (!rootFolder && args.projectRoot) {
+					rootFolder = args.projectRoot;
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
 				}
 
-				const outputPath = args.output
-					? path.resolve(args.projectRoot, args.output)
-					: path.resolve(
-							args.projectRoot,
-							'scripts',
-							'task-complexity-report.json'
-						);
-
-				log.info(`${toolName}: Report output path: ${outputPath}`);
-
-				// Ensure output directory exists
-				const outputDir = path.dirname(outputPath);
-				try {
-					if (!fs.existsSync(outputDir)) {
-						fs.mkdirSync(outputDir, { recursive: true });
-						log.info(`${toolName}: Created output directory: ${outputDir}`);
-					}
-				} catch (dirError) {
-					log.error(
-						`${toolName}: Failed to create output directory ${outputDir}: ${dirError.message}`
-					);
-					return createErrorResponse(
-						`Failed to create output directory: ${dirError.message}`
-					);
-				}
-
-				// 3. Call Direct Function - Pass projectRoot in first arg object
 				const result = await analyzeTaskComplexityDirect(
 					{
-						tasksJsonPath: tasksJsonPath,
-						outputPath: outputPath,
-						threshold: args.threshold,
-						research: args.research,
-						projectRoot: args.projectRoot,
-						ids: args.ids,
-						from: args.from,
-						to: args.to
+						projectRoot: rootFolder,
+						...args
 					},
 					log,
 					{ session }
 				);
 
-				// 4. Handle Result
-				log.info(
-					`${toolName}: Direct function result: success=${result.success}`
-				);
+				if (result.success) {
+					log.info(`Task complexity analysis complete: ${result.data.message}`);
+					log.info(
+						`Report summary: ${JSON.stringify(result.data.reportSummary)}`
+					);
+				} else {
+					log.error(
+						`Failed to analyze task complexity: ${result.error.message}`
+					);
+				}
+
 				return handleApiResult(result, log, 'Error analyzing task complexity');
 			} catch (error) {
-				log.error(
-					`Critical error in ${toolName} tool execute: ${error.message}`
-				);
-				return createErrorResponse(
-					`Internal tool error (${toolName}): ${error.message}`
-				);
+				log.error(`Error in analyze tool: ${error.message}`);
+				return createErrorResponse(error.message);
 			}
-		})
+		}
 	});
 }

mcp-server/src/tools/clear-subtasks.js

@@ -7,10 +7,9 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	withNormalizedProjectRoot
+	getProjectRootFromSession
 } from './utils.js';
 import { clearSubtasksDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the clearSubtasks tool with the MCP server
@@ -30,44 +29,41 @@ export function registerClearSubtasksTool(server) {
 				file: z
 					.string()
 					.optional()
-					.describe(
-						'Absolute path to the tasks file (default: tasks/tasks.json)'
-					),
+					.describe('Path to the tasks file (default: tasks/tasks.json)'),
 				projectRoot: z
 					.string()
-					.describe('The directory of the project. Must be an absolute path.')
+					.optional()
+					.describe(
+						'Root directory of the project (default: current working directory)'
+					)
 			})
 			.refine((data) => data.id || data.all, {
 				message: "Either 'id' or 'all' parameter must be provided",
 				path: ['id', 'all']
 			}),
-		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+		execute: async (args, { log, session, reportProgress }) => {
 			try {
 				log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
+				await reportProgress({ progress: 0 });
 
-				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				let tasksJsonPath;
-				try {
-					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: args.projectRoot, file: args.file },
-						log
-					);
-				} catch (error) {
-					log.error(`Error finding tasks.json: ${error.message}`);
-					return createErrorResponse(
-						`Failed to find tasks.json: ${error.message}`
-					);
+				let rootFolder = getProjectRootFromSession(session, log);
+
+				if (!rootFolder && args.projectRoot) {
+					rootFolder = args.projectRoot;
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
 				}
 
 				const result = await clearSubtasksDirect(
 					{
-						tasksJsonPath: tasksJsonPath,
-						id: args.id,
-						all: args.all
+						projectRoot: rootFolder,
+						...args
 					},
-					log
+					log,
+					{ reportProgress, mcpLog: log, session }
 				);
 
+				reportProgress({ progress: 100 });
+
 				if (result.success) {
 					log.info(`Subtasks cleared successfully: ${result.data.message}`);
 				} else {
@@ -79,6 +75,6 @@ export function registerClearSubtasksTool(server) {
 				log.error(`Error in clearSubtasks tool: ${error.message}`);
 				return createErrorResponse(error.message);
 			}
-		})
+		}
 	});
 }

mcp-server/src/tools/complexity-report.js

@@ -7,10 +7,9 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	withNormalizedProjectRoot
+	getProjectRootFromSession
 } from './utils.js';
 import { complexityReportDirect } from '../core/task-master-core.js';
-import path from 'path';
 
 /**
  * Register the complexityReport tool with the MCP server
@@ -29,30 +28,35 @@ export function registerComplexityReportTool(server) {
 				),
 			projectRoot: z
 				.string()
-				.describe('The directory of the project. Must be an absolute path.')
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
 		}),
-		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+		execute: async (args, { log, session, reportProgress }) => {
 			try {
 				log.info(
 					`Getting complexity report with args: ${JSON.stringify(args)}`
 				);
+				// await reportProgress({ progress: 0 });
 
-				// Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
-				const reportPath = args.file
-					? path.resolve(args.projectRoot, args.file)
-					: path.resolve(
-							args.projectRoot,
-							'scripts',
-							'task-complexity-report.json'
-						);
+				let rootFolder = getProjectRootFromSession(session, log);
+
+				if (!rootFolder && args.projectRoot) {
+					rootFolder = args.projectRoot;
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
+				}
 
 				const result = await complexityReportDirect(
 					{
-						reportPath: reportPath
+						projectRoot: rootFolder,
+						...args
 					},
-					log
+					log /*, { reportProgress, mcpLog: log, session}*/
 				);
 
+				// await reportProgress({ progress: 100 });
+
 				if (result.success) {
 					log.info(
 						`Successfully retrieved complexity report${result.fromCache ? ' (from cache)' : ''}`
@@ -74,6 +78,6 @@ export function registerComplexityReportTool(server) {
 					`Failed to retrieve complexity report: ${error.message}`
 				);
 			}
-		})
+		}
 	});
 }

mcp-server/src/tools/expand-all.js

@@ -7,10 +7,9 @@ import { z } from 'zod';
 import {
 	handleApiResult,
 	createErrorResponse,
-	withNormalizedProjectRoot
+	getProjectRootFromSession
 } from './utils.js';
 import { expandAllTasksDirect } from '../core/task-master-core.js';
-import { findTasksJsonPath } from '../core/utils/path-utils.js';
 
 /**
  * Register the expandAll tool with the MCP server
@@ -19,27 +18,22 @@ import { findTasksJsonPath } from '../core/utils/path-utils.js';
 export function registerExpandAllTool(server) {
 	server.addTool({
 		name: 'expand_all',
-		description:
-			'Expand all pending tasks into subtasks based on complexity or defaults',
+		description: 'Expand all pending tasks into subtasks',
 		parameters: z.object({
 			num: z
 				.string()
 				.optional()
-				.describe(
-					'Target number of subtasks per task (uses complexity/defaults otherwise)'
-				),
+				.describe('Number of subtasks to generate for each task'),
 			research: z
 				.boolean()
 				.optional()
 				.describe(
-					'Enable research-backed subtask generation (e.g., using Perplexity)'
+					'Enable Perplexity AI for research-backed subtask generation'
 				),
 			prompt: z
 				.string()
 				.optional()
-				.describe(
-					'Additional context to guide subtask generation for all tasks'
-				),
+				.describe('Additional context to guide subtask generation'),
 			force: z
 				.boolean()
 				.optional()
@@ -49,61 +43,47 @@ export function registerExpandAllTool(server) {
 			file: z
 				.string()
 				.optional()
-				.describe(
-					'Absolute path to the tasks file in the /tasks folder inside the project root (default: tasks/tasks.json)'
-				),
+				.describe('Path to the tasks file (default: tasks/tasks.json)'),
 			projectRoot: z
 				.string()
 				.optional()
 				.describe(
-					'Absolute path to the project root directory (derived from session if possible)'
+					'Root directory of the project (default: current working directory)'
 				)
 		}),
-		execute: withNormalizedProjectRoot(async (args, { log, session }) => {
+		execute: async (args, { log, session }) => {
 			try {
-				log.info(
-					`Tool expand_all execution started with args: ${JSON.stringify(args)}`
-				);
+				log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
 
-				let tasksJsonPath;
-				try {
-					tasksJsonPath = findTasksJsonPath(
-						{ projectRoot: args.projectRoot, file: args.file },
-						log
-					);
-					log.info(`Resolved tasks.json path: ${tasksJsonPath}`);
-				} catch (error) {
-					log.error(`Error finding tasks.json: ${error.message}`);
-					return createErrorResponse(
-						`Failed to find tasks.json: ${error.message}`
-					);
+				let rootFolder = getProjectRootFromSession(session, log);
+
+				if (!rootFolder && args.projectRoot) {
+					rootFolder = args.projectRoot;
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
 				}
 
 				const result = await expandAllTasksDirect(
 					{
-						tasksJsonPath: tasksJsonPath,
-						num: args.num,
-						research: args.research,
-						prompt: args.prompt,
-						force: args.force,
-						projectRoot: args.projectRoot
+						projectRoot: rootFolder,
+						...args
 					},
 					log,
 					{ session }
 				);
 
+				if (result.success) {
+					log.info(`Successfully expanded all tasks: ${result.data.message}`);
+				} else {
+					log.error(
+						`Failed to expand all tasks: ${result.error?.message || 'Unknown error'}`
+					);
+				}
+
 				return handleApiResult(result, log, 'Error expanding all tasks');
 			} catch (error) {
-				log.error(
-					`Unexpected error in expand_all tool execute: ${error.message}`
-				);
-				if (error.stack) {
-					log.error(error.stack);
-				}
-				return createErrorResponse(
-					`An unexpected error occurred: ${error.message}`
-				);
+				log.error(`Error in expand-all tool: ${error.message}`);
+				return createErrorResponse(error.message);
 			}
-		})
+		}
 	});
 }